borgapi 0.6.1__py3-none-any.whl → 0.7.1__py3-none-any.whl

test/borgapi/test_03_create.py

@@ -1,136 +0,0 @@
-"""Test create command"""
-import sys
-from io import BytesIO, TextIOWrapper
-
-from borg.archive import Archive
-
-from .test_01_borgapi import BorgapiTests
-
-
-class CreateTests(BorgapiTests):
-    """Create command tests"""
-
-    def test_01_basic(self):
-        """Create new archive"""
-        self.api.create(self.archive, self.data)
-        output = self.api.list(self.repo, json=True)
-        num_archives = len(output["archives"])
-        self.assertEqual(num_archives, 1, "Archive not saved")
-        archive_name = output["archives"][0]["name"]
-        self.assertEqual(archive_name, "1", "Archive name does not match set name")
-
-    def test_02_second(self):
-        """Create second archive after data modification"""
-        self.api.create(self.archive, self.data)
-        with open(self.file_3, "w+") as fp:
-            fp.write("New Data")
-        self.api.create(f"{self.repo}::2", self.data)
-
-        output = self.api.list(self.repo, json=True)
-        num_archives = len(output["archives"])
-        self.assertEqual(num_archives, 2, "Multiple archives not saved")
-        archive_1_name = output["archives"][0]["name"]
-        self.assertEqual(archive_1_name, "1", "Archive name does not match set name")
-        archive_2_name = output["archives"][1]["name"]
-        self.assertEqual(archive_2_name, "2", "Archive name does not match set name")
-
-    def test_03_already_exists(self):
-        """Create an archive with an existing name"""
-        self.api.create(self.archive, self.data)
-        self.assertRaises(
-            Archive.AlreadyExists,
-            self.api.create,
-            self.archive,
-            self.data,
-        )
-
-    def test_04_stdin(self):
-        """Read input from stdin and save to archvie"""
-        temp_stdin = TextIOWrapper(BytesIO(bytes(self.file_3_text, "utf-8")))
-        sys.stdin = temp_stdin
-        name = "file_3_stdin.txt"
-        mode = "0777"  # "-rwxrwxrwx"
-
-        try:
-            self.api.create(
-                self.archive,
-                "-",
-                stdin_name=name,
-                stdin_mode=mode,
-            )
-        finally:
-            temp_stdin.close()
-            sys.stdin = sys.__stdin__
-
-        output = self.api.list(self.archive, json_lines=True)
-        self.assertEqual(output["path"], name, "Unexpected file name")
-        self.assertEqual(output["mode"], "-rwxrwxrwx", "Unexpected file mode")
-
-    def test_04_output_string(self):
-        """Create string info"""
-        output = self.api.create(self.archive, self.data, stats=True, list=True)
-        self._display("create string info", output, False)
-        self.assertType(output["stats"], str)
-        self.assertType(output["list"], str)
-
-    def test_05_output_json(self):
-        """Create json info"""
-        output = self.api.create(
-            self.archive,
-            self.data,
-            json=True,
-            log_json=True,
-            list=True,
-        )
-        self._display("create string info", output, False)
-        self.assertType(output["stats"], dict)
-        self.assertAnyType(output["list"], list, dict)
-
-    def test_06_output_mixed_1(self):
-        """Create mixed output (stats json, list string)"""
-        output = self.api.create(self.archive, self.data, json=True, list=True)
-        self._display("create mixed output (stats json, list string)", output, False)
-        self.assertType(output["stats"], dict)
-        self.assertType(output["list"], str)
-
-    def test_07_output_mixed_2(self):
-        """Create mixed output (stats string, list json)"""
-        output = self.api.create(
-            self.archive,
-            self.data,
-            stats=True,
-            log_json=True,
-            list=True,
-        )
-        self._display("create mixed output (stats string, list json)", output, False)
-        self.assertType(output["stats"], str)
-        self.assertAnyType(output["list"], list, dict)
-
-    def test_08_list_string(self):
-        """Create list string"""
-        output = self.api.create(self.archive, self.data, list=True)
-        self._display("create list string", output)
-        self.assertType(output, str)
-
-    def test_09_stats_json(self):
-        """Create stats json"""
-        output = self.api.create(self.archive, self.data, json=True)
-        self._display("create stats json", output)
-        self.assertType(output, dict)
-
-    def test_10_list_json(self):
-        """Create list json"""
-        output = self.api.create(
-            self.archive,
-            self.data,
-            log_json=True,
-            list=True,
-        )
-        self._display("create list json", output)
-        self.assertAnyType(output, list, dict)
-
-    def test_11_stats_string(self):
-        """Create stats string"""
-        output = self.api.create(self.archive, self.data, stats=True)
-        self._display("create stats string", output)
-        self.assertType(output, str)

test/borgapi/test_04_extract.py

@@ -1,52 +0,0 @@
-"""Test extract command"""
-from os import remove
-
-from .test_01_borgapi import BorgapiTests
-
-
-class ExtractTests(BorgapiTests):
-    """Extract command tests"""
-
-    def setUp(self):
-        super().setUp()
-        self._create_default()
-
-    def test_01_basic(self):
-        """Extract file"""
-        remove(self.file_1)
-        self.assertFileNotExists(self.file_1)
-
-        self.api.extract(self.archive, self.file_1)
-        self.assertFileExists(self.file_1)
-
-    def test_02_not_exist(self):
-        """Extract path that does not exist"""
-        with self.assertLogs("borg", "WARNING") as logger:
-            self.api.extract(self.archive, self.file_3)
-        message = logger.records[0].getMessage()
-        self.assertRegex(
-            message,
-            r".*?file_3.*never",
-            "Warning not logged for bad path",
-        )
-
-    def test_03_stdout(self):
-        """Capture Extracted File"""
-        output = self.api.extract(self.archive, self.file_1, stdout=True)
-        self.assertEqual(
-            output,
-            bytes(self.file_1_text, "utf-8"),
-            "Extracted file text does not match",
-        )
-
-    def test_04_output_string(self):
-        """list to log"""
-        output = self.api.extract(self.archive, list=True, dry_run=True)
-        self._display("extract 1", output)
-        self.assertType(output, str)
-
-    def test_05_output_json(self):
-        """list to json"""
-        output = self.api.extract(self.archive, log_json=True, list=True, dry_run=True)
-        self._display("extract 2", output)
-        self.assertAnyType(output, list, dict)

test/borgapi/test_05_rename.py

@@ -1,32 +0,0 @@
-"""Test rename command"""
-from borg.archive import Archive
-
-from .test_01_borgapi import BorgapiTests
-
-
-class RenameTests(BorgapiTests):
-    """Rename command tests"""
-
-    def setUp(self):
-        super().setUp()
-        self._create_default()
-
-    def test_01_basic(self):
-        """Rename a archive"""
-        output = self.api.list(self.repo, json=True)
-        original_name = output["archives"][0]["name"]
-        self.api.rename(self.archive, "2")
-        output = self.api.list(self.repo, json=True)
-        new_name = output["archives"][0]["name"]
-        self.assertNotEqual(new_name, original_name, "Name change did not occur")
-        self.assertEqual(new_name, "2", "Name did not change to expected output")
-
-    def test_02_no_exist(self):
-        """Rename nonexistant archive"""
-        self.assertRaises(
-            Archive.DoesNotExist,
-            self.api.rename,
-            f"{self.repo}::2",
-            "3",
-            msg="Renamed archive that does not exist",
-        )

test/borgapi/test_06_list.py

@@ -1,59 +0,0 @@
-"""Test list command"""
-from .test_01_borgapi import BorgapiTests
-
-
-class ListTests(BorgapiTests):
-    """List command tests"""
-
-    def setUp(self):
-        super().setUp()
-        self._create_default()
-
-    def test_01_basic(self):
-        """List repo archvies and archive files"""
-        output = self.api.list(self.repo, json=True)
-        num_archvies = len(output["archives"])
-        self.assertEqual(num_archvies, 1, "Unexpected number of archives returned")
-
-        output = self.api.list(self.archive, json_lines=True)
-        num_files = len(output)
-        self.assertEqual(num_files, 3, "Unexpected number of files returned")
-
-    def test_02_repo_basic(self):
-        """List repo"""
-        output = self.api.list(self.repo)
-        self._display("list repo", output)
-        self.assertType(output, str)
-
-    def test_03_repo_short(self):
-        """List repo short"""
-        output = self.api.list(self.repo, short=True)
-        self._display("list repo short", output)
-        self.assertType(output, str)
-
-    def test_04_repo_json(self):
-        """List repo json"""
-        output = self.api.list(self.repo, json=True)
-        self._display("list repo json", output)
-        self.assertAnyType(output, list, dict)
-        output = self.api.list(self.repo, log_json=True)
-        self._display("list repo log json", output)
-        self.assertAnyType(output, str)
-
-    def test_05_archive_basic(self):
-        """List archive"""
-        output = self.api.list(self.archive)
-        self._display("list archive", output)
-        self.assertType(output, str)
-
-    def test_06_archive_short(self):
-        """List archive short"""
-        output = self.api.list(self.archive, short=True)
-        self._display("list archive short", output)
-        self.assertType(output, str)
-
-    def test_07_archive_json(self):
-        """List archive json"""
-        output = self.api.list(self.archive, json_lines=True)
-        self._display("list archive json", output)
-        self.assertAnyType(output, list, dict)

test/borgapi/test_07_diff.py

@@ -1,54 +0,0 @@
-"""Test deff command"""
-from .test_01_borgapi import BorgapiTests
-
-
-class DiffTests(BorgapiTests):
-    """Diff command tests"""
-
-    def setUp(self):
-        super().setUp()
-        self._create_default()
-
-    def test_01_add_file(self):
-        """Diff new file"""
-        with open(self.file_3, "w") as fp:
-            fp.write(self.file_3_text)
-        self.api.create(f"{self.repo}::2", self.data)
-        output = self.api.diff(self.archive, "2", json_lines=True)
-        self.assertType(output, dict)
-        modify_path = output["path"]
-        modify_type = output["changes"][0]["type"]
-        self.assertEqual(modify_path, self.file_3, "Unexpected new filename")
-        self.assertEqual(modify_type, "added", "New file not listed as added")
-
-    def test_02_modify_file(self):
-        """Diff modified file"""
-        with open(self.file_3, "w") as fp:
-            fp.write(self.file_3_text)
-        with open(self.file_2, "w") as fp:
-            fp.write(self.file_3_text)
-        self.api.create(f"{self.repo}::2", self.data)
-        output = self.api.diff(self.archive, "2", json_lines=True, sort=True)
-        self.assertType(output, list)
-        modify_path = output[0]["path"]
-        modify_type = output[0]["changes"][0]["type"]
-        self.assertEqual(modify_path, self.file_2, "Unexpected file changed")
-        self.assertEqual(modify_type, "modified", "Unexpected change type")
-
-    def test_03_output(self):
-        """Diff string"""
-        with open(self.file_3, "w") as fp:
-            fp.write(self.file_3_text)
-        self.api.create(f"{self.repo}::2", self.data)
-        output = self.api.diff(self.archive, "2")
-        self._display("diff sting", output)
-        self.assertType(output, str)
-
-    def test_04_output_json(self):
-        """Diff json"""
-        with open(self.file_3, "w") as fp:
-            fp.write(self.file_3_text)
-        self.api.create(f"{self.repo}::2", self.data)
-        output = self.api.diff(self.archive, "2", log_json=True)
-        self._display("diff log json", output)
-        self.assertAnyType(output, str)

test/borgapi/test_08_delete.py

@@ -1,68 +0,0 @@
-"""Test delete command"""
-from borg.archive import Archive
-from borg.repository import Repository
-
-from .test_01_borgapi import BorgapiTests
-
-
-class DeleteTests(BorgapiTests):
-    """Delete command tests"""
-
-    def test_01_repository(self):
-        """Delete repository"""
-        self._create_default()
-        self.api.delete(self.repo)
-        self.assertRaises(
-            Repository.DoesNotExist,
-            self.api.list,
-            self.repo,
-            msg="Deleted repository still exists",
-        )
-
-    # pylint: disable=invalid-name
-    def test_02_repository_not_exist(self):
-        """Delete repository that doesn't exist"""
-        self._make_clean(self.repo)
-        self.assertRaises(
-            Repository.InvalidRepository,
-            self.api.delete,
-            self.repo,
-            msg="Deleted nonexistant repository",
-        )
-
-    def test_03_archive(self):
-        """Delete archive"""
-        self._create_default()
-        self.api.delete(self.archive)
-        self.assertRaises(
-            Archive.DoesNotExist,
-            self.api.list,
-            self.archive,
-            msg="Deleted archive still exists",
-        )
-
-    def test_04_archive_not_exist(self):
-        """Delete archvie that doesn't exist"""
-        with self.assertLogs("borg", "WARNING") as logger:
-            self.api.delete(self.archive)
-
-        message = logger.records[0].getMessage()
-        self.assertRegex(
-            message,
-            r".*?1.*not found",
-            "Warning not logged for bad archive name",
-        )
-
-    def test_05_stats_string(self):
-        """Archvie stats string"""
-        self._create_default()
-        output = self.api.delete(self.archive, stats=True)
-        self._display("delete 1", output)
-        self.assertType(output, str)
-
-    def test_06_stats_json(self):
-        """Archvie stats json"""
-        self._create_default()
-        output = self.api.delete(self.archive, stats=True, log_json=True)
-        self._display("delete 2", output)
-        self.assertType(output, list, dict)

test/borgapi/test_09_prune.py

@@ -1,48 +0,0 @@
-"""Test prune command"""
-from os import remove
-from time import sleep
-
-from .test_01_borgapi import BorgapiTests
-
-
-class PruneTests(BorgapiTests):
-    """Prune command tests"""
-
-    def setUp(self):
-        super().setUp()
-        self._create_default()
-        sleep(1)
-        with open(self.file_3, "w") as fp:
-            fp.write(self.file_3_text)
-        self.api.create(f"{self.repo}::2", self.data)
-        sleep(1)
-        remove(self.file_1)
-        self.api.create(f"{self.repo}::3", self.data)
-        sleep(1)
-        with open(self.file_2, "w") as fp:
-            fp.write(self.file_1_text)
-        self.api.create(f"{self.repo}::4", self.data)
-        sleep(1)
-        remove(self.file_2)
-        self.api.create(f"{self.repo}::5", self.data)
-        sleep(1)
-
-    # pylint: disable=invalid-sequence-index
-    def test_01_basic(self):
-        """Prune archives"""
-        self.api.prune(self.repo, keep_last="3")
-        output = self.api.list(self.repo, json=True)
-        num_archives = len(output["archives"])
-        self.assertEqual(num_archives, 3, "Unexpected number of archvies pruned")
-
-    def test_02_output_list(self):
-        """Prune output list"""
-        output = self.api.prune(self.repo, keep_last="3", dry_run=True, list=True)
-        self._display("prune list", output)
-        self.assertType(output, str)
-
-    def test_03_output_stats(self):
-        """Prune output stats"""
-        output = self.api.prune(self.repo, keep_last="3", dry_run=True, stats=True)
-        self._display("prune stats", output)
-        self.assertType(output, str)

test/borgapi/test_10_info.py

@@ -1,50 +0,0 @@
-"""Test info command"""
-from .test_01_borgapi import BorgapiTests
-
-
-class InfoTests(BorgapiTests):
-    """Info command tests"""
-
-    def setUp(self):
-        super().setUp()
-        self._create_default()
-
-    def test_01_repository(self):
-        """Repository info"""
-        output = self.api.info(self.repo, json=True)
-        self.assertKeyExists("cache", output)
-        self.assertKeyNotExists("archives", output)
-
-    def test_02_archive(self):
-        """Archive info"""
-        output = self.api.info(self.archive, json=True)
-        self.assertKeyExists("cache", output)
-        self.assertKeyExists("archives", output)
-
-    def test_03_repo_string(self):
-        """Repo output string"""
-        output = self.api.info(self.repo)
-        self._display("info repo string", output)
-        self.assertType(output, str)
-
-    def test_04_repo_json(self):
-        """Repo output json"""
-        output = self.api.info(self.repo, json=True)
-        self._display("info repo json", output)
-        self.assertAnyType(output, list, dict)
-
-        output = self.api.info(self.repo, log_json=True)
-        self._display("info repo log json", output)
-        self.assertType(output, str)
-
-    def test_05_archive_string(self):
-        """Archive output string"""
-        output = self.api.info(self.archive)
-        self._display("info archive string", output)
-        self.assertType(output, str)
-
-    def test_06_archive_json(self):
-        """Archive output json"""
-        output = self.api.info(self.archive, json=True)
-        self._display("info archive json", output)
-        self.assertAnyType(output, list, dict)

test/borgapi/test_11_mount.py

@@ -1,50 +0,0 @@
-"""Test mount and unmount commands"""
-from os import getenv
-from os.path import join
-from shutil import rmtree
-from time import sleep
-
-from .test_01_borgapi import BorgapiTests
-
-
-class MountTests(BorgapiTests):
-    """Mount and Unmount command tests"""
-
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        cls.mountpoint = join(cls.temp, "mount")
-        cls.repo_file = join(cls.mountpoint, "1", cls.file_1)
-        cls.archive_file = join(cls.mountpoint, cls.file_1)
-
-    def setUp(self):
-        if getenv("BORGAPI_TEST_MOUNT_SKIP"):
-            self.skipTest("llfuse not setup")
-        super().setUp()
-        self._create_default()
-        self._make_clean(self.mountpoint)
-
-    def tearDown(self):
-        if not getenv("BORGAPI_TEST_KEEP_TEMP"):
-            rmtree(self.mountpoint)
-        super().tearDown()
-
-    def test_01_repository(self):
-        """Mount and unmount a repository"""
-        output = self.api.mount(self.repo, self.mountpoint)
-        sleep(5)
-        self.assertTrue(output["pid"] != 0)
-        self.assertFileExists(self.repo_file)
-        self.api.umount(self.mountpoint)
-        self.assertFileNotExists(self.repo_file)
-        sleep(3)
-
-    def test_02_archive(self):
-        """Mount and unmount a archive"""
-        output = self.api.mount(self.archive, self.mountpoint)
-        sleep(5)
-        self.assertTrue(output["pid"] != 0)
-        self.assertFileExists(self.archive_file)
-        self.api.umount(self.mountpoint)
-        self.assertFileNotExists(self.archive_file)
-        sleep(3)

test/borgapi/test_12_key.py

@@ -1,81 +0,0 @@
-"""Test key commands"""
-from os.path import join
-from shutil import rmtree
-
-from .test_01_borgapi import BorgapiTests
-
-
-class KeyTests(BorgapiTests):
-    """Key command tests"""
-
-    @classmethod
-    def setUpClass(cls):
-        super().setUpClass()
-        cls.export_dir = join(cls.temp, "export")
-        cls.key_file = join(cls.export_dir, "key.txt")
-
-    def setUp(self):
-        """Setup export / import tests"""
-        super().setUp()
-        self._make_clean(self.export_dir)
-        self._create_default()
-
-    def tearDown(self):
-        """Tear down export / import tests"""
-        rmtree(self.export_dir)
-        super().tearDown()
-
-    def test_01_change_passphrase(self):
-        """Change key passphrase"""
-        repo_config_file = join(self.repo, "config")
-        repo_config = self._read_config(filename=repo_config_file)
-
-        original_value = repo_config["repository"]["key"]
-
-        self.api.set_environ(dictionary={"BORG_NEW_PASSPHRASE": "newpass"})
-        self.api.key_change_passphrase(self.repo)
-        self.api.unset_environ("BORG_NEW_PASSPHRASE")
-
-        repo_config = self._read_config(filename=repo_config_file)
-        key_change_value = repo_config["repository"]["key"]
-
-        self.assertNotEqual(
-            key_change_value,
-            original_value,
-            "Changed key matches original",
-        )
-
-    def test_02_export(self):
-        """Export repo excryption key"""
-        self.api.key_export(self.repo, self.key_file)
-        self.assertFileExists(
-            self.key_file,
-            "Repo key not exported to expected location",
-        )
-
-    def test_03_export_paper(self):
-        """Export repo excryption key"""
-        self.api.key_export(self.repo, self.key_file, paper=True)
-        self.assertFileExists(
-            self.key_file,
-            "Repo key not exported to expected location",
-        )
-
-    def test_04_import(self):
-        """Import original key to repository"""
-        self.api.key_export(self.repo, self.key_file)
-
-        repo_config_file = join(self.repo, "config")
-        repo_config = self._read_config(filename=repo_config_file)
-        original_value = repo_config["repository"]["key"]
-
-        self.api.key_import(self.repo, self.key_file)
-
-        repo_config = self._read_config(filename=repo_config_file)
-        restored_value = repo_config["repository"]["key"]
-
-        self.assertEqual(
-            restored_value,
-            original_value,
-            "Restored key does not match original",
-        )

test/borgapi/test_13_export_tar.py

@@ -1,38 +0,0 @@
-"""Test export tar command"""
-from os.path import join
-from shutil import rmtree
-
-from .test_01_borgapi import BorgapiTests
-
-
-class ExportTarTests(BorgapiTests):
-    """Export Tar command tests"""
-
-    def setUp(self):
-        super().setUp()
-        self._create_default()
-
-        self.export_dir = join(self.temp, "export")
-        self._make_clean(self.export_dir)
-        self.tar_file = join(self.export_dir, "export.tar")
-
-    def tearDown(self):
-        rmtree(self.export_dir)
-        super().tearDown()
-
-    def test_01_basic(self):
-        """Export tar file"""
-        self.api.export_tar(self.archive, self.tar_file)
-        self.assertFileExists(self.tar_file, "Tar file not exported")
-
-    def test_02_stdout(self):
-        """Export tar stdout"""
-        output = self.api.export_tar(self.archive, "-")
-        self._display("export tar 2", output)
-        self.assertType(output, bytes)
-
-    def test_03_output_json(self):
-        """Export tar output"""
-        output = self.api.export_tar(self.archive, self.tar_file, list=True)
-        self._display("export tar 1", output)
-        self.assertType(output, str)