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

{borgapi-0.6.1.dist-info → borgapi-0.7.1.dist-info}/METADATA

@@ -1,27 +1,30 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: borgapi
-Version: 0.6.1
+Version: 0.7.1
 Summary: Wrapper for borgbackup to easily use in code
-Home-page: https://github.com/spslater/borgapi
-Author: Sean Slater
-Author-email: seanslater@whatno.io
-License: MIT License
-Keywords: borgbackup backup api
+Author-email: Sean Slater <seanslater@whatno.io>
+Project-URL: homepage, https://github.com/spslater/borgapi
+Project-URL: documentation, https://github.com/spslater/borgapi/blob/master/README.md
+Project-URL: repository, https://github.com/spslater/borgapi.git
+Project-URL: issues, https://github.com/spslater/borgapi/issues
+Project-URL: changelog, https://github.com/spslater/borgapi/blob/master/CHANGELOG.md
+Keywords: borgbackup,backup,api
 Classifier: Development Status :: 4 - Beta
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Operating System :: OS Independent
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Topic :: Utilities
 Classifier: Topic :: System :: Archiving :: Backup
-Requires-Python: >=3.8
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: borgbackup[llfuse] (==1.2.4)
-Requires-Dist: python-dotenv (>=1.0.0)
+Requires-Dist: borgbackup[llfuse]~=1.4.0
+Requires-Dist: python-dotenv~=1.0.0
+Dynamic: license-file
 
 # BorgAPI
 
@@ -36,10 +39,10 @@ pip install borgapi
 ```
 
 Requires:
-* `borgbackup`: 1.2.4
-* `python-dotenv`: 1.0.0
+* `borgbackup`: 1.4.0
+* `python-dotenv`: 1.0.1
 
-Supports Python 3.8 to 3.11
+Supports Python 3.9 to 3.13
 
 ## Usage
 ```python
@@ -48,12 +51,12 @@ import borgapi
 api = borgapi.BorgAPI(defaults={}, options={})
 
 # Initalize new repository
-api.init("/foo/bar", make_parent_dirs=True)
+api.init("foo/bar", make_parent_dirs=True)
 
 # Create backup 
-result = api.create("/foo/bar::backup", "/home", "/mnt/baz", json=True)
+result = api.create("foo/bar::backup", "/home", "/mnt/baz", json=True)
 print(result['archive']["name"]) # backup
-print(result["repository"]["location"]) # /foo/bar
+print(result["repository"]["location"]) # foo/bar
 ```
 
 ### BorgAPI Init arguments
@@ -62,7 +65,8 @@ class BorgAPI(
     defaults: dict = None,
     options: dict = None,
     log_level: str = "warning",
-    log_json: bool = False
+    log_json: bool = False,
+    environ: dict = None,
 )
 ```
 * __defaults__: dictionary that has command names as keys and value that is a dict of
@@ -96,12 +100,35 @@ class BorgAPI(
   level as and keyword argument
 * __log_json__: log lines written by logger are formatted as json lines, passed into the
   logging setup
+* __environ__: dictionary that contains environmental variables that should be set before running
+  any commands. Useful for setting the passphrase or passcommand for the repository or other
+  settings like that. See [Environment Variables](#Setting-Environment-Variables) section for
+  how to set environmental variables after initalization or what the defaults are.
+```python
+{
+  "BORG_CHECK_I_KNOW_WHAT_I_AM_DOING": "YES",
+  "BORG_PASSCOMMAND": "cat ~/.borg/password",
+}
+```
 
 ### Setting Environment Variables
 You are able to manage the environment variables used by borg to be able to use different settings
 for different repositories.
 
-There are 3 ways you can set the variables:
+When initialzing the `BorgAPI` object, you can include a dictionary with the `environ` argument.
+
+The following are the defaults that BorgAPI will always load so that user input does not hold up
+the app from progressing.
+```ini
+BORG_EXIT_CODES=modern,
+BORG_PASSPHRASE="",
+BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK=no,
+BORG_RELOCATED_REPO_ACCESS_IS_OK=no,
+BORG_CHECK_I_KNOW_WHAT_I_AM_DOING=NO,
+BORG_DELETE_I_KNOW_WHAT_I_AM_DOING=NO,
+```
+
+There are 3 ways you can set the variables after initialization:
 1. `filename`: Path to a file that contains the variables and their values. See the
    [python-dotenv README](https://github.com/theskumar/python-dotenv/blob/master/README.md#file-format)
    for more information.
@@ -124,14 +151,6 @@ will be used, which is searching for a ".env" file somewhere above in the curren
 [Environment Variables](https://borgbackup.readthedocs.io/en/stable/usage/general.html#environment-variables)
 used by `borgbackup`.
 
-#### IMPORTANT
-For commands that borg requires a confirmation on if no environment variable is given, the api will
-become stuck as it waits for a `yes` or `no` answer.
-* BORG_UNKNOWN_UNENCRYPTED_REPO_ACCESS_IS_OK
-* BORG_RELOCATED_REPO_ACCESS_IS_OK
-* BORG_CHECK_I_KNOW_WHAT_I_AM_DOING
-* BORG_DELETE_I_KNOW_WHAT_I_AM_DOING
-
 ### Removing Environment Variables
 If you want to unset a variable so it doesn't get used for another command you can use the
 `unset_environ` method. It'll remove any variables passed in from the current environment.
@@ -158,7 +177,7 @@ So the `--storage-quota` argument in `init` gets turned into the keyword argumen
 
 ```python
 api.init(
-    repository="/foor/bar",
+    repository="foor/bar",
     encryption="repokey",
     append_only=True,
     storage_quota="5G",
@@ -175,9 +194,9 @@ diff_args = {
 }
 
 api.diff(
-    "/foo/bar::tuesday",
+    "foo/bar::tuesday",
     "friday",
-    "/foo/bar",
+    "foo/bar",
     "/baz",
     **diff_args,
 )
@@ -197,20 +216,18 @@ api.diff(
 * info
 * mount
 * umount
-* key_change_passphrase (key change-passphrase)
-* key_export (key export)
-* key_import (key import)
+* key change-passphrase (key_change_passphrase)
+* key export (key_export)
+* key import (key_import)
 * upgrade
-* export_tar
+* recreate
+* immport-tar (immport_tar)
+* export-tar (export_tar)
 * serve
 * config
-* with-lock
-* break-lock
-* benchmark crud
-
-### Unavailable Borg Commands
-* recreate
-  * Since this is an experimental feature there are no current plans to implament this.
+* with-lock (with_lock)
+* break-lock (break_lock)
+* benchmark crud (benchmark_crud)
 
 ### Command Quirks
 Things that were changed from the way the default borg commands work to make things a bit
@@ -235,7 +252,8 @@ which outputs the stats info as a json object, it gets written to stdout.
 
 If either `json` or `log_json` is set, it'll try to convert the tuple output to json.
 If it is unable and there is output that is captured it'll return the plaintext value.
-If no output is captured, it returns `None`.
+If no output is captured, it returns `None` if expecting a string or `{}` (an empty
+dictionary) if expection some kind of JSON output.
 
 If multiple outputs are requested at the same time (like `--stats` and `--list`) the command
 will return a dictionary with aptly named keys (`--list` key is "list"). If only one output
@@ -267,6 +285,12 @@ Commands not listed return no output (None)
   - info: `--info`
 - info
   - always returns bare value
+- recreate:
+  - list: `--list`, `--log-json`
+  - stats: `--stats`
+- import tar
+  - list: `--list`
+  - stats: `--stats`, `--json`
 - export tar
   - list: `--list`, `--log-json`
   - tar: filename == "-"
@@ -277,7 +301,7 @@ Commands not listed return no output (None)
   - always returns bare value
 
 ## Roadmap
-- Start work on Borg's beta branch chagnes and keeping up with those
+- Start work on Borg's beta branch again and keeping up with those
 
 ## Links
 * [PyPi Project](https://pypi.org/project/borgapi)

borgapi-0.7.1.dist-info/RECORD

@@ -0,0 +1,10 @@
+borgapi/__init__.py,sha256=UksYdsjxl0cESQ_VZ0ye64JpZtQzlrnU5UiUiqxpLRc,1469
+borgapi/borgapi.py,sha256=Wxv4bupAsOn2h5h3NYjGP65CdX1Gl47MbtHaLckCrg0,52079
+borgapi/capture.py,sha256=bYnvo4JvjAkYVRFYnf1Mn-yeVkmBvmwL0m2obCb8TUk,12533
+borgapi/helpers.py,sha256=wI41AL1VjQHwAJeqXvY94jZS5SrQVvGM0Pf2o3d2RoM,710
+borgapi/options.py,sha256=tVD30frgYnUS9GmJbAyxuP_DdsjUn8_ImZV39VE7JHo,31835
+borgapi-0.7.1.dist-info/licenses/LICENSE,sha256=g7PjdvkUMJa85GMb6zUCyW8aX_yk5Ym1x7if5W5ULPI,1050
+borgapi-0.7.1.dist-info/METADATA,sha256=T6WyITECYLzD49XsJvflnZFFz7AjpyFNnaWDAdqMZ2c,10204
+borgapi-0.7.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+borgapi-0.7.1.dist-info/top_level.txt,sha256=Ena1GrMubckEQBF7NtgxYXqFP_9for5BS7xFOLiGONo,8
+borgapi-0.7.1.dist-info/RECORD,,

{borgapi-0.6.1.dist-info → borgapi-0.7.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.40.0)
+Generator: setuptools (80.10.2)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{borgapi-0.6.1.dist-info → borgapi-0.7.1.dist-info}/top_level.txt

@@ -1,2 +1 @@
 borgapi
-test

borgapi-0.6.1.dist-info/RECORD

@@ -1,27 +0,0 @@
-borgapi/__init__.py,sha256=djERfEQ24Ray3amPnnW4kad1OLKVqe5hLWnBxyTI_vM,111
-borgapi/borgapi.py,sha256=tq7nJInEmQay5Aez_rpECmLzmQSNYH6MiYPB3XK1g8o,40094
-borgapi/options.py,sha256=Iqp80mIb4sJY3COVjiokkxLnCJJqHqf2_iVdgPpyeIE,29327
-test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-test/test_00_options.py,sha256=cypNm4WNYsAqtbOlqFudPJujE8KUDUSowo5hmqjaSew,2220
-test/borgapi/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-test/borgapi/test_01_borgapi.py,sha256=jfW5zD_phBIRsnMrqThWm36oibujkHU6Q9S5gGA3t9M,7530
-test/borgapi/test_02_init.py,sha256=VJIqpSG73YMOccsa-pXBcRBbI6MJLACWFCYoVguXnPE,2471
-test/borgapi/test_03_create.py,sha256=f3Z1iQ_Qr06ztUa_r70VbigypPu_-ZL1w0rEheddw0g,4883
-test/borgapi/test_04_extract.py,sha256=zb9UrdpGC-HhrM1O5_evAkrddNvsLGVoumK9LNsLw8E,1598
-test/borgapi/test_05_rename.py,sha256=wRLx44-u6yIa_Z1MpR_BMTwmBtWGItZOqvO99NeuVIo,999
-test/borgapi/test_06_list.py,sha256=2xW5DmQsVaVffX8RaQo5NjNE2QvgSdkiU9UTIwkF46U,2028
-test/borgapi/test_07_diff.py,sha256=qMie1yZKDGCvUn5-pP-B3RCcc2tsJAYZVHnlluctZpw,2075
-test/borgapi/test_08_delete.py,sha256=S0y6-J4qYlipuuZxOGtJoIAIAupGsQpDKk8AW_aGtRM,2050
-test/borgapi/test_09_prune.py,sha256=lZm_gsETCf4m2JhrWblu-E0HMBHKqkYYzSnwHDPW75w,1578
-test/borgapi/test_10_info.py,sha256=zlUsm00p2E71AKJAjQL7AlZqVW4Ua7GgmFY7LhOwuwQ,1624
-test/borgapi/test_11_mount.py,sha256=2bIWHRMWcjnS5rMOR1erxmfNtOzIHaFlGxI_O412W_c,1555
-test/borgapi/test_12_key.py,sha256=vLyCtt0twjmBpfh9-gJ0vXVNq3qnn2VwcN-h_yAUDM8,2514
-test/borgapi/test_13_export_tar.py,sha256=qd1HXdO8y9Gy16JJ80VFkDj0RaJ9JJXu9df69M81dx4,1132
-test/borgapi/test_14_config.py,sha256=eQqHdzYrBEAuAbVXAkTKacFxbXpb89sFrn7h9_OAdW0,1668
-test/borgapi/test_15_benchmark_crud.py,sha256=rabhvkRe5AM8R4HDrFOE0pC9M8alSRtsJripUDTemL4,759
-test/borgapi/test_16_compact.py,sha256=zGsAxv6E4eHgJPxKOJCQrzSEmchLjIPza_PDEO05xmA,1017
-borgapi-0.6.1.dist-info/LICENSE,sha256=g7PjdvkUMJa85GMb6zUCyW8aX_yk5Ym1x7if5W5ULPI,1050
-borgapi-0.6.1.dist-info/METADATA,sha256=FdIoXb0Wxq27FnRVba5dxrqd7PaMVOYy5ZoyXeYh1NE,9085
-borgapi-0.6.1.dist-info/WHEEL,sha256=pkctZYzUS4AYVn6dJ-7367OJZivF2e8RA9b_ZBjif18,92
-borgapi-0.6.1.dist-info/top_level.txt,sha256=23Hbpr8OhmPV1WMBvLmZOwEC-3buY84J7ZckxsN7Id4,13
-borgapi-0.6.1.dist-info/RECORD,,

test/borgapi/test_01_borgapi.py

@@ -1,226 +0,0 @@
-"""Test borgapi module"""
-import logging
-import unittest
-from configparser import ConfigParser
-from os import getenv, makedirs, remove
-from os.path import exists, join
-from shutil import rmtree
-
-from dotenv import load_dotenv
-
-from borgapi import BorgAPI
-
-
-# pylint: disable=too-many-public-methods
-class BorgapiTests(unittest.TestCase):
-    """Test for the borgbackup self.api"""
-
-    # pylint: disable=invalid-name
-    @staticmethod
-    def assertFileExists(path, msg=None):
-        """Assert if a path exists or not"""
-        if not exists(path):
-            raise AssertionError(msg or f"{path} does not exist")
-
-    @staticmethod
-    def assertFileNotExists(path, msg=None):
-        """Assert if a path exists or not"""
-        if exists(path):
-            raise AssertionError(msg or f"{path} does exist")
-
-    @staticmethod
-    def assertKeyExists(key, dictionary, msg=None):
-        """Assert a key exists in a dictionary"""
-        if key not in dictionary:
-            raise AssertionError(msg or f"{key} does not exist in dictionary")
-
-    @staticmethod
-    def assertKeyNotExists(key, dictionary, msg=None):
-        """Assert a key does not exist in a dictionary"""
-        if key in dictionary:
-            raise AssertionError(msg or f"{key} exists in dictionary")
-
-    @staticmethod
-    def assertType(obj, type_, msg=None):
-        """Assert an object is an instance of type"""
-        if not isinstance(obj, type_):
-            raise AssertionError(msg or f"{obj} is not type {type_}, it is {type(obj)}")
-
-    @staticmethod
-    def assertAnyType(obj, *types, msg=None):
-        """Assert an object is an instance of type"""
-        if not any([isinstance(obj, t) for t in types]):
-            raise AssertionError(
-                msg or f"{obj} is not any of {types}; it is {type(obj)}"
-            )
-
-    @staticmethod
-    def assertSubclass(obj, class_, msg=None):
-        """Assert an object is an subclass of class"""
-        if not issubclass(obj, class_):
-            raise AssertionError(msg or f"{obj} is not a subtype of {class_}")
-
-    @staticmethod
-    def assertNone(obj, msg=None):
-        """Assert an object is None"""
-        if obj is not None:
-            raise AssertionError(msg or f"Value is not None: {obj}")
-
-    @staticmethod
-    def assertNotNone(obj, msg=None):
-        """Assert an object is None"""
-        if obj is None:
-            raise AssertionError(msg or "Value is None")
-
-    @staticmethod
-    def _try_pass(error, func, *args, **kwargs):
-        try:
-            func(*args, **kwargs)
-        except error:
-            pass
-
-    @staticmethod
-    def _make_clean(directory):
-        try:
-            makedirs(directory)
-        except FileExistsError:
-            rmtree(directory)
-            makedirs(directory)
-
-    @staticmethod
-    def _read_config(string=None, filename=None):
-        """Convert config string into dictionary"""
-        config = ConfigParser()
-        if filename:
-            with open(filename, "r") as fp:
-                config.read_file(fp)
-        else:
-            config.read_string(string)
-        return config
-
-    @staticmethod
-    def _display(header, output, single=True):
-        """display captured output"""
-        if getenv("BORGAPI_TEST_OUTPUT_DISPLAY"):
-            print(header)
-            if single:
-                print(output)
-            else:
-                for name, value in output.items():
-                    print(f"~~~~~~~~~~ {name} ~~~~~~~~~~")
-                    print(value)
-            print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~")
-            print()
-
-    @classmethod
-    def setUpClass(cls):
-        """Initalize environment for borg use"""
-
-        cls.temp = "test/temp"
-        cls.data = join(cls.temp, "data")
-        cls.repo = join(cls.temp, "repo")
-        cls.logs = join(cls.temp, "logs")
-
-        cls.archive = f"{cls.repo}::1"
-
-        cls._try_pass(FileNotFoundError, rmtree, cls.data)
-        cls._try_pass(FileNotFoundError, rmtree, cls.repo)
-        if not getenv("BORGAPI_TEST_KEEP_LOGS"):
-            cls._try_pass(FileNotFoundError, rmtree, cls.logs)
-
-        cls.file_1 = join(cls.data, "file_1.txt")
-        cls.file_1_text = "Hello World"
-        cls.file_2 = join(cls.data, "file_2.txt")
-        cls.file_2_text = "Goodbye Fools"
-        cls.file_3 = join(cls.data, "file_3.txt")
-        cls.file_3_text = "New File Added"
-
-        cls._try_pass(FileExistsError, makedirs, cls.data)
-        cls._try_pass(FileExistsError, makedirs, cls.repo)
-        cls._try_pass(FileExistsError, makedirs, cls.logs)
-        load_dotenv("test/res/test_env")
-
-    @classmethod
-    def tearDownClass(cls):
-        """Remove temp directory"""
-        if not getenv("BORGAPI_TEST_KEEP_LOGS") and not getenv(
-            "BORGAPI_TEST_KEEP_TEMP"
-        ):
-            cls._try_pass(FileNotFoundError, rmtree, cls.temp)
-
-    def setUp(self):
-        """Setup files data"""
-        self._try_pass(FileExistsError, makedirs, self.data)
-        self._try_pass(FileExistsError, makedirs, self.repo)
-        self._try_pass(FileExistsError, makedirs, self.logs)
-
-        with open(self.file_1, "w") as fp:
-            fp.write(self.file_1_text)
-        with open(self.file_2, "w") as fp:
-            fp.write(self.file_2_text)
-
-        self._try_pass(FileNotFoundError, remove, self.file_3)
-
-        self.api = BorgAPI()
-        self.api.init(self.repo)
-
-    def tearDown(self):
-        """Resets mess made"""
-        if not getenv("BORGAPI_TEST_KEEP_TEMP"):
-            self._try_pass(FileNotFoundError, rmtree, self.data)
-            self._try_pass(FileNotFoundError, rmtree, self.repo)
-            if not getenv("BORGAPI_TEST_KEEP_LOGS"):
-                self._try_pass(FileNotFoundError, rmtree, self.logs)
-
-    def _create_default(self):
-        self.api.create(self.archive, self.data)
-
-
-class SingleTests(BorgapiTests):
-    """Simple Command and Class Methodss tests"""
-
-    def test_01_borgapi_logger(self):
-        """Verify loggers are setup correctly for borgapi"""
-        loggers = logging.root.manager.loggerDict
-        self.assertIn("borgapi", loggers, "borgapi logger not present")
-        self.assertIn("borg", loggers, "borg logger not present")
-
-    def test_02_set_environ(self):
-        """Set new env variable"""
-        key = "TEST_VARIABLE"
-
-        with open(self.file_3, "w") as fp:
-            fp.write(f"{key}={self.file_3_text}")
-        self.api.set_environ(filename=self.file_3)
-        got = getenv(key)
-        self.assertEqual(got, self.file_3_text)
-
-        self.api.set_environ(dictionary={key: self.file_1_text})
-        got = getenv(key)
-        self.assertEqual(got, self.file_1_text)
-
-        self.api.set_environ(**{key: self.file_2_text})
-        got = getenv(key)
-        self.assertEqual(got, self.file_2_text)
-
-    def test_03_unset_environ(self):
-        """Remove env variable"""
-        key = "TEST_VARIABLE"
-
-        self.api.set_environ(**{key: self.file_1_text})
-        got = getenv(key)
-        self.assertEqual(got, self.file_1_text)
-        self.api.unset_environ(key)
-        got = getenv(key)
-        self.assertFalse(got)
-
-        with open(self.file_3, "w") as fp:
-            fp.write(f"{key}={self.file_3_text}")
-        self.api.set_environ(filename=self.file_3)
-        self.api.unset_environ()
-        got = getenv(key)
-        self.assertFalse(got)
-
-    @unittest.skip("WIP: Don't know what locking would be used for")
-    def test_04_lock(self):
-        """Don't know what locking would be used for, so don't know how to test"""

test/borgapi/test_02_init.py

@@ -1,78 +0,0 @@
-"""Test init command"""
-from os import urandom
-from os.path import join
-
-from borg.repository import Repository
-
-from .test_01_borgapi import BorgapiTests
-
-
-class InitTests(BorgapiTests):
-    """Init command tests"""
-
-    def setUp(self):
-        super().setUp()
-        self._make_clean(self.repo)
-
-    def test_01_basic(self):
-        """Initalize new repository"""
-        self.api.init(self.repo)
-        self.assertFileExists(join(self.repo, "README"))
-
-    def test_02_already_exists(self):
-        """Initalize a repo in a directory where one already exists"""
-        self.api.init(self.repo)
-        self.assertRaises(
-            Repository.AlreadyExists,
-            self.api.init,
-            self.repo,
-            msg="Duplicate repositroy overwrites old repo",
-        )
-
-    def test_03_path_exists(self):
-        """Initalize a repo in a directory where other data exists"""
-        self.api.init(self.repo)
-        self.assertRaises(
-            Repository.PathAlreadyExists,
-            self.api.init,
-            self.data,
-            msg="Repositroy overwrites directory with other data",
-        )
-
-    def test_04_make_parent(self):
-        """Init a repo where parents don't exist with different flags"""
-        deep_repo = join(self.repo, "make/parents")
-
-        self.assertRaises(
-            Repository.ParentPathDoesNotExist,
-            self.api.init,
-            deep_repo,
-            msg="Repository made with missing directories",
-        )
-        self.api.init(deep_repo, make_parent_dirs=True)
-        output = self.api.list(deep_repo, json=True)
-        self.assertKeyExists("repository", output, "Repository not initalzied")
-
-    def test_05_storage_quota(self):
-        """Limit the size of the repo"""
-        self.api.init(self.repo, storage_quota="10M")
-        with open(self.file_3, "wb") as fp:
-            fp.write(urandom(10 * 1024 * 1024))
-        self.assertRaises(
-            Repository.StorageQuotaExceeded,
-            self.api.create,
-            self.archive,
-            self.data,
-            msg="Stored more than quota allowed",
-        )
-
-    def test_06_append_only(self):
-        """Repo in append only mode"""
-        self.api.init(self.repo, append_only=True)
-        output = self.api.config(self.repo, list=True)
-        config = self._read_config(output)
-        self.assertEqual(
-            config["repository"]["append_only"],
-            "1",
-            "Repo not in append_only mode",
-        )