regscale-cli 6.26.0.0__py3-none-any.whl → 6.27.0.1__py3-none-any.whl

tests/regscale/integrations/commercial/wizv2/test_file_cleanup.py

@@ -0,0 +1,283 @@
+"""Tests for file cleanup utilities."""
+
+import os
+import tempfile
+import unittest
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+
+from regscale.integrations.commercial.wizv2.file_cleanup import ReportFileCleanup
+
+
+class TestReportFileCleanup(unittest.TestCase):
+    """Test cases for ReportFileCleanup."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.test_dir = tempfile.mkdtemp()
+        self.file_prefix = "test_report_"
+
+    def tearDown(self):
+        """Clean up test files."""
+        if os.path.exists(self.test_dir):
+            for filename in os.listdir(self.test_dir):
+                filepath = os.path.join(self.test_dir, filename)
+                try:
+                    os.remove(filepath)
+                except Exception:
+                    pass
+            try:
+                os.rmdir(self.test_dir)
+            except Exception:
+                pass
+
+    def _create_test_file(self, filename: str, age_seconds: int = 0) -> str:
+        """
+        Create a test file and optionally set its modification time.
+
+        :param str filename: Name of the file to create
+        :param int age_seconds: How many seconds old the file should be
+        :return: Full path to the created file
+        """
+        filepath = os.path.join(self.test_dir, filename)
+        Path(filepath).touch()
+        if age_seconds > 0:
+            import time
+
+            current_time = time.time()
+            os.utime(filepath, (current_time - age_seconds, current_time - age_seconds))
+        return filepath
+
+    def test_cleanup_no_files(self):
+        """Test cleanup when no files exist."""
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix)
+        # Should not raise any exceptions
+
+    def test_cleanup_directory_not_exists(self):
+        """Test cleanup when directory doesn't exist."""
+        non_existent = os.path.join(self.test_dir, "non_existent")
+        ReportFileCleanup.cleanup_old_files(non_existent, self.file_prefix)
+        # Should not raise any exceptions
+
+    def test_cleanup_keeps_recent_files(self):
+        """Test that recent files are kept."""
+        for i in range(3):
+            self._create_test_file(f"{self.file_prefix}{i}.csv")
+
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, keep_count=5)
+
+        remaining_files = [f for f in os.listdir(self.test_dir) if f.startswith(self.file_prefix)]
+        self.assertEqual(len(remaining_files), 3)
+
+    def test_cleanup_deletes_old_files(self):
+        """Test that old files beyond keep_count are deleted."""
+        for i in range(10):
+            self._create_test_file(f"{self.file_prefix}{i:02d}.csv", age_seconds=100 - i * 10)
+
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, keep_count=3)
+
+        remaining_files = [f for f in os.listdir(self.test_dir) if f.startswith(self.file_prefix)]
+        self.assertEqual(len(remaining_files), 3)
+
+    def test_cleanup_respects_extension_grouping(self):
+        """Test that files are grouped by extension before cleanup."""
+        for i in range(6):
+            self._create_test_file(f"{self.file_prefix}{i:02d}.csv", age_seconds=100 - i * 10)
+        for i in range(6):
+            self._create_test_file(f"{self.file_prefix}{i:02d}.json", age_seconds=100 - i * 10)
+
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, keep_count=3)
+
+        csv_files = [f for f in os.listdir(self.test_dir) if f.endswith(".csv")]
+        json_files = [f for f in os.listdir(self.test_dir) if f.endswith(".json")]
+
+        self.assertEqual(len(csv_files), 3)
+        self.assertEqual(len(json_files), 3)
+
+    def test_cleanup_with_custom_extensions(self):
+        """Test cleanup with custom extension list."""
+        self._create_test_file(f"{self.file_prefix}01.csv")
+        self._create_test_file(f"{self.file_prefix}02.txt")
+        self._create_test_file(f"{self.file_prefix}03.log")
+
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, extensions=[".txt", ".log"], keep_count=1)
+
+        remaining_files = os.listdir(self.test_dir)
+        self.assertIn(f"{self.file_prefix}01.csv", remaining_files)
+        self.assertIn(f"{self.file_prefix}02.txt", remaining_files)
+        self.assertIn(f"{self.file_prefix}03.log", remaining_files)
+
+    def test_cleanup_default_extensions(self):
+        """Test cleanup uses default extensions when not specified."""
+        self._create_test_file(f"{self.file_prefix}01.csv")
+        self._create_test_file(f"{self.file_prefix}02.json")
+        self._create_test_file(f"{self.file_prefix}03.jsonl")
+        self._create_test_file(f"{self.file_prefix}04.txt")
+
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, keep_count=5)
+
+        remaining_files = os.listdir(self.test_dir)
+        self.assertEqual(len(remaining_files), 4)
+
+    def test_cleanup_ignores_non_matching_prefix(self):
+        """Test that files with different prefix are not deleted."""
+        self._create_test_file(f"{self.file_prefix}01.csv")
+        self._create_test_file("other_prefix_01.csv")
+
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, keep_count=0)
+
+        remaining_files = os.listdir(self.test_dir)
+        self.assertIn("other_prefix_01.csv", remaining_files)
+
+    def test_cleanup_handles_delete_exception(self):
+        """Test cleanup handles exceptions when deleting files."""
+        for i in range(10):
+            self._create_test_file(f"{self.file_prefix}{i:02d}.csv", age_seconds=100 - i * 10)
+
+        with patch("os.remove", side_effect=PermissionError("Permission denied")):
+            # Should not raise exception, just log warning
+            ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, keep_count=3)
+
+    def test_cleanup_handles_general_exception(self):
+        """Test cleanup handles general exceptions."""
+        with patch("os.path.exists", return_value=True):
+            with patch("os.listdir", side_effect=PermissionError("Permission denied")):
+                # Should not raise exception, just log warning
+                ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix)
+
+    def test_find_matching_files(self):
+        """Test _find_matching_files method."""
+        self._create_test_file(f"{self.file_prefix}01.csv")
+        self._create_test_file(f"{self.file_prefix}02.json")
+        self._create_test_file("other_file.csv")
+
+        entries = ReportFileCleanup._find_matching_files(self.test_dir, self.file_prefix, [".csv", ".json"])
+
+        self.assertEqual(len(entries), 2)
+        filenames = [entry[0] for entry in entries]
+        self.assertIn(f"{self.file_prefix}01.csv", filenames)
+        self.assertIn(f"{self.file_prefix}02.json", filenames)
+
+    def test_find_matching_files_multiple_extensions_per_file(self):
+        """Test that only one entry is created per file even if multiple extensions match."""
+        self._create_test_file(f"{self.file_prefix}01.csv")
+
+        entries = ReportFileCleanup._find_matching_files(self.test_dir, self.file_prefix, [".csv", ".json"])
+
+        # Should only have one entry for the .csv file
+        self.assertEqual(len(entries), 1)
+        self.assertEqual(entries[0][2], ".csv")
+
+    def test_group_files_by_extension(self):
+        """Test _group_files_by_extension method."""
+        entries = [
+            ("file1.csv", "/path/file1.csv", ".csv"),
+            ("file2.csv", "/path/file2.csv", ".csv"),
+            ("file3.json", "/path/file3.json", ".json"),
+        ]
+
+        grouped = ReportFileCleanup._group_files_by_extension(entries)
+
+        self.assertEqual(len(grouped), 2)
+        self.assertEqual(len(grouped[".csv"]), 2)
+        self.assertEqual(len(grouped[".json"]), 1)
+
+    def test_group_files_by_extension_empty(self):
+        """Test _group_files_by_extension with empty list."""
+        grouped = ReportFileCleanup._group_files_by_extension([])
+        self.assertEqual(grouped, {})
+
+    def test_cleanup_files_by_extension(self):
+        """Test _cleanup_files_by_extension method."""
+        # Create test files
+        files = []
+        for i in range(5):
+            filepath = self._create_test_file(f"{self.file_prefix}{i:02d}.csv", age_seconds=100 - i * 10)
+            files.append((f"{self.file_prefix}{i:02d}.csv", filepath))
+
+        files_by_ext = {".csv": files}
+        deleted_count = ReportFileCleanup._cleanup_files_by_extension(files_by_ext, keep_count=2)
+
+        self.assertEqual(deleted_count, 3)
+        remaining_files = os.listdir(self.test_dir)
+        self.assertEqual(len(remaining_files), 2)
+
+    def test_cleanup_files_by_extension_no_files_to_delete(self):
+        """Test _cleanup_files_by_extension when all files should be kept."""
+        # Create test files
+        files = []
+        for i in range(3):
+            filepath = self._create_test_file(f"{self.file_prefix}{i:02d}.csv")
+            files.append((f"{self.file_prefix}{i:02d}.csv", filepath))
+
+        files_by_ext = {".csv": files}
+        deleted_count = ReportFileCleanup._cleanup_files_by_extension(files_by_ext, keep_count=5)
+
+        self.assertEqual(deleted_count, 0)
+        remaining_files = os.listdir(self.test_dir)
+        self.assertEqual(len(remaining_files), 3)
+
+    def test_cleanup_files_by_extension_delete_all(self):
+        """Test _cleanup_files_by_extension with keep_count=0."""
+        # Create test files
+        files = []
+        for i in range(5):
+            filepath = self._create_test_file(f"{self.file_prefix}{i:02d}.csv")
+            files.append((f"{self.file_prefix}{i:02d}.csv", filepath))
+
+        files_by_ext = {".csv": files}
+        deleted_count = ReportFileCleanup._cleanup_files_by_extension(files_by_ext, keep_count=0)
+
+        self.assertEqual(deleted_count, 5)
+        remaining_files = os.listdir(self.test_dir)
+        self.assertEqual(len(remaining_files), 0)
+
+    def test_cleanup_files_by_extension_with_delete_failure(self):
+        """Test _cleanup_files_by_extension handles delete failures gracefully."""
+        # Create test files
+        files = []
+        for i in range(5):
+            filepath = self._create_test_file(f"{self.file_prefix}{i:02d}.csv", age_seconds=100 - i * 10)
+            files.append((f"{self.file_prefix}{i:02d}.csv", filepath))
+
+        files_by_ext = {".csv": files}
+
+        with patch("os.remove", side_effect=[None, PermissionError("Permission denied"), None]):
+            deleted_count = ReportFileCleanup._cleanup_files_by_extension(files_by_ext, keep_count=2)
+            # Should continue processing even if one delete fails
+            self.assertGreaterEqual(deleted_count, 0)
+
+    def test_cleanup_files_sorted_by_modification_time(self):
+        """Test that files are sorted by modification time before deletion."""
+        # Create files with specific modification times
+        self._create_test_file(f"{self.file_prefix}oldest.csv", age_seconds=1000)
+        self._create_test_file(f"{self.file_prefix}middle.csv", age_seconds=500)
+        self._create_test_file(f"{self.file_prefix}newest.csv", age_seconds=100)
+
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, keep_count=1)
+
+        remaining_files = os.listdir(self.test_dir)
+        self.assertEqual(len(remaining_files), 1)
+        self.assertIn(f"{self.file_prefix}newest.csv", remaining_files)
+
+    def test_cleanup_multiple_extensions_independent(self):
+        """Test that different extensions are cleaned up independently."""
+        # Create CSV files
+        for i in range(10):
+            self._create_test_file(f"{self.file_prefix}{i:02d}.csv", age_seconds=200 - i * 10)
+
+        # Create JSON files
+        for i in range(5):
+            self._create_test_file(f"{self.file_prefix}{i:02d}.json", age_seconds=100 - i * 10)
+
+        ReportFileCleanup.cleanup_old_files(self.test_dir, self.file_prefix, keep_count=3)
+
+        csv_files = [f for f in os.listdir(self.test_dir) if f.endswith(".csv")]
+        json_files = [f for f in os.listdir(self.test_dir) if f.endswith(".json")]
+
+        self.assertEqual(len(csv_files), 3)
+        self.assertEqual(len(json_files), 3)
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/regscale/integrations/commercial/wizv2/test_file_operations.py

@@ -0,0 +1,260 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Test suite for FileOperations module.
+
+Tests cover:
+- JSON file loading and saving
+- Cache validation by file age
+- Load cache or fetch pattern
+- Multi-file search operations
+"""
+
+import datetime
+import json
+import os
+import tempfile
+import pytest
+from pathlib import Path
+
+from regscale.integrations.commercial.wizv2.core.file_operations import FileOperations
+
+
+class TestFileOperationsBasics:
+    """Test basic file I/O operations."""
+
+    def test_save_and_load_json_file(self):
+        """Test saving and loading JSON data."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = os.path.join(tmpdir, "test.json")
+            test_data = {"key": "value", "number": 42, "list": [1, 2, 3]}
+
+            # Save data
+            success = FileOperations.save_json_file(test_data, file_path)
+            assert success is True
+            assert os.path.exists(file_path)
+
+            # Load data
+            loaded_data = FileOperations.load_json_file(file_path)
+            assert loaded_data == test_data
+
+    def test_load_json_file_nonexistent(self):
+        """Test loading nonexistent file returns None."""
+        result = FileOperations.load_json_file("/nonexistent/path/file.json")
+        assert result is None
+
+    def test_save_json_file_creates_directory(self):
+        """Test that save_json_file creates parent directories."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            nested_path = os.path.join(tmpdir, "level1", "level2", "test.json")
+            test_data = {"nested": True}
+
+            success = FileOperations.save_json_file(test_data, nested_path, create_dir=True)
+            assert success is True
+            assert os.path.exists(nested_path)
+
+            loaded = FileOperations.load_json_file(nested_path)
+            assert loaded == test_data
+
+
+class TestFileOperationsCaching:
+    """Test cache-related operations."""
+
+    def test_get_file_age_existing_file(self):
+        """Test getting age of existing file."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("test")
+            temp_path = f.name
+
+        try:
+            age = FileOperations.get_file_age(temp_path)
+            assert age is not None
+            assert isinstance(age, datetime.timedelta)
+            assert age.total_seconds() < 5  # Just created, should be very recent
+        finally:
+            os.unlink(temp_path)
+
+    def test_get_file_age_nonexistent(self):
+        """Test getting age of nonexistent file returns None."""
+        age = FileOperations.get_file_age("/nonexistent/file.json")
+        assert age is None
+
+    def test_is_cache_valid_fresh_file(self):
+        """Test cache validation for fresh file."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write('{"fresh": true}')
+            temp_path = f.name
+
+        try:
+            is_valid = FileOperations.is_cache_valid(temp_path, max_age_hours=1)
+            assert is_valid is True
+        finally:
+            os.unlink(temp_path)
+
+    def test_is_cache_valid_nonexistent(self):
+        """Test cache validation for nonexistent file."""
+        is_valid = FileOperations.is_cache_valid("/nonexistent/cache.json", max_age_hours=1)
+        assert is_valid is False
+
+    def test_load_cache_or_fetch_uses_cache(self):
+        """Test that load_cache_or_fetch uses valid cache."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".json") as f:
+            json.dump({"cached": True}, f)
+            temp_path = f.name
+
+        try:
+            fetch_called = False
+
+            def fetch_fn():
+                nonlocal fetch_called
+                fetch_called = True
+                return {"fetched": True}
+
+            result = FileOperations.load_cache_or_fetch(
+                file_path=temp_path, fetch_fn=fetch_fn, max_age_hours=1, save_cache=False
+            )
+
+            assert result == {"cached": True}
+            assert fetch_called is False  # Should not fetch when cache is valid
+        finally:
+            os.unlink(temp_path)
+
+    def test_load_cache_or_fetch_fetches_when_no_cache(self):
+        """Test that load_cache_or_fetch fetches when cache doesn't exist."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            cache_path = os.path.join(tmpdir, "cache.json")
+
+            def fetch_fn():
+                return {"fetched": True}
+
+            result = FileOperations.load_cache_or_fetch(
+                file_path=cache_path, fetch_fn=fetch_fn, max_age_hours=1, save_cache=True
+            )
+
+            assert result == {"fetched": True}
+            assert os.path.exists(cache_path)  # Should save cache
+
+            # Verify cache was saved correctly
+            cached_data = FileOperations.load_json_file(cache_path)
+            assert cached_data == {"fetched": True}
+
+
+class TestFileOperationsSearch:
+    """Test file search operations."""
+
+    def test_search_single_json_file_found(self):
+        """Test searching for item in single JSON file - found."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".json") as f:
+            test_data = [{"id": "1", "name": "Alice"}, {"id": "2", "name": "Bob"}, {"id": "3", "name": "Charlie"}]
+            json.dump(test_data, f)
+            temp_path = f.name
+
+        try:
+
+            def match_fn(item, identifier):
+                return item.get("id") == identifier
+
+            result = FileOperations.search_single_json_file("2", temp_path, match_fn)
+            assert result is not None
+            assert result["name"] == "Bob"
+        finally:
+            os.unlink(temp_path)
+
+    def test_search_single_json_file_not_found(self):
+        """Test searching for item in single JSON file - not found."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, suffix=".json") as f:
+            test_data = [{"id": "1", "name": "Alice"}]
+            json.dump(test_data, f)
+            temp_path = f.name
+
+        try:
+
+            def match_fn(item, identifier):
+                return item.get("id") == identifier
+
+            result = FileOperations.search_single_json_file("999", temp_path, match_fn)
+            assert result is None
+        finally:
+            os.unlink(temp_path)
+
+    def test_search_json_files_multiple_files(self):
+        """Test searching across multiple JSON files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create multiple files
+            file1 = os.path.join(tmpdir, "file1.json")
+            file2 = os.path.join(tmpdir, "file2.json")
+            file3 = os.path.join(tmpdir, "file3.json")
+
+            with open(file1, "w") as f:
+                json.dump([{"id": "1", "name": "File1Item"}], f)
+
+            with open(file2, "w") as f:
+                json.dump([{"id": "2", "name": "File2Item"}], f)
+
+            with open(file3, "w") as f:
+                json.dump([{"id": "3", "name": "File3Item"}], f)
+
+            def match_fn(item, identifier):
+                return item.get("id") == identifier
+
+            # Search across all files - should find in file2
+            result, source_file = FileOperations.search_json_files("2", [file1, file2, file3], match_fn)
+
+            assert result is not None
+            assert result["name"] == "File2Item"
+            assert source_file == file2
+
+    def test_search_json_files_not_found(self):
+        """Test searching across files when item doesn't exist."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file1 = os.path.join(tmpdir, "file1.json")
+
+            with open(file1, "w") as f:
+                json.dump([{"id": "1"}], f)
+
+            def match_fn(item, identifier):
+                return item.get("id") == identifier
+
+            result, source_file = FileOperations.search_json_files("999", [file1], match_fn)
+
+            assert result is None
+            assert source_file is None
+
+
+class TestFileOperationsEdgeCases:
+    """Test edge cases and error handling."""
+
+    def test_save_json_file_invalid_data(self):
+        """Test saving non-serializable data returns False."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            file_path = os.path.join(tmpdir, "test.json")
+
+            # Try to save non-serializable data
+            class NonSerializable:
+                pass
+
+            success = FileOperations.save_json_file({"obj": NonSerializable()}, file_path)
+            assert success is False
+
+    def test_load_json_file_invalid_json(self):
+        """Test loading invalid JSON returns None."""
+        with tempfile.NamedTemporaryFile(mode="w", delete=False) as f:
+            f.write("not valid json{[")
+            temp_path = f.name
+
+        try:
+            result = FileOperations.load_json_file(temp_path)
+            assert result is None
+        finally:
+            os.unlink(temp_path)
+
+    def test_search_json_files_with_nonexistent_files(self):
+        """Test search gracefully handles nonexistent files."""
+
+        def match_fn(item, identifier):
+            return item.get("id") == identifier
+
+        result, source = FileOperations.search_json_files("1", ["/nonexistent1.json", "/nonexistent2.json"], match_fn)
+
+        assert result is None
+        assert source is None

tests/regscale/integrations/commercial/wizv2/test_issue.py

@@ -1,7 +1,7 @@
 import pytest
 from unittest.mock import patch
 from regscale.integrations.commercial.wizv2.issue import WizIssue
-from regscale.integrations.commercial.wizv2.constants import WizVulnerabilityType
+from regscale.integrations.commercial.wizv2.core.constants import WizVulnerabilityType
 from regscale.models import IssueSeverity, IssueStatus