anvil-dev-framework 0.1.7 → 0.1.9

package/global/tests/test_optimization_applier.py

@@ -0,0 +1,508 @@
+"""
+Tests for Optimization Applier Service (Phase 6).
+
+Tests the safe application of token efficiency optimizations with
+backup, rollback, and tracking capabilities.
+"""
+
+import pytest
+from datetime import datetime, timezone
+from pathlib import Path
+from unittest.mock import Mock, patch, MagicMock
+import tempfile
+import shutil
+
+# Import the module under test
+import sys
+sys.path.insert(0, str(Path(__file__).parent.parent / "lib"))
+
+from optimization_applier import (
+    OptimizationApplier,
+    OptimizationType,
+    OptimizationResult,
+    AppliedOptimization,
+)
+
+
+class TestOptimizationType:
+    """Tests for OptimizationType enum."""
+
+    def test_optimization_types_exist(self):
+        """Test that all optimization types are defined."""
+        assert OptimizationType.REMOVE_UNUSED_PATTERN.value == "remove_unused_pattern"
+        assert OptimizationType.DEFER_LOADING.value == "defer_loading"
+        assert OptimizationType.CONSOLIDATE_COMMANDS.value == "consolidate_commands"
+        assert OptimizationType.REDUCE_CONTEXT.value == "reduce_context"
+        assert OptimizationType.PRUNE_RARELY_USED.value == "prune_rarely_used"
+
+    def test_optimization_type_from_string(self):
+        """Test creating OptimizationType from string."""
+        opt_type = OptimizationType("defer_loading")
+        assert opt_type == OptimizationType.DEFER_LOADING
+
+    def test_invalid_optimization_type(self):
+        """Test that invalid type raises ValueError."""
+        with pytest.raises(ValueError):
+            OptimizationType("invalid_type")
+
+
+class TestOptimizationResult:
+    """Tests for OptimizationResult dataclass."""
+
+    def test_result_defaults(self):
+        """Test default values for OptimizationResult."""
+        result = OptimizationResult(success=False)
+
+        assert result.success is False
+        assert result.optimization_id is None
+        assert result.recommendation_id is None
+        assert result.optimization_type is None
+        assert result.files_modified == []
+        assert result.backup_paths == []
+        assert result.tokens_before == 0
+        assert result.tokens_after == 0
+        assert result.savings == 0
+        assert result.error_message is None
+        assert result.commit_hash is None
+        assert result.applied_at is not None
+
+    def test_result_with_values(self):
+        """Test OptimizationResult with custom values."""
+        result = OptimizationResult(
+            success=True,
+            optimization_id=1,
+            recommendation_id=100,
+            optimization_type=OptimizationType.DEFER_LOADING,
+            files_modified=["file1.md", "file2.md"],
+            tokens_before=1000,
+            tokens_after=700,
+            savings=300
+        )
+
+        assert result.success is True
+        assert result.optimization_id == 1
+        assert result.savings == 300
+
+
+class TestAppliedOptimization:
+    """Tests for AppliedOptimization dataclass."""
+
+    def test_applied_optimization_creation(self):
+        """Test creating AppliedOptimization record."""
+        now = datetime.now(timezone.utc)
+        applied = AppliedOptimization(
+            id=1,
+            recommendation_id=100,
+            optimization_type="defer_loading",
+            description="Defer patterns command",
+            files_modified=["CLAUDE.md"],
+            tokens_saved=500,
+            applied_at=now,
+            commit_hash="abc123"
+        )
+
+        assert applied.id == 1
+        assert applied.recommendation_id == 100
+        assert applied.tokens_saved == 500
+        assert applied.reverted is False
+        assert applied.reverted_at is None
+
+
+class TestOptimizationApplier:
+    """Tests for OptimizationApplier class."""
+
+    @pytest.fixture
+    def temp_project(self):
+        """Create a temporary project directory for testing."""
+        temp_dir = tempfile.mkdtemp()
+        yield Path(temp_dir)
+        shutil.rmtree(temp_dir)
+
+    @pytest.fixture
+    def applier(self, temp_project):
+        """Create an OptimizationApplier with temp project."""
+        return OptimizationApplier(project_root=temp_project, auto_commit=False)
+
+    def test_init_creates_backup_dir(self, temp_project):
+        """Test that initialization creates backup directory."""
+        applier = OptimizationApplier(project_root=temp_project)
+
+        backup_dir = temp_project / ".claude" / "backups" / "optimizations"
+        assert backup_dir.exists()
+
+    def test_init_default_values(self, applier):
+        """Test default initialization values."""
+        assert applier.auto_commit is False
+        assert applier._applied_optimizations == []
+        assert applier._next_id == 1
+
+    def test_apply_recommendation_invalid_type(self, applier):
+        """Test applying recommendation with invalid type."""
+        result = applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="invalid_type",
+            description="Test",
+            target_files=[],
+            changes={},
+            estimated_savings=100
+        )
+
+        assert result.success is False
+        assert "Unknown optimization type" in result.error_message
+
+    def test_apply_recommendation_creates_backup(self, applier, temp_project):
+        """Test that applying creates backup of target files."""
+        # Create a test file
+        test_file = temp_project / "test.md"
+        test_file.write_text("original content")
+
+        result = applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Remove test pattern",
+            target_files=["test.md"],
+            changes={"pattern": "original"},
+            estimated_savings=50
+        )
+
+        assert result.success is True
+        assert len(result.backup_paths) == 1
+        assert Path(result.backup_paths[0]).exists()
+
+    def test_apply_recommendation_modifies_file(self, applier, temp_project):
+        """Test that applying modifies target file."""
+        # Create a test file
+        test_file = temp_project / "test.md"
+        test_file.write_text("This is the pattern to remove. Keep this.")
+
+        result = applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Remove pattern",
+            target_files=["test.md"],
+            changes={"pattern": "pattern to remove. "},
+            estimated_savings=50
+        )
+
+        assert result.success is True
+        assert test_file.read_text() == "This is the Keep this."
+
+    def test_apply_recommendation_tracks_optimization(self, applier, temp_project):
+        """Test that applied optimization is tracked."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("test content")
+
+        applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Test optimization",
+            target_files=["test.md"],
+            changes={"pattern": "test"},
+            estimated_savings=50
+        )
+
+        optimizations = applier.get_applied_optimizations()
+        assert len(optimizations) == 1
+        assert optimizations[0].description == "Test optimization"
+
+    def test_get_applied_optimizations_excludes_reverted(self, applier, temp_project):
+        """Test that reverted optimizations are excluded by default."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("content")
+
+        # Apply and then mark as reverted
+        applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Test",
+            target_files=["test.md"],
+            changes={"pattern": ""},
+            estimated_savings=50
+        )
+        applier._applied_optimizations[0].reverted = True
+
+        optimizations = applier.get_applied_optimizations(include_reverted=False)
+        assert len(optimizations) == 0
+
+        optimizations_all = applier.get_applied_optimizations(include_reverted=True)
+        assert len(optimizations_all) == 1
+
+    def test_get_total_savings(self, applier, temp_project):
+        """Test calculating total token savings."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("content")
+
+        applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Test 1",
+            target_files=["test.md"],
+            changes={"pattern": ""},
+            estimated_savings=100
+        )
+
+        test_file.write_text("more content")
+        applier.apply_recommendation(
+            recommendation_id=2,
+            recommendation_type="remove_unused_pattern",
+            description="Test 2",
+            target_files=["test.md"],
+            changes={"pattern": ""},
+            estimated_savings=200
+        )
+
+        savings = applier.get_total_savings()
+        assert savings["optimizations_count"] == 2
+        assert savings["total_tokens_saved"] == 300
+        assert savings["reverted_count"] == 0
+
+    def test_generate_impact_report(self, applier, temp_project):
+        """Test generating impact report."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("content")
+
+        applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Test optimization for report",
+            target_files=["test.md"],
+            changes={"pattern": ""},
+            estimated_savings=150
+        )
+
+        report = applier.generate_impact_report()
+
+        assert "Optimization Impact Report" in report
+        assert "Active Optimizations" in report
+        assert "1" in report  # optimization ID
+        assert "Test optimization for report" in report or "Test optimization" in report
+
+
+class TestRemovePatternOptimization:
+    """Tests for the remove_unused_pattern optimization type."""
+
+    @pytest.fixture
+    def temp_project(self):
+        temp_dir = tempfile.mkdtemp()
+        yield Path(temp_dir)
+        shutil.rmtree(temp_dir)
+
+    @pytest.fixture
+    def applier(self, temp_project):
+        return OptimizationApplier(project_root=temp_project, auto_commit=False)
+
+    def test_remove_pattern_single_occurrence(self, applier, temp_project):
+        """Test removing a pattern that occurs once."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("Before REMOVE_ME After")
+
+        result = applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Remove pattern",
+            target_files=["test.md"],
+            changes={"pattern": "REMOVE_ME "},
+            estimated_savings=20
+        )
+
+        assert result.success is True
+        assert test_file.read_text() == "Before After"
+
+    def test_remove_pattern_multiple_occurrences(self, applier, temp_project):
+        """Test removing a pattern with multiple occurrences."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("A REMOVE B REMOVE C")
+
+        result = applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Remove pattern",
+            target_files=["test.md"],
+            changes={"pattern": "REMOVE "},
+            estimated_savings=20
+        )
+
+        assert result.success is True
+        assert test_file.read_text() == "A B C"
+
+    def test_remove_pattern_not_found(self, applier, temp_project):
+        """Test when pattern is not found in file."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("Some content without pattern")
+
+        result = applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Remove nonexistent",
+            target_files=["test.md"],
+            changes={"pattern": "NONEXISTENT"},
+            estimated_savings=20
+        )
+
+        assert result.success is True
+        assert result.files_modified == []  # File not modified
+
+
+class TestReduceContextOptimization:
+    """Tests for the reduce_context optimization type."""
+
+    @pytest.fixture
+    def temp_project(self):
+        temp_dir = tempfile.mkdtemp()
+        yield Path(temp_dir)
+        shutil.rmtree(temp_dir)
+
+    @pytest.fixture
+    def applier(self, temp_project):
+        return OptimizationApplier(project_root=temp_project, auto_commit=False)
+
+    def test_reduce_context_removes_section(self, applier, temp_project):
+        """Test removing a markdown section."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("""# Main
+
+## Keep This
+Content to keep.
+
+## Remove This
+Content to remove.
+
+## Also Keep
+More content.
+""")
+
+        result = applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="reduce_context",
+            description="Remove section",
+            target_files=["test.md"],
+            changes={"sections": ["Remove This"]},
+            estimated_savings=100
+        )
+
+        assert result.success is True
+        content = test_file.read_text()
+        assert "Keep This" in content
+        assert "Remove This" not in content
+        assert "Also Keep" in content
+
+
+class TestRollback:
+    """Tests for optimization rollback functionality."""
+
+    @pytest.fixture
+    def temp_project(self):
+        temp_dir = tempfile.mkdtemp()
+        yield Path(temp_dir)
+        shutil.rmtree(temp_dir)
+
+    @pytest.fixture
+    def applier(self, temp_project):
+        return OptimizationApplier(project_root=temp_project, auto_commit=False)
+
+    def test_rollback_nonexistent_optimization(self, applier):
+        """Test rolling back optimization that doesn't exist."""
+        success = applier.rollback_optimization(999)
+        assert success is False
+
+    def test_rollback_already_reverted(self, applier, temp_project):
+        """Test rolling back already-reverted optimization."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("content")
+
+        applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Test",
+            target_files=["test.md"],
+            changes={"pattern": ""},
+            estimated_savings=50
+        )
+
+        # Manually mark as reverted
+        applier._applied_optimizations[0].reverted = True
+
+        success = applier.rollback_optimization(1)
+        assert success is False
+
+    def test_rollback_without_commit_hash_marks_reverted(self, applier, temp_project):
+        """Test that rollback without commit hash marks optimization as reverted."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("content")
+
+        applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Test",
+            target_files=["test.md"],
+            changes={"pattern": ""},
+            estimated_savings=50
+        )
+
+        # Verify initial state
+        opt = applier._applied_optimizations[0]
+        assert opt.reverted is False
+        assert opt.commit_hash is None  # No commit hash since auto_commit=False
+
+        # Rollback without commit_hash still marks as reverted
+        success = applier.rollback_optimization(1)
+
+        # The implementation marks as reverted and returns True
+        # even without a commit hash (no git revert needed)
+        assert success is True
+        assert opt.reverted is True
+        assert opt.reverted_at is not None
+
+
+class TestBackupRestore:
+    """Tests for backup and restore functionality."""
+
+    @pytest.fixture
+    def temp_project(self):
+        temp_dir = tempfile.mkdtemp()
+        yield Path(temp_dir)
+        shutil.rmtree(temp_dir)
+
+    @pytest.fixture
+    def applier(self, temp_project):
+        return OptimizationApplier(project_root=temp_project, auto_commit=False)
+
+    def test_create_backup(self, applier, temp_project):
+        """Test creating a backup of a file."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("original content")
+
+        backup_path = applier._create_backup(test_file)
+
+        assert backup_path is not None
+        assert backup_path.exists()
+        assert backup_path.read_text() == "original content"
+
+    def test_create_backup_nonexistent_file(self, applier, temp_project):
+        """Test creating backup of nonexistent file."""
+        test_file = temp_project / "nonexistent.md"
+
+        backup_path = applier._create_backup(test_file)
+
+        assert backup_path is None
+
+    def test_backup_preserves_content(self, applier, temp_project):
+        """Test that backup preserves original content after modification."""
+        test_file = temp_project / "test.md"
+        test_file.write_text("original content with PATTERN")
+
+        result = applier.apply_recommendation(
+            recommendation_id=1,
+            recommendation_type="remove_unused_pattern",
+            description="Remove pattern",
+            target_files=["test.md"],
+            changes={"pattern": "PATTERN"},
+            estimated_savings=20
+        )
+
+        # Check file was modified
+        assert test_file.read_text() == "original content with "
+
+        # Check backup has original content
+        backup_path = Path(result.backup_paths[0])
+        assert backup_path.read_text() == "original content with PATTERN"