Add test files and configuration

tests/test_generation.py

@@ -0,0 +1,204 @@
+"""Tests for pattern generation functionality."""
+
+from src.generators.merge import PatternMerger
+from src.generators.pattern import PatternGenerator
+
+
+class TestPatternGenerator:
+    """Tests for PatternGenerator class."""
+
+    def test_generate_python_patterns(self):
+        """Test generation of Python patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(languages=["python"])
+        assert "__pycache__/" in content
+        assert "*.py[cod]" in content
+        assert ".venv/" in content
+
+    def test_generate_nodejs_patterns(self):
+        """Test generation of Node.js patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(languages=["nodejs"])
+        assert "node_modules/" in content
+        assert "*.log" in content
+
+    def test_generate_django_patterns(self):
+        """Test generation of Django patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(frameworks=["django"])
+        assert "db.sqlite3" in content
+        assert "media/" in content
+
+    def test_generate_react_patterns(self):
+        """Test generation of React patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(frameworks=["react"])
+        assert "build/" in content
+        assert ".next/" in content
+
+    def test_generate_vscode_patterns(self):
+        """Test generation of VSCode patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(ides=["vscode"])
+        assert ".vscode/" in content
+
+    def test_generate_jetbrains_patterns(self):
+        """Test generation of JetBrains patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(ides=["jetbrains"])
+        assert ".idea/" in content
+
+    def test_generate_macos_patterns(self):
+        """Test generation of macOS patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(os_list=["macos"])
+        assert ".DS_Store" in content
+
+    def test_generate_windows_patterns(self):
+        """Test generation of Windows patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(os_list=["windows"])
+        assert "Thumbs.db" in content
+
+    def test_generate_linux_patterns(self):
+        """Test generation of Linux patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(os_list=["linux"])
+        assert "*~" in content
+
+    def test_generate_custom_patterns(self):
+        """Test generation of custom patterns."""
+        generator = PatternGenerator()
+        content = generator.generate(custom_patterns=["custom_dir/", "*.custom"])
+        assert "custom_dir/" in content
+        assert "*.custom" in content
+
+    def test_generate_empty_when_no_options(self):
+        """Test that empty content is generated when no options provided."""
+        generator = PatternGenerator()
+        content = generator.generate()
+        assert ".DS_Store" in content
+        assert "Thumbs.db" in content
+
+    def test_get_supported_languages(self):
+        """Test getting list of supported languages."""
+        generator = PatternGenerator()
+        languages = generator.get_supported_languages()
+        assert "python" in languages
+        assert "nodejs" in languages
+        assert "go" in languages
+
+    def test_get_supported_frameworks(self):
+        """Test getting list of supported frameworks."""
+        generator = PatternGenerator()
+        frameworks = generator.get_supported_frameworks()
+        assert "django" in frameworks
+        assert "react" in frameworks
+        assert "flask" in frameworks
+
+    def test_get_supported_ides(self):
+        """Test getting list of supported IDEs."""
+        generator = PatternGenerator()
+        ides = generator.get_supported_ides()
+        assert "vscode" in ides
+        assert "jetbrains" in ides
+
+    def test_get_supported_os(self):
+        """Test getting list of supported operating systems."""
+        generator = PatternGenerator()
+        os_list = generator.get_supported_os()
+        assert "macos" in os_list
+        assert "windows" in os_list
+        assert "linux" in os_list
+
+    def test_validate_valid_pattern(self):
+        """Test validation of valid patterns."""
+        generator = PatternGenerator()
+        is_valid, error = generator.validate_pattern("*.log")
+        assert is_valid is True
+        assert error == ""
+
+    def test_validate_empty_pattern(self):
+        """Test validation of empty patterns."""
+        generator = PatternGenerator()
+        is_valid, error = generator.validate_pattern("")
+        assert is_valid is False
+        assert "empty" in error.lower()
+
+    def test_validate_comment_pattern(self):
+        """Test validation of comment patterns."""
+        generator = PatternGenerator()
+        is_valid, error = generator.validate_pattern("# This is a comment")
+        assert is_valid is True
+
+    def test_validate_negation_pattern(self):
+        """Test validation of negation patterns."""
+        generator = PatternGenerator()
+        is_valid, error = generator.validate_pattern("!important.txt")
+        assert is_valid is True
+
+
+class TestPatternMerger:
+    """Tests for PatternMerger class."""
+
+    def test_merge_priority(self):
+        """Test merging patterns with priority strategy."""
+        merger = PatternMerger()
+        patterns_by_category = {
+            "os": ["*.log"],
+            "language": ["node_modules/", "*.pyc"],
+        }
+        merged, conflicts = merger.merge(patterns_by_category)
+        assert len(conflicts) == 0
+
+    def test_merge_deduplication(self):
+        """Test that merging deduplicates patterns."""
+        merger = PatternMerger()
+        patterns_by_category = {
+            "language": ["*.log", "*.log"],
+            "framework": ["*.log"],
+        }
+        merged, conflicts = merger.merge(patterns_by_category)
+        log_count = sum(1 for p in merged if "*.log" in p)
+        assert log_count == 1
+
+    def test_deduplicate_method(self):
+        """Test deduplicate method directly."""
+        merger = PatternMerger()
+        patterns = ["*.log", "*.log", "node_modules/", "*.log"]
+        unique = merger.deduplicate(patterns)
+        assert len(unique) == 2
+
+    def test_merge_empty_categories(self):
+        """Test merging with empty categories."""
+        merger = PatternMerger()
+        merged, conflicts = merger.merge({})
+        assert merged == []
+
+    def test_merge_with_custom_patterns(self):
+        """Test merging with custom patterns."""
+        merger = PatternMerger()
+        patterns_by_category = {
+            "language": ["*.pyc"],
+        }
+        merged, conflicts = merger.merge(patterns_by_category, custom_patterns=["custom.txt"])
+        assert "custom.txt" in merged
+
+    def test_get_pattern_sources(self):
+        """Test getting pattern sources."""
+        merger = PatternMerger()
+        patterns = ["*.log", "node_modules/", ".DS_Store"]
+        sources = merger.get_pattern_sources(patterns)
+        assert "os" in sources or "other" in sources
+
+    def test_resolve_conflict_keep_existing(self):
+        """Test conflict resolution keeping existing."""
+        merger = PatternMerger()
+        result = merger.resolve_conflict("new.txt", "old.txt", "keep_existing")
+        assert result == "old.txt"
+
+    def test_resolve_conflict_keep_new(self):
+        """Test conflict resolution keeping new."""
+        merger = PatternMerger()
+        result = merger.resolve_conflict("new.txt", "old.txt", "keep_new")
+        assert result == "new.txt"