Compare commits
50
Commits
1fb0513467
..
main
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
c63665011a
|
||
|
|
345a4322a6
|
||
|
|
fea2e0456a
|
||
|
|
8aef768a23
|
||
|
|
efdff589f7
|
||
|
|
50546f2ebb
|
||
|
|
2c7233ce45
|
||
|
|
68b6d77f30
|
||
|
|
980913ee2a
|
||
|
|
0773a384dd
|
||
|
|
4bce0edba5
|
||
|
|
be93015136
|
||
|
|
c2ef47e4ea
|
||
|
|
ec27b8d77f
|
||
|
|
5e33781974
|
||
|
|
fdb2fc960a
|
||
|
|
c5cfe49758
|
||
|
|
8d0fd46f44
|
||
|
|
b65955f9f6
|
||
|
|
6d54019a18
|
||
|
|
7547db1ea8
|
||
|
|
37e87f31b5
|
||
|
|
4ac8b64085
|
||
|
|
34e3e41382
|
||
|
|
0ffb5c47ac
|
||
|
|
59a3f94ec8
|
||
|
|
408beefc66
|
||
|
|
b54f7e1817
|
||
|
|
9e6aadf7d3
|
||
|
|
ac59969d82
|
||
|
|
db4059ff36
|
||
|
|
dc50ef1b07
|
||
|
|
fa3ba2a6bd
|
||
|
|
e8b088f13e
|
||
|
|
535f7a33fe
|
||
|
|
85bce54b05
|
||
|
|
125b77a839
|
||
|
|
17c104c6c8
|
||
|
|
7dbb1bcaee
|
||
|
|
a7fd325fa7
|
||
|
|
8a479a8455
|
||
|
|
3e486eb3ab
|
||
|
|
331e72b373
|
||
|
|
13cae98776
|
||
|
|
7cd90f8d11
|
||
|
|
d0fb5b65fb
|
||
|
|
a3ace84c8b
|
||
|
|
10eccd360c
|
||
|
|
0829c33053
|
||
|
|
cfe3b28436
|
No files matched your search
@@ -1,3 +1,4 @@
|
||||
CLAUDE.md
|
||||
.idea/
|
||||
__pycache__/
|
||||
test/
|
||||
@@ -0,0 +1,2 @@
|
||||
Daniele Fucini <dfucini@gmail.com>
|
||||
Daniele Fucini <dfucini@gmail.com> <Fuxino@users.noreply.github.com>
|
||||
@@ -4,9 +4,9 @@
|
||||
|
||||
pkgname=simple_backup
|
||||
pkgdesc='Simple backup script that uses rsync to copy files'
|
||||
pkgver=4.3.0
|
||||
pkgver=4.7.0
|
||||
pkgrel=1
|
||||
url="https://git.shouldnt.work/fuxino/${pkgname}"
|
||||
url="https://git.shouldnt.work/fuxino/$pkgname"
|
||||
arch=('any')
|
||||
license=('GPL-3.0-or-later')
|
||||
makedepends=('git'
|
||||
@@ -18,21 +18,31 @@ depends=('python>=3.10'
|
||||
optdepends=('python-systemd: use systemd log'
|
||||
'python-dbus: for desktop notifications'
|
||||
'python-paramiko: for remote backup through ssh')
|
||||
checkdepends=('python-pytest'
|
||||
'python-paramiko'
|
||||
'openssh')
|
||||
conflicts=('simple_backup-git')
|
||||
source=(git+${url}?signed#tag=${pkgver})
|
||||
source=("git+$url?signed#tag=$pkgver")
|
||||
validpgpkeys=('7E12BC1FF3B6EDB2CD8053EB981A2B2A3BBF5514')
|
||||
sha256sums=('7d9ea50d5829ac3c681a979745f1ae7afd2453eb46ceeae4f441ef5ae4540bd2')
|
||||
sha256sums=('2e457b9efe12d7670bc6c279a3d31291be1debc6eab1d3971a77bf9c0fc6fd19')
|
||||
|
||||
build()
|
||||
{
|
||||
cd ${srcdir}/${pkgname}
|
||||
cd "$srcdir"/"$pkgname"
|
||||
python -m build --wheel --no-isolation
|
||||
}
|
||||
|
||||
check()
|
||||
{
|
||||
cd "$srcdir"/"$pkgname"
|
||||
python -m pytest
|
||||
}
|
||||
|
||||
package()
|
||||
{
|
||||
cd ${srcdir}/${pkgname}
|
||||
python -m installer --destdir=${pkgdir} dist/*.whl
|
||||
install -Dm644 ${pkgname}/${pkgname}.conf ${pkgdir}/usr/share/doc/${pkgname}/${pkgname}.conf
|
||||
install -Dm644 man/${pkgname}.1 ${pkgdir}/usr/share/man/man1/${pkgname}.1
|
||||
cd "$srcdir"/"$pkgname"
|
||||
python -m installer --destdir="$pkgdir" dist/*.whl
|
||||
install -Dm644 "$pkgname"/"$pkgname".conf "$pkgdir"/usr/share/doc/"$pkgname"/"$pkgname".conf
|
||||
install -Dm644 README.md "$pkgdir"/usr/share/doc/"$pkgname"/README.md
|
||||
install -Dm644 man/"$pkgname".1 "$pkgdir"/usr/share/man/man1/"$pkgname".1
|
||||
}
|
||||
@@ -14,6 +14,7 @@ simple_backup -h
|
||||
to print all possible command line options.
|
||||
|
||||
## Dependencies
|
||||
simple_backup requires Python 3.10 or later.
|
||||
The script uses rsync to actually run the backup, so you will have to install it on your system. For example on Arch Linux:
|
||||
|
||||
```bash
|
||||
@@ -22,12 +23,15 @@ sudo pacman -Syu rsync
|
||||
|
||||
Optional dependencies are systemd-python to enable using systemd journal for logging, dbus-python for desktop notifications, and paramiko (version 3.2 or later) for remote backup.
|
||||
|
||||
## Install
|
||||
## Installation
|
||||
For Arch Linux and Arch-based distros, two packages are available in the AUR (aur.archlinux.org):
|
||||
- **simple_backup** for the release version
|
||||
- **simple_backup-git** for the git version
|
||||
|
||||
To install it from source, first clone the repository:
|
||||
Install one with your AUR helper, e.g. `aur sync simple_backup` with aurutils.
|
||||
|
||||
### Other distributions
|
||||
First clone the repository:
|
||||
|
||||
```bash
|
||||
git clone https://git.shouldnt.work/fuxino/simple_backup.git
|
||||
@@ -54,10 +58,29 @@ To back up files that your user can't read, run simple_backup with sudo or doas.
|
||||
In that case the user who ran the command is detected automatically, so that '~' (in the inputs and in the default configuration file path) refers to that user's home directory, not root's.
|
||||
When running as root in other ways (e.g. from a systemd service), specify the user with the --user (or -u) argument.
|
||||
|
||||
## Progress
|
||||
When run in a terminal, simple_backup shows a progress bar with the percentage of files copied, the copy speed and an estimated time to completion.
|
||||
Speed and estimated time follow the last 30 seconds, so the estimate adapts when big files are being copied.
|
||||
Disable it with --no-progress.
|
||||
|
||||
## Old backups
|
||||
The number of old backups to keep can be set with the --keep (or -k) argument (or in the configuration file).
|
||||
Old backups are only removed if rsync completes successfully, so that they are not deleted when the new backup may be incomplete.
|
||||
By default, old backups are only removed if rsync completes successfully, so that they are not deleted when the new backup may be incomplete.
|
||||
The only rsync error that is ignored is return code 24 (source files vanished during the transfer), which is common when backing up a live system.
|
||||
To free space on the destination first, use --remove-before-backup: old backups are then removed before rsync starts, even if the new backup fails.
|
||||
|
||||
## Last backup
|
||||
After each successful backup, simple_backup saves its time and directory to `~/.local/state/simple_backup/last_backup` (or `$XDG_STATE_HOME/simple_backup/last_backup`).
|
||||
It also saves the number of files, so that the next run can show progress and an estimated time while rsync is still looking for files.
|
||||
When run with sudo or doas, the file goes to the home directory of the user who ran the command.
|
||||
To see when the last backup was made (e.g. `Last backup: 2026-10-25 14:03 (2 days ago)`), run:
|
||||
|
||||
```bash
|
||||
simple_backup --last-backup
|
||||
```
|
||||
|
||||
The first line of the file is the completion time in ISO 8601 format (e.g. `2026-10-25T14:03:12+02:00`), the second the backup directory, and the third (if known) the number of files.
|
||||
Scripts (e.g. a status bar indicator) can easily read the first line to remind you when a backup is overdue.
|
||||
|
||||
## Remote backup
|
||||
> **Warning**
|
||||
@@ -66,6 +89,7 @@ The only rsync error that is ignored is return code 24 (source files vanished du
|
||||
It's possible to use a remote server as destination for the backup. Just use the --ssh-user and --ssh-host arguments (or set them in the configuration file).
|
||||
Both are required: if only one of them is set, simple_backup exits with an error.
|
||||
For this to work, rsync must be installed on the server too.
|
||||
The host can be an alias from `~/.ssh/config`: its HostName, Port and IdentityFile are used (ProxyJump and ProxyCommand are not supported).
|
||||
|
||||
The output directory is a path on the server. A leading '~' and relative paths refer to the user's home directory on the server.
|
||||
On the command line, quote '~' so that your local shell doesn't expand it:
|
||||
@@ -86,4 +110,6 @@ sudo --preserve-env=SSH_AUTH_SOCK -s simple_backup [options]
|
||||
|
||||
or by editing the sudoers file.
|
||||
If SSH key authentication is not available, password authentication will be used instead.
|
||||
In that case, if sshpass is installed, it is used to pass the password to rsync, so that you only have to enter it once; otherwise you will be asked for it more than once.
|
||||
sshpass has some security risks (see sshpass(1)), so use SSH key authentication if possible.
|
||||
Check the man page for more details.
|
||||
+68
-29
@@ -1,31 +1,34 @@
|
||||
.TH SIMPLE_BACKUP 1 2026-10-08 SIMPLE_BACKUP 4.3.0
|
||||
.TH SIMPLE_BACKUP 1 2026-11-21 SIMPLE_BACKUP 4.7.0
|
||||
.SH NAME
|
||||
simple_backup \- Backup files and folders using rsync
|
||||
.SH SYNOPSIS
|
||||
.B simple_backup
|
||||
\-h, \-\-help
|
||||
.PD 0
|
||||
.P
|
||||
.PD
|
||||
.B simple_backup
|
||||
[\-c, \-\-config FILE]
|
||||
[\-i, \-\-input INPUT [INPUT...]]
|
||||
[\-o, \-\-output DIR]
|
||||
.PD 0
|
||||
.P
|
||||
.PD
|
||||
.RS 14 [\-e, \-\-exclude FILE|DIR|PATTERN [FILE|...]]
|
||||
[\-k, \-\-keep N]
|
||||
[\-\-ssh\-host HOSTNAME]
|
||||
[\-\-ssh\-user USERNAME]
|
||||
[\-\-keyfile FILE]
|
||||
.PD 0
|
||||
.P
|
||||
.PD
|
||||
[\-s, \-\-checksum]
|
||||
[\-z, \-\-compress]
|
||||
.SY simple_backup
|
||||
\-h,\~\-\-help
|
||||
.YS
|
||||
.SY simple_backup
|
||||
\-\-last\-backup
|
||||
[\-u,\~\-\-user\~USERNAME]
|
||||
.YS
|
||||
.SY simple_backup
|
||||
[\-v,\~\-\-verbose]
|
||||
[\-c,\~\-\-config\~FILE]
|
||||
[\-i,\~\-\-inputs\~INPUT\~[INPUT...]]
|
||||
[\-o,\~\-\-output\~DIR]
|
||||
[\-e,\~\-\-exclude\~FILE|DIR|PATTERN\~[FILE|...]]
|
||||
[\-k,\~\-\-keep\~N]
|
||||
[\-u,\~\-\-user\~USERNAME]
|
||||
[\-\-ssh\-host\~HOSTNAME]
|
||||
[\-\-ssh\-user\~USERNAME]
|
||||
[\-\-keyfile\~FILE]
|
||||
[\-\-remote\-sudo]
|
||||
[\-\-numeric\-ids]
|
||||
[\-s,\~\-\-checksum]
|
||||
[\-z,\~\-\-compress]
|
||||
[\-\-rsync\-options\~OPTION\~[OPTION...]]
|
||||
[\-\-remove\-before\-backup]
|
||||
.RE
|
||||
[\-\-no\-syslog]
|
||||
[\-\-no\-progress]
|
||||
.YS
|
||||
.SH DESCRIPTION
|
||||
.B simple_backup
|
||||
is a python script for performing backup of files and folders.
|
||||
@@ -36,15 +39,20 @@ in a configuration file (default location $HOME/.config/simple_backup/simple_bac
|
||||
or directly on the command line.
|
||||
.P
|
||||
Parameters specified on the command line will override those in the configuration file.
|
||||
The exceptions are remote_sudo and numeric_ids: if enabled in the configuration file, they
|
||||
can\(aqt be disabled on the command line.
|
||||
.SH OPTIONS
|
||||
.TP
|
||||
.B \-h, \-\-help
|
||||
Print a short help message and exit.
|
||||
.TP
|
||||
.B \-v, \-\-verbose
|
||||
More verbose output.
|
||||
.TP
|
||||
.B \-c, \-\-config FILE
|
||||
Specify the configuration file, useful to specify a different one from the default.
|
||||
.TP
|
||||
.B \-i, \-\-input INPUT [INPUT...]
|
||||
.B \-i, \-\-inputs INPUT [INPUT...]
|
||||
Specify the files and directories to backup. Multiple inputs can be specified, just separate
|
||||
them with a space. If filenames or paths contain spaces, don't forget to escape them,
|
||||
or to use single or double quotes around them.
|
||||
@@ -64,7 +72,7 @@ not preserved either.
|
||||
.TP
|
||||
.B \-e, \-\-exclude FILE|DIR|PATTERN [FILE|...]]
|
||||
Specify files, directories or patterns to exclude from the backup. Matching files and directories
|
||||
will not be copied. Multiple elements can be specified, in the same way as for the \-\-input option.
|
||||
will not be copied. Multiple elements can be specified, in the same way as for the \-\-inputs option.
|
||||
.TP
|
||||
.B \-k, \-\-keep N
|
||||
Specify how many old backups (so excluding the current one) will be kept. The default behavior
|
||||
@@ -86,13 +94,13 @@ Username for connecting to the server in case of remote backup.
|
||||
.B \-\-keyfile FILE
|
||||
Location of the SSH key for server authentication.
|
||||
.TP
|
||||
.B \-s, \-\-checksums
|
||||
.B \-s, \-\-checksum
|
||||
Same as rsync option \(aq\-\-checksum\(aq, use checksums instead of mod\-time and size
|
||||
to skip files.
|
||||
.TP
|
||||
.B \-z, \-\-compress
|
||||
Compress data during transfer (rsync \(aq\-\-compress\(aq option). Useful for remote backup
|
||||
if saving bandwith is needed.
|
||||
if saving bandwidth is needed.
|
||||
.TP
|
||||
.B \-\-remove\-before\-backup
|
||||
Remove old backups (if necessary) before creating the new backup. Useful to free some space
|
||||
@@ -105,6 +113,17 @@ according to \-\-keep will be left, and the new backup may be incomplete. In par
|
||||
.B \-\-no\-syslog
|
||||
Don't use systemd journal for logging.
|
||||
.TP
|
||||
.B \-\-no\-progress
|
||||
Don't show a progress bar while rsync copies the files. The progress bar is only shown when
|
||||
the output is a terminal, so it never appears in the systemd journal or in redirected output.
|
||||
It shows the percentage of files copied, the copy speed and the estimated time, both from the
|
||||
last 30 seconds; the time shows \(aq\-\-:\-\-:\-\-\(aq when no file finished in that time (e.g. while
|
||||
copying a big file).
|
||||
While rsync is still looking for files, the percentage and estimated time (marked with
|
||||
\(aq~\(aq) are based on the number of files in the last backup (or on the files found so far,
|
||||
once this backup has more), and stay below 100%. Without a previous count the bar shows
|
||||
\(aq(scanning)\(aq instead.
|
||||
.TP
|
||||
.B \-\-rsync\-options OPTIONS [OPTION...]
|
||||
By default, the following rsync options are used:
|
||||
.RS
|
||||
@@ -139,6 +158,12 @@ needs to be allowed to run without password in the same way.
|
||||
.TP
|
||||
.B \-\-numeric\-ids
|
||||
Use rsync \-\-numeric\-ids option. This causes rsync to use numeric uid/gid instead of trying to map uid/gid names from the local machine to the server.
|
||||
.TP
|
||||
.B \-\-last\-backup
|
||||
Print the date of the last successful backup and how long ago it was made (for example
|
||||
\(aqLast backup: 2026\-10\-25 14:03 (2 days ago)\(aq), then exit. The exit status is 0, or 1
|
||||
if no backup has been recorded yet or the state file can\(aqt be read (see
|
||||
.BR FILES ).
|
||||
.SH CONFIGURATION
|
||||
An example configuration file is provided at \(aq/usr/share/doc/simple_backup/simple_backup.conf\(aq.
|
||||
Copy it to the default location ($HOME/.config/simple_backup) and edit it as needed.
|
||||
@@ -146,6 +171,8 @@ Copy it to the default location ($HOME/.config/simple_backup) and edit it as nee
|
||||
It is possible to choose a directory on a remote server as destination for the backup. The files
|
||||
are copied by rsync through SSH. Server hostname and username must be specified, either in the
|
||||
configuration file, or on the command line (\(aq\-\-ssh\-host\(aq and \(aq\-\-ssh\-user\(aq options).
|
||||
The host can be an alias from \fI~/.ssh/config\fR: its HostName, Port and IdentityFile are used
|
||||
(ProxyJump and ProxyCommand are not supported).
|
||||
.P
|
||||
The output directory is a path on the server. A leading \(aq~\(aq and relative paths refer to the
|
||||
home directory of the user on the server. On the command line, quote \(aq~\(aq so that the local
|
||||
@@ -201,13 +228,25 @@ Backup failed because output directory for storing the backup does not exist.
|
||||
Permission denied to access the output directory.
|
||||
.TP
|
||||
.B 4
|
||||
rsync error (rsync returned a value other than 0 or 24).
|
||||
rsync error (rsync returned a value other than 0 or 24, or rsync is not installed).
|
||||
.TP
|
||||
.B 5
|
||||
SSH connection failed.
|
||||
.TP
|
||||
.B 6
|
||||
Bad configuration file or options (for example, only one of SSH host and SSH user specified).
|
||||
.SH FILES
|
||||
.TP
|
||||
.I $XDG_STATE_HOME/simple_backup/last_backup
|
||||
Written after each successful backup (local or remote), replacing the previous one. The first line
|
||||
is the completion time in ISO 8601 format with the UTC offset (for example
|
||||
\(aq2026\-10\-25T14:03:12+02:00\(aq), the second line the backup directory (prefixed with
|
||||
\(aquser@host:\(aq for remote backups), and the third line, if present, the number of files, used
|
||||
for the progress bar estimate (only counted when the progress bar is shown, otherwise the previous
|
||||
count is kept). The default location is
|
||||
\fI~/.local/state/simple_backup/last_backup\fR. When running as root with sudo, doas or \-\-user,
|
||||
the file is written to that user\(aqs \fI~/.local/state\fR and owned by them. Useful for scripts
|
||||
that remind you when a backup is overdue.
|
||||
.SH SEE ALSO
|
||||
.BR rsync (1)
|
||||
.SH AUTHORS
|
||||
|
||||
@@ -47,6 +47,22 @@ packages = ["simple_backup"]
|
||||
[tool.setuptools.dynamic]
|
||||
version = { attr = "simple_backup.__version__" }
|
||||
|
||||
[tool.mypy]
|
||||
files = ["simple_backup", "tests"]
|
||||
disallow_untyped_defs = true
|
||||
warn_unused_ignores = true
|
||||
|
||||
# No usable stubs (types-paramiko lags behind paramiko 5)
|
||||
[[tool.mypy.overrides]]
|
||||
module = ["paramiko", "systemd", "dbus"]
|
||||
ignore_missing_imports = true
|
||||
|
||||
[tool.ruff]
|
||||
line-length = 120
|
||||
|
||||
[tool.ruff.lint]
|
||||
select = ["E", "F", "W", "I", "B", "UP"]
|
||||
|
||||
[tool.pytest.ini_options]
|
||||
testpaths = ["tests"]
|
||||
# Import the repo copy, not an installed one
|
||||
|
||||
@@ -1,3 +1,3 @@
|
||||
"""Init."""
|
||||
|
||||
__version__ = '4.3.0'
|
||||
__version__ = '4.7.0'
|
||||
@@ -1,7 +1,7 @@
|
||||
# Example config file for simple_backup
|
||||
|
||||
[backup]
|
||||
# Files and directories to backup. Multiple items can be separated using a comma (','). It is possible to use wildcards (i.e. '*' to match multiple characters and '~' for the user's home directory).
|
||||
# Files and directories to backup. Multiple items can be separated using a comma (','). It is possible to use wildcards (e.g. '*' to match multiple characters) and '~' for the user's home directory.
|
||||
inputs=/home/user
|
||||
|
||||
# Output directory. For remote backups, this is a path on the server ('~' and relative paths refer to the home directory on the server).
|
||||
@@ -13,7 +13,8 @@ exclude=*.bak
|
||||
# Number of old backups (i.e. excluding the one that's being created) to keep (use -1 to keep all)
|
||||
keep=-1
|
||||
|
||||
# Uncomment the following section to enable backup to remote server through ssh
|
||||
# Uncomment the following section to enable backup to remote server through ssh.
|
||||
# ssh_host can be an alias from ~/.ssh/config (its HostName, Port and IdentityFile are used)
|
||||
# [server]
|
||||
# ssh_host=
|
||||
# ssh_user=
|
||||
|
||||
+557
-189
File diff suppressed because it is too large.
Load diff
+27
-3
@@ -1,7 +1,9 @@
|
||||
"""Shared fixtures for the simple_backup tests"""
|
||||
|
||||
import sys
|
||||
from typing import Callable
|
||||
from collections.abc import Callable, Iterator
|
||||
from datetime import datetime, timedelta
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
@@ -9,13 +11,35 @@ from simple_backup import simple_backup as sb
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def no_side_effects(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Keep tests out of the systemd journal and the desktop notifications"""
|
||||
def no_side_effects(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
|
||||
"""Keep tests out of the systemd journal, the desktop notifications and the user's state directory"""
|
||||
|
||||
if hasattr(sb, 'j_handler'):
|
||||
sb.logger.removeHandler(sb.j_handler)
|
||||
|
||||
monkeypatch.setattr(sb, '_notify', lambda text: None)
|
||||
monkeypatch.setenv('XDG_STATE_HOME', str(tmp_path / 'state'))
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def fake_now(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Give each backup a new timestamp, as real runs within the same second would collide"""
|
||||
|
||||
def times() -> Iterator[datetime]:
|
||||
t = datetime(2026, 10, 14, 10, 0, 0)
|
||||
|
||||
while True:
|
||||
yield t
|
||||
t += timedelta(hours=1)
|
||||
|
||||
it = times()
|
||||
|
||||
class FakeDatetime:
|
||||
@staticmethod
|
||||
def now() -> datetime:
|
||||
return next(it)
|
||||
|
||||
monkeypatch.setattr(sb, 'datetime', FakeDatetime)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
|
||||
+97
-13
@@ -2,8 +2,11 @@
|
||||
|
||||
import os
|
||||
import pwd
|
||||
import subprocess
|
||||
import sys
|
||||
from collections.abc import Callable
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable, Optional
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
|
||||
@@ -23,11 +26,14 @@ class FakeBackup:
|
||||
|
||||
instances: list['FakeBackup'] = []
|
||||
check_code = 0
|
||||
run_code = 0
|
||||
destination = '/backups/simple_backup/2026-10-25_10-00-00'
|
||||
|
||||
def __init__(self, inputs: Any, output: Any, exclude: Any, keep: Any, options: str,
|
||||
ssh_host: Optional[str] = None, ssh_user: Optional[str] = None,
|
||||
ssh_keyfile: Optional[str] = None, remote_sudo: bool = False,
|
||||
remove_before: bool = False, verbose: bool = False) -> None:
|
||||
ssh_host: str | None = None, ssh_user: str | None = None,
|
||||
ssh_keyfile: str | None = None, remote_sudo: bool = False,
|
||||
remove_before: bool = False, verbose: bool = False, progress: bool = False,
|
||||
file_estimate: int = 0) -> None:
|
||||
self.inputs = inputs
|
||||
self.output = output
|
||||
self.exclude = exclude
|
||||
@@ -39,7 +45,10 @@ class FakeBackup:
|
||||
self.remote_sudo = remote_sudo
|
||||
self.remove_before = remove_before
|
||||
self.verbose = verbose
|
||||
self.homedir: Optional[str] = None
|
||||
self.progress = progress
|
||||
self.file_estimate = file_estimate
|
||||
self.file_count: int | None = None
|
||||
self.homedir: str | None = None
|
||||
self.ran = False
|
||||
self.closed = False
|
||||
FakeBackup.instances.append(self)
|
||||
@@ -52,7 +61,7 @@ class FakeBackup:
|
||||
def run(self) -> int:
|
||||
self.ran = True
|
||||
|
||||
return 0
|
||||
return FakeBackup.run_code
|
||||
|
||||
def close(self) -> None:
|
||||
self.closed = True
|
||||
@@ -62,6 +71,7 @@ class FakeBackup:
|
||||
def fake_backup(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
FakeBackup.instances = []
|
||||
FakeBackup.check_code = 0
|
||||
FakeBackup.run_code = 0
|
||||
monkeypatch.setattr(sb, 'Backup', FakeBackup)
|
||||
|
||||
|
||||
@@ -79,19 +89,21 @@ def as_root(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Run as root, with no sudo/doas variables set"""
|
||||
|
||||
monkeypatch.setattr(os, 'geteuid', lambda: 0)
|
||||
# Writing the state file as root would call seteuid() (covered in test_state.py)
|
||||
monkeypatch.setattr(sb, '_write_state', lambda user, destination, file_count=None: None)
|
||||
|
||||
for var in ['SUDO_USER', 'SUDO_UID', 'DOAS_USER']:
|
||||
monkeypatch.delenv(var, raising=False)
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def config_calls(monkeypatch: pytest.MonkeyPatch) -> list[tuple[str, Optional[str]]]:
|
||||
def config_calls(monkeypatch: pytest.MonkeyPatch) -> list[tuple[str, str | None]]:
|
||||
"""Record the config file path and user instead of reading the file"""
|
||||
|
||||
calls: list[tuple[str, Optional[str]]] = []
|
||||
calls: list[tuple[str, str | None]] = []
|
||||
read_config = sb._read_config
|
||||
|
||||
def record(config_file: str, user: Optional[str] = None) -> dict[str, Any]:
|
||||
def record(config_file: str, user: str | None = None) -> sb.ConfigArgs:
|
||||
calls.append((config_file, user))
|
||||
|
||||
return read_config('/nonexistent/simple_backup.conf', user)
|
||||
@@ -168,6 +180,15 @@ ssh_keyfile=/keys/id
|
||||
assert b.keep == 0
|
||||
assert (b.ssh_host, b.ssh_user, b.ssh_keyfile) == ('cli-host', 'cli-user', '/cli/key')
|
||||
|
||||
def test_inputs_and_output_only_from_cli(self, run_cli: RunCli, tmp_path: Path) -> None:
|
||||
config_file = tmp_path / 'simple_backup.conf'
|
||||
config_file.write_text('[backup]\nkeep=3\n')
|
||||
|
||||
assert run_cli('-c', str(config_file), '-i', '/cli/in', '-o', '/cli/out') == 0
|
||||
|
||||
b = last_backup()
|
||||
assert (b.inputs, b.output, b.keep) == (['/cli/in'], '/cli/out', 3)
|
||||
|
||||
def test_ssh_host_and_user_from_cli_and_config(self, run_cli: RunCli, config: Callable[[str], str]) -> None:
|
||||
config_file = config('backup_dir=/backups\n[server]\nssh_user=user')
|
||||
|
||||
@@ -189,6 +210,18 @@ ssh_keyfile=/keys/id
|
||||
assert FakeBackup.instances == []
|
||||
assert 'Both SSH host and SSH user are needed' in caplog.text
|
||||
|
||||
@pytest.mark.parametrize('config_keep, argv', [
|
||||
('keep=-2', []),
|
||||
('', ['-k', '-2']),
|
||||
])
|
||||
def test_keep_below_minus_one(self, run_cli: RunCli, config: Callable[[str], str],
|
||||
caplog: pytest.LogCaptureFixture, config_keep: str, argv: list[str]) -> None:
|
||||
config_file = config(f'backup_dir=/backups\n{config_keep}')
|
||||
|
||||
assert run_cli('-c', config_file, *argv) == 6
|
||||
assert FakeBackup.instances == []
|
||||
assert 'Invalid number of backups to keep: -2' in caplog.text
|
||||
|
||||
def test_bad_config(self, run_cli: RunCli, config: Callable[[str], str],
|
||||
caplog: pytest.LogCaptureFixture) -> None:
|
||||
config_file = config('backup_dir=/backups\nkeep=abc')
|
||||
@@ -224,6 +257,29 @@ ssh_keyfile=/keys/id
|
||||
b = last_backup()
|
||||
assert b.remote_sudo and b.remove_before and b.verbose
|
||||
|
||||
@pytest.mark.parametrize('tty, argv, progress', [
|
||||
(True, [], True),
|
||||
(True, ['--no-progress'], False),
|
||||
(False, [], False),
|
||||
])
|
||||
def test_progress(self, run_cli: RunCli, config: Callable[[str], str], monkeypatch: pytest.MonkeyPatch,
|
||||
tty: bool, argv: list[str], progress: bool) -> None:
|
||||
monkeypatch.setattr(sb.sys.stderr, 'isatty', lambda: tty)
|
||||
|
||||
assert run_cli('-c', config('backup_dir=/backups'), *argv) == 0
|
||||
assert last_backup().progress is progress
|
||||
|
||||
@pytest.mark.parametrize('tty, estimate', [(True, 1234), (False, 0)])
|
||||
def test_file_estimate(self, run_cli: RunCli, config: Callable[[str], str], monkeypatch: pytest.MonkeyPatch,
|
||||
tmp_path: Path, tty: bool, estimate: int) -> None:
|
||||
monkeypatch.setattr(sb.sys.stderr, 'isatty', lambda: tty)
|
||||
state = tmp_path / 'state' / 'simple_backup' / 'last_backup'
|
||||
state.parent.mkdir(parents=True)
|
||||
state.write_text('2026-10-25T10:00:00+02:00\n/backups/old\n1234\n')
|
||||
|
||||
assert run_cli('-c', config('backup_dir=/backups')) == 0
|
||||
assert last_backup().file_estimate == estimate
|
||||
|
||||
def test_check_params_failure(self, run_cli: RunCli, config: Callable[[str], str]) -> None:
|
||||
FakeBackup.check_code = 2
|
||||
|
||||
@@ -233,23 +289,37 @@ ssh_keyfile=/keys/id
|
||||
assert not b.ran
|
||||
assert b.closed
|
||||
|
||||
@pytest.mark.parametrize('check_code, run_code, saved', [(0, 0, True), (2, 0, False), (0, 4, False)])
|
||||
def test_state_saved_only_on_success(self, run_cli: RunCli, config: Callable[[str], str], tmp_path: Path,
|
||||
check_code: int, run_code: int, saved: bool) -> None:
|
||||
FakeBackup.check_code = check_code
|
||||
FakeBackup.run_code = run_code
|
||||
|
||||
assert run_cli('-c', config('backup_dir=/backups')) == (check_code or run_code)
|
||||
|
||||
state = tmp_path / 'state' / 'simple_backup' / 'last_backup'
|
||||
assert state.exists() is saved
|
||||
|
||||
if saved:
|
||||
assert state.read_text().splitlines()[1] == FakeBackup.destination
|
||||
|
||||
|
||||
class TestUser:
|
||||
@pytest.mark.usefixtures('as_user')
|
||||
def test_current_user(self, run_cli: RunCli, config_calls: list[tuple[str, Optional[str]]]) -> None:
|
||||
def test_current_user(self, run_cli: RunCli, config_calls: list[tuple[str, str | None]]) -> None:
|
||||
assert run_cli() == 0
|
||||
assert config_calls == [(f'{HOME}/.config/simple_backup/simple_backup.conf', USER)]
|
||||
assert last_backup().homedir == HOME
|
||||
|
||||
@pytest.mark.usefixtures('as_root')
|
||||
def test_explicit_user(self, run_cli: RunCli, config_calls: list[tuple[str, Optional[str]]]) -> None:
|
||||
def test_explicit_user(self, run_cli: RunCli, config_calls: list[tuple[str, str | None]]) -> None:
|
||||
assert run_cli('-u', USER, '-c', '~/other.conf') == 0
|
||||
assert config_calls == [(f'{HOME}/other.conf', USER)]
|
||||
assert last_backup().homedir == HOME
|
||||
|
||||
@pytest.mark.usefixtures('as_root')
|
||||
@pytest.mark.parametrize('var', ['SUDO_USER', 'DOAS_USER'])
|
||||
def test_sudo_or_doas_user(self, run_cli: RunCli, config_calls: list[tuple[str, Optional[str]]],
|
||||
def test_sudo_or_doas_user(self, run_cli: RunCli, config_calls: list[tuple[str, str | None]],
|
||||
monkeypatch: pytest.MonkeyPatch, var: str) -> None:
|
||||
monkeypatch.setenv(var, USER)
|
||||
|
||||
@@ -258,7 +328,7 @@ class TestUser:
|
||||
assert last_backup().homedir == HOME
|
||||
|
||||
@pytest.mark.usefixtures('as_root')
|
||||
def test_root_without_user(self, run_cli: RunCli, config_calls: list[tuple[str, Optional[str]]],
|
||||
def test_root_without_user(self, run_cli: RunCli, config_calls: list[tuple[str, str | None]],
|
||||
caplog: pytest.LogCaptureFixture) -> None:
|
||||
assert run_cli() == 0
|
||||
# '~' is left to expanduser, i.e. $HOME
|
||||
@@ -290,6 +360,20 @@ class TestDetectUser:
|
||||
assert sb._detect_user() == USER
|
||||
|
||||
|
||||
def test_run_as_script(tmp_path: Path) -> None:
|
||||
"""Running the module directly passes simple_backup()'s return code to the shell"""
|
||||
|
||||
repo = Path(sb.__file__).resolve().parents[1]
|
||||
env = {**os.environ, 'PYTHONPATH': str(repo), 'HOME': str(tmp_path)}
|
||||
|
||||
# No config file and no inputs: check_params() returns 1
|
||||
result = subprocess.run([sys.executable, '-m', 'simple_backup.simple_backup', '--no-syslog',
|
||||
'-c', str(tmp_path / 'missing.conf')], env=env, cwd=tmp_path,
|
||||
capture_output=True, check=False)
|
||||
|
||||
assert result.returncode == 1
|
||||
|
||||
|
||||
class TestTargetUid:
|
||||
@pytest.mark.usefixtures('as_user')
|
||||
def test_non_root(self) -> None:
|
||||
|
||||
+19
-5
@@ -45,6 +45,13 @@ def test_expand_inputs_glob(tmp_path: Path) -> None:
|
||||
assert sorted(result) == [f'{tmp_path}/a.txt', f'{tmp_path}/b.txt']
|
||||
|
||||
|
||||
def test_expand_inputs_glob_characters_in_name(tmp_path: Path) -> None:
|
||||
(tmp_path / 'Photos [2020]').mkdir()
|
||||
(tmp_path / 'Photos 2').mkdir()
|
||||
|
||||
assert sb._expand_inputs([f'{tmp_path}/Photos [2020]'], USER) == [f'{tmp_path}/Photos [2020]']
|
||||
|
||||
|
||||
def test_expand_inputs_no_match(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
|
||||
assert sb._expand_inputs([f'{tmp_path}/missing'], USER) == []
|
||||
assert 'No file or directory matching input' in caplog.text
|
||||
@@ -85,6 +92,7 @@ keep=3
|
||||
|
||||
config_args = sb._read_config(config_file, USER)
|
||||
|
||||
assert config_args['inputs'] is not None
|
||||
assert sorted(config_args['inputs']) == [f'{tmp_path}/one', f'{tmp_path}/two']
|
||||
# Expanded later, as it may be a path on the server
|
||||
assert config_args['output'] == '~/backups'
|
||||
@@ -176,9 +184,9 @@ numeric_ids=
|
||||
|
||||
config_args = sb._read_config(config_file, USER)
|
||||
|
||||
for key in ['ssh_host', 'ssh_user', 'ssh_keyfile']:
|
||||
assert config_args[key] is None
|
||||
|
||||
assert config_args['ssh_host'] is None
|
||||
assert config_args['ssh_user'] is None
|
||||
assert config_args['ssh_keyfile'] is None
|
||||
assert config_args['remote_sudo'] is False
|
||||
assert config_args['numeric_ids'] is False
|
||||
|
||||
@@ -216,9 +224,15 @@ backup_dir=/backups
|
||||
sb._read_config(config_file, USER)
|
||||
|
||||
|
||||
def test_inputs_and_backup_dir_optional(tmp_path: Path) -> None:
|
||||
config_args = sb._read_config(write_config(tmp_path, '[backup]\nkeep=2\n'), USER)
|
||||
|
||||
assert config_args['inputs'] is None
|
||||
assert config_args['output'] is None
|
||||
assert config_args['keep'] == 2
|
||||
|
||||
|
||||
@pytest.mark.parametrize('text', [
|
||||
'[backup]\nbackup_dir=/backups\n',
|
||||
'[backup]\ninputs=/tmp\n',
|
||||
'[other]\ninputs=/tmp\n',
|
||||
'inputs=/tmp\n',
|
||||
])
|
||||
|
||||
+266
-30
@@ -1,9 +1,12 @@
|
||||
"""Tests for local backups, with real rsync runs and with a fake Popen"""
|
||||
|
||||
import errno
|
||||
import io
|
||||
import os
|
||||
from datetime import datetime, timedelta
|
||||
from collections.abc import Callable
|
||||
from pathlib import Path
|
||||
from typing import Any, Callable, Iterator, Optional
|
||||
from shutil import which
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
|
||||
@@ -12,25 +15,7 @@ from simple_backup import simple_backup as sb
|
||||
OPTIONS = '-r -v --ignore-missing-args --mkpath -a -h -H -X -s'
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def fake_now(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Give each backup a new timestamp, as real runs within the same second would collide"""
|
||||
|
||||
def times() -> Iterator[datetime]:
|
||||
t = datetime(2026, 10, 14, 10, 0, 0)
|
||||
|
||||
while True:
|
||||
yield t
|
||||
t += timedelta(hours=1)
|
||||
|
||||
it = times()
|
||||
|
||||
class FakeDatetime:
|
||||
@staticmethod
|
||||
def now() -> datetime:
|
||||
return next(it)
|
||||
|
||||
monkeypatch.setattr(sb, 'datetime', FakeDatetime)
|
||||
pytestmark = pytest.mark.usefixtures('fake_now')
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
@@ -51,9 +36,10 @@ def out(tmp_path: Path) -> Path:
|
||||
return out
|
||||
|
||||
|
||||
def make_backup(out: Path, inputs: list[str], keep: int = -1, exclude: Optional[list[str]] = None,
|
||||
remove_before: bool = False) -> sb.Backup:
|
||||
backup = sb.Backup(inputs, str(out), exclude or [], keep, OPTIONS, remove_before=remove_before)
|
||||
def make_backup(out: Path, inputs: list[str], keep: int = -1, exclude: list[str] | None = None,
|
||||
remove_before: bool = False, progress: bool = False, verbose: bool = False) -> sb.Backup:
|
||||
backup = sb.Backup(inputs, str(out), exclude or [], keep, OPTIONS, remove_before=remove_before,
|
||||
progress=progress, verbose=verbose)
|
||||
|
||||
assert backup.check_params() == 0
|
||||
|
||||
@@ -79,14 +65,14 @@ class TestCheckParams:
|
||||
assert sb.Backup([], str(out), [], -1, OPTIONS).check_params() == 1
|
||||
|
||||
def test_no_output(self) -> None:
|
||||
assert sb.Backup(['/x'], None, [], -1, OPTIONS).check_params() == 2 # type: ignore[arg-type]
|
||||
assert sb.Backup(['/x'], None, [], -1, OPTIONS).check_params() == 2
|
||||
|
||||
def test_missing_output(self, tmp_path: Path) -> None:
|
||||
assert sb.Backup(['/x'], str(tmp_path / 'missing'), [], -1, OPTIONS).check_params() == 2
|
||||
|
||||
def test_relative_output(self, out: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.chdir(out.parent)
|
||||
backup = sb.Backup(['/x'], out.name, [], None, OPTIONS) # type: ignore[arg-type]
|
||||
backup = sb.Backup(['/x'], out.name, [], None, OPTIONS)
|
||||
|
||||
assert backup.check_params() == 0
|
||||
assert backup.output == str(out)
|
||||
@@ -102,6 +88,18 @@ class TestRsync:
|
||||
assert 'Backup completed' in caplog.text
|
||||
assert 'rsync: sent' in caplog.text
|
||||
|
||||
def test_elapsed_time(self, src: Path, out: Path, monkeypatch: pytest.MonkeyPatch,
|
||||
caplog: pytest.LogCaptureFixture) -> None:
|
||||
notifications: list[str] = []
|
||||
monkeypatch.setattr(sb, '_notify', notifications.append)
|
||||
# Start, then the notification and the log line
|
||||
monkeypatch.setattr(sb, 'default_timer', iter([0.0, 863.187, 863.2]).__next__)
|
||||
|
||||
assert run_backup(out, [str(src)]) == 0
|
||||
|
||||
assert notifications[-1] == 'Backup completed in 14:23'
|
||||
assert 'Elapsed time: 14:23' in caplog.text
|
||||
|
||||
def test_hard_links(self, src: Path, out: Path) -> None:
|
||||
assert run_backup(out, [str(src)]) == 0
|
||||
(src / 'changed.txt').write_text('second')
|
||||
@@ -140,6 +138,15 @@ class TestRsync:
|
||||
|
||||
assert backups(out) == remaining
|
||||
|
||||
def test_removal_logged(self, src: Path, out: Path, caplog: pytest.LogCaptureFixture) -> None:
|
||||
for _ in range(3):
|
||||
assert run_backup(out, [str(src)]) == 0
|
||||
|
||||
assert run_backup(out, [str(src)], keep=0) == 0
|
||||
assert 'Removing backup 2026-10-14_10-00-00 (1/3)...' in caplog.text
|
||||
assert 'Removing backup 2026-10-14_12-00-00 (3/3)...' in caplog.text
|
||||
assert 'Removed 3 backups' in caplog.text
|
||||
|
||||
def test_remove_before(self, src: Path, out: Path) -> None:
|
||||
assert run_backup(out, [str(src)]) == 0
|
||||
assert run_backup(out, [str(src)], keep=0, remove_before=True) == 0
|
||||
@@ -149,6 +156,19 @@ class TestRsync:
|
||||
# Nothing to link against, as the old backup was removed first
|
||||
assert copied(out, backup, src / 'same.txt').stat().st_nlink == 1
|
||||
|
||||
def test_removal_os_error(self, src: Path, out: Path, monkeypatch: pytest.MonkeyPatch,
|
||||
caplog: pytest.LogCaptureFixture) -> None:
|
||||
assert run_backup(out, [str(src)]) == 0
|
||||
|
||||
def busy(path: str) -> None:
|
||||
raise OSError(errno.EBUSY, os.strerror(errno.EBUSY), path)
|
||||
|
||||
monkeypatch.setattr(sb, 'rmtree', busy)
|
||||
|
||||
assert run_backup(out, [str(src)], keep=0) == 0
|
||||
assert backups(out) == ['2026-10-14_10-00-00', '2026-10-14_11-00-00']
|
||||
assert 'Error while removing backup 2026-10-14_10-00-00. Device or resource busy' in caplog.text
|
||||
|
||||
def test_stray_files_and_symlinks(self, src: Path, out: Path) -> None:
|
||||
assert run_backup(out, [str(src)]) == 0
|
||||
|
||||
@@ -177,13 +197,192 @@ class TestRsync:
|
||||
assert run_backup(out, [str(src)], keep=0) == 0
|
||||
assert backups(out) == ['2026-10-14_12-00-00']
|
||||
|
||||
def test_progress(self, src: Path, out: Path, caplog: pytest.LogCaptureFixture,
|
||||
capsys: pytest.CaptureFixture[str]) -> None:
|
||||
assert run_backup(out, [str(src)], progress=True) == 0
|
||||
|
||||
assert '100%' in capsys.readouterr().err
|
||||
# Only the summary is logged, not the progress updates
|
||||
assert 'rsync: sent' in caplog.text
|
||||
assert 'rsync: total size' in caplog.text
|
||||
assert '%' not in caplog.text
|
||||
|
||||
def test_file_count(self, src: Path, out: Path) -> None:
|
||||
backup = make_backup(out, [str(src)], progress=True)
|
||||
|
||||
assert backup.run() == 0
|
||||
# The source folder, its two files and the implied parent folders
|
||||
assert backup.file_count is not None and backup.file_count >= 3
|
||||
|
||||
def test_no_file_count_without_progress(self, src: Path, out: Path) -> None:
|
||||
backup = make_backup(out, [str(src)])
|
||||
|
||||
assert backup.run() == 0
|
||||
assert backup.file_count is None
|
||||
|
||||
def test_cli(self, src: Path, out: Path, tmp_path: Path, run_cli: Callable[..., int]) -> None:
|
||||
config_file = str(tmp_path / 'missing.conf')
|
||||
|
||||
for _ in range(2):
|
||||
assert run_cli('-c', config_file, '-i', str(src), '-o', str(out), '-k', '0') == 0
|
||||
|
||||
assert backups(out) == ['2026-10-14_11-00-00']
|
||||
# The fake clock also advances when the state file is written
|
||||
assert backups(out) == ['2026-10-14_12-00-00']
|
||||
state = (tmp_path / 'state' / 'simple_backup' / 'last_backup').read_text().splitlines()
|
||||
assert state[0].startswith('2026-10-14T13:00:00')
|
||||
assert state[1] == f'{out}/simple_backup/2026-10-14_12-00-00'
|
||||
|
||||
|
||||
class ChunkStream(io.BufferedIOBase):
|
||||
"""Returns the given chunks one per read1() call, like a pipe"""
|
||||
|
||||
def __init__(self, chunks: list[bytes]) -> None:
|
||||
self.chunks = chunks
|
||||
|
||||
def read1(self, size: int = -1) -> bytes:
|
||||
return self.chunks.pop(0) if self.chunks else b''
|
||||
|
||||
|
||||
class TestReadRecords:
|
||||
def test_split_on_newline_and_cr(self) -> None:
|
||||
stream = ChunkStream([b'file\n\r 1.00M 50%\r 2.00M 100%\n\nsent 1 bytes\ntotal'])
|
||||
|
||||
assert list(sb._read_records(stream)) == ['file', '', ' 1.00M 50%', ' 2.00M 100%', '', 'sent 1 bytes',
|
||||
'total']
|
||||
|
||||
def test_records_across_chunks(self) -> None:
|
||||
stream = ChunkStream([b'fi', b'le\r', b'\nna', 'mé\n'.encode(), b'\xff\n'])
|
||||
|
||||
assert list(sb._read_records(stream)) == ['file', '', 'namé', '�']
|
||||
|
||||
|
||||
@pytest.mark.parametrize(('seconds', 'text'), [
|
||||
(0.4, '00:00'), (59.6, '01:00'), (863.187, '14:23'), (3599.4, '59:59'), (3600, '1:00:00'), (37230, '10:20:30'),
|
||||
])
|
||||
def test_format_duration(seconds: float, text: str) -> None:
|
||||
assert sb._format_duration(seconds) == text
|
||||
|
||||
|
||||
@pytest.mark.parametrize(('size', 'size_bytes'), [
|
||||
('30,000,000B', 30_000_000), ('4,000,000', 4_000_000), ('30.0MB', 30_000_000), ('30,0MB', 30_000_000),
|
||||
('2.00M', 2_000_000), ('1.5GB', 1_500_000_000), ('28.6MiB', 29_989_273), ('512B', 512), ('?', None),
|
||||
('1.2.3MB', None),
|
||||
])
|
||||
def test_parse_size(size: str, size_bytes: int | None) -> None:
|
||||
assert sb._parse_size(size) == size_bytes
|
||||
|
||||
|
||||
@pytest.mark.parametrize(('speed', 'text'), [
|
||||
(0, '0B/s'), (999, '999B/s'), (1500, '1.5KB/s'), (10_500_000, '10.5MB/s'), (2e9, '2.0GB/s'), (3e12, '3.0TB/s'),
|
||||
])
|
||||
def test_format_speed(speed: float, text: str) -> None:
|
||||
assert sb._format_speed(speed) == text
|
||||
|
||||
|
||||
class TestProgressBar:
|
||||
@pytest.fixture(autouse=True)
|
||||
def terminal(self, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(sb, 'get_terminal_size', lambda: os.terminal_size((100, 24)))
|
||||
# 30 s elapsed at each update
|
||||
monkeypatch.setattr(sb, 'default_timer', iter([0.0, 30.0]).__next__)
|
||||
|
||||
def test_scanning(self, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
bar = sb._ProgressBar()
|
||||
|
||||
assert bar.update(' 2.00M 25% 1.47MB/s 0:00:02 (xfr#1, ir-chk=1009/2632)')
|
||||
assert capsys.readouterr().err == '\r1,623 files checked 2.00M copied 66.7KB/s (scanning)\033[K'
|
||||
|
||||
def test_update(self, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
bar = sb._ProgressBar()
|
||||
|
||||
# With --link-dest rsync's percentage leaves out linked files, so the files are counted instead
|
||||
assert bar.update(' 4,000,000 1% 2.97MB/s 0:00:01 (xfr#2, to-chk=1/4)')
|
||||
assert capsys.readouterr().err == \
|
||||
'\r[######################--------] 75% 3/4 files 4,000,000 copied 133.3KB/s ETA 0:00:10\033[K'
|
||||
|
||||
def test_keeps_counts_within_file(self, monkeypatch: pytest.MonkeyPatch,
|
||||
capsys: pytest.CaptureFixture[str]) -> None:
|
||||
monkeypatch.setattr(sb, 'default_timer', iter([0.0, 30.0, 30.0]).__next__)
|
||||
bar = sb._ProgressBar()
|
||||
|
||||
assert bar.update(' 2.00M 1% 1.47MB/s 0:00:02 (xfr#1, to-chk=2/4)')
|
||||
assert bar.update(' 3.00M 2% 1.47MB/s 0:00:03')
|
||||
assert capsys.readouterr().err.endswith('] 50% 2/4 files 3.00M copied 100.0KB/s ETA 0:00:30\033[K')
|
||||
|
||||
def test_eta_follows_recent_pace(self, monkeypatch: pytest.MonkeyPatch,
|
||||
capsys: pytest.CaptureFixture[str]) -> None:
|
||||
monkeypatch.setattr(sb, 'default_timer', iter([0.0, 100.0, 130.0]).__next__)
|
||||
bar = sb._ProgressBar()
|
||||
|
||||
# Fast while linking unchanged files, then one file in the last 30 s
|
||||
assert bar.update(' 10.00M 1% 1.47MB/s 0:00:02 (xfr#1, to-chk=100/1000)')
|
||||
assert capsys.readouterr().err.endswith(' 100.0KB/s ETA 0:00:11\033[K')
|
||||
assert bar.update(' 70.00M 7% 1.47MB/s 0:00:02 (xfr#2, to-chk=99/1000)')
|
||||
assert capsys.readouterr().err.endswith(' 2.0MB/s ETA 0:49:30\033[K')
|
||||
|
||||
def test_eta_unknown_within_big_file(self, monkeypatch: pytest.MonkeyPatch,
|
||||
capsys: pytest.CaptureFixture[str]) -> None:
|
||||
monkeypatch.setattr(sb, 'default_timer', iter([0.0, 10.0, 50.0]).__next__)
|
||||
bar = sb._ProgressBar()
|
||||
|
||||
assert bar.update(' 10.00M 1% 1.47MB/s 0:00:02 (xfr#1, to-chk=10/20)')
|
||||
# No file finished in the last 30 s
|
||||
assert bar.update(' 50.00M 5% 1.47MB/s 0:00:02')
|
||||
assert capsys.readouterr().err.endswith(' 50.00M copied 1.0MB/s ETA --:--:--\033[K')
|
||||
|
||||
def test_estimate_while_scanning(self, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
bar = sb._ProgressBar(estimate=4000)
|
||||
|
||||
assert bar.update(' 2.00M 25% 1.47MB/s 0:00:02 (xfr#1, ir-chk=1000/2000)')
|
||||
assert bar.total is None
|
||||
assert capsys.readouterr().err == \
|
||||
'\r[#######-----------------------] ~25% 1,000/~4,000 files 2.00M copied 66.7KB/s ETA ~0:01:30\033[K'
|
||||
|
||||
def test_estimate_exceeded(self, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
bar = sb._ProgressBar(estimate=1000)
|
||||
|
||||
# More files than in the last backup: estimate from the files found so far
|
||||
assert bar.update(' 2.00M 25% 1.47MB/s 0:00:02 (xfr#1, ir-chk=500/2000)')
|
||||
assert capsys.readouterr().err == \
|
||||
'\r[######################--------] ~75% 1,500/~2,000 files 2.00M copied 66.7KB/s ETA ~0:00:10\033[K'
|
||||
|
||||
def test_estimate_capped_while_scanning(self, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
bar = sb._ProgressBar(estimate=1000)
|
||||
|
||||
# All files found so far are checked, but rsync may still find more
|
||||
assert bar.update(' 2.00M 25% 1.47MB/s 0:00:02 (xfr#1, ir-chk=0/2000)')
|
||||
assert bar.total is None
|
||||
assert ' ~99% 2,000/~2,000 files 2.00M copied 66.7KB/s ETA ~0:00:00\033[K' in capsys.readouterr().err
|
||||
|
||||
def test_no_estimate_without_last_count(self, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
bar = sb._ProgressBar()
|
||||
|
||||
# The files found so far are only a guess at the total near the end of the scan
|
||||
assert bar.update(' 2.00M 25% 1.47MB/s 0:00:02 (xfr#1, ir-chk=0/2000)')
|
||||
assert capsys.readouterr().err == '\r2,000 files checked 2.00M copied 66.7KB/s (scanning)\033[K'
|
||||
|
||||
def test_real_total_replaces_estimate(self, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
bar = sb._ProgressBar(estimate=4000)
|
||||
|
||||
assert bar.update(' 4,000,000 1% 2.97MB/s 0:00:01 (xfr#2, to-chk=1/4)')
|
||||
assert bar.total == 4
|
||||
assert ' 75% 3/4 files' in capsys.readouterr().err
|
||||
|
||||
def test_not_progress(self, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
bar = sb._ProgressBar()
|
||||
|
||||
for record in ['home/user/file 50% 1:00:00', 'sent 1 bytes received 2 bytes', 'total size is 3']:
|
||||
assert not bar.update(record)
|
||||
|
||||
bar.clear()
|
||||
assert capsys.readouterr().err == ''
|
||||
|
||||
def test_narrow_terminal(self, monkeypatch: pytest.MonkeyPatch, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
monkeypatch.setattr(sb, 'get_terminal_size', lambda: os.terminal_size((20, 24)))
|
||||
|
||||
assert sb._ProgressBar().update(' 6.00M 100% 1.48MB/s 0:00:03 (xfr#3, to-chk=0/4)')
|
||||
# No room for the bar
|
||||
assert capsys.readouterr().err == '\r100% 4/4 files 6.\033[K'
|
||||
|
||||
|
||||
class FakePopen:
|
||||
@@ -191,10 +390,13 @@ class FakePopen:
|
||||
|
||||
returncode = 0
|
||||
calls: list[list[str]] = []
|
||||
output = b'sending incremental file list\nsent 1 bytes received 2 bytes\ntotal size is 3\n'
|
||||
|
||||
def __init__(self, args: list[str], **kwargs: Any) -> None:
|
||||
FakePopen.calls.append(args)
|
||||
os.makedirs(args[args.index('/') + 1])
|
||||
self.stdin = io.BytesIO()
|
||||
self.stdout = io.BytesIO(FakePopen.output)
|
||||
|
||||
def __enter__(self) -> 'FakePopen':
|
||||
return self
|
||||
@@ -202,8 +404,8 @@ class FakePopen:
|
||||
def __exit__(self, *args: Any) -> None:
|
||||
pass
|
||||
|
||||
def communicate(self) -> tuple[bytes, None]:
|
||||
return b'sending incremental file list\nsent 1 bytes received 2 bytes\ntotal size is 3\n', None
|
||||
def wait(self) -> int:
|
||||
return FakePopen.returncode
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
@@ -230,10 +432,44 @@ class TestReturnCodes:
|
||||
assert run_backup(out, [str(src)]) == 0
|
||||
|
||||
(args,) = fake_popen.calls
|
||||
assert args[0] == '/usr/bin/rsync'
|
||||
assert args[0] == which('rsync')
|
||||
assert f'--link-dest={out}/simple_backup/{old_backups[-1]}' in args
|
||||
assert args[args.index('/') + 1] == f'{out}/simple_backup/2026-10-14_10-00-00'
|
||||
|
||||
@pytest.mark.parametrize('lines, logged', [
|
||||
([f'file{n}' for n in range(5)] + ['sent 1 bytes', 'total size is 3'], ['sent 1 bytes', 'total size is 3']),
|
||||
([], []),
|
||||
(['total size is 3'], ['total size is 3']),
|
||||
])
|
||||
def test_summary_logged(self, src: Path, out: Path, fake_popen: type[FakePopen], monkeypatch: pytest.MonkeyPatch,
|
||||
caplog: pytest.LogCaptureFixture, lines: list[str], logged: list[str]) -> None:
|
||||
monkeypatch.setattr(fake_popen, 'output', ''.join(f'{line}\n' for line in lines).encode())
|
||||
|
||||
assert run_backup(out, [str(src)]) == 0
|
||||
assert [m[7:] for m in caplog.messages if m.startswith('rsync: ')] == logged
|
||||
|
||||
@pytest.mark.parametrize('returncode, level', [(0, 'INFO'), (23, 'WARNING'), (1, 'ERROR')])
|
||||
def test_verbose_one_line_per_message(self, src: Path, out: Path, fake_popen: type[FakePopen],
|
||||
caplog: pytest.LogCaptureFixture, returncode: int, level: str) -> None:
|
||||
fake_popen.returncode = returncode
|
||||
|
||||
run_backup(out, [str(src)], verbose=True)
|
||||
|
||||
rsync = [(r.levelname, r.getMessage()) for r in caplog.records if r.getMessage().startswith('rsync: ')]
|
||||
lines = ['sending incremental file list', 'sent 1 bytes received 2 bytes', 'total size is 3']
|
||||
assert rsync == [(level, f'rsync: {line}') for line in lines]
|
||||
|
||||
def test_rsync_missing(self, src: Path, out: Path, tmp_path: Path, fake_popen: type[FakePopen],
|
||||
old_backups: list[str], monkeypatch: pytest.MonkeyPatch,
|
||||
caplog: pytest.LogCaptureFixture) -> None:
|
||||
monkeypatch.setenv('PATH', str(tmp_path / 'empty'))
|
||||
|
||||
assert run_backup(out, [str(src)], keep=0, remove_before=True) == 4
|
||||
assert fake_popen.calls == []
|
||||
# Nothing was removed
|
||||
assert backups(out) == old_backups
|
||||
assert 'rsync not found' in caplog.text
|
||||
|
||||
@pytest.mark.parametrize('returncode, result, removed', [
|
||||
(0, 0, True),
|
||||
(24, 0, True),
|
||||
|
||||
+163
-19
@@ -10,7 +10,7 @@ import warnings
|
||||
from getpass import GetPassWarning
|
||||
from pathlib import Path
|
||||
from shutil import which
|
||||
from typing import Any, Optional
|
||||
from typing import Any
|
||||
|
||||
import pytest
|
||||
|
||||
@@ -30,7 +30,7 @@ class FakeSSH:
|
||||
self.home = home
|
||||
self.bin_dir = bin_dir
|
||||
self.commands: list[str] = []
|
||||
self.fail_on: Optional[str] = None
|
||||
self.fail_on: str | None = None
|
||||
self.closed = False
|
||||
|
||||
def exec_command(self, command: str) -> tuple[None, io.BytesIO, io.BytesIO]:
|
||||
@@ -186,7 +186,7 @@ class TestRemoveOldBackups:
|
||||
assert [c for c in ssh.commands if 'rm -r' in c][0].startswith('sudo rm -r ')
|
||||
|
||||
@pytest.mark.parametrize('names', [[], None])
|
||||
def test_nothing_to_remove(self, remote_home: Path, names: Optional[list[str]]) -> None:
|
||||
def test_nothing_to_remove(self, remote_home: Path, names: list[str] | None) -> None:
|
||||
if names is not None:
|
||||
make_backups(remote_home, *names)
|
||||
|
||||
@@ -254,9 +254,13 @@ class RecordPopen:
|
||||
|
||||
returncode = 0
|
||||
calls: list[list[str]] = []
|
||||
envs: list[dict[str, str] | None] = []
|
||||
|
||||
def __init__(self, args: list[str], **kwargs: Any) -> None:
|
||||
RecordPopen.calls.append(args)
|
||||
RecordPopen.envs.append(kwargs.get('env'))
|
||||
self.stdin = io.BytesIO()
|
||||
self.stdout = io.BytesIO(b'sent 1 bytes received 2 bytes\ntotal size is 3\n')
|
||||
|
||||
def __enter__(self) -> 'RecordPopen':
|
||||
return self
|
||||
@@ -264,8 +268,8 @@ class RecordPopen:
|
||||
def __exit__(self, *args: Any) -> None:
|
||||
pass
|
||||
|
||||
def communicate(self) -> tuple[bytes, None]:
|
||||
return b'sent 1 bytes received 2 bytes\ntotal size is 3\n', None
|
||||
def wait(self) -> int:
|
||||
return RecordPopen.returncode
|
||||
|
||||
|
||||
@pytest.mark.usefixtures('connect')
|
||||
@@ -274,6 +278,7 @@ class TestRsyncArgs:
|
||||
def record_popen(self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
|
||||
RecordPopen.returncode = 0
|
||||
RecordPopen.calls = []
|
||||
RecordPopen.envs = []
|
||||
monkeypatch.setattr(sb, 'Popen', RecordPopen)
|
||||
# The input must exist locally
|
||||
(tmp_path / 'input').mkdir()
|
||||
@@ -320,19 +325,26 @@ class TestRsyncArgs:
|
||||
|
||||
def test_password_auth(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
monkeypatch.setattr(sb, 'which', lambda cmd: f'/usr/bin/{cmd}')
|
||||
monkeypatch.setenv('SSHPASS', 'secret')
|
||||
monkeypatch.delenv('SSHPASS', raising=False)
|
||||
backup = connected_backup()
|
||||
backup.inputs = [str(tmp_path / 'input')]
|
||||
backup._password_auth = True
|
||||
backup._password = 'secret'
|
||||
|
||||
assert backup.run() == 0
|
||||
|
||||
(args,) = RecordPopen.calls
|
||||
assert shlex.split(self.ssh_command(args)) == ['sshpass', '-e', 'ssh', '-l', 'user', '-o',
|
||||
'StrictHostKeyChecking=accept-new']
|
||||
# The password must not stay in the environment
|
||||
# Only rsync gets the password, never our own environment
|
||||
(env,) = RecordPopen.envs
|
||||
assert env is not None and env['SSHPASS'] == 'secret'
|
||||
assert 'SSHPASS' not in os.environ
|
||||
|
||||
def test_no_password_env(self, tmp_path: Path) -> None:
|
||||
self.run(tmp_path)
|
||||
|
||||
assert RecordPopen.envs == [None]
|
||||
|
||||
def test_failure(self, tmp_path: Path, remote_home: Path) -> None:
|
||||
base = make_backups(remote_home, '2026-10-01_10-00-00')
|
||||
RecordPopen.returncode = 23
|
||||
@@ -346,11 +358,11 @@ class TestRsyncArgs:
|
||||
class FakeClient:
|
||||
"""paramiko.SSHClient stand-in; connect() takes its outcomes from a list"""
|
||||
|
||||
def __init__(self, outcomes: list[Optional[BaseException]]) -> None:
|
||||
def __init__(self, outcomes: list[BaseException | None]) -> None:
|
||||
self.outcomes = outcomes
|
||||
self.connects: list[dict[str, Any]] = []
|
||||
self.policies: list[str] = []
|
||||
self.known_hosts: Optional[str] = None
|
||||
self.known_hosts: str | None = None
|
||||
self.closed = False
|
||||
|
||||
def load_host_keys(self, filename: str) -> None:
|
||||
@@ -363,12 +375,12 @@ class FakeClient:
|
||||
self.policies.append(type(policy).__name__)
|
||||
|
||||
def connect(self, hostname: str, **kwargs: Any) -> None:
|
||||
self.connects.append(kwargs)
|
||||
self.connects.append({'hostname': hostname, **kwargs})
|
||||
outcome = self.outcomes.pop(0)
|
||||
|
||||
if isinstance(outcome, UserWarning):
|
||||
# Like WarningPolicy for an unknown host key
|
||||
warnings.warn(outcome)
|
||||
warnings.warn(outcome, stacklevel=2)
|
||||
elif outcome is not None:
|
||||
raise outcome
|
||||
|
||||
@@ -402,8 +414,35 @@ class TestLogin:
|
||||
assert remote_backup()._ssh_connect(str(tmp_path)) is client
|
||||
assert client.known_hosts == f'{tmp_path}/.ssh/known_hosts'
|
||||
assert client.connects[0]['timeout'] == sb.SSH_TIMEOUT
|
||||
assert client.connects[0]['hostname'] == 'server'
|
||||
assert 'port' not in client.connects[0]
|
||||
assert not client.closed
|
||||
|
||||
def test_ssh_config(self, client: FakeClient, tmp_path: Path) -> None:
|
||||
(tmp_path / '.ssh').mkdir()
|
||||
key = tmp_path / '.ssh' / 'id_backup'
|
||||
key.touch()
|
||||
(tmp_path / '.ssh' / 'config').write_text(
|
||||
f'Host server\n HostName backup.example.org\n Port 2222\n'
|
||||
f' IdentityFile {key}\n IdentityFile {tmp_path}/.ssh/missing\n')
|
||||
client.outcomes = [ssh_error(), None]
|
||||
|
||||
assert remote_backup()._ssh_connect(str(tmp_path)) is client
|
||||
|
||||
for params in client.connects:
|
||||
assert (params['hostname'], params['port']) == ('backup.example.org', 2222)
|
||||
assert params['key_filename'] == [str(key)]
|
||||
|
||||
def test_bad_ssh_config(self, client: FakeClient, tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
|
||||
(tmp_path / '.ssh').mkdir()
|
||||
(tmp_path / '.ssh' / 'config').write_text('Host server\n Port abc\n')
|
||||
client.outcomes = [None]
|
||||
|
||||
assert remote_backup()._ssh_connect(str(tmp_path)) is client
|
||||
assert client.connects[0]['hostname'] == 'server'
|
||||
assert 'port' not in client.connects[0]
|
||||
assert 'Cannot read' in caplog.text
|
||||
|
||||
@pytest.mark.parametrize('answer, connected', [('y', True), (' Yes', True), ('n', False), ('', False)])
|
||||
def test_unknown_host_key(self, client: FakeClient, monkeypatch: pytest.MonkeyPatch,
|
||||
answer: str, connected: bool) -> None:
|
||||
@@ -442,13 +481,13 @@ class TestLogin:
|
||||
def test_password(self, client: FakeClient, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
client.outcomes = [ssh_error(), ssh_error(), None]
|
||||
monkeypatch.setattr(sb, 'getpass', lambda prompt: 'secret')
|
||||
monkeypatch.setenv('SSHPASS', '')
|
||||
monkeypatch.delenv('SSHPASS', raising=False)
|
||||
backup = remote_backup()
|
||||
|
||||
assert backup._ssh_connect() is client
|
||||
assert client.connects[-1]['password'] == 'secret'
|
||||
assert backup._password_auth
|
||||
assert os.environ['SSHPASS'] == 'secret'
|
||||
assert backup._password == 'secret'
|
||||
assert 'SSHPASS' not in os.environ
|
||||
|
||||
def test_wrong_password(self, client: FakeClient, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
client.outcomes = [ssh_error(), ssh_error(), ssh_error()]
|
||||
@@ -460,7 +499,7 @@ class TestLogin:
|
||||
def test_password_no_terminal(self, client: FakeClient, monkeypatch: pytest.MonkeyPatch,
|
||||
caplog: pytest.LogCaptureFixture) -> None:
|
||||
def no_tty(prompt: str) -> str:
|
||||
warnings.warn('Can not control echo on the terminal.', GetPassWarning)
|
||||
warnings.warn('Can not control echo on the terminal.', GetPassWarning, stacklevel=2)
|
||||
|
||||
return ''
|
||||
|
||||
@@ -472,7 +511,7 @@ class TestLogin:
|
||||
|
||||
@pytest.mark.parametrize('outcome, connected', [(None, True), ('error', False)])
|
||||
def test_keyfile(self, client: FakeClient, monkeypatch: pytest.MonkeyPatch,
|
||||
outcome: Optional[str], connected: bool) -> None:
|
||||
outcome: str | None, connected: bool) -> None:
|
||||
pkey = object()
|
||||
client.outcomes = [ssh_error(), ssh_error(), ssh_error() if outcome else None]
|
||||
monkeypatch.setattr(sb.Backup, '_load_ssh_key', lambda self: pkey)
|
||||
@@ -546,7 +585,7 @@ class TestLoadKey:
|
||||
def test_no_terminal(self, keys: Path, monkeypatch: pytest.MonkeyPatch,
|
||||
caplog: pytest.LogCaptureFixture) -> None:
|
||||
def no_tty(prompt: str) -> str:
|
||||
warnings.warn('Can not control echo on the terminal.', GetPassWarning)
|
||||
warnings.warn('Can not control echo on the terminal.', GetPassWarning, stacklevel=2)
|
||||
|
||||
return ''
|
||||
|
||||
@@ -556,7 +595,7 @@ class TestLoadKey:
|
||||
assert 'Unable to get passphrase' in caplog.text
|
||||
|
||||
@pytest.mark.parametrize('content', [None, 'not a key\n'])
|
||||
def test_bad_file(self, tmp_path: Path, caplog: pytest.LogCaptureFixture, content: Optional[str]) -> None:
|
||||
def test_bad_file(self, tmp_path: Path, caplog: pytest.LogCaptureFixture, content: str | None) -> None:
|
||||
keyfile = tmp_path / 'id'
|
||||
|
||||
if content is not None:
|
||||
@@ -564,3 +603,108 @@ class TestLoadKey:
|
||||
|
||||
assert remote_backup(ssh_keyfile=str(keyfile))._load_ssh_key() is None
|
||||
assert 'Unable to load SSH key' in caplog.text
|
||||
|
||||
|
||||
FAKE_SSH = """#!/bin/sh
|
||||
# Record the arguments, then run the remote command locally in the fake remote home
|
||||
for a in "$@"; do printf '%s\\n' "$a"; done >> "{log}"
|
||||
echo --- >> "{log}"
|
||||
|
||||
while [ $# -gt 0 ]; do
|
||||
case $1 in
|
||||
-i|-l|-o|-p) shift 2 ;;
|
||||
-*) shift ;;
|
||||
*) break ;;
|
||||
esac
|
||||
done
|
||||
|
||||
# The host
|
||||
shift
|
||||
cd "{home}" && HOME="{home}" exec sh -c "$*"
|
||||
"""
|
||||
|
||||
FAKE_SSHPASS = """#!/bin/sh
|
||||
printf '%s' "${{SSHPASS-unset}}" > "{log}"
|
||||
# -e
|
||||
shift
|
||||
exec "$@"
|
||||
"""
|
||||
|
||||
|
||||
@pytest.mark.usefixtures('connect', 'fake_now')
|
||||
class TestRsyncOverSsh:
|
||||
"""Whole remote backups: real rsync, with fake ssh and sshpass commands that run the remote side locally"""
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def fake_ssh(self, ssh: FakeSSH, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
self.ssh_log = tmp_path / 'ssh.log'
|
||||
self.sshpass_log = tmp_path / 'sshpass.log'
|
||||
|
||||
for name, script, log in [('ssh', FAKE_SSH, self.ssh_log), ('sshpass', FAKE_SSHPASS, self.sshpass_log)]:
|
||||
path = ssh.bin_dir / name
|
||||
path.write_text(script.format(log=log, home=ssh.home))
|
||||
path.chmod(0o755)
|
||||
|
||||
monkeypatch.setenv('PATH', f'{ssh.bin_dir}:{os.environ["PATH"]}')
|
||||
monkeypatch.delenv('SSHPASS', raising=False)
|
||||
|
||||
self.src = tmp_path / 'src dir'
|
||||
self.src.mkdir()
|
||||
(self.src / 'same.txt').write_text('unchanged')
|
||||
(self.src / 'changed.txt').write_text('first')
|
||||
|
||||
def run(self, keep: int = -1, password: str | None = None, **kwargs: Any) -> int:
|
||||
backup = connected_backup(keep=keep, **kwargs)
|
||||
backup.inputs = [str(self.src)]
|
||||
backup._password = password
|
||||
|
||||
return backup.run()
|
||||
|
||||
def ssh_calls(self) -> list[list[str]]:
|
||||
return [c.strip('\n').split('\n') for c in self.ssh_log.read_text().split('---\n') if c != '']
|
||||
|
||||
def copied(self, remote_home: Path, backup: str, name: str) -> Path:
|
||||
return remote_home / 'backups' / 'simple_backup' / backup / str(self.src).lstrip('/') / name
|
||||
|
||||
def test_backups(self, remote_home: Path) -> None:
|
||||
assert self.run() == 0
|
||||
(self.src / 'changed.txt').write_text('second')
|
||||
assert self.run(keep=1) == 0
|
||||
assert self.run(keep=1) == 0
|
||||
|
||||
old, new = '2026-10-14_11-00-00', '2026-10-14_12-00-00'
|
||||
assert remote_dirs(remote_home / 'backups' / 'simple_backup') == [old, new]
|
||||
assert self.copied(remote_home, new, 'changed.txt').read_text() == 'second'
|
||||
# Unchanged files are hard-linked to the previous backup (--link-dest on the server)
|
||||
assert self.copied(remote_home, old, 'same.txt').stat().st_ino == \
|
||||
self.copied(remote_home, new, 'same.txt').stat().st_ino
|
||||
|
||||
for call in self.ssh_calls():
|
||||
assert call[:5] == ['-o', 'StrictHostKeyChecking=accept-new', '-l', 'user', 'server']
|
||||
# rsync passes the remote command as separate arguments
|
||||
assert call[5:7] == ['rsync', '--server']
|
||||
|
||||
def test_keyfile(self, remote_home: Path) -> None:
|
||||
assert self.run(ssh_keyfile='/keys/my key') == 0
|
||||
|
||||
(call,) = self.ssh_calls()
|
||||
assert call[:4] == ['-i', '/keys/my key', '-o', 'StrictHostKeyChecking=accept-new']
|
||||
|
||||
def test_password(self, remote_home: Path) -> None:
|
||||
assert self.run(password='secret') == 0
|
||||
|
||||
assert self.sshpass_log.read_text() == 'secret'
|
||||
assert 'SSHPASS' not in os.environ
|
||||
assert len(remote_dirs(remote_home / 'backups' / 'simple_backup')) == 1
|
||||
|
||||
def test_remote_sudo(self, remote_home: Path) -> None:
|
||||
assert self.run() == 0
|
||||
assert self.run(keep=0, remote_sudo=True) == 0
|
||||
|
||||
assert remote_dirs(remote_home / 'backups' / 'simple_backup') == ['2026-10-14_11-00-00']
|
||||
assert self.ssh_calls()[-1][5:7] == ['sudo rsync', '--server']
|
||||
|
||||
def test_progress(self, remote_home: Path, capsys: pytest.CaptureFixture[str]) -> None:
|
||||
assert self.run(progress=True) == 0
|
||||
|
||||
assert '100%' in capsys.readouterr().err
|
||||
@@ -0,0 +1,160 @@
|
||||
"""Tests for the last backup state file and --last-backup"""
|
||||
|
||||
import os
|
||||
import pwd
|
||||
from collections.abc import Callable
|
||||
from datetime import datetime, timedelta
|
||||
from pathlib import Path
|
||||
|
||||
import pytest
|
||||
|
||||
from simple_backup import simple_backup as sb
|
||||
|
||||
DESTINATION = '/backups/simple_backup/2026-10-25_10-00-00'
|
||||
|
||||
|
||||
@pytest.fixture(autouse=True)
|
||||
def as_user(monkeypatch: pytest.MonkeyPatch) -> None:
|
||||
"""Run as a non-root user (the tests may run as root in a chroot)"""
|
||||
|
||||
monkeypatch.setattr(os, 'geteuid', lambda: 1000)
|
||||
monkeypatch.setenv('USER', 'user')
|
||||
|
||||
|
||||
@pytest.fixture
|
||||
def state(tmp_path: Path) -> Path:
|
||||
return tmp_path / 'state' / 'simple_backup' / 'last_backup'
|
||||
|
||||
|
||||
def write_state(state: Path, text: str) -> None:
|
||||
state.parent.mkdir(parents=True)
|
||||
state.write_text(text)
|
||||
|
||||
|
||||
def test_write(state: Path) -> None:
|
||||
sb._write_state(None, DESTINATION)
|
||||
|
||||
time, destination = state.read_text().splitlines()
|
||||
assert abs(datetime.now().astimezone() - datetime.fromisoformat(time)) < timedelta(minutes=1)
|
||||
assert destination == DESTINATION
|
||||
# No temporary file left behind
|
||||
assert os.listdir(state.parent) == ['last_backup']
|
||||
|
||||
|
||||
def test_overwrite(state: Path) -> None:
|
||||
write_state(state, '2026-10-01T10:00:00+02:00\n/old\n')
|
||||
|
||||
sb._write_state(None, DESTINATION)
|
||||
|
||||
assert state.read_text().splitlines()[1] == DESTINATION
|
||||
|
||||
|
||||
def test_file_count(state: Path) -> None:
|
||||
sb._write_state(None, DESTINATION, 1234)
|
||||
|
||||
assert state.read_text().splitlines()[2] == '1234'
|
||||
assert sb._last_file_count(None) == 1234
|
||||
|
||||
|
||||
def test_file_count_kept_when_unknown(state: Path) -> None:
|
||||
write_state(state, '2026-10-01T10:00:00+02:00\n/old\n1234\n')
|
||||
|
||||
sb._write_state(None, DESTINATION)
|
||||
|
||||
assert state.read_text().splitlines()[1:] == [DESTINATION, '1234']
|
||||
|
||||
|
||||
@pytest.mark.parametrize('text', [None, '2026-10-01T10:00:00+02:00\n/old\n', '2026-10-01T10:00:00+02:00\n/old\nx\n'])
|
||||
def test_no_file_count(state: Path, text: str | None) -> None:
|
||||
if text is not None:
|
||||
write_state(state, text)
|
||||
|
||||
assert sb._last_file_count(None) == 0
|
||||
|
||||
|
||||
def test_relative_xdg_state_home_ignored(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
|
||||
monkeypatch.setenv('XDG_STATE_HOME', 'relative')
|
||||
monkeypatch.setenv('HOME', str(tmp_path / 'home'))
|
||||
|
||||
sb._write_state(None, DESTINATION)
|
||||
|
||||
assert (tmp_path / 'home' / '.local' / 'state' / 'simple_backup' / 'last_backup').exists()
|
||||
|
||||
|
||||
def test_write_error(monkeypatch: pytest.MonkeyPatch, tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
|
||||
# A file where the state directory should be
|
||||
(tmp_path / 'not a dir').write_text('')
|
||||
monkeypatch.setenv('XDG_STATE_HOME', str(tmp_path / 'not a dir'))
|
||||
|
||||
sb._write_state(None, DESTINATION)
|
||||
|
||||
assert 'Cannot save the time of the last backup' in caplog.text
|
||||
|
||||
|
||||
def test_root_writes_as_user(monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
|
||||
calls: list[tuple[str, int]] = []
|
||||
egid = os.getegid()
|
||||
owner = pwd.struct_passwd(('user', 'x', 1000, 1001, '', str(tmp_path / 'home'), '/bin/sh'))
|
||||
|
||||
monkeypatch.setattr(os, 'geteuid', lambda: 0)
|
||||
monkeypatch.setattr(pwd, 'getpwnam', lambda name: owner)
|
||||
monkeypatch.setattr(os, 'seteuid', lambda uid: calls.append(('euid', uid)))
|
||||
monkeypatch.setattr(os, 'setegid', lambda gid: calls.append(('egid', gid)))
|
||||
|
||||
sb._write_state('user', DESTINATION)
|
||||
|
||||
# Root's XDG_STATE_HOME is not used
|
||||
assert (tmp_path / 'home' / '.local' / 'state' / 'simple_backup' / 'last_backup').exists()
|
||||
assert calls == [('egid', 1001), ('euid', 1000), ('euid', 0), ('egid', egid)]
|
||||
|
||||
|
||||
class TestStateOwner:
|
||||
def test_non_root(self) -> None:
|
||||
assert sb._state_owner('user') is None
|
||||
|
||||
@pytest.mark.parametrize('name, expected', [('user', 'user'), ('root', None), ('unknown', None), (None, None)])
|
||||
def test_root(self, monkeypatch: pytest.MonkeyPatch, name: str | None, expected: str | None) -> None:
|
||||
users = {'user': pwd.struct_passwd(('user', 'x', 1000, 1000, '', '/home/user', '/bin/sh')),
|
||||
'root': pwd.struct_passwd(('root', 'x', 0, 0, '', '/root', '/bin/sh'))}
|
||||
|
||||
def getpwnam(name: str) -> pwd.struct_passwd:
|
||||
if name not in users:
|
||||
raise KeyError(name)
|
||||
|
||||
return users[name]
|
||||
|
||||
monkeypatch.setattr(os, 'geteuid', lambda: 0)
|
||||
monkeypatch.setattr(pwd, 'getpwnam', getpwnam)
|
||||
|
||||
owner = sb._state_owner(name)
|
||||
assert (owner.pw_name if owner is not None else None) == expected
|
||||
|
||||
|
||||
class TestShow:
|
||||
@pytest.mark.parametrize('days, age', [(0, 'today'), (1, 'yesterday'), (3, '3 days ago')])
|
||||
def test_age(self, run_cli: Callable[..., int], state: Path, capsys: pytest.CaptureFixture[str],
|
||||
days: int, age: str) -> None:
|
||||
completed = (datetime.now() - timedelta(days=days)).replace(hour=12, minute=30).astimezone()
|
||||
write_state(state, f'{completed.isoformat(timespec="seconds")}\n{DESTINATION}\n')
|
||||
|
||||
assert run_cli('--last-backup') == 0
|
||||
assert capsys.readouterr().out == \
|
||||
f'Last backup: {completed:%Y-%m-%d} 12:30 ({age})\nDirectory: {DESTINATION}\n'
|
||||
|
||||
def test_after_write(self, run_cli: Callable[..., int], capsys: pytest.CaptureFixture[str]) -> None:
|
||||
sb._write_state(None, DESTINATION)
|
||||
|
||||
assert run_cli('--last-backup') == 0
|
||||
assert '(today)' in capsys.readouterr().out
|
||||
|
||||
def test_no_backup(self, run_cli: Callable[..., int], capsys: pytest.CaptureFixture[str]) -> None:
|
||||
assert run_cli('--last-backup') == 1
|
||||
assert capsys.readouterr().out == 'No backup recorded yet\n'
|
||||
|
||||
@pytest.mark.parametrize('text', ['', '2026-10-25T10:00:00+02:00\n', 'yesterday\n/backups\n'])
|
||||
def test_bad_file(self, run_cli: Callable[..., int], state: Path, capsys: pytest.CaptureFixture[str],
|
||||
text: str) -> None:
|
||||
write_state(state, text)
|
||||
|
||||
assert run_cli('--last-backup') == 1
|
||||
assert 'Cannot read' in capsys.readouterr().err
|
||||
Reference in new issue
Block a user