feat: add cleanup_all option to CleanupCommand and CLI

Author: Cyber-Syntax

autotarcompress/cli.py

@@ -185,7 +185,7 @@ def cleanup(
         raise typer.Exit(1)
 
     facade: BackupFacade = runner.initialize_config()
-    success = facade.execute_command("cleanup")
+    success = facade.execute_command("cleanup", cleanup_all=all_backups)
     if not success:
         raise typer.Exit(1)
 

autotarcompress/commands/cleanup.py

@@ -17,31 +17,37 @@
 class CleanupCommand(Command):
     """Command to clean up old backup, encrypted, and decrypted files."""
 
-    def __init__(self, config: BackupConfig) -> None:
+    def __init__(self, config: BackupConfig, cleanup_all: bool = False) -> None:
         """Initialize CleanupCommand.
 
         Args:
             config (BackupConfig): Backup configuration with retention and
                 folder settings.
+            cleanup_all (bool): If True, delete all backup files regardless
+                of retention policy.
 
         """
         self.config: BackupConfig = config
+        self.cleanup_all: bool = cleanup_all
         self.logger: logging.Logger = logging.getLogger(__name__)
 
     def execute(self) -> bool:
         """Delete old backup, encrypted, and decrypted files.
 
-        Per retention policy.
+        Per retention policy or all files if cleanup_all is True.
 
         Returns:
             bool: Always True (cleanup always completes, even if nothing
                 to delete).
 
         """
-        self._cleanup_files(".tar.xz", self.config.keep_backup)
-        self._cleanup_files(".tar.xz-decrypted", self.config.keep_backup)
-        self._cleanup_files(".tar-extracted", self.config.keep_backup)
-        self._cleanup_files(".tar.xz.enc", self.config.keep_enc_backup)
+        if self.cleanup_all:
+            self._cleanup_all_files()
+        else:
+            self._cleanup_files(".tar.xz", self.config.keep_backup)
+            self._cleanup_files(".tar.xz-decrypted", self.config.keep_backup)
+            self._cleanup_files(".tar-extracted", self.config.keep_backup)
+            self._cleanup_files(".tar.xz.enc", self.config.keep_enc_backup)
         return True
 
     def _cleanup_files(self, ext: str, keep_count: int) -> None:
@@ -96,3 +102,15 @@ def _extract_date_from_filename(filename: str) -> datetime.datetime:
                 self.logger.error("Failed to delete %s: %s", old_file, e)
                 print(f"Failed to delete {old_file}: {e}")
         return None
+
+    def _cleanup_all_files(self) -> None:
+        """Delete all backup files regardless of retention policy.
+
+        This method removes all backup files of all types without
+        respecting the keep_count configuration.
+
+        """
+        extensions = [".tar.xz", ".tar.xz-decrypted", ".tar-extracted", ".tar.xz.enc"]
+
+        for ext in extensions:
+            self._cleanup_files(ext, 0)  # keep_count=0 means delete all

autotarcompress/facade.py

@@ -41,11 +41,12 @@ def configure(self) -> None:
         self.config.save()
         print("\nConfiguration saved successfully!")
 
-    def execute_command(self, command_name: str) -> Any:
+    def execute_command(self, command_name: str, **kwargs: Any) -> Any:
         """Execute a predefined command by name.
 
         Args:
             command_name (str): The name of the command to execute.
+            **kwargs: Additional parameters to pass to the command constructor.
 
         Returns:
             Any: The result of the command's execution.
@@ -54,7 +55,12 @@ def execute_command(self, command_name: str) -> Any:
             ValueError: If the command name is not recognized.
 
         """
-        if command_name in self.commands:
+        if command_name == "cleanup":
+            # Handle cleanup command with potential parameters
+            cleanup_all = kwargs.get("cleanup_all", False)
+            command = CleanupCommand(self.config, cleanup_all=cleanup_all)
+            return command.execute()
+        elif command_name in self.commands:
             return self.commands[command_name].execute()
         raise ValueError(f"Unknown command: {command_name}")
 

tests/commands/test_cleanup.py

@@ -118,6 +118,23 @@ def test_initialization(self, mock_config: BackupConfig) -> None:
         assert isinstance(command.logger, logging.Logger)
         assert command.logger.name == "autotarcompress.commands.cleanup"
 
+    def test_initialization_with_cleanup_all(self, mock_config: BackupConfig) -> None:
+        """Test CleanupCommand initialization with cleanup_all parameter.
+
+        Args:
+            mock_config: Mock backup configuration.
+
+        """
+        command = CleanupCommand(mock_config, cleanup_all=True)
+
+        assert command.config is mock_config
+        assert command.cleanup_all is True
+        assert isinstance(command.logger, logging.Logger)
+
+        # Test default value
+        command_default = CleanupCommand(mock_config)
+        assert command_default.cleanup_all is False
+
     @patch.object(CleanupCommand, "_cleanup_files")
     def test_execute_calls_cleanup_methods(
         self, mock_cleanup: Mock, cleanup_command: CleanupCommand
@@ -475,3 +492,65 @@ def test_file_extension_filtering(self, cleanup_command: CleanupCommand) -> None
 
             # Should only process the 2 .tar.xz files and delete 1 (oldest)
             assert mock_unlink.call_count == 1
+
+    def test_cleanup_all_files_functionality(self, mock_config: BackupConfig) -> None:
+        """Test that cleanup_all deletes all files regardless of retention policy.
+
+        Args:
+            mock_config: Mock backup configuration.
+
+        """
+        command = CleanupCommand(mock_config, cleanup_all=True)
+
+        # Mock files for different extensions
+        test_files = [
+            "15-12-2024.tar.xz",
+            "14-12-2024.tar.xz",
+            "13-12-2024.tar.xz-decrypted",
+            "12-12-2024.tar-extracted",
+            "11-12-2024.tar.xz.enc",
+        ]
+
+        with patch("os.listdir", return_value=test_files), patch(
+            "pathlib.Path.unlink"
+        ) as mock_unlink, patch("pathlib.Path.is_dir", return_value=False):
+            command._cleanup_all_files()
+
+            # Should delete all files (4 calls for 4 different extensions)
+            # Each extension will be processed, but only matching files deleted
+            assert mock_unlink.call_count == len(test_files)
+
+    def test_execute_with_cleanup_all_calls_cleanup_all_files(
+        self, mock_config: BackupConfig
+    ) -> None:
+        """Test that execute() calls _cleanup_all_files when cleanup_all is True.
+
+        Args:
+            mock_config: Mock backup configuration.
+
+        """
+        command = CleanupCommand(mock_config, cleanup_all=True)
+
+        with patch.object(command, "_cleanup_all_files") as mock_cleanup_all:
+            result = command.execute()
+
+            assert result is True
+            mock_cleanup_all.assert_called_once()
+
+    def test_execute_without_cleanup_all_calls_regular_cleanup(
+        self, mock_config: BackupConfig
+    ) -> None:
+        """Test that execute() calls regular cleanup when cleanup_all is False.
+
+        Args:
+            mock_config: Mock backup configuration.
+
+        """
+        command = CleanupCommand(mock_config, cleanup_all=False)
+
+        with patch.object(command, "_cleanup_files") as mock_cleanup_files:
+            result = command.execute()
+
+            assert result is True
+            # Should be called 4 times for different file extensions
+            assert mock_cleanup_files.call_count == 4

tests/test_main.py

@@ -236,7 +236,18 @@ def test_cleanup_command_success(self, mock_init_config: MagicMock) -> None:
 
         result = self.runner.invoke(app, ["cleanup"])
         assert result.exit_code == 0
-        mock_facade.execute_command.assert_called_once_with("cleanup")
+        mock_facade.execute_command.assert_called_once_with("cleanup", cleanup_all=False)
+
+    @patch("autotarcompress.runner.initialize_config")
+    def test_cleanup_command_all_success(self, mock_init_config: MagicMock) -> None:
+        """Test successful cleanup --all command execution."""
+        mock_facade = MagicMock()
+        mock_facade.execute_command.return_value = True
+        mock_init_config.return_value = mock_facade
+
+        result = self.runner.invoke(app, ["cleanup", "--all"])
+        assert result.exit_code == 0
+        mock_facade.execute_command.assert_called_once_with("cleanup", cleanup_all=True)
 
     @patch("autotarcompress.runner.run_main_loop")
     @patch("autotarcompress.runner.initialize_config")