Merge ~dash3/charm-duplicity:lp/1981596 into charm-duplicity:master

[Nishant Dash]

MR-2 for lp 1981596, updated MR 431126; Refactored lib_duplicity + unit and functional tests; small fix for tox
+ removed old dict constructors from test_duplicity functional test
+ Improvements and Cleanup

To fully support a retention period (lp:1981596), deletion command support will first need
to be added to the charm. After that, cron jobs can be setup along with added values in
config.yaml to have the charm inherently support a retention period.
This commit hopes to address part of the feature request.

+ Refactor and rebased from master since last MR
+ Improvements and Cleanup

Modified:
 src/
  README: added notes on new deletion commands + examples
  actions.yaml: new entries for the new run actions to support deletion commands

 src/actions/
  actions.py: added and modified to support deletion commands through juju run action
  symlinks to added actions

 src/lib/
  lib_duplicity.py: added fns to wrap and build the duplicity commands for deletion, Refactored gtom previous MR

 src/tests/
  added functional and unit tests; Refactored

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[Nishant Dash (dash3)]

Another note:

If using [charm] in charmcraft.yaml, it will currently only build with charmcraft/2.1/candidate
To make it build with charmcraft/2.0/stable, you will need to specify [charm/2.x/stable]

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

FAILED: Continuous integration, rev:09ece407e28ca5018f84c66372bf3b66a43eef5b
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/17/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1066/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1484/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/17//rebuild

review: Needs Fixing (continuous-integration)

[Nishant Dash (dash3)]

FAIL: test_encryption_true_no_key_no_passphrase_blocks is a test that is known to fail with the current workaround of adding an artificial delay for it failing as well.

[Eric Chen (eric-chen)]

This MR is quite big. I need more time to review it. But I check some simple thing quickly. Please check my inline comment.

review: Needs Fixing

[Martin Kalcok (martin-kalcok)]

Thanks for your work on this. It was not an easy first task. Overall this change looks good to me. I left some in-line comments, please review them.

review: Needs Fixing

[Chi Wai CHAN (raychan96)]

I will fix the functional tests in here: https://code.launchpad.net/~raychan96/charm-duplicity/+git/charm-duplicity/+merge/431319, please rebase you patch after that has been merged.

review: Needs Fixing

[Chi Wai CHAN (raychan96)]

Please see inline comment related to functional tests. Thanks

[Eric Chen (eric-chen)]

see inline message

review: Needs Fixing

[Nishant Dash (dash3)]

Acknowledged the concerns and left a question below with regards to testing.

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

PASSED: Continuous integration, rev:d32ab9ca67ba7079471805136891e5ba7fb23949
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/21/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1329/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1658/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/21//rebuild

review: Approve (continuous-integration)

[Martin Kalcok (martin-kalcok)]

Overall looks good. Thanks. Just last few nit picks I found in code that I highlighted inline.

[Nishant Dash (dash3)]

ok noted and addressed.

[Chi Wai CHAN (raychan96)]

Thanks for the patch; overall LGTM, I left some suggestions to improve the readability (just me being picky).

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

FAILED: Continuous integration, rev:f936d9b6c1ee42043accf87f6b2c4dc789c798bc
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/22/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1447/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1699/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/22//rebuild

review: Needs Fixing (continuous-integration)

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

FAILED: Continuous integration, rev:f936d9b6c1ee42043accf87f6b2c4dc789c798bc
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/23/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1448/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1700/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/23//rebuild

review: Needs Fixing (continuous-integration)

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

PASSED: Continuous integration, rev:16b3ee2193af08f7bc741e84c395313cb4ea80e2
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/24/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1449/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1701/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/24//rebuild

review: Approve (continuous-integration)

[Robert Gildein (rgildein)]

review: Needs Fixing

[Martin Kalcok (martin-kalcok)]

LGTM. Thanks for this new functionality and also cleaning up a lot of old tech debt.

review: Approve

[Mert Kirpici (mertkirpici)]

Hey Nishant, I left a small suggestion regarding the flake8 issue below.

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

PASSED: Continuous integration, rev:796232d746f544539ab732aabda1df27db96624f
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/25/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1450/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1702/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/25//rebuild

review: Approve (continuous-integration)

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

FAILED: Continuous integration, rev:7534fb2330d71c3007d6c7d8ac024771e52f9782
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/26/
Executed test runs:
    ABORTED: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1453/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1705/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/26//rebuild

review: Needs Fixing (continuous-integration)

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

FAILED: Continuous integration, rev:7534fb2330d71c3007d6c7d8ac024771e52f9782
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/27/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1461/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1709/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/27//rebuild

review: Needs Fixing (continuous-integration)

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

FAILED: Continuous integration, rev:81897f77ba78c3d8db73fe188253f742fc659e7b
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/28/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1463/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1714/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/28//rebuild

review: Needs Fixing (continuous-integration)

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

This merge proposal is being monitored by mergebot. Change the status to Approved to merge.

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

PASSED: Continuous integration, rev:81897f77ba78c3d8db73fe188253f742fc659e7b
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/29/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1469/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1720/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/29//rebuild

review: Approve (continuous-integration)

[Robert Gildein (rgildein)]

LGTM, good job. Thanks

review: Approve

[Chi Wai CHAN (raychan96)]

review: Approve

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

FAILED: Continuous integration, rev:81897f77ba78c3d8db73fe188253f742fc659e7b
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/30/
Executed test runs:
    FAILURE: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1472/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1723/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/30//rebuild

review: Needs Fixing (continuous-integration)

[Mert Kirpici (mertkirpici)]

Hi Nishant, thanks for taking care of the linting issue! Linked the bug to the MP for better visibility.

[🤖 prod-jenkaas-bootstack (prod-jenkaas-bootstack)]

PASSED: Continuous integration, rev:81897f77ba78c3d8db73fe188253f742fc659e7b
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/31/
Executed test runs:
    SUCCESS: https://jenkins.canonical.com/bootstack/job/lp-charm-test-functest/1482/
    None: https://jenkins.canonical.com/bootstack/job/lp-update-mp/1732/

Click here to trigger a rebuild:
https://jenkins.canonical.com/bootstack/job/lp-charm-duplicity-ci/31//rebuild

review: Approve (continuous-integration)

[Przemyslaw Lal (przemeklal)]

LGTM, we confirmed that it works as expected with GPG encryption enabled

review: Approve

[Erhan Sunar (esunar)]

review: Approve

[🤖 Canonical IS Merge Bot (canonical-is-mergebot)]

Change successfully merged at revision b6789e90b7f9c7089822fecd915f85ae920a7d98

diff --git a/src/README.md b/src/README.md
index 9666142..443c0c9 100644
--- a/src/README.md
+++ b/src/README.md
@@ -110,17 +110,25 @@ juju add-relation nrpe ubuntu       # required on host
 juju add-relation nrpe duplicity
 ```
 
+### Cleaning up backups
+
+Deletion commands such as `remove-older-than`, `remove-all-but-n-full` and
+`remove-all-inc-of-but-n-full` can be used with run action and a specified
+parameter.
+For example:
+    `juju run-action duplicity/0 remove-older-than time=2022-10-02T19:44:00+00:00`
+        where time follows the same w3 standard as duplicity and yaml
+    `juju run-action duplicity/0 remove-all-but-n-full count=1`
+
 # Known Limitations and Future Features
 
-This charm is currently still under development. The only supported Duplicity action right now
-is full backups (through both an action and periodic backups). The following is the list
-of future Duplicity functionality:
+This charm is currently still under development. The only supported Duplicity actions right now is full backups (through both an action and periodic backups) and removal of backups.
+The following is the list of future Duplicity functionality:
 
 - incremental backups
 - restoring backups
 - verifying backups
-- listing  backed-up files
-- cleaning up backed files
+- listing backed-up files
 - additional supported backends
 
 # Upstream and Bugs
diff --git a/src/actions.yaml b/src/actions.yaml
index a683112..8a6d230 100644
--- a/src/actions.yaml
+++ b/src/actions.yaml
@@ -11,4 +11,41 @@ do-backup:
 #    checksum saved during backup
 list-current-files:
   description: |
-    Lists the latest backed up files on the remote repository
\ No newline at end of file
+    Lists the latest backed up files on the remote repository
+remove-older-than:
+  description: |
+    Delete all backup sets older than the given time on the remote repository
+  params:
+    time:
+      type:
+        - string
+        - number
+      format: date-time
+      description: |
+        Time string follows the same time format (w3) as duplicity. For example:
+        now, 2022-09-30T13:31:15+00:00, 1665058250, 3D4H are all valid.
+  required: [time]
+remove-all-but-n-full:
+  description: |
+    Keep only the most recent 'count' number of full backup(s) and any
+    associated incremental sets and delete the rest from the remote repository.
+  params:
+    count:
+      type: integer
+      minimum: 1
+      description: |
+        Count must be larger than zero. A value of 1 means that only the single
+        most recent backup chain will be kept.
+  required: [count]
+remove-all-inc-of-but-n-full:
+  description: |
+    Keep only the most recent 'count' number of full backup(s) but NOT any of
+    their incremental sets and delete the rest from the remote repository.
+  params:
+    count:
+      type: integer
+      minimum: 1
+      description: |
+        Count must be larger than zero. A value of 1 means that only the single
+        most recent backup chain will be kept intact.
+  required: [count]
\ No newline at end of file
diff --git a/src/actions/actions.py b/src/actions/actions.py
index 6722ab3..68b9243 100755
--- a/src/actions/actions.py
+++ b/src/actions/actions.py
@@ -19,19 +19,43 @@ helper = DuplicityHelper()
 error_file = "/var/run/periodic_backup.error"
 
 
-def do_backup(*args):
+def do_backup(*_):
     """do-backup action."""
     output = helper.do_backup()
-    hookenv.function_set(dict(output=output.decode("utf-8")))
+    hookenv.action_set({"output": output.decode("utf-8")})
 
 
-def list_current_files(*args):
+def list_current_files(*_):
     """list-current-files action."""
     output = helper.list_current_files()
-    hookenv.function_set(dict(output=output.decode("utf-8")))
+    hookenv.action_set({"output": output.decode("utf-8")})
 
 
-ACTIONS = {"do-backup": do_backup, "list-current-files": list_current_files}
+def remove_older_than(*_):
+    """remove-older-than action."""
+    output = helper.remove_older_than(hookenv.action_get("time"))
+    hookenv.action_set({"output": output.decode("utf-8")})
+
+
+def remove_all_but_n_full(*_):
+    """remove-all-but-n-full action."""
+    output = helper.remove_all_but_n_full(hookenv.action_get("count"))
+    hookenv.action_set({"output": output.decode("utf-8")})
+
+
+def remove_all_inc_of_but_n_full(*_):
+    """remove-all-inc-of-but-n-full action."""
+    output = helper.remove_all_inc_of_but_n_full(hookenv.action_get("count"))
+    hookenv.action_set({"output": output.decode("utf-8")})
+
+
+ACTIONS = {
+    "do-backup": do_backup,
+    "list-current-files": list_current_files,
+    "remove-older-than": remove_older_than,
+    "remove-all-but-n-full": remove_all_but_n_full,
+    "remove-all-inc-of-but-n-full": remove_all_inc_of_but_n_full,
+}
 
 
 def main(args):
@@ -45,18 +69,20 @@ def main(args):
     except CalledProcessError as e:
         err_msg = (
             'Command "{}" failed with return code "{}" '
-            "and error output:\n{}".format(
-                e.cmd, e.returncode, e.output.decode("utf-8")
+            "and error output:{}{}".format(
+                e.cmd, e.returncode, os.linesep, e.output.decode("utf-8")
             )
         )
         hookenv.log(err_msg, level=hookenv.ERROR)
-        hookenv.function_fail(err_msg)
+        hookenv.action_fail(err_msg)
     except Exception as e:
         hookenv.log(
-            "do-backup action failed: {}\n{}".format(e, traceback.print_exc()),
+            "{} action failed: {}{}{}".format(
+                action_name, e, os.linesep, traceback.print_exc()
+            ),
             level=hookenv.ERROR,
         )
-        hookenv.function_fail(str(e))
+        hookenv.action_fail(str(e))
     else:
         if action_name == "do-backup":
             clear_flag("duplicity.failed_backup")
diff --git a/src/actions/remove-all-but-n-full b/src/actions/remove-all-but-n-full
new file mode 120000
index 0000000..405a394
--- /dev/null
+++ b/src/actions/remove-all-but-n-full
@@ -0,0 +1 @@
+actions.py
\ No newline at end of file
diff --git a/src/actions/remove-all-inc-of-but-n-full b/src/actions/remove-all-inc-of-but-n-full
new file mode 120000
index 0000000..405a394
--- /dev/null
+++ b/src/actions/remove-all-inc-of-but-n-full
@@ -0,0 +1 @@
+actions.py
\ No newline at end of file
diff --git a/src/actions/remove-older-than b/src/actions/remove-older-than
new file mode 120000
index 0000000..405a394
--- /dev/null
+++ b/src/actions/remove-older-than
@@ -0,0 +1 @@
+actions.py
\ No newline at end of file
diff --git a/src/lib/lib_duplicity.py b/src/lib/lib_duplicity.py
index ad2f768..3b6bd57 100644
--- a/src/lib/lib_duplicity.py
+++ b/src/lib/lib_duplicity.py
@@ -28,42 +28,20 @@ class DuplicityHelper:
         """Introduce configurations."""
         self.charm_config = hookenv.config()
 
-    @property
-    def backup_cmd(self):
-        """Juju action do-backup handler."""
-        cmd = ["duplicity"]
-        if self.charm_config.get("private_ssh_key"):
-            if self.charm_config.get("backend") == "rsync":
-                cmd.append(
-                    '--rsync-options=-e "ssh -i {}"'.format(PRIVATE_SSH_KEY_PATH)
-                )
-            else:
-                cmd.append(
-                    "--ssh-options=-oIdentityFile={}".format(PRIVATE_SSH_KEY_PATH)
-                )
-        # later switch to
-        # cmd.append('full' if self.charm_config.get('full_backup') else 'incr')
-        # when full_backup implemented
-        cmd.append("full")
-        cmd.extend([self.charm_config.get("aux_backup_directory"), self._backup_url()])
+    def _build_cmd(self, duplicity_command, *args):
+        """Duplicity command builder."""
+        cmd = ["duplicity", duplicity_command]
+        cmd.extend([str(arg) for arg in args])
+        cmd.append(self._backup_url())
         cmd.extend(self._additional_options())
+        if "remove" in duplicity_command:
+            cmd.append("--force")
         return cmd
 
-    @property
-    def list_files_cmd(self):
-        """Juju action list-current-files handler."""
-        cmd = ["duplicity", "list-current-files", self._backup_url()]
-        if self.charm_config.get("private_ssh_key"):
-            if self.charm_config.get("backend") == "rsync":
-                cmd.append(
-                    '--rsync-options=-e "ssh -i {}"'.format(PRIVATE_SSH_KEY_PATH)
-                )
-            else:
-                cmd.append(
-                    "--ssh-options=-oIdentityFile={}".format(PRIVATE_SSH_KEY_PATH)
-                )
-        cmd.extend(self._additional_options())
-        return cmd
+    def _executor(self, cmd):
+        self._set_environment_vars()
+        self.safe_log("Duplicity Command: {}".format(cmd))
+        return subprocess.check_output(cmd, stderr=subprocess.STDOUT)
 
     def _backup_url(self):
         """Remote URL.
@@ -128,6 +106,16 @@ class DuplicityHelper:
         # backups named after the unit
         cmd = []
 
+        if self.charm_config.get("private_ssh_key"):
+            if self.charm_config.get("backend") == "rsync":
+                cmd.append(
+                    '--rsync-options=-e "ssh -i {}"'.format(PRIVATE_SSH_KEY_PATH)
+                )
+            else:
+                cmd.append(
+                    "--ssh-options=-oIdentityFile={}".format(PRIVATE_SSH_KEY_PATH)
+                )
+
         if self.charm_config.get("disable_encryption"):
             cmd.append("--no-encryption")
         elif self.charm_config.get("gpg_public_key"):
@@ -175,12 +163,10 @@ class DuplicityHelper:
         :param: kwargs
         :type: dictionary of values that may be used instead of config values
         """
-        self._set_environment_vars()
-        cmd = self.backup_cmd
-        self.safe_log("Duplicity Command: {}".format(cmd))
+        cmd = self._build_cmd("full", self.charm_config.get("aux_backup_directory"))
         if self.charm_config.get("backend") == "rsync":
             self.create_remote_dirs()
-        return subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        return self._executor(cmd)
 
     def safe_log(self, message, level=hookenv.INFO):
         """Replace password in the log with ***."""
@@ -241,10 +227,8 @@ class DuplicityHelper:
         :param: kwargs
         :type: dictionary of values that may be used instead of config values
         """
-        self._set_environment_vars()
-        cmd = self.list_files_cmd
-        self.safe_log("Duplicity Command: {}".format(cmd))
-        return subprocess.check_output(cmd, stderr=subprocess.STDOUT)
+        cmd = self._build_cmd("list-current-files")
+        return self._executor(cmd)
 
     def restore(self):
         # TODO
@@ -252,20 +236,32 @@ class DuplicityHelper:
         """Restore the full monty or selected folders/files."""
         raise NotImplementedError()
 
-    def remove_older_than(self):
-        # TODO
-        # duplicity remove-older-than time [options] target_url
-        """Delete all backup sets older than the given time."""
-        raise NotImplementedError()
+    def remove_older_than(self, time):
+        """Delete all backup sets older than the given time.
 
-    def remove_all_but_n_full(self):
-        # TODO
-        # duplicity remove-all-but-n-full <count> <target_url>
-        """Keep the last count full backups and associated incremental sets."""
-        raise NotImplementedError()
+        :param: kwargs
+        :type: dictionary of values that may be used instead of config values
+            - used types from kwargs: time
+        """
+        cmd = self._build_cmd("remove-older-than", time)
+        return self._executor(cmd)
 
-    def remove_all_inc_of_but_n_full(self):
-        # TODO
-        # duplicity remove-all-inc-of-but-n-full <count> <target_url>
-        """Keep only old full backups and not their increments."""
-        raise NotImplementedError()
+    def remove_all_but_n_full(self, count):
+        """Keep the last count full backups and associated incremental sets.
+
+        :param: kwargs
+        :type: dictionary of values that may be used instead of config values
+            - used types from kwargs: count
+        """
+        cmd = self._build_cmd("remove-all-but-n-full", count)
+        return self._executor(cmd)
+
+    def remove_all_inc_of_but_n_full(self, count):
+        """Keep only old full backups and not their increments.
+
+        :param: kwargs
+        :type: dictionary of values that may be used instead of config values
+            - used types from kwargs: count
+        """
+        cmd = self._build_cmd("remove-all-inc-of-but-n-full", count)
+        return self._executor(cmd)
diff --git a/src/tests/functional/requirements.txt b/src/tests/functional/requirements.txt
index d4871a5..4a6e1d8 100644
--- a/src/tests/functional/requirements.txt
+++ b/src/tests/functional/requirements.txt
@@ -1,5 +1,4 @@
 flake8
-juju
 mock
 git+https://github.com/openstack-charmers/zaza.git#egg=zaza
 python-openstackclient
diff --git a/src/tests/functional/tests/test_duplicity.py b/src/tests/functional/tests/test_duplicity.py
index 29200cd..a926ab5 100644
--- a/src/tests/functional/tests/test_duplicity.py
+++ b/src/tests/functional/tests/test_duplicity.py
@@ -38,7 +38,7 @@ class DuplicityBackupCronTest(BaseDuplicityTest):
         """Verify cron job creation."""
         options = ["daily", "weekly", "monthly"]
         for option in options:
-            new_config = dict(backup_frequency=option)
+            new_config = {"backup_frequency": option}
             zaza.model.set_application_config(self.application_name, new_config)
             try:
                 zaza.model.block_until_file_has_contents(
@@ -57,7 +57,7 @@ class DuplicityBackupCronTest(BaseDuplicityTest):
     def test_cron_creation_cron_string(self):
         """Verify cron job creation."""
         cron_string = "* * * * *"
-        new_config = dict(backup_frequency=cron_string)
+        new_config = {"backup_frequency": cron_string}
         zaza.model.set_application_config(self.application_name, new_config)
         try:
             zaza.model.block_until_file_has_contents(
@@ -76,7 +76,7 @@ class DuplicityBackupCronTest(BaseDuplicityTest):
     def test_cron_invalid_cron_string(self):
         """Verify cron job creation with invalid frequency."""
         cron_string = "* * * *"
-        new_config = dict(backup_frequency=cron_string)
+        new_config = {"backup_frequency": cron_string}
         zaza.model.set_application_config(self.application_name, new_config)
         try:
             duplicity_workload_checker = utils.get_workload_application_status_checker(
@@ -96,7 +96,7 @@ class DuplicityBackupCronTest(BaseDuplicityTest):
         """Verify manual or invalid cron job frequency."""
         options = ["manual"]
         for option in options:
-            new_config = dict(backup_frequency=option)
+            new_config = {"backup_frequency": option}
             zaza.model.set_application_config(self.application_name, new_config)
             try:
                 zaza.model.block_until_file_missing(
@@ -123,9 +123,11 @@ class DuplicityEncryptionValidationTest(BaseDuplicityTest):
     @utils.config_restore("duplicity")
     def test_encryption_true_no_key_no_passphrase_blocks(self):
         """Verify unit is blocked with no passphrase or key."""
-        new_config = dict(
-            encryption_passphrase="", gpg_public_key="", disable_encryption="False"
-        )
+        new_config = {
+            "encryption_passphrase": "",
+            "gpg_public_key": "",
+            "disable_encryption": "False",
+        }
         zaza.model.set_application_config(
             self.application_name, new_config, self.model_name
         )
@@ -150,7 +152,7 @@ class DuplicityEncryptionValidationTest(BaseDuplicityTest):
     def test_encryption_true_with_key(self):
         """Verify encryption with a valid gpg key."""
         zaza.model.set_application_config(
-            self.application_name, dict(disable_encryption="False"), self.model_name
+            self.application_name, {"disable_encryption": "False"}, self.model_name
         )
         try:
             duplicity_workload_checker = utils.get_workload_application_status_checker(
@@ -163,7 +165,7 @@ class DuplicityEncryptionValidationTest(BaseDuplicityTest):
                 "no passphrase or key."
             )
         zaza.model.set_application_config(
-            self.application_name, dict(gpg_public_key="S0M3k3Y")
+            self.application_name, {"gpg_public_key": "S0M3k3Y"}
         )
         try:
             zaza.model.block_until_all_units_idle()
@@ -177,7 +179,7 @@ class DuplicityEncryptionValidationTest(BaseDuplicityTest):
     def test_encryption_true_with_passphrase(self):
         """Verify encryption with a valid passphrase."""
         zaza.model.set_application_config(
-            self.application_name, dict(disable_encryption="False"), self.model_name
+            self.application_name, {"disable_encryption": "False"}, self.model_name
         )
         try:
             duplicity_workload_checker = utils.get_workload_application_status_checker(
@@ -190,7 +192,7 @@ class DuplicityEncryptionValidationTest(BaseDuplicityTest):
                 "no passphrase or key."
             )
         zaza.model.set_application_config(
-            self.application_name, dict(encryption_passphrase="somephrase")
+            self.application_name, {"encryption_passphrase": "somephrase"}
         )
         try:
             zaza.model.block_until_all_units_idle()
@@ -201,33 +203,25 @@ class DuplicityEncryptionValidationTest(BaseDuplicityTest):
             )
 
 
-class DuplicityBackupCommandTest(BaseDuplicityTest):
-    """Verify do-backup command."""
+class BaseDuplicityCommandTest(BaseDuplicityTest):
+    """VHelper class to use for duplicity command tests."""
 
     @classmethod
     def setUpClass(cls):
         """Set up do-backup command tests."""
         super().setUpClass()
         cls.backup_host = zaza.model.get_units("backup-host")[0]
-        cls.duplicity_unit = zaza.model.get_units("duplicity")[0]
-        cls.backup_host_ip = cls.backup_host.public_address
+        cls.duplicity_unit = zaza.model.get_units("duplicity")[0].name
         user_pass_pair = ubuntu_user_pass.split(":")
-        cls.remote_user = user_pass_pair[0]
-        cls.remote_pass = user_pass_pair[1]
-        cls.action = "do-backup"
         cls.ssh_priv_key = cls.get_ssh_priv_key()
-
-    def get_config(self, **kwargs):
-        """Return app config."""
-        base_config = dict(
-            remote_backup_url=self.backup_host_ip,
-            aux_backup_directory=ubuntu_backup_directory_source,
-            remote_user=self.remote_user,
-            remote_password=self.remote_pass,
-        )
-        for key, value in kwargs.items():
-            base_config[key] = value
-        return base_config
+        cls.base_config = {
+            "remote_backup_url": cls.backup_host.public_address,
+            "aux_backup_directory": ubuntu_backup_directory_source,
+            "remote_user": user_pass_pair[0],
+            "remote_password": user_pass_pair[1],
+        }
+        cls.auxiliary_actions = []
+        cls.action_params = None
 
     @staticmethod
     def get_ssh_priv_key():
@@ -237,208 +231,357 @@ class DuplicityBackupCommandTest(BaseDuplicityTest):
         encoded_ssh_private_key = base64.b64encode(ssh_private_key)
         return encoded_ssh_private_key.decode("utf-8")
 
-    @utils.config_restore("duplicity")
-    def test_scp_full_do_backup_action(self):
-        """Verify do-backup action with scp."""
-        additional_config = dict(backend="scp")
-        new_config = self.get_config(**additional_config)
-        utils.set_config_and_wait(self.application_name, new_config)
+    def _run(self, **config):
+        """Run action on zaza model."""
+        config.update(self.base_config)
+        utils.set_config_and_wait(self.application_name, config)
+        for a in self.auxiliary_actions:
+            zaza.model.run_action(self.duplicity_unit, a, raise_on_failure=True)
         zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
+            self.duplicity_unit,
+            self.action,
+            action_params=self.action_params,
+            raise_on_failure=True,
         )
 
+
+class DuplicityBackupCommandTest(BaseDuplicityCommandTest):
+    """Verify do-backup command."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up do-backup command tests."""
+        super().setUpClass()
+        cls.action = "do-backup"
+
     @utils.config_restore("duplicity")
-    def test_file_full_do_backup_action(self):
-        """Verify do-backup action with ftp."""
-        additional_config = dict(
-            backend="file", remote_backup_url="/home/ubuntu/test-backups"
-        )
-        new_config = self.get_config(**additional_config)
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+    def test_scp_full(self):
+        """Verify do-backup action with scp."""
+        additional_config = {"backend": "scp"}
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
-    def test_scp_full_ssh_key_auth_backup_action(self):
+    def test_file_full(self):
+        """Verify do-backup action with file."""
+        additional_config = {
+            "backend": "file",
+            "remote_backup_url": "/home/ubuntu/test-backups",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_scp_full_ssh_key(self):
         """Verify do-backup action with scp and private key."""
-        additional_config = dict(
-            backend="scp", private_ssh_key=self.ssh_priv_key, remote_password=""
-        )
-        new_config = self.get_config(**additional_config)
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+        additional_config = {
+            "backend": "scp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
-    def test_rsync_full_ssh_key_auth_backup_action(self):
+    def test_rsync_full_ssh_key(self):
         """Verify do-backup action with rsync and private key."""
-        additional_config = dict(
-            backend="rsync", private_ssh_key=self.ssh_priv_key, remote_password=""
-        )
-        new_config = self.get_config(**additional_config)
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+        additional_config = {
+            "backend": "rsync",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
-    def test_sftp_full_do_backup(self):
+    def test_sftp_full(self):
         """Verify do-backup action with sftp and password."""
-        additional_config = dict(backend="sftp")
-        new_config = self.get_config(**additional_config)
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+        additional_config = {"backend": "sftp"}
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
-    def test_sftp_full_ssh_key_do_backup(self):
-        """Verify do-backup action with sftp with private key."""
-        additional_config = dict(
-            backend="sftp", private_ssh_key=self.ssh_priv_key, remote_password=""
-        )
-        new_config = self.get_config(**additional_config)
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+    def test_sftp_full_ssh_key(self):
+        """Verify do-backup action with sftp and private key."""
+        additional_config = {
+            "backend": "sftp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
-    def test_ftp_full_do_backup(self):
-        """Verify do-backup action with ftp."""
-        additional_config = dict(backend="ftp")
-        new_config = self.get_config(**additional_config)
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+    def test_ftp_full(self):
+        """Verify do-backup action with ftp and password."""
+        additional_config = {"backend": "ftp"}
+        self._run(**additional_config)
 
 
-class DuplicityListFilesCommandTest(BaseDuplicityTest):
-    """Verify list-current-files action."""
+class DuplicityListFilesCommandTest(BaseDuplicityCommandTest):
+    """Verify list-current-files command."""
 
     @classmethod
     def setUpClass(cls):
-        """Set up list-current-files action tests."""
+        """Set up list-current-files command tests."""
         super().setUpClass()
-        cls.backup_host = zaza.model.get_units("backup-host")[0]
-        cls.duplicity_unit = zaza.model.get_units("duplicity")[0]
-        cls.backup_host_ip = cls.backup_host.public_address
-        user_pass_pair = ubuntu_user_pass.split(":")
-        cls.remote_user = user_pass_pair[0]
-        cls.remote_pass = user_pass_pair[1]
         cls.action = "list-current-files"
-        cls.ssh_priv_key = cls.get_ssh_priv_key()
-
-    def get_config(self, **kwargs):
-        """Get charm config."""
-        base_config = dict(
-            remote_backup_url=self.backup_host_ip,
-            aux_backup_directory=ubuntu_backup_directory_source,
-            remote_user=self.remote_user,
-            remote_password=self.remote_pass,
-        )
-        base_config.update(kwargs)
-        return base_config
-
-    @staticmethod
-    def get_ssh_priv_key():
-        """Get ssh private key."""
-        with open("./tests/resources/testing_id_rsa", "rb") as f:
-            ssh_private_key = f.read()
-        encoded_ssh_private_key = base64.b64encode(ssh_private_key)
-        return encoded_ssh_private_key.decode("utf-8")
+        cls.auxiliary_actions = ["do-backup"]
 
     @utils.config_restore("duplicity")
-    def test_scp_full_list_current_files_action(self):
-        """Verify list-current-files work with scp backend."""
-        new_config = self.get_config(backend="scp")
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, "do-backup", raise_on_failure=True
-        )
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+    def test_scp_full_list_current_files(self):
+        """Verify list-current-files action with scp."""
+        additional_config = {"backend": "scp"}
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
-    def test_file_full_list_current_files_action(self):
-        """Verify list-current-files work with file backend."""
-        new_config = self.get_config(
-            backend="file", remote_backup_url="/home/ubuntu/test-backups"
-        )
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, "do-backup", raise_on_failure=True
-        )
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+    def test_file_full_list_current_files(self):
+        """Verify list-current-files action with file."""
+        additional_config = {
+            "backend": "file",
+            "remote_backup_url": "/home/ubuntu/test-backups",
+        }
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
-    def test_scp_full_ssh_key_auth_list_current_files_action(self):
-        """Verify list-current-files work after do-backup run."""
-        new_config = self.get_config(
-            backend="scp", private_ssh_key=self.ssh_priv_key, remote_password=""
-        )
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, "do-backup", raise_on_failure=True
-        )
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+    def test_scp_full_ssh_key_list_current_files(self):
+        """Verify list-current-files action with scp and private key."""
+        additional_config = {
+            "backend": "scp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
-    def test_rsync_full_ssh_key_auth_list_current_files_action(self):
-        """Verify list-current-files work with rsync backend after do-backup run."""
-        new_config = self.get_config(
-            backend="rsync", private_ssh_key=self.ssh_priv_key, remote_password=""
-        )
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, "do-backup", raise_on_failure=True
-        )
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+    def test_rsync_full_ssh_key_list_current_files(self):
+        """Verify list-current-files action with rsync and private key."""
+        additional_config = {
+            "backend": "rsync",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
     def test_sftp_full_list_current_files(self):
-        """Verify list-current-files work with sftp backend after do-backup run."""
-        new_config = self.get_config(backend="sftp")
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, "do-backup", raise_on_failure=True
-        )
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+        """Verify list-current-files action with sftp and password."""
+        additional_config = {"backend": "sftp"}
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
     def test_sftp_full_ssh_key_list_current_files(self):
-        """Verify list-current-files work with sftp backend after do-backup run."""
-        new_config = self.get_config(
-            backend="sftp", private_ssh_key=self.ssh_priv_key, remote_password=""
-        )
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, "do-backup", raise_on_failure=True
-        )
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+        """Verify list-current-files action with sftp and private key."""
+        additional_config = {
+            "backend": "sftp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
 
     @utils.config_restore("duplicity")
     def test_ftp_full_list_current_files(self):
-        """Verify list-current-files work with ftp backend after do-backup run."""
-        new_config = self.get_config(backend="ftp")
-        utils.set_config_and_wait(self.application_name, new_config)
-        zaza.model.run_action(
-            self.duplicity_unit.name, "do-backup", raise_on_failure=True
-        )
-        zaza.model.run_action(
-            self.duplicity_unit.name, self.action, raise_on_failure=True
-        )
+        """Verify list-current-files action with ftp and password."""
+        additional_config = {"backend": "ftp"}
+        self._run(**additional_config)
+
+
+class DuplicityRemoveOlderThanCommandTest(BaseDuplicityCommandTest):
+    """Verify remove-older-than command."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up remove-older-than command tests."""
+        super().setUpClass()
+        cls.action = "remove-older-than"
+        cls.auxiliary_actions = ["do-backup", "do-backup"]
+        cls.action_params = {"time": "now"}
+
+    @utils.config_restore("duplicity")
+    def test_scp_full_list_remove_older_than(self):
+        """Verify remove-older-than action with scp."""
+        additional_config = {"backend": "scp"}
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_file_full_remove_older_than(self):
+        """Verify remove-older-than action with file."""
+        additional_config = {
+            "backend": "file",
+            "remote_backup_url": "/home/ubuntu/test-backups",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_scp_full_ssh_key_remove_older_than(self):
+        """Verify remove-older-than action with scp and private key."""
+        additional_config = {
+            "backend": "scp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_rsync_full_ssh_key_remove_older_than(self):
+        """Verify remove-older-than action with rsync and private key."""
+        additional_config = {
+            "backend": "rsync",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_sftp_full_remove_older_than(self):
+        """Verify remove-older-than action with sftp and password."""
+        additional_config = {"backend": "sftp"}
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_sftp_full_ssh_key_remove_older_than(self):
+        """Verify remove-older-than action with sftp and private key."""
+        additional_config = {
+            "backend": "sftp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_ftp_full_remove_older_than(self):
+        """Verify remove-older-than action with ftp and password."""
+        additional_config = {"backend": "ftp"}
+        self._run(**additional_config)
+
+
+class DuplicityRemoveAllButNFullCommandTest(BaseDuplicityCommandTest):
+    """Verify remove-all-but-n-full command."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up remove-all-but-n-full command tests."""
+        super().setUpClass()
+        cls.action = "remove-all-but-n-full"
+        cls.auxiliary_actions = ["do-backup", "do-backup"]
+        cls.action_params = {"count": 1}
+
+    @utils.config_restore("duplicity")
+    def test_scp_full_list_remove_all_but_n_full(self):
+        """Verify remove-all-but-n-full action with scp."""
+        additional_config = {"backend": "scp"}
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_file_full_remove_all_but_n_full(self):
+        """Verify remove-all-but-n-full action with file."""
+        additional_config = {
+            "backend": "file",
+            "remote_backup_url": "/home/ubuntu/test-backups",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_scp_full_ssh_key_remove_all_but_n_full(self):
+        """Verify remove-all-but-n-full action with scp and private key."""
+        additional_config = {
+            "backend": "scp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_rsync_full_ssh_key_remove_all_but_n_full(self):
+        """Verify remove-all-but-n-full action with rsync and private key."""
+        additional_config = {
+            "backend": "rsync",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_sftp_full_remove_all_but_n_full(self):
+        """Verify remove-all-but-n-full action with sftp and password."""
+        additional_config = {"backend": "sftp"}
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_sftp_full_ssh_key_remove_all_but_n_full(self):
+        """Verify remove-all-but-n-full action with sftp and private key."""
+        additional_config = {
+            "backend": "sftp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_ftp_full_remove_all_but_n_full(self):
+        """Verify remove-all-but-n-full action with ftp and password."""
+        additional_config = {"backend": "ftp"}
+        self._run(**additional_config)
+
+
+class DuplicityRemoveAllIncOfButNFullCommandTest(BaseDuplicityCommandTest):
+    """Verify remove-all-inc-of-but-n-fullcommand."""
+
+    @classmethod
+    def setUpClass(cls):
+        """Set up remove-all-inc-of-but-n-full command tests."""
+        super().setUpClass()
+        cls.action = "remove-all-inc-of-but-n-full"
+        cls.auxiliary_actions = ["do-backup", "do-backup"]
+        cls.action_params = {"count": 1}
+
+    @utils.config_restore("duplicity")
+    def test_scp_full_list_remove_all_inc_of_but_n_full(self):
+        """Verify remove-all-inc-of-but-n-full action with scp."""
+        additional_config = {"backend": "scp"}
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_file_full_remove_all_inc_of_but_n_full(self):
+        """Verify remove-all-inc-of-but-n-full action with file."""
+        additional_config = {
+            "backend": "file",
+            "remote_backup_url": "/home/ubuntu/test-backups",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_scp_full_ssh_key_remove_all_inc_of_but_n_full(self):
+        """Verify remove-all-inc-of-but-n-full action with scp and private key."""
+        additional_config = {
+            "backend": "scp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_rsync_full_ssh_key_remove_all_inc_of_but_n_full(self):
+        """Verify remove-all-inc-of-but-n-full action with rsync and private key."""
+        additional_config = {
+            "backend": "rsync",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_sftp_full_remove_all_inc_of_but_n_full(self):
+        """Verify remove-all-inc-of-but-n-full action with sftp and password."""
+        additional_config = {"backend": "sftp"}
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_sftp_full_ssh_remove_all_inc_of_but_n_full(self):
+        """Verify remove-all-inc-of-but-n-full action with sftp and private key."""
+        additional_config = {
+            "backend": "sftp",
+            "private_ssh_key": self.ssh_priv_key,
+            "remote_password": "",
+        }
+        self._run(**additional_config)
+
+    @utils.config_restore("duplicity")
+    def test_ftp_full_remove_all_inc_of_but_n_full(self):
+        """Verify remove-all-inc-of-but-n-full action with ftp and password."""
+        additional_config = {"backend": "ftp"}
+        self._run(**additional_config)
diff --git a/src/tests/functional/tests/tests.yaml b/src/tests/functional/tests/tests.yaml
index 155c4e9..74aa1bd 100644
--- a/src/tests/functional/tests/tests.yaml
+++ b/src/tests/functional/tests/tests.yaml
@@ -4,6 +4,9 @@ tests:
   - tests.test_duplicity.DuplicityEncryptionValidationTest
   - tests.test_duplicity.DuplicityBackupCommandTest
   - tests.test_duplicity.DuplicityListFilesCommandTest
+  - tests.test_duplicity.DuplicityRemoveOlderThanCommandTest
+  - tests.test_duplicity.DuplicityRemoveAllButNFullCommandTest
+  - tests.test_duplicity.DuplicityRemoveAllIncOfButNFullCommandTest
 configure:
   - tests.configure.set_ubuntu_password_on_backup_host
   - tests.configure.set_ssh_password_access_on_backup_host
diff --git a/src/tests/unit/test_actions.py b/src/tests/unit/test_actions.py
index 632b762..d24aa4c 100644
--- a/src/tests/unit/test_actions.py
+++ b/src/tests/unit/test_actions.py
@@ -52,6 +52,64 @@ class TestActions:
         mock_list_current_files.assert_called_with(action_args)
         assert mock_remove.called == error_path_exists
 
+    @pytest.mark.parametrize("error_path_exists", [True, False])
+    @patch("actions.remove_older_than")
+    @patch("actions.os.path.exists")
+    @patch("actions.os.remove")
+    def test_remove_older_than_action_run_success(
+        self,
+        mock_remove,
+        mock_exists,
+        mock_remove_older_than,
+        error_path_exists,
+    ):
+        """Verify remove_older_than action."""
+        action_args = ["actions/remove_older_than"]
+        mock_exists.return_value = error_path_exists
+        actions.ACTIONS["remove_older_than"] = mock_remove_older_than
+        actions.main(action_args)
+        mock_remove_older_than.assert_called_with(action_args)
+        assert mock_remove.called == error_path_exists
+
+    @pytest.mark.parametrize("error_path_exists", [True, False])
+    @patch("actions.remove_all_but_n_full")
+    @patch("actions.os.path.exists")
+    @patch("actions.os.remove")
+    def test_remove_all_but_n_full_run_success(
+        self,
+        mock_remove,
+        mock_exists,
+        mock_remove_all_but_n_full,
+        error_path_exists,
+    ):
+        """Verify remove_all_but_n_full action."""
+        action_args = ["actions/remove_all_but_n_full"]
+        mock_exists.return_value = error_path_exists
+        actions.ACTIONS["remove_all_but_n_full"] = mock_remove_all_but_n_full
+        actions.main(action_args)
+        mock_remove_all_but_n_full.assert_called_with(action_args)
+        assert mock_remove.called == error_path_exists
+
+    @pytest.mark.parametrize("error_path_exists", [True, False])
+    @patch("actions.remove_all_inc_of_but_n_full")
+    @patch("actions.os.path.exists")
+    @patch("actions.os.remove")
+    def test_remove_all_inc_of_but_n_full_run_success(
+        self,
+        mock_remove,
+        mock_exists,
+        mock_remove_all_inc_of_but_n_full,
+        error_path_exists,
+    ):
+        """Verify remove_all_inc_of_but_n_full action."""
+        action_args = ["actions/remove_all_inc_of_but_n_full"]
+        mock_exists.return_value = error_path_exists
+        mock_temp = mock_remove_all_inc_of_but_n_full
+        actions.ACTIONS["remove_all_inc_of_but_n_full"] = mock_temp
+        actions.main(action_args)
+        mock_remove_all_inc_of_but_n_full.assert_called_with(action_args)
+        assert mock_remove.called == error_path_exists
+
     @patch("actions.do_backup")
     @patch("actions.clear_flag")
     @patch("actions.os.remove")
@@ -101,7 +159,7 @@ class TestActions:
             assert type(exception_raised) == type(e)
             for expected_contain in expected_fail_contains:
                 assert expected_contain in str(e)
-        mock_hookenv.function_fail.assert_called()
+        mock_hookenv.action_fail.assert_called()
         mock_remove.assert_not_called()
         mock_clear_flag.assert_not_called()
 
@@ -118,7 +176,7 @@ class TestDoBackupAction:
         expected_dict_input = dict(output=result.decode("utf-8"))
         actions.do_backup()
         mock_helper.do_backup.assert_called_once()
-        mock_hookenv.function_set.called_with(expected_dict_input)
+        mock_hookenv.action_set.called_with(expected_dict_input)
 
 
 class TestListCurrentFilesAction:
@@ -133,4 +191,49 @@ class TestListCurrentFilesAction:
         expected_dict_input = dict(output=result.decode("utf-8"))
         actions.list_current_files()
         mock_helper.list_current_files.assert_called_once()
-        mock_hookenv.function_set.called_with(expected_dict_input)
+        mock_hookenv.action_set.called_with(expected_dict_input)
+
+
+class TestRemoveOlderThanAction:
+    """Verify remove-older-than action."""
+
+    @patch("actions.helper")
+    @patch("actions.hookenv")
+    def test_remove_older_than(self, mock_hookenv, mock_helper):
+        """Verify remove-older-than action."""
+        result = "action_output".encode("utf-8")
+        mock_helper.remove_older_than.return_value = result
+        expected_dict_input = dict(output=result.decode("utf-8"))
+        actions.remove_older_than()
+        mock_helper.remove_older_than.assert_called_once()
+        mock_hookenv.action_set.called_with(expected_dict_input)
+
+
+class TestRemoveAllButNFullAction:
+    """Verify remove-all-but-n-full action."""
+
+    @patch("actions.helper")
+    @patch("actions.hookenv")
+    def test_remove_all_but_n_full(self, mock_hookenv, mock_helper):
+        """Verify remove-all-but-n-full action."""
+        result = "action_output".encode("utf-8")
+        mock_helper.remove_all_but_n_full.return_value = result
+        expected_dict_input = dict(output=result.decode("utf-8"))
+        actions.remove_all_but_n_full()
+        mock_helper.remove_all_but_n_full.assert_called_once()
+        mock_hookenv.action_set.called_with(expected_dict_input)
+
+
+class TestRemoveAllIncOfButNFullAction:
+    """Verify remove-all-inc-of-but-n-full action."""
+
+    @patch("actions.helper")
+    @patch("actions.hookenv")
+    def test_remove_all_inc_of_but_n_full(self, mock_hookenv, mock_helper):
+        """Verify remove-all-inc-of-but-n-full action."""
+        result = "action_output".encode("utf-8")
+        mock_helper.remove_all_inc_of_but_n_full.return_value = result
+        expected_dict_input = dict(output=result.decode("utf-8"))
+        actions.remove_all_inc_of_but_n_full()
+        mock_helper.remove_all_inc_of_but_n_full.assert_called_once()
+        mock_hookenv.action_set.called_with(expected_dict_input)
diff --git a/src/tests/unit/test_lib_duplicity.py b/src/tests/unit/test_lib_duplicity.py
index 90edf7a..06375c2 100644
--- a/src/tests/unit/test_lib_duplicity.py
+++ b/src/tests/unit/test_lib_duplicity.py
@@ -22,15 +22,17 @@ class TestDuplicityHelper:
             ("else", "host", None),
         ],
     )
-    def test_backup_cmd(
+    def test_run_cmd_backup_and_list(
         self, duplicity_helper, backend, remote_backup_url, expected_destination
     ):
-        """Verify backup command."""
+        """Verify full-backup and list-current-files _run_cmd."""
         duplicity_helper.charm_config["backend"] = backend
         duplicity_helper.charm_config["remote_backup_url"] = remote_backup_url
-        command = duplicity_helper.backup_cmd
-        assert "duplicity" in command
+        command = duplicity_helper._build_cmd("full", "/tmp/duplicity")
+        assert expected_destination in command
         assert "/tmp/duplicity" in command
+        command = duplicity_helper._build_cmd("list-current-files")
+        assert "duplicity" in command
         assert expected_destination in command
 
     @pytest.mark.parametrize(
@@ -45,17 +47,95 @@ class TestDuplicityHelper:
             ("else", "host", None),
         ],
     )
-    def test_list_current_files_cmd(
-        self, duplicity_helper, backend, remote_backup_url, expected_destination
+    @pytest.mark.parametrize(
+        "time",
+        [
+            ("now"),
+            (328974),
+            ("20220910T15:15:15+02:00"),
+            ("3D4S"),
+        ],
+    )
+    def test_run_cmd_remove_older_than(
+        self, duplicity_helper, backend, remote_backup_url, expected_destination, time
     ):
-        """Verify list-current-files command."""
+        """Verify remove-older-than command through _run_cmd."""
         duplicity_helper.charm_config["backend"] = backend
         duplicity_helper.charm_config["remote_backup_url"] = remote_backup_url
-        command = duplicity_helper.backup_cmd
+        command = duplicity_helper._build_cmd("remove-older-than", time)
+        assert "duplicity" in command
         assert expected_destination in command
-        command = duplicity_helper.list_files_cmd
+        assert "--force" in command
+        assert str(time) in command
+        assert "remove-older-than" in command
+
+    @pytest.mark.parametrize(
+        "backend,remote_backup_url,expected_destination",
+        [
+            ("scp", "some.host/backups", "scp://some.host/backups/unit-mock-0"),
+            ("rsync", "some.host/backups", "rsync://some.host/backups/unit-mock-0"),
+            ("ftp", "some.host/backups", "ftp://some.host/backups/unit-mock-0"),
+            ("sftp", "some.host/backups", "sftp://some.host/backups/unit-mock-0"),
+            ("s3", "some.host/backups", "s3://some.host/backups/unit-mock-0"),
+            ("file", "some.host/backups", "file://some.host/backups/unit-mock-0"),
+            ("else", "host", None),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "count",
+        [
+            (0),
+            (1),
+            (2204),
+            (999999999999),
+        ],
+    )
+    def test_run_cmd_remove_all_but_n_full(
+        self, duplicity_helper, backend, remote_backup_url, expected_destination, count
+    ):
+        """Verify remove-all-but-n-full command through _run_cmd."""
+        duplicity_helper.charm_config["backend"] = backend
+        duplicity_helper.charm_config["remote_backup_url"] = remote_backup_url
+        command = duplicity_helper._build_cmd("remove-all-but-n-full", count)
         assert "duplicity" in command
         assert expected_destination in command
+        assert "--force" in command
+        assert str(count) in command
+        assert "remove-all-but-n-full" in command
+
+    @pytest.mark.parametrize(
+        "backend,remote_backup_url,expected_destination",
+        [
+            ("scp", "some.host/backups", "scp://some.host/backups/unit-mock-0"),
+            ("rsync", "some.host/backups", "rsync://some.host/backups/unit-mock-0"),
+            ("ftp", "some.host/backups", "ftp://some.host/backups/unit-mock-0"),
+            ("sftp", "some.host/backups", "sftp://some.host/backups/unit-mock-0"),
+            ("s3", "some.host/backups", "s3://some.host/backups/unit-mock-0"),
+            ("file", "some.host/backups", "file://some.host/backups/unit-mock-0"),
+            ("else", "host", None),
+        ],
+    )
+    @pytest.mark.parametrize(
+        "count",
+        [
+            (0),
+            (1),
+            (2204),
+            (999999999999),
+        ],
+    )
+    def test_run_cmd_remove_all_inc_of_but_n_full(
+        self, duplicity_helper, backend, remote_backup_url, expected_destination, count
+    ):
+        """Verify remove-all-inc-of-but-n-full command through _run_cmd."""
+        duplicity_helper.charm_config["backend"] = backend
+        duplicity_helper.charm_config["remote_backup_url"] = remote_backup_url
+        command = duplicity_helper._build_cmd("remove-all-inc-of-but-n-full", count)
+        assert "duplicity" in command
+        assert expected_destination in command
+        assert "--force" in command
+        assert str(count) in command
+        assert "remove-all-inc-of-but-n-full" in command
 
     @pytest.mark.parametrize(
         "user,password,expected_destination",
@@ -78,7 +158,7 @@ class TestDuplicityHelper:
         duplicity_helper.charm_config["remote_backup_url"] = remote_backup_url
         duplicity_helper.charm_config["remote_user"] = user
         duplicity_helper.charm_config["remote_password"] = password
-        command = duplicity_helper.backup_cmd
+        command = duplicity_helper._build_cmd("full")
         assert expected_destination in command
 
     @pytest.mark.parametrize(
@@ -124,7 +204,7 @@ class TestDuplicityHelper:
         duplicity_helper.charm_config["disable_encryption"] = disable_encryption
         duplicity_helper.charm_config["gpg_public_key"] = gpg_public_key
         duplicity_helper.charm_config["private_ssh_key"] = private_ssh_key
-        command = duplicity_helper.backup_cmd
+        command = duplicity_helper._build_cmd("full")
         for expected_option in expected_options:
             assert expected_option in command
 
@@ -134,7 +214,7 @@ class TestDuplicityHelper:
     )
     @patch("lib_duplicity.subprocess")
     @patch("lib_duplicity.os")
-    def test_do_backup(
+    def test_executor(
         self,
         mock_os,
         mock_subprocess,
@@ -143,7 +223,7 @@ class TestDuplicityHelper:
         aws_access_key_id,
         encryption_passphrase,
     ):
-        """Verify do backup action."""
+        """Verify executor function."""
         duplicity_helper.charm_config["aws_secret_access_key"] = aws_secret_access_key
         duplicity_helper.charm_config["aws_access_key_id"] = aws_access_key_id
         duplicity_helper.charm_config["encryption_passphrase"] = encryption_passphrase
@@ -156,6 +236,36 @@ class TestDuplicityHelper:
         ]
         mock_os.environ.__setitem__.assert_has_calls(calls, any_order=True)
 
+    @patch("lib_duplicity.subprocess")
+    def test_do_backup(self, mock_subprocess, duplicity_helper):
+        """Verify do_backup action."""
+        duplicity_helper.do_backup()
+        mock_subprocess.check_output.assert_called_once()
+
+    @patch("lib_duplicity.subprocess")
+    def test_list_current_files(self, mock_subprocess, duplicity_helper):
+        """Verify list_current_files action."""
+        duplicity_helper.list_current_files()
+        mock_subprocess.check_output.assert_called_once()
+
+    @patch("lib_duplicity.subprocess")
+    def test_remove_older_than(self, mock_subprocess, duplicity_helper):
+        """Verify remove_older_than action."""
+        duplicity_helper.remove_older_than(time="now")
+        mock_subprocess.check_output.assert_called_once()
+
+    @patch("lib_duplicity.subprocess")
+    def test_remove_all_but_n_full(self, mock_subprocess, duplicity_helper):
+        """Verify remove_all_but_n_full action."""
+        duplicity_helper.remove_all_but_n_full(count=1)
+        mock_subprocess.check_output.assert_called_once()
+
+    @patch("lib_duplicity.subprocess")
+    def test_remove_all_inc_of_but_n_full(self, mock_subprocess, duplicity_helper):
+        """Verify remove_all_inc_of_but_n_full action."""
+        duplicity_helper.remove_all_inc_of_but_n_full(count=1)
+        mock_subprocess.check_output.assert_called_once()
+
     @pytest.mark.parametrize(
         "backup_frequency,expected_frequency",
         [
diff --git a/src/tox.ini b/src/tox.ini
index 25b8687..3b939b5 100644
--- a/src/tox.ini
+++ b/src/tox.ini
@@ -55,7 +55,10 @@ exclude =
 
 max-line-length = 88
 max-complexity = 10
-ignore = E402 #TODO remove it.
+# multiple lines because of https://bugs.launchpad.net/charm-duplicity/+bug/1998094
+ignore =
+  #TODO remove it.
+  E402
 
 [testenv:black]
 commands =