python parser testing refactoring

src/know_lang_bot/parser/languages/python/parser.py

@@ -109,12 +109,12 @@ class PythonParser(LanguageParser):
             LOG.debug(f"Skipping file {file_path}: unsupported extension")
             return []
 
-        # Check file size limit
-        if file_path.stat().st_size > self.language_config.max_file_size:
-            LOG.warning(f"Skipping file {file_path}: exceeds size limit of {self.language_config.max_file_size} bytes")
-            return []
-
         try:
+            # Check file size limit
+            if file_path.stat().st_size > self.language_config.max_file_size:
+                LOG.warning(f"Skipping file {file_path}: exceeds size limit of {self.language_config.max_file_size} bytes")
+                return []
+
             with open(file_path, 'rb') as f:
                 source_code = f.read()
             

tests/conftest.py

@@ -0,0 +1,46 @@
+import pytest
+import tempfile
+import git
+from pathlib import Path
+from typing import Dict
+from know_lang_bot.config import AppConfig, ParserConfig, LanguageConfig
+from know_lang_bot.parser.languages.python.parser import PythonParser
+from tests.test_data.python_files import TEST_FILES
+
+@pytest.fixture
+def test_config() -> AppConfig:
+    """Provides test configuration"""
+    return AppConfig(
+        parser=ParserConfig(
+            languages={
+                "python": LanguageConfig(
+                    file_extensions=[".py"],
+                    tree_sitter_language="python",
+                    max_file_size=1_000_000,
+                    chunk_types=["class_definition", "function_definition"]
+                )
+            }
+        )
+    )
+
+@pytest.fixture
+def temp_repo():
+    """Create a temporary git repository with sample Python files"""
+    with tempfile.TemporaryDirectory() as temp_dir:
+        repo = git.Repo.init(temp_dir)
+        
+        for filename, content in TEST_FILES.items():
+            file_path = Path(temp_dir) / filename
+            file_path.write_text(content)
+            repo.index.add([str(file_path)])
+        
+        repo.index.commit("Initial commit")
+        
+        yield temp_dir
+
+@pytest.fixture
+def python_parser(test_config):
+    """Provides initialized Python parser"""
+    parser = PythonParser(test_config)
+    parser.setup()
+    return parser

tests/parser/test_python_parser.py

@@ -0,0 +1,145 @@
+import pytest
+from pathlib import Path
+from know_lang_bot.core.types import ChunkType
+from tests.test_data.python_files import (
+    TEST_FILES,
+    INVALID_SYNTAX, 
+    SIMPLE_FILE_EXPECTATIONS,
+    NESTED_CLASS_EXPECTATIONS,
+    COMPLEX_FILE_EXPECTATIONS
+)
+from know_lang_bot.core.types import CodeChunk
+from know_lang_bot.parser.languages.python.parser import PythonParser
+from typing import List
+import tempfile
+
+def find_chunk_by_criteria(chunks: List[CodeChunk], **criteria) -> CodeChunk:
+    """Helper function to find a chunk matching given criteria"""
+    for chunk in chunks:
+        if all(getattr(chunk, k) == v for k, v in criteria.items()):
+            return chunk
+    return None
+
+def verify_chunk_matches_expectation(
+    chunk: CodeChunk,
+    expected_name: str,
+    expected_docstring: str,
+    expected_content_snippet: str
+) -> bool:
+    """Verify that a chunk matches expected values"""
+    return (
+        chunk.name == expected_name and
+        expected_content_snippet in chunk.content and
+        chunk.docstring is not None and
+        expected_docstring in chunk.docstring
+    )
+
+
+class TestPythonParser:
+    """Test suite for PythonParser"""
+
+    def test_parser_initialization(self, python_parser: PythonParser):
+        """Test parser initialization"""
+        assert python_parser.parser is not None
+        assert python_parser.language is not None
+
+    def test_simple_file_parsing(self, python_parser: PythonParser, temp_repo: tempfile.TemporaryDirectory):
+        """Test parsing a simple Python file with function and class"""
+        chunks = python_parser.parse_file(Path(temp_repo) / "simple.py")
+
+        # Test function
+        function_chunk = find_chunk_by_criteria(
+            chunks,
+            type=ChunkType.FUNCTION,
+            name="hello_world"
+        )
+        assert function_chunk is not None
+        expected = SIMPLE_FILE_EXPECTATIONS['hello_world']
+        assert verify_chunk_matches_expectation(
+            function_chunk,
+            expected.name,
+            expected.docstring,
+            expected.content_snippet
+        )
+
+        # Test class
+        class_chunk = find_chunk_by_criteria(
+            chunks,
+            type=ChunkType.CLASS,
+            name="SimpleClass"
+        )
+        assert class_chunk is not None
+        expected = SIMPLE_FILE_EXPECTATIONS['SimpleClass']
+        assert verify_chunk_matches_expectation(
+            class_chunk,
+            expected.name,
+            expected.docstring,
+            expected.content_snippet
+        )
+
+    def test_complex_file_parsing(self, python_parser: PythonParser, temp_repo: tempfile.TemporaryDirectory):
+        """Test parsing a complex Python file"""
+        chunks = python_parser.parse_file(Path(temp_repo) / "complex.py")
+        
+        # Test complex function
+        complex_func = find_chunk_by_criteria(
+            chunks,
+            type=ChunkType.FUNCTION,
+            name="complex_function"
+        )
+        assert complex_func is not None
+        expected = COMPLEX_FILE_EXPECTATIONS['complex_function']
+        assert verify_chunk_matches_expectation(
+            complex_func,
+            expected.name,
+            expected.docstring,
+            expected.content_snippet
+        )
+        
+        # Test complex class
+        complex_class = find_chunk_by_criteria(
+            chunks,
+            type=ChunkType.CLASS,
+            name="ComplexClass"
+        )
+        assert complex_class is not None
+        expected = COMPLEX_FILE_EXPECTATIONS['ComplexClass']
+        assert verify_chunk_matches_expectation(
+            complex_class,
+            expected.name,
+            expected.docstring,
+            expected.content_snippet
+        )
+
+    def test_error_handling(self, python_parser: PythonParser, temp_repo: tempfile.TemporaryDirectory):
+        """Test error handling for various error cases"""
+        # Test invalid syntax
+        invalid_file = Path(temp_repo) / "invalid.py"
+        invalid_file.write_text(INVALID_SYNTAX)
+        chunks = python_parser.parse_file(invalid_file)
+        assert chunks == []
+        
+        # Test non-existent file
+        nonexistent = Path(temp_repo) / "nonexistent.py"
+        chunks = python_parser.parse_file(nonexistent)
+        assert chunks == []
+        
+        # Test non-Python file
+        non_python = Path(temp_repo) / "readme.md"
+        non_python.write_text("# README")
+        chunks = python_parser.parse_file(non_python)
+        assert chunks == []
+
+    def test_file_size_limits(self, python_parser: PythonParser, temp_repo: tempfile.TemporaryDirectory):
+        """Test file size limit enforcement"""
+        large_file = Path(temp_repo) / "large.py"
+        # Create a file larger than the limit
+        large_file.write_text("x = 1\n" * 1_000_000)
+        
+        chunks = python_parser.parse_file(large_file)
+        assert chunks == []
+
+    @pytest.mark.parametrize("test_file", TEST_FILES.keys())
+    def test_supported_extensions(self, python_parser: PythonParser, test_file: str):
+        """Test file extension support"""
+        assert any(test_file.endswith(ext) for ext in python_parser.language_config.file_extensions)

tests/test_parser.py

@@ -1,152 +0,0 @@
-from know_lang_bot.code_parser.parser import CodeChunk, CodeParser, ChunkType
-from pathlib import Path
-from tests.test_constants import (
-    SIMPLE_FILE_EXPECTATIONS,
-    NESTED_CLASS_EXPECTATIONS,
-    COMPLEX_FILE_EXPECTATIONS,
-    INVALID_SYNTAX,
-    TEST_FILES,
-)
-import pytest
-import tempfile
-import git
-
-
-@pytest.fixture
-def temp_repo():
-    """Create a temporary git repository with sample Python files"""
-    with tempfile.TemporaryDirectory() as temp_dir:
-        # Initialize git repo
-        repo = git.Repo.init(temp_dir)
-        
-        # Create sample Python files
-        for filename, content in TEST_FILES.items():
-            file_path = Path(temp_dir) / filename
-            file_path.write_text(content)
-            repo.index.add([str(file_path)])
-        
-        repo.index.commit("Initial commit")
-        
-        yield temp_dir
-
-def find_chunk_by_criteria(chunks: list[CodeChunk], **criteria) -> CodeChunk:
-    """Helper function to find a chunk matching given criteria"""
-    for chunk in chunks:
-        if all(getattr(chunk, k) == v for k, v in criteria.items()):
-            return chunk
-    return None
-
-def test_init_parser(temp_repo):
-    """Test parser initialization"""
-    parser = CodeParser(temp_repo)
-    assert parser.repo_path == Path(temp_repo)
-    assert parser.language is not None
-    assert parser.parser is not None
-
-def test_parse_simple_file(temp_repo):
-    """Test parsing a simple Python file with function and class"""
-    parser = CodeParser(temp_repo)
-    chunks = parser.parse_file(Path(temp_repo) / "simple.py")
-
-    # Test function
-    function_chunk = find_chunk_by_criteria(chunks, type=ChunkType.FUNCTION, name="hello_world")
-    assert function_chunk is not None
-    expected = SIMPLE_FILE_EXPECTATIONS['hello_world']
-    assert expected.content_snippet in function_chunk.content
-    assert function_chunk.docstring is not None
-    assert function_chunk.docstring in expected.docstring
-
-    # Test class
-    class_chunk = find_chunk_by_criteria(chunks, type=ChunkType.CLASS, name="SimpleClass")
-    assert class_chunk is not None
-    expected = SIMPLE_FILE_EXPECTATIONS['SimpleClass']
-    assert expected.content_snippet in class_chunk.content
-    assert class_chunk.docstring is not None
-    assert class_chunk.docstring in expected.docstring
-
-
-def test_parse_nested_classes(temp_repo):
-    """Test parsing nested class definitions"""
-    parser = CodeParser(temp_repo)
-    chunks = parser.parse_file(Path(temp_repo) / "nested.py")
-    
-    # Test outer class
-    outer_class = find_chunk_by_criteria(chunks, type=ChunkType.CLASS, name="OuterClass")
-    assert outer_class is not None
-    expected = NESTED_CLASS_EXPECTATIONS['OuterClass']
-    assert expected.content_snippet in outer_class.content
-    assert outer_class.docstring is not None
-    assert outer_class.docstring in expected.docstring
-
-    # Verify inner class: Not implemented yet
-    pass
-
-def test_parse_complex_file(temp_repo):
-    """Test parsing a complex Python file"""
-    parser = CodeParser(temp_repo)
-    chunks = parser.parse_file(Path(temp_repo) / "complex.py")
-    
-    # Test function with type hints
-    complex_func = find_chunk_by_criteria(
-        chunks, 
-        type=ChunkType.FUNCTION,
-        name="complex_function"
-    )
-    assert complex_func is not None
-    expected = COMPLEX_FILE_EXPECTATIONS['complex_function']
-    assert expected.content_snippet in complex_func.content
-    assert complex_func.docstring is not None
-    assert complex_func.docstring in expected.docstring
-    
-    # Test complex class
-    complex_class = find_chunk_by_criteria(
-        chunks,
-        type=ChunkType.CLASS,
-        name="ComplexClass"
-    )
-    assert complex_class is not None
-    expected = COMPLEX_FILE_EXPECTATIONS['ComplexClass']
-    assert expected.content_snippet in complex_class.content
-    assert complex_class.docstring is not None
-    assert complex_class.docstring in expected.docstring 
-
-
-def test_parse_repository(temp_repo):
-    """Test parsing entire repository"""
-    parser = CodeParser(temp_repo)
-    chunks = parser.parse_repository()
-    
-    file_paths = {chunk.file_path for chunk in chunks}
-    assert len(file_paths) == 3
-    
-    # Verify we can find chunks from each test file
-    for filename in TEST_FILES.keys():
-        file_chunks = [c for c in chunks if Path(c.file_path).name == filename]
-        assert len(file_chunks) > 0
-
-def test_error_handling(temp_repo):
-    """Test error handling for invalid files"""
-    parser = CodeParser(temp_repo)
-    
-    # Test invalid syntax
-    invalid_file = Path(temp_repo) / "invalid.py"
-    invalid_file.write_text(INVALID_SYNTAX)
-    chunks = parser.parse_file(invalid_file)
-    assert chunks == []
-    
-    # Test non-existent file
-    nonexistent = Path(temp_repo) / "nonexistent.py"
-    chunks = parser.parse_file(nonexistent)
-    assert chunks == []
-
-def test_non_python_files(temp_repo):
-    """Test handling of non-Python files"""
-    parser = CodeParser(temp_repo)
-    
-    # Create a non-Python file
-    non_python = Path(temp_repo) / "readme.md"
-    non_python.write_text("# README")
-    
-    # Should skip non-Python files
-    chunks = parser.parse_file(non_python)
-    assert chunks == []