PyHardLinkBackup 1.0.0__py3-none-any.whl

PyHardLinkBackup/constants.py

@@ -0,0 +1,16 @@
+from pathlib import Path
+
+import PyHardLinkBackup
+
+
+CLI_EPILOG = 'Project Homepage: https://github.com/jedie/PyHardLinkBackup'
+
+BASE_PATH = Path(PyHardLinkBackup.__file__).parent
+
+
+##########################################################################
+# "Settings" for PyHardLinkBackup:
+
+CHUNK_SIZE = 64 * 1024 * 1024  # 64 MB
+SMALL_FILE_THRESHOLD = 1000  # bytes
+HASH_ALGO = 'sha256'

PyHardLinkBackup/tests/__init__.py

@@ -0,0 +1,36 @@
+import os
+import unittest.util
+from pathlib import Path
+
+from bx_py_utils.test_utils.deny_requests import deny_any_real_request
+from cli_base.cli_tools.verbosity import MAX_LOG_LEVEL, setup_logging
+from rich import print  # noqa
+from typeguard import install_import_hook
+
+
+# Check type annotations via typeguard in all tests:
+install_import_hook(packages=('PyHardLinkBackup',))
+
+
+def pre_configure_tests() -> None:
+    print(f'Configure unittests via "load_tests Protocol" from {Path(__file__).relative_to(Path.cwd())}')
+
+    # Hacky way to display more "assert"-Context in failing tests:
+    _MIN_MAX_DIFF = unittest.util._MAX_LENGTH - unittest.util._MIN_DIFF_LEN
+    unittest.util._MAX_LENGTH = int(os.environ.get('UNITTEST_MAX_LENGTH', 2000))
+    unittest.util._MIN_DIFF_LEN = unittest.util._MAX_LENGTH - _MIN_MAX_DIFF
+
+    # Deny any request via docket/urllib3 because tests they should mock all requests:
+    deny_any_real_request()
+
+    # Display DEBUG logs in tests:
+    setup_logging(verbosity=MAX_LOG_LEVEL)
+
+
+def load_tests(loader, tests, pattern):
+    """
+    Use unittest "load_tests Protocol" as a hook to setup test environment before running tests.
+    https://docs.python.org/3/library/unittest.html#load-tests-protocol
+    """
+    pre_configure_tests()
+    return loader.discover(start_dir=Path(__file__).parent, pattern=pattern)

PyHardLinkBackup/tests/test_backup.py

@@ -0,0 +1,399 @@
+import datetime
+import os
+import tempfile
+import textwrap
+import zlib
+from pathlib import Path
+from unittest import TestCase
+
+from bx_py_utils.test_utils.assertion import assert_text_equal
+from bx_py_utils.test_utils.datetime import parse_dt
+from freezegun import freeze_time
+from tabulate import tabulate
+
+from PyHardLinkBackup.backup import BackupResult, backup_tree
+from PyHardLinkBackup.constants import CHUNK_SIZE
+from PyHardLinkBackup.utilities.file_size_database import FileSizeDatabase
+from PyHardLinkBackup.utilities.filesystem import iter_scandir_files
+from PyHardLinkBackup.utilities.tests.test_file_hash_database import assert_hash_db_info
+
+
+def set_file_times(path: Path, dt: datetime.datetime):
+    # move dt to UTC if it has timezone info:
+    if dt.tzinfo is not None:
+        dt = dt.astimezone(datetime.timezone.utc).replace(tzinfo=None)
+    fixed_time = dt.timestamp()
+    for entry in iter_scandir_files(path, excludes=set()):
+        os.utime(entry.path, (fixed_time, fixed_time))
+
+
+def fs_tree_overview(root: Path) -> str:
+    lines = []
+    for entry in iter_scandir_files(root, excludes=set()):
+        file_path = Path(entry.path)
+        try:
+            file_stat = entry.stat()
+        except FileNotFoundError:
+            crc32 = '-'
+            nlink = '-'
+            size = '-'
+            birthtime = '-'
+        else:
+            crc32 = zlib.crc32(file_path.read_bytes())
+            crc32 = f'{crc32:08x}'
+            nlink = file_stat.st_nlink
+            size = file_stat.st_size
+            birthtime = getattr(file_stat, 'st_birthtime', file_stat.st_mtime)
+            birthtime = datetime.datetime.fromtimestamp(birthtime).strftime('%H:%M:%S')
+
+        if entry.is_symlink():
+            file_type = 'symlink'
+        elif nlink > 1:
+            file_type = 'hardlink'
+        else:
+            file_type = 'file'
+
+        lines.append(
+            [
+                str(file_path.relative_to(root)),
+                birthtime,
+                file_type,
+                nlink,
+                size,
+                crc32,
+            ]
+        )
+
+    result = tabulate(sorted(lines), headers=['path', 'birthtime', 'type', 'nlink', 'size', 'CRC32'], tablefmt='plain')
+    return result
+
+
+def assert_fs_tree_overview(root: Path, expected_overview: str):
+    expected_overview = textwrap.dedent(expected_overview).strip()
+    actual_overview = fs_tree_overview(root)
+    assert_text_equal(
+        actual_overview,
+        expected_overview,
+        msg=f'Filesystem tree overview does not match expected overview.\n\n{actual_overview}\n\n',
+    )
+
+
+class BackupTreeTestCase(TestCase):
+    def test_happy_path(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            src_root = temp_path / 'source'
+            backup_root = temp_path / 'backup'
+
+            src_root.mkdir()
+            backup_root.mkdir()
+
+            file1_path = src_root / 'file2.txt'
+            file1_path.write_text('This is file 1')
+
+            (src_root / 'symlink2file1').symlink_to(file1_path)
+            os.link(file1_path, src_root / 'hardlink2file1')
+
+            sub_dir = src_root / 'subdir'
+            sub_dir.mkdir()
+            (sub_dir / 'file.txt').write_text('This is file in subdir')
+
+            # Only files bigger than MIN_SIZE will be considered for hardlinking:
+            size_db_min_file = src_root / 'min_sized_file1.bin'
+            size_db_min_file.write_bytes(b'X' * FileSizeDatabase.MIN_SIZE)
+
+            # Same content and big enough to be considered for hardlinking:
+            size_db_min_file = src_root / 'min_sized_file2.bin'
+            size_db_min_file.write_bytes(b'X' * FileSizeDatabase.MIN_SIZE)
+
+            # Larger then CHUNK_SIZE file will be handled differently:
+            large_file = src_root / 'large_file.bin'
+            large_file.write_bytes(b'Y' * (CHUNK_SIZE + 1))
+
+            excluded_dir = src_root / '.cache'
+            excluded_dir.mkdir()
+            (excluded_dir / 'tempfile.tmp').write_text('Temporary file that should be excluded')
+
+            # FIXME: freezegun doesn't handle this, see: https://github.com/spulec/freezegun/issues/392
+            # Set modification times to a fixed time for easier testing:
+            set_file_times(src_root, dt=parse_dt('2026-01-01T12:00:00+0000'))
+
+            #######################################################################################
+            # Create first backup:
+
+            with freeze_time('2026-01-01T12:34:56Z', auto_tick_seconds=0):
+                result = backup_tree(
+                    src_root=src_root,
+                    backup_root=backup_root,
+                    excludes={'.cache'},
+                )
+            backup_dir = result.backup_dir
+            self.assertEqual(
+                str(Path(backup_dir).relative_to(temp_path)),
+                'backup/source/20260101_123456',
+            )
+            self.assertEqual(
+                result,
+                BackupResult(
+                    backup_dir=backup_dir,
+                    backup_count=7,
+                    backup_size=67110929,
+                    symlink_files=1,
+                    hardlinked_files=1,
+                    hardlinked_size=1000,
+                    copied_files=5,
+                    copied_size=67109915,
+                    copied_small_files=3,
+                    copied_small_size=50,
+                ),
+            )
+
+            # The sources:
+            assert_fs_tree_overview(
+                root=src_root,
+                expected_overview="""
+                    path                 birthtime    type        nlink      size  CRC32
+                    .cache/tempfile.tmp  12:00:00     file            1        38  41d7a2c9
+                    file2.txt            12:00:00     hardlink        2        14  8a11514a
+                    hardlink2file1       12:00:00     hardlink        2        14  8a11514a
+                    large_file.bin       12:00:00     file            1  67108865  9671eaac
+                    min_sized_file1.bin  12:00:00     file            1      1000  f0d93de4
+                    min_sized_file2.bin  12:00:00     file            1      1000  f0d93de4
+                    subdir/file.txt      12:00:00     file            1        22  c0167e63
+                    symlink2file1        12:00:00     symlink         2        14  8a11514a
+                """,
+            )
+            # The backup:
+            # * /.cache/ -> excluded
+            # * min_sized_file1.bin and min_sized_file2.bin -> hardlinked
+            assert_fs_tree_overview(
+                root=backup_dir,
+                expected_overview="""
+                    path                 birthtime    type        nlink      size  CRC32
+                    file2.txt            12:00:00     file            1        14  8a11514a
+                    hardlink2file1       12:00:00     file            1        14  8a11514a
+                    large_file.bin       12:00:00     file            1  67108865  9671eaac
+                    min_sized_file1.bin  12:00:00     hardlink        2      1000  f0d93de4
+                    min_sized_file2.bin  12:00:00     hardlink        2      1000  f0d93de4
+                    subdir/file.txt      12:00:00     file            1        22  c0167e63
+                    symlink2file1        12:00:00     symlink         2        14  8a11514a
+                """,
+            )
+
+            # Let's check our FileHashDatabase:
+            assert_hash_db_info(
+                backup_root=backup_root,
+                expected="""
+                    bb/c4/bbc4de2ca238d1… -> source/20260101_123456/min_sized_file1.bin
+                    e6/37/e6374ac11d9049… -> source/20260101_123456/large_file.bin
+                """,
+            )
+
+            #######################################################################################
+            # Just backup again:
+
+            with freeze_time('2026-01-02T12:34:56Z', auto_tick_seconds=0):
+                result = backup_tree(
+                    src_root=src_root,
+                    backup_root=backup_root,
+                    excludes={'.cache'},
+                )
+            backup_dir = result.backup_dir
+            self.assertEqual(
+                str(Path(backup_dir).relative_to(temp_path)),
+                'backup/source/20260102_123456',
+            )
+            self.assertEqual(
+                result,
+                BackupResult(
+                    backup_dir=backup_dir,
+                    backup_count=7,
+                    backup_size=67110929,
+                    symlink_files=1,
+                    hardlinked_files=3,  # <<< More hardlinks this time!
+                    hardlinked_size=67110865,
+                    copied_files=3,
+                    copied_size=50,
+                    copied_small_files=3,
+                    copied_small_size=50,
+                ),
+            )
+            # The second backup:
+            # * /.cache/ -> excluded
+            # * min_sized_file1.bin and min_sized_file2.bin -> hardlinked
+            assert_fs_tree_overview(
+                root=backup_dir,
+                expected_overview="""
+                    path                 birthtime    type        nlink      size  CRC32
+                    file2.txt            12:00:00     file            1        14  8a11514a
+                    hardlink2file1       12:00:00     file            1        14  8a11514a
+                    large_file.bin       12:00:00     hardlink        2  67108865  9671eaac
+                    min_sized_file1.bin  12:00:00     hardlink        4      1000  f0d93de4
+                    min_sized_file2.bin  12:00:00     hardlink        4      1000  f0d93de4
+                    subdir/file.txt      12:00:00     file            1        22  c0167e63
+                    symlink2file1        12:00:00     symlink         2        14  8a11514a
+                """,
+            )
+
+            # The FileHashDatabase remains the same:
+            assert_hash_db_info(
+                backup_root=backup_root,
+                expected="""
+                    bb/c4/bbc4de2ca238d1… -> source/20260101_123456/min_sized_file1.bin
+                    e6/37/e6374ac11d9049… -> source/20260101_123456/large_file.bin
+                """,
+            )
+
+            #######################################################################################
+            # Don't create broken hardlinks!
+
+            """DocWrite: README.md ## FileHashDatabase - Missing hardlink target file
+            If a hardlink source from a old backup is missing, we cannot create a hardlink to it.
+            But it still works to hardlink same files within the current backup.
+            """
+
+            # Let's remove one of the files used for hardlinking from the first backup:
+            (backup_root / 'source/20260101_123456/min_sized_file1.bin').unlink()
+
+            # Backup again:
+            with freeze_time('2026-01-03T12:34:56Z', auto_tick_seconds=0):
+                result = backup_tree(
+                    src_root=src_root,
+                    backup_root=backup_root,
+                    excludes={'.cache'},
+                )
+            backup_dir = result.backup_dir
+            self.assertEqual(
+                result,
+                BackupResult(
+                    backup_dir=backup_dir,
+                    backup_count=7,
+                    backup_size=67110929,
+                    symlink_files=1,
+                    hardlinked_files=2,  # <<< Less hardlinks this time, because of missing link source!
+                    hardlinked_size=67109865,
+                    copied_files=4,
+                    copied_size=1050,
+                    copied_small_files=3,
+                    copied_small_size=50,
+                ),
+            )
+
+            # Note: min_sized_file1.bin and min_sized_file2.bin are hardlinked,
+            # but not with the first backup anymore! So it's only nlink=2 now!
+            assert_fs_tree_overview(
+                root=backup_dir,
+                expected_overview="""
+                    path                 birthtime    type        nlink      size  CRC32
+                    file2.txt            12:00:00     file            1        14  8a11514a
+                    hardlink2file1       12:00:00     file            1        14  8a11514a
+                    large_file.bin       12:00:00     hardlink        3  67108865  9671eaac
+                    min_sized_file1.bin  12:00:00     hardlink        2      1000  f0d93de4
+                    min_sized_file2.bin  12:00:00     hardlink        2      1000  f0d93de4
+                    subdir/file.txt      12:00:00     file            1        22  c0167e63
+                    symlink2file1        12:00:00     symlink         2        14  8a11514a
+                """,
+            )
+
+            # Note: min_sized_file1.bin is now from the 2026-01-03 backup!
+            self.assertEqual(backup_dir.name, '20260103_123456')  # Latest backup dir name
+            assert_hash_db_info(
+                backup_root=backup_root,
+                expected="""
+                    bb/c4/bbc4de2ca238d1… -> source/20260103_123456/min_sized_file1.bin
+                    e6/37/e6374ac11d9049… -> source/20260101_123456/large_file.bin
+                """,
+            )
+
+    def test_symlink(self):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            temp_path = Path(temp_dir)
+
+            src_root = temp_path / 'src'
+            backup_root = temp_path / 'bak'
+
+            src_root.mkdir()
+            backup_root.mkdir()
+
+            source_file_path = src_root / 'source_file.txt'
+            source_file_path.write_text('File in the "source" directory.')
+
+            symlink2source_file_path = src_root / 'symlink2source'
+            symlink2source_file_path.symlink_to(source_file_path)
+            self.assertEqual(symlink2source_file_path.read_text(), 'File in the "source" directory.')
+
+            outside_file_path = temp_path / 'outside_file.txt'
+            outside_file_path.write_text('File outside the "source" directory!')
+
+            symlink2outside_file_path = src_root / 'symlink2outside'
+            symlink2outside_file_path.symlink_to(outside_file_path)
+            self.assertEqual(symlink2outside_file_path.read_text(), 'File outside the "source" directory!')
+
+            # FIXME: freezegun doesn't handle this, see: https://github.com/spulec/freezegun/issues/392
+            # Set modification times to a fixed time for easier testing:
+            set_file_times(src_root, dt=parse_dt('2026-01-01T12:00:00+0000'))
+
+            broken_symlink_path = src_root / 'broken_symlink'
+            broken_symlink_path.symlink_to(temp_path / 'not/existing/file.txt')
+            broken_symlink_path.is_symlink()
+
+            #######################################################################################
+            # Create first backup:
+
+            with freeze_time('2026-01-01T12:34:56Z', auto_tick_seconds=0):
+                result = backup_tree(src_root=src_root, backup_root=backup_root, excludes=set())
+            backup_dir1 = result.backup_dir
+            self.assertEqual(
+                str(Path(backup_dir1).relative_to(temp_path)),
+                'bak/src/20260101_123456',
+            )
+
+            assert_fs_tree_overview(
+                root=temp_path,  # The complete overview os source + backup and outside file
+                expected_overview="""
+                    path                                     birthtime    type     nlink    size    CRC32
+                    bak/src/20260101_123456/broken_symlink   -            symlink  -        -       -
+                    bak/src/20260101_123456/source_file.txt  12:00:00     file     1        31      9309a10c
+                    bak/src/20260101_123456/symlink2outside  12:00:00     symlink  1        36      24b5bf4c
+                    bak/src/20260101_123456/symlink2source   12:00:00     symlink  1        31      9309a10c
+                    outside_file.txt                         12:00:00     file     1        36      24b5bf4c
+                    src/broken_symlink                       -            symlink  -        -       -
+                    src/source_file.txt                      12:00:00     file     1        31      9309a10c
+                    src/symlink2outside                      12:00:00     symlink  1        36      24b5bf4c
+                    src/symlink2source                       12:00:00     symlink  1        31      9309a10c
+                """,
+            )
+
+            self.assertEqual(
+                result,
+                BackupResult(
+                    backup_dir=backup_dir1,
+                    backup_count=4,
+                    backup_size=98,
+                    symlink_files=3,
+                    hardlinked_files=0,
+                    hardlinked_size=0,
+                    copied_files=1,
+                    copied_size=31,
+                    copied_small_files=1,
+                    copied_small_size=31,
+                ),
+            )
+
+            """DocWrite: README.md ## backup implementation - Symlinks
+            Symlinks are copied as symlinks in the backup."""
+            self.assertEqual(
+                (backup_dir1 / 'symlink2outside').read_text(),
+                'File outside the "source" directory!',
+            )
+            self.assertEqual(
+                (backup_dir1 / 'symlink2source').read_text(),
+                'File in the "source" directory.',
+            )
+            self.assertEqual((backup_dir1 / 'symlink2outside').readlink(), outside_file_path)
+            self.assertEqual((backup_dir1 / 'symlink2source').readlink(), source_file_path)
+
+            """DocWrite: README.md ## backup implementation - Symlinks
+            Symlinks are not stored in our FileHashDatabase, because they are not considered for hardlinking."""
+            assert_hash_db_info(backup_root=backup_root, expected='')

PyHardLinkBackup/tests/test_doc_write.py

@@ -0,0 +1,25 @@
+from unittest import TestCase
+
+from bx_py_utils.doc_write.api import GeneratedInfo, generate
+from bx_py_utils.path import assert_is_file
+
+from PyHardLinkBackup.cli_dev import PACKAGE_ROOT
+
+
+class DocuWriteApiTestCase(TestCase):
+    def test_up2date_docs(self):
+        """DocWrite: about-docs.md # generate Doc-Write
+
+        These documentation files are generated automatically with the "Doc-Write" tool.
+        They updated automatically by unittests.
+
+        More information about Doc-Write can be found here:
+
+        https://github.com/boxine/bx_py_utils/tree/master/bx_py_utils/doc_write
+        """
+        assert_is_file(PACKAGE_ROOT / 'pyproject.toml')
+
+        info: GeneratedInfo = generate(base_path=PACKAGE_ROOT)
+        self.assertGreaterEqual(len(info.paths), 1)
+        self.assertEqual(info.update_count, 0, 'No files should be updated, commit the changes')
+        self.assertEqual(info.remove_count, 0, 'No files should be removed, commit the changes')

PyHardLinkBackup/tests/test_doctests.py

@@ -0,0 +1,10 @@
+from bx_py_utils.test_utils.unittest_utils import BaseDocTests
+
+import PyHardLinkBackup
+
+
+class DocTests(BaseDocTests):
+    def test_doctests(self):
+        self.run_doctests(
+            modules=(PyHardLinkBackup,),
+        )

PyHardLinkBackup/tests/test_project_setup.py

@@ -0,0 +1,46 @@
+import subprocess
+from unittest import TestCase
+
+from bx_py_utils.path import assert_is_file
+from cli_base.cli_tools.code_style import assert_code_style
+from cli_base.cli_tools.subprocess_utils import ToolsExecutor
+from manageprojects.test_utils.project_setup import check_editor_config, get_py_max_line_length
+from packaging.version import Version
+
+from PyHardLinkBackup import __version__
+from PyHardLinkBackup.cli_dev import PACKAGE_ROOT
+
+
+class ProjectSetupTestCase(TestCase):
+    def test_version(self):
+        self.assertIsNotNone(__version__)
+
+        version = Version(__version__)  # Will raise InvalidVersion() if wrong formatted
+        self.assertEqual(str(version), __version__)
+
+        cli_bin = PACKAGE_ROOT / 'cli.py'
+        assert_is_file(cli_bin)
+
+        output = subprocess.check_output([cli_bin, 'version'], text=True)
+        self.assertIn(f'PyHardLinkBackup v{__version__}', output)
+
+        dev_cli_bin = PACKAGE_ROOT / 'dev-cli.py'
+        assert_is_file(dev_cli_bin)
+
+        output = subprocess.check_output([dev_cli_bin, 'version'], text=True)
+        self.assertIn(f'PyHardLinkBackup v{__version__}', output)
+
+    def test_code_style(self):
+        return_code = assert_code_style(package_root=PACKAGE_ROOT)
+        self.assertEqual(return_code, 0, 'Code style error, see output above!')
+
+    def test_check_editor_config(self):
+        check_editor_config(package_root=PACKAGE_ROOT)
+
+        max_line_length = get_py_max_line_length(package_root=PACKAGE_ROOT)
+        self.assertEqual(max_line_length, 119)
+
+    def test_pre_commit_hooks(self):
+        executor = ToolsExecutor(cwd=PACKAGE_ROOT)
+        for command in ('migrate-config', 'validate-config', 'validate-manifest'):
+            executor.verbose_check_call('pre-commit', command, exit_on_error=True)

PyHardLinkBackup/tests/test_readme.py

@@ -0,0 +1,75 @@
+from bx_py_utils.auto_doc import assert_readme_block
+from bx_py_utils.path import assert_is_file
+from cli_base.cli_tools.test_utils.rich_test_utils import NoColorEnvRich, invoke
+from manageprojects.tests.base import BaseTestCase
+
+from PyHardLinkBackup import constants
+from PyHardLinkBackup.cli_dev import PACKAGE_ROOT
+
+
+def assert_cli_help_in_readme(text_block: str, marker: str):
+    README_PATH = PACKAGE_ROOT / 'README.md'
+    assert_is_file(README_PATH)
+
+    text_block = text_block.replace(constants.CLI_EPILOG, '')
+    text_block = f'```\n{text_block.strip()}\n```'
+    assert_readme_block(
+        readme_path=README_PATH,
+        text_block=text_block,
+        start_marker_line=f'[comment]: <> (✂✂✂ auto generated {marker} start ✂✂✂)',
+        end_marker_line=f'[comment]: <> (✂✂✂ auto generated {marker} end ✂✂✂)',
+    )
+
+
+class ReadmeTestCase(BaseTestCase):
+
+    def test_main_help(self):
+        with NoColorEnvRich():
+            stdout = invoke(cli_bin=PACKAGE_ROOT / 'cli.py', args=['--help'], strip_line_prefix='usage: ')
+
+        self.assert_in_content(
+            got=stdout,
+            parts=(
+                'usage: ./cli.py [-h]',
+                ' version ',
+                'Print version and exit',
+                constants.CLI_EPILOG,
+            ),
+        )
+
+        # Installed via pipx is called 'phlb', not 'cli.py':
+        stdout = stdout.replace('./cli.py', 'phlb')
+
+        assert_cli_help_in_readme(text_block=stdout, marker='main help')
+
+    def test_backup_help(self):
+        with NoColorEnvRich():
+            stdout = invoke(cli_bin=PACKAGE_ROOT / 'cli.py', args=['backup', '--help'], strip_line_prefix='usage: ')
+        self.assert_in_content(
+            got=stdout,
+            parts=(
+                'usage: ./cli.py backup [-h] ',
+                'Backup the source directory to the destination',
+            ),
+        )
+
+        # Installed via pipx is called 'phlb', not 'cli.py':
+        stdout = stdout.replace('./cli.py', 'phlb')
+
+        assert_cli_help_in_readme(text_block=stdout, marker='backup help')
+
+    def test_dev_help(self):
+        with NoColorEnvRich():
+            stdout = invoke(cli_bin=PACKAGE_ROOT / 'dev-cli.py', args=['--help'], strip_line_prefix='usage: ')
+        self.assert_in_content(
+            got=stdout,
+            parts=(
+                'usage: ./dev-cli.py [-h]',
+                ' lint ',
+                ' coverage ',
+                ' update-readme-history ',
+                ' publish ',
+                constants.CLI_EPILOG,
+            ),
+        )
+        assert_cli_help_in_readme(text_block=stdout, marker='dev help')

PyHardLinkBackup/tests/test_readme_history.py

@@ -0,0 +1,8 @@
+from unittest import TestCase
+
+from cli_base.cli_tools.git_history import update_readme_history
+
+
+class ReadmeHistoryTestCase(TestCase):
+    def test_readme_history(self):
+        update_readme_history(raise_update_error=True)