code-memory 0.1.0__py3-none-any.whl

tests/test_logging.py

@@ -0,0 +1,169 @@
+"""Tests for logging configuration module."""
+
+from __future__ import annotations
+
+import logging
+import io
+
+import pytest
+
+import logging_config
+
+
+class TestSetupLogging:
+    """Tests for setup_logging function."""
+
+    def test_creates_logger(self):
+        """Test that setup_logging creates a logger."""
+        # Reset initialization state for this test
+        logging_config._initialized = False
+        logger = logging_config.setup_logging(level="INFO")
+        assert logger is not None
+        assert logger.name == "code_memory"
+
+    def test_respects_level(self):
+        """Test that log level is set correctly."""
+        # Create a fresh logger with custom stream
+        stream = io.StringIO()
+        logger = logging.getLogger("test_code_memory_1")
+        logger.handlers.clear()
+        logger.setLevel(logging.DEBUG)
+        handler = logging.StreamHandler(stream)
+        handler.setLevel(logging.DEBUG)
+        logger.addHandler(handler)
+        assert logger.level == logging.DEBUG
+
+    def test_custom_level_string(self):
+        """Test custom log level string."""
+        logger = logging.getLogger("test_code_memory_2")
+        logger.handlers.clear()
+        logger.setLevel(logging.WARNING)
+        assert logger.level == logging.WARNING
+
+
+class TestGetLogger:
+    """Tests for get_logger function."""
+
+    def test_get_module_logger(self):
+        """Test getting a module-specific logger."""
+        logger = logging_config.get_logger("test_module")
+        assert logger.name == "code_memory.test_module"
+
+    def test_different_modules_different_loggers(self):
+        """Test that different modules get different loggers."""
+        logger1 = logging_config.get_logger("module1")
+        logger2 = logging_config.get_logger("module2")
+        assert logger1.name != logger2.name
+
+
+class TestToolLogger:
+    """Tests for ToolLogger context manager."""
+
+    def test_logs_invocation(self):
+        """Test that tool invocation is logged."""
+        # Create a logger with a string stream to capture output
+        stream = io.StringIO()
+        handler = logging.StreamHandler(stream)
+        handler.setFormatter(logging.Formatter('%(message)s'))
+
+        logger = logging.getLogger("code_memory.tools")
+        logger.handlers.clear()
+        logger.setLevel(logging.INFO)
+        logger.addHandler(handler)
+
+        with logging_config.ToolLogger("test_tool", query="test"):
+            pass
+
+        output = stream.getvalue()
+        assert "Tool invoked" in output
+
+    def test_logs_completion(self):
+        """Test that tool completion is logged."""
+        stream = io.StringIO()
+        handler = logging.StreamHandler(stream)
+        handler.setFormatter(logging.Formatter('%(message)s'))
+
+        logger = logging.getLogger("code_memory.tools")
+        logger.handlers.clear()
+        logger.setLevel(logging.INFO)
+        logger.addHandler(handler)
+
+        with logging_config.ToolLogger("test_tool", query="test"):
+            pass
+
+        output = stream.getvalue()
+        assert "Tool completed" in output
+
+    def test_logs_error_on_exception(self):
+        """Test that exceptions are logged."""
+        stream = io.StringIO()
+        handler = logging.StreamHandler(stream)
+        handler.setFormatter(logging.Formatter('%(message)s'))
+
+        logger = logging.getLogger("code_memory.tools")
+        logger.handlers.clear()
+        logger.setLevel(logging.INFO)
+        logger.addHandler(handler)
+
+        try:
+            with logging_config.ToolLogger("test_tool", query="test"):
+                raise ValueError("Test error")
+        except ValueError:
+            pass
+
+        output = stream.getvalue()
+        assert "Tool failed" in output
+
+    def test_result_count_logged(self):
+        """Test that result count is logged."""
+        stream = io.StringIO()
+        handler = logging.StreamHandler(stream)
+        handler.setFormatter(logging.Formatter('%(message)s'))
+
+        logger = logging.getLogger("code_memory.tools")
+        logger.handlers.clear()
+        logger.setLevel(logging.INFO)
+        logger.addHandler(handler)
+
+        with logging_config.ToolLogger("test_tool") as log:
+            log.set_result_count(5)
+
+        output = stream.getvalue()
+        assert "count=5" in output
+
+
+class TestIndexingLogger:
+    """Tests for IndexingLogger class."""
+
+    def test_tracks_files_processed(self):
+        """Test that files processed are tracked."""
+        idx_logger = logging_config.IndexingLogger("test")
+        idx_logger.file_indexed("file1.py", 3)
+        idx_logger.file_indexed("file2.py", 2)
+        assert idx_logger.files_processed == 2
+        assert idx_logger.items_indexed == 5
+
+    def test_tracks_files_skipped(self):
+        """Test that files skipped are tracked."""
+        idx_logger = logging_config.IndexingLogger("test")
+        idx_logger.file_skipped("file1.py", "unchanged")
+        assert idx_logger.files_skipped == 1
+
+
+class TestPreconfiguredLoggers:
+    """Tests for pre-configured logger functions."""
+
+    def test_get_server_logger(self):
+        """Test getting server logger."""
+        logger = logging_config.get_server_logger()
+        assert "server" in logger.name
+
+    def test_get_db_logger(self):
+        """Test getting db logger."""
+        logger = logging_config.get_db_logger()
+        assert "db" in logger.name
+
+    def test_get_query_logger(self):
+        """Test getting query logger."""
+        logger = logging_config.get_query_logger()
+        assert "queries" in logger.name

tests/test_tools.py

@@ -0,0 +1,114 @@
+"""Integration tests for MCP tools."""
+
+from __future__ import annotations
+
+import pytest
+import sys
+
+
+class TestSearchCodeValidation:
+    """Tests for search_code tool input validation."""
+
+    def test_empty_query_returns_error(self):
+        """Test that empty query returns structured error."""
+        import server
+        result = server.search_code("", "definition")
+        assert result.get("error") is True
+        assert "ValidationError" in result.get("error_type", "")
+
+    def test_invalid_search_type_returns_error(self):
+        """Test that invalid search_type returns structured error."""
+        import server
+        result = server.search_code("test", "invalid_type")
+        assert result.get("error") is True
+        assert "ValidationError" in result.get("error_type", "")
+
+
+class TestSearchDocsValidation:
+    """Tests for search_docs tool input validation."""
+
+    def test_empty_query_returns_error(self):
+        """Test that empty query returns structured error."""
+        import server
+        result = server.search_docs("")
+        assert result.get("error") is True
+        assert "ValidationError" in result.get("error_type", "")
+
+    def test_invalid_top_k_returns_error(self):
+        """Test that invalid top_k returns structured error."""
+        import server
+        result = server.search_docs("test", top_k=-1)
+        assert result.get("error") is True
+
+
+class TestSearchHistoryValidation:
+    """Tests for search_history tool input validation."""
+
+    def test_invalid_search_type_returns_error(self):
+        """Test that invalid search_type returns structured error."""
+        import server
+        result = server.search_history("test", search_type="invalid")
+        assert result.get("error") is True
+        assert "ValidationError" in result.get("error_type", "")
+
+    def test_file_history_requires_target_file(self):
+        """Test that file_history requires target_file."""
+        import server
+        result = server.search_history("test", search_type="file_history", target_file=None)
+        assert result.get("error") is True
+        assert "target_file" in result.get("message", "").lower()
+
+    def test_blame_requires_target_file(self):
+        """Test that blame requires target_file."""
+        import server
+        result = server.search_history("test", search_type="blame", target_file=None)
+        assert result.get("error") is True
+        assert "target_file" in result.get("message", "").lower()
+
+    def test_invalid_line_range_returns_error(self):
+        """Test that invalid line range returns error."""
+        import server
+        # This should work since we're in a git repo, but line_start > line_end
+        result = server.search_history(
+            "test",
+            search_type="blame",
+            target_file="server.py",
+            line_start=10,
+            line_end=5
+        )
+        assert result.get("error") is True
+
+
+class TestIndexCodebaseValidation:
+    """Tests for index_codebase tool input validation."""
+
+    def test_nonexistent_directory_returns_error(self):
+        """Test that nonexistent directory returns structured error."""
+        import server
+        result = server.index_codebase("/nonexistent/directory")
+        assert result.get("error") is True
+        assert "ValidationError" in result.get("error_type", "")
+
+
+class TestToolResponseStructure:
+    """Tests for consistent tool response structure."""
+
+    def test_success_response_has_status(self):
+        """Test that successful responses have status field."""
+        import server
+        # search_docs should work even without indexed content
+        result = server.search_docs("test query")
+        # Either it succeeds or fails gracefully
+        if "status" in result:
+            assert result["status"] in ("ok", "error")
+        elif "error" in result:
+            assert result["error"] is True
+
+    def test_error_response_structure(self):
+        """Test that error responses have consistent structure."""
+        import server
+        result = server.search_code("", "definition")
+        assert "error" in result
+        assert result["error"] is True
+        assert "error_type" in result
+        assert "message" in result

tests/test_validation.py

@@ -0,0 +1,216 @@
+"""Tests for input validation module."""
+
+from __future__ import annotations
+
+import pytest
+
+from errors import ValidationError
+import validation as val
+
+
+class TestValidateQuery:
+    """Tests for validate_query function."""
+
+    def test_valid_query(self):
+        """Test that valid queries pass validation."""
+        result = val.validate_query("test query")
+        assert result == "test query"
+
+    def test_strips_whitespace(self):
+        """Test that whitespace is stripped."""
+        result = val.validate_query("  test query  ")
+        assert result == "test query"
+
+    def test_empty_query_fails(self):
+        """Test that empty queries raise ValidationError."""
+        with pytest.raises(ValidationError) as exc_info:
+            val.validate_query("")
+        assert "too short" in str(exc_info.value.message)
+
+    def test_whitespace_only_fails(self):
+        """Test that whitespace-only queries raise ValidationError."""
+        with pytest.raises(ValidationError) as exc_info:
+            val.validate_query("   ")
+        assert "too short" in str(exc_info.value.message)
+
+    def test_long_query_fails(self):
+        """Test that overly long queries raise ValidationError."""
+        long_query = "a" * 1001
+        with pytest.raises(ValidationError) as exc_info:
+            val.validate_query(long_query, max_length=1000)
+        assert "too long" in str(exc_info.value.message)
+
+    def test_custom_min_length(self):
+        """Test custom minimum length."""
+        with pytest.raises(ValidationError):
+            val.validate_query("ab", min_length=5)
+
+
+class TestValidateSearchType:
+    """Tests for validate_search_type function."""
+
+    def test_valid_search_type(self):
+        """Test that valid search types pass."""
+        result = val.validate_search_type("definition", ["definition", "references"])
+        assert result == "definition"
+
+    def test_invalid_search_type(self):
+        """Test that invalid search types raise ValidationError."""
+        with pytest.raises(ValidationError) as exc_info:
+            val.validate_search_type("invalid", ["definition", "references"])
+        assert "Invalid search type" in str(exc_info.value.message)
+
+    def test_empty_search_type(self):
+        """Test that empty search type raises ValidationError."""
+        with pytest.raises(ValidationError):
+            val.validate_search_type("", ["definition"])
+
+
+class TestValidateLineNumber:
+    """Tests for validate_line_number function."""
+
+    def test_valid_line_number(self):
+        """Test that valid line numbers pass."""
+        result = val.validate_line_number(10, "line_start")
+        assert result == 10
+
+    def test_none_allowed(self):
+        """Test that None is allowed."""
+        result = val.validate_line_number(None, "line_start")
+        assert result is None
+
+    def test_negative_fails(self):
+        """Test that negative numbers raise ValidationError."""
+        with pytest.raises(ValidationError):
+            val.validate_line_number(-1, "line_start")
+
+    def test_zero_fails(self):
+        """Test that zero raises ValidationError with default min."""
+        with pytest.raises(ValidationError):
+            val.validate_line_number(0, "line_start")
+
+
+class TestValidateLineRange:
+    """Tests for validate_line_range function."""
+
+    def test_valid_range(self):
+        """Test that valid ranges pass."""
+        start, end = val.validate_line_range(1, 10)
+        assert start == 1
+        assert end == 10
+
+    def test_start_greater_than_end_fails(self):
+        """Test that start > end raises ValidationError."""
+        with pytest.raises(ValidationError):
+            val.validate_line_range(10, 1)
+
+
+class TestValidateTopK:
+    """Tests for validate_top_k function."""
+
+    def test_valid_value(self):
+        """Test that valid values pass."""
+        result = val.validate_top_k(10)
+        assert result == 10
+
+    def test_none_uses_default(self):
+        """Test that None returns default."""
+        result = val.validate_top_k(None)
+        assert result == 10
+
+    def test_zero_uses_default(self):
+        """Test that zero returns default."""
+        result = val.validate_top_k(0)
+        assert result == 10
+
+    def test_too_large_fails(self):
+        """Test that values > max raise ValidationError."""
+        with pytest.raises(ValidationError):
+            val.validate_top_k(200, max_val=100)
+
+    def test_negative_fails(self):
+        """Test that negative values raise ValidationError."""
+        with pytest.raises(ValidationError):
+            val.validate_top_k(-1, min_val=1, default=10)
+
+
+class TestValidateDirectory:
+    """Tests for validate_directory function."""
+
+    def test_existing_directory(self, temp_dir):
+        """Test that existing directories pass."""
+        result = val.validate_directory(str(temp_dir))
+        assert result == temp_dir
+
+    def test_nonexistent_fails(self):
+        """Test that nonexistent directories raise ValidationError."""
+        with pytest.raises(ValidationError) as exc_info:
+            val.validate_directory("/nonexistent/path")
+        assert "not found" in str(exc_info.value.message)
+
+    def test_file_not_directory_fails(self, temp_dir):
+        """Test that files (not directories) raise ValidationError."""
+        test_file = temp_dir / "test.txt"
+        test_file.write_text("test")
+        with pytest.raises(ValidationError):
+            val.validate_directory(str(test_file))
+
+
+class TestValidateFile:
+    """Tests for validate_file function."""
+
+    def test_existing_file(self, temp_dir):
+        """Test that existing files pass."""
+        test_file = temp_dir / "test.txt"
+        test_file.write_text("test")
+        result = val.validate_file(str(test_file))
+        assert result == test_file
+
+    def test_nonexistent_fails(self):
+        """Test that nonexistent files raise ValidationError."""
+        with pytest.raises(ValidationError) as exc_info:
+            val.validate_file("/nonexistent/file.txt")
+        assert "not found" in str(exc_info.value.message)
+
+    def test_directory_not_file_fails(self, temp_dir):
+        """Test that directories (not files) raise ValidationError."""
+        with pytest.raises(ValidationError):
+            val.validate_file(str(temp_dir))
+
+
+class TestSanitizeFtsQuery:
+    """Tests for sanitize_fts_query function."""
+
+    def test_simple_query(self):
+        """Test that simple queries pass through."""
+        result = val.sanitize_fts_query("simple query")
+        assert result == "simple query"
+
+    def test_escapes_quotes(self):
+        """Test that quotes are escaped."""
+        result = val.sanitize_fts_query('test "quoted"')
+        assert '""' in result or '"' in result
+
+
+class TestValidateCommitHash:
+    """Tests for validate_commit_hash function."""
+
+    def test_valid_full_hash(self):
+        """Test that valid full hashes pass."""
+        result = val.validate_commit_hash("a" * 40)
+        assert result == "a" * 40
+
+    def test_valid_short_hash(self):
+        """Test that valid short hashes pass."""
+        result = val.validate_commit_hash("abc1234")
+        assert result == "abc1234"
+
+    def test_invalid_format_fails(self):
+        """Test that invalid formats raise ValidationError."""
+        with pytest.raises(ValidationError):
+            val.validate_commit_hash("not-a-hash")
+
+    def test_too_short_fails(self):
+        """Test that too-short hashes raise ValidationError."""
+        with pytest.raises(ValidationError):
+            val.validate_commit_hash("abc123")