Add HTML template and unit tests

tests/unit/test_analyzers.py

@@ -0,0 +1,237 @@
+"""Unit tests for analyzers."""
+
+import tempfile
+from pathlib import Path
+
+import pytest
+from vibeguard.analyzers.languages.python import PythonAnalyzer
+from vibeguard.analyzers.languages.javascript import JavaScriptAnalyzer
+from vibeguard.analyzers.languages.typescript import TypeScriptAnalyzer
+from vibeguard.analyzers.languages.go import GoAnalyzer
+from vibeguard.analyzers.languages.rust import RustAnalyzer
+from vibeguard.analyzers.factory import AnalyzerFactory
+
+
+class TestPythonAnalyzer:
+    """Tests for Python analyzer."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.analyzer = PythonAnalyzer()
+
+    def test_parse_valid_python(self):
+        """Test parsing valid Python code."""
+        code = """
+def hello():
+    return "world"
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(code)
+            f.flush()
+
+        try:
+            tree = self.analyzer.parse_file(Path(f.name))
+            assert tree is not None
+        finally:
+            Path(f.name).unlink()
+
+    def test_parse_invalid_python(self):
+        """Test parsing invalid Python code returns None."""
+        code = """
+def hello()
+    return "world"
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write(code)
+            f.flush()
+
+        try:
+            tree = self.analyzer.parse_file(Path(f.name))
+            assert tree is None
+        finally:
+            Path(f.name).unlink()
+
+    def test_get_language(self):
+        """Test getting language name."""
+        assert self.analyzer.get_language() == "python"
+
+    def test_supports_extension(self):
+        """Test extension checking."""
+        assert self.analyzer.supports_extension(".py")
+        assert self.analyzer.supports_extension(".pyi")
+        assert not self.analyzer.supports_extension(".js")
+
+
+class TestJavaScriptAnalyzer:
+    """Tests for JavaScript analyzer."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.analyzer = JavaScriptAnalyzer()
+
+    def test_parse_javascript(self):
+        """Test parsing JavaScript code."""
+        code = """
+function hello() {
+    return "world";
+}
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".js", delete=False) as f:
+            f.write(code)
+            f.flush()
+
+        try:
+            content = self.analyzer.parse_file(Path(f.name))
+            assert content is not None
+        finally:
+            Path(f.name).unlink()
+
+    def test_get_language(self):
+        """Test getting language name."""
+        assert self.analyzer.get_language() == "javascript"
+
+
+class TestTypeScriptAnalyzer:
+    """Tests for TypeScript analyzer."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.analyzer = TypeScriptAnalyzer()
+
+    def test_parse_typescript(self):
+        """Test parsing TypeScript code."""
+        code = """
+function hello(): string {
+    return "world";
+}
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".ts", delete=False) as f:
+            f.write(code)
+            f.flush()
+
+        try:
+            content = self.analyzer.parse_file(Path(f.name))
+            assert content is not None
+        finally:
+            Path(f.name).unlink()
+
+    def test_get_language(self):
+        """Test getting language name."""
+        assert self.analyzer.get_language() == "typescript"
+
+
+class TestGoAnalyzer:
+    """Tests for Go analyzer."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.analyzer = GoAnalyzer()
+
+    def test_parse_go(self):
+        """Test parsing Go code."""
+        code = """
+package main
+
+func hello() string {
+    return "world"
+}
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".go", delete=False) as f:
+            f.write(code)
+            f.flush()
+
+        try:
+            content = self.analyzer.parse_file(Path(f.name))
+            assert content is not None
+        finally:
+            Path(f.name).unlink()
+
+    def test_get_language(self):
+        """Test getting language name."""
+        assert self.analyzer.get_language() == "go"
+
+
+class TestRustAnalyzer:
+    """Tests for Rust analyzer."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.analyzer = RustAnalyzer()
+
+    def test_parse_rust(self):
+        """Test parsing Rust code."""
+        code = """
+fn hello() -> &'static str {
+    return "world";
+}
+"""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".rs", delete=False) as f:
+            f.write(code)
+            f.flush()
+
+        try:
+            content = self.analyzer.parse_file(Path(f.name))
+            assert content is not None
+        finally:
+            Path(f.name).unlink()
+
+    def test_get_language(self):
+        """Test getting language name."""
+        assert self.analyzer.get_language() == "rust"
+
+
+class TestAnalyzerFactory:
+    """Tests for analyzer factory."""
+
+    def test_get_python_analyzer(self):
+        """Test getting Python analyzer."""
+        analyzer = AnalyzerFactory.get_analyzer(Path("test.py"))
+        assert analyzer is not None
+        assert analyzer.get_language() == "python"
+
+    def test_get_javascript_analyzer(self):
+        """Test getting JavaScript analyzer."""
+        analyzer = AnalyzerFactory.get_analyzer(Path("test.js"))
+        assert analyzer is not None
+        assert analyzer.get_language() == "javascript"
+
+    def test_get_typescript_analyzer(self):
+        """Test getting TypeScript analyzer."""
+        analyzer = AnalyzerFactory.get_analyzer(Path("test.ts"))
+        assert analyzer is not None
+        assert analyzer.get_language() == "typescript"
+
+    def test_get_go_analyzer(self):
+        """Test getting Go analyzer."""
+        analyzer = AnalyzerFactory.get_analyzer(Path("test.go"))
+        assert analyzer is not None
+        assert analyzer.get_language() == "go"
+
+    def test_get_rust_analyzer(self):
+        """Test getting Rust analyzer."""
+        analyzer = AnalyzerFactory.get_analyzer(Path("test.rs"))
+        assert analyzer is not None
+        assert analyzer.get_language() == "rust"
+
+    def test_get_unsupported_file(self):
+        """Test getting analyzer for unsupported file."""
+        analyzer = AnalyzerFactory.get_analyzer(Path("test.txt"))
+        assert analyzer is None
+
+    def test_get_supported_languages(self):
+        """Test getting supported languages."""
+        languages = AnalyzerFactory.get_supported_languages()
+        assert "python" in languages
+        assert "javascript" in languages
+        assert "typescript" in languages
+        assert "go" in languages
+        assert "rust" in languages
+
+    def test_get_supported_extensions(self):
+        """Test getting supported extensions."""
+        extensions = AnalyzerFactory.get_supported_extensions()
+        assert ".py" in extensions
+        assert ".js" in extensions
+        assert ".ts" in extensions
+        assert ".go" in extensions
+        assert ".rs" in extensions