auto-coder 1.0.0__py3-none-any.whl → 2.0.0__py3-none-any.whl

autocoder/common/search_replace_patch/tests/test_base.py

@@ -0,0 +1,188 @@
+"""
+Test module for base classes and enums
+"""
+
+import unittest
+from typing import List, Tuple
+
+from ..base import BaseReplacer, ReplaceResult, ReplaceStrategy
+
+
+class MockReplacer(BaseReplacer):
+    """Mock replacer for testing BaseReplacer"""
+    
+    def __init__(self, strategy: ReplaceStrategy = ReplaceStrategy.STRING):
+        super().__init__(strategy)
+        self.should_succeed = True
+        self.should_handle = True
+    
+    def replace(self, content: str, search_blocks: List[Tuple[str, str]]) -> ReplaceResult:
+        if self.should_succeed:
+            return ReplaceResult(
+                success=True,
+                message="Mock replacement successful",
+                new_content=content + "_modified",
+                applied_count=len(search_blocks),
+                total_count=len(search_blocks)
+            )
+        else:
+            return ReplaceResult(
+                success=False,
+                message="Mock replacement failed",
+                total_count=len(search_blocks)
+            )
+    
+    def can_handle(self, content: str, search_blocks: List[Tuple[str, str]]) -> bool:
+        return self.should_handle
+
+
+class TestReplaceStrategy(unittest.TestCase):
+    """Test ReplaceStrategy enum"""
+    
+    def test_strategy_enum_values(self):
+        """Test that strategy enum has correct values"""
+        self.assertEqual(ReplaceStrategy.STRING.value, "string")
+        self.assertEqual(ReplaceStrategy.PATCH.value, "patch")
+        self.assertEqual(ReplaceStrategy.SIMILARITY.value, "similarity")
+    
+    def test_enum_uniqueness(self):
+        """Test that all enum values are unique"""
+        values = [strategy.value for strategy in ReplaceStrategy]
+        self.assertEqual(len(values), len(set(values)))
+
+
+class TestReplaceResult(unittest.TestCase):
+    """Test ReplaceResult dataclass"""
+    
+    def test_default_values(self):
+        """Test default values of ReplaceResult"""
+        result = ReplaceResult(success=True, message="test")
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.message, "test")
+        self.assertIsNone(result.new_content)
+        self.assertEqual(result.applied_count, 0)
+        self.assertEqual(result.total_count, 0)
+        self.assertEqual(result.errors, [])
+        self.assertEqual(result.metadata, {})
+    
+    def test_full_initialization(self):
+        """Test full initialization of ReplaceResult"""
+        result = ReplaceResult(
+            success=True,
+            message="test message",
+            new_content="new content",
+            applied_count=5,
+            total_count=10,
+            errors=["error1", "error2"],
+            metadata={"key": "value"}
+        )
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.message, "test message")
+        self.assertEqual(result.new_content, "new content")
+        self.assertEqual(result.applied_count, 5)
+        self.assertEqual(result.total_count, 10)
+        self.assertEqual(result.errors, ["error1", "error2"])
+        self.assertEqual(result.metadata, {"key": "value"})
+
+
+class TestBaseReplacer(unittest.TestCase):
+    """Test BaseReplacer abstract base class"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.replacer = MockReplacer()
+    
+    def test_initialization(self):
+        """Test proper initialization"""
+        replacer = MockReplacer(ReplaceStrategy.SIMILARITY)
+        self.assertEqual(replacer.strategy, ReplaceStrategy.SIMILARITY)
+    
+    def test_get_strategy_name(self):
+        """Test get_strategy_name method"""
+        self.assertEqual(self.replacer.get_strategy_name(), "string")
+        
+        similarity_replacer = MockReplacer(ReplaceStrategy.SIMILARITY)
+        self.assertEqual(similarity_replacer.get_strategy_name(), "similarity")
+    
+    def test_validate_search_blocks_empty(self):
+        """Test validation with empty search blocks"""
+        self.assertFalse(self.replacer.validate_search_blocks([]))
+    
+    def test_validate_search_blocks_valid(self):
+        """Test validation with valid search blocks"""
+        valid_blocks = [
+            ("old_text", "new_text"),
+            ("another_old", "another_new"),
+        ]
+        self.assertTrue(self.replacer.validate_search_blocks(valid_blocks))
+    
+    def test_validate_search_blocks_empty_search(self):
+        """Test validation with empty search text"""
+        # Empty search text is now valid for insertion
+        valid_blocks = [
+            ("", "new_text"),  # This is now valid for insertion
+            ("old_text", "new_text"),
+        ]
+        self.assertTrue(self.replacer.validate_search_blocks(valid_blocks))
+        
+        # Only whitespace search text is still invalid
+        invalid_blocks = [
+            ("   ", "new_text"),
+        ]
+        self.assertFalse(self.replacer.validate_search_blocks(invalid_blocks))
+    
+    def test_validate_search_blocks_wrong_type(self):
+        """Test validation with wrong types"""
+        invalid_blocks = [
+            (123, "new_text"),
+            ("old_text", 456),
+        ]
+        self.assertFalse(self.replacer.validate_search_blocks(invalid_blocks))
+    
+    def test_replace_abstract_method_implemented(self):
+        """Test that replace method is implemented in mock"""
+        result = self.replacer.replace("content", [("old", "new")])
+        self.assertIsInstance(result, ReplaceResult)
+        self.assertTrue(result.success)
+    
+    def test_can_handle_abstract_method_implemented(self):
+        """Test that can_handle method is implemented in mock"""
+        can_handle = self.replacer.can_handle("content", [("old", "new")])
+        self.assertIsInstance(can_handle, bool)
+        self.assertTrue(can_handle)
+    
+    def test_mock_replacer_success(self):
+        """Test mock replacer success case"""
+        self.replacer.should_succeed = True
+        result = self.replacer.replace("test_content", [("old", "new")])
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.message, "Mock replacement successful")
+        self.assertEqual(result.new_content, "test_content_modified")
+        self.assertEqual(result.applied_count, 1)
+        self.assertEqual(result.total_count, 1)
+    
+    def test_mock_replacer_failure(self):
+        """Test mock replacer failure case"""
+        self.replacer.should_succeed = False
+        result = self.replacer.replace("test_content", [("old", "new")])
+        
+        self.assertFalse(result.success)
+        self.assertEqual(result.message, "Mock replacement failed")
+        self.assertIsNone(result.new_content)
+        self.assertEqual(result.applied_count, 0)
+        self.assertEqual(result.total_count, 1)
+    
+    def test_mock_replacer_can_handle(self):
+        """Test mock replacer can_handle method"""
+        self.replacer.should_handle = True
+        self.assertTrue(self.replacer.can_handle("content", [("old", "new")]))
+        
+        self.replacer.should_handle = False
+        self.assertFalse(self.replacer.can_handle("content", [("old", "new")]))
+
+
+if __name__ == '__main__':
+    unittest.main() 

autocoder/common/search_replace_patch/tests/test_empty_line_insert.py

@@ -0,0 +1,233 @@
+"""
+Test module for empty line insertion functionality
+"""
+
+import unittest
+from unittest.mock import patch
+
+from ..manager import SearchReplaceManager
+from ..base import ReplaceStrategy
+
+
+class TestEmptyLineInsert(unittest.TestCase):
+    """Test empty line insertion (file head insertion) functionality"""
+    
+    def setUp(self):
+        """Set up test fixtures"""
+        self.manager = SearchReplaceManager()
+    
+    def test_insert_at_file_head_regex(self):
+        """Test inserting content at file head using regex strategy"""
+        content = "line1\nline2\nline3\n"
+        search_blocks = [("", "# Header comment")]
+        
+        result = self.manager.replace(content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 1)
+        self.assertEqual(result.total_count, 1)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            self.assertTrue(result.new_content.startswith("# Header comment\n"))
+            self.assertIn("line1", result.new_content)
+    
+    def test_insert_at_file_head_similarity(self):
+        """Test inserting content at file head using similarity strategy"""
+        content = "line1\nline2\nline3\n"
+        search_blocks = [("", "#!/usr/bin/env python3")]
+        
+        result = self.manager.replace(content, search_blocks, ReplaceStrategy.SIMILARITY)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 1)
+        self.assertEqual(result.total_count, 1)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            self.assertTrue(result.new_content.startswith("#!/usr/bin/env python3\n"))
+    
+    def test_insert_multiple_blocks(self):
+        """Test inserting multiple blocks at file head"""
+        content = "original content\n"
+        search_blocks = [
+            ("", "# First comment"),
+            ("", "# Second comment")
+        ]
+        
+        result = self.manager.replace(content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 2)
+        self.assertEqual(result.total_count, 2)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            # 后插入的内容会出现在前面（插入顺序是反向的）
+            self.assertTrue(result.new_content.startswith("# Second comment\n"))
+            self.assertIn("# First comment", result.new_content)
+            self.assertIn("original content", result.new_content)
+            
+            # 验证完整顺序
+            expected_content = "# Second comment\n# First comment\noriginal content\n"
+            self.assertEqual(result.new_content, expected_content)
+    
+    def test_insert_with_mixed_operations(self):
+        """Test mixing insertion and replacement operations"""
+        content = "Hello world\nGoodbye world\n"
+        search_blocks = [
+            ("", "# File header"),
+            ("Hello world", "Hi world")
+        ]
+        
+        result = self.manager.replace(content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 2)
+        self.assertEqual(result.total_count, 2)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            self.assertTrue(result.new_content.startswith("# File header\n"))
+            self.assertIn("Hi world", result.new_content)
+            self.assertIn("Goodbye world", result.new_content)
+    
+    def test_insert_empty_file(self):
+        """Test inserting content into an empty file"""
+        content = ""
+        search_blocks = [("", "New file content")]
+        
+        result = self.manager.replace(content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 1)
+        self.assertEqual(result.total_count, 1)
+        self.assertEqual(result.new_content, "New file content\n")
+    
+    def test_insert_with_newline_preservation(self):
+        """Test that newlines are properly handled in insertions"""
+        content = "existing line\n"
+        search_blocks = [("", "inserted line")]
+        
+        result = self.manager.replace(content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            # Should have newline after inserted content
+            self.assertTrue(result.new_content.startswith("inserted line\n"))
+            self.assertIn("existing line", result.new_content)
+    
+    def test_insert_multiline_content(self):
+        """Test inserting multiline content"""
+        content = "original\n"
+        search_blocks = [("", "line1\nline2\nline3")]
+        
+        result = self.manager.replace(content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            self.assertTrue(result.new_content.startswith("line1\nline2\nline3\n"))
+            self.assertIn("original", result.new_content)
+    
+    def test_insert_with_fallback_strategy(self):
+        """Test insertion with fallback strategy"""
+        content = "test content\n"
+        search_blocks = [("", "header")]
+        
+        result = self.manager.replace_with_fallback(content, search_blocks)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 1)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            self.assertTrue(result.new_content.startswith("header\n"))
+        self.assertIn('used_strategy', result.metadata)
+    
+    def test_insert_validation(self):
+        """Test that insertion operations pass validation"""
+        content = "test"
+        search_blocks = [("", "insert")]
+        
+        # Should pass validation
+        regex_replacer = self.manager.get_replacer(ReplaceStrategy.STRING)
+        if regex_replacer:
+            self.assertTrue(regex_replacer.validate_search_blocks(search_blocks))
+        
+        similarity_replacer = self.manager.get_replacer(ReplaceStrategy.SIMILARITY)
+        if similarity_replacer:
+            self.assertTrue(similarity_replacer.validate_search_blocks(search_blocks))
+    
+    def test_insert_only_blocks(self):
+        """Test when all blocks are insert operations"""
+        content = "original\n"
+        search_blocks = [
+            ("", "header1"),
+            ("", "header2"),
+            ("", "header3")
+        ]
+        
+        result = self.manager.replace(content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 3)
+        self.assertEqual(result.total_count, 3)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            # 后插入的内容会出现在前面（插入顺序是反向的）
+            self.assertTrue(result.new_content.startswith("header3\n"))
+            self.assertIn("header2", result.new_content)
+            self.assertIn("header1", result.new_content)
+            self.assertIn("original", result.new_content)
+            
+            # 验证完整顺序：header3, header2, header1, original
+            expected_content = "header3\nheader2\nheader1\noriginal\n"
+            self.assertEqual(result.new_content, expected_content)
+    
+    def test_real_world_shebang_insertion(self):
+        """Test a real-world scenario: adding shebang to Python file"""
+        python_content = """import os
+import sys
+
+def main():
+    print("Hello, World!")
+
+if __name__ == "__main__":
+    main()
+"""
+        
+        search_blocks = [("", "#!/usr/bin/env python3")]
+        
+        result = self.manager.replace(python_content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 1)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            self.assertTrue(result.new_content.startswith("#!/usr/bin/env python3\n"))
+            self.assertIn("import os", result.new_content)
+            self.assertIn("def main():", result.new_content)
+    
+    def test_real_world_license_header_insertion(self):
+        """Test a real-world scenario: adding license header to code file"""
+        code_content = """function hello() {
+    console.log("Hello, World!");
+}
+"""
+        
+        license_header = """/*
+ * Copyright (c) 2024 Example Corp.
+ * Licensed under the MIT License
+ */"""
+        
+        search_blocks = [("", license_header)]
+        
+        result = self.manager.replace(code_content, search_blocks, ReplaceStrategy.STRING)
+        
+        self.assertTrue(result.success)
+        self.assertEqual(result.applied_count, 1)
+        self.assertIsNotNone(result.new_content)
+        if result.new_content:
+            self.assertTrue(result.new_content.startswith("/*\n * Copyright"))
+            self.assertIn("function hello()", result.new_content)
+
+
+if __name__ == '__main__':
+    unittest.main()