codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/tests/test_router.py

@@ -0,0 +1,41 @@
+"""Tests for the command router."""
+
+from __future__ import annotations
+
+import click
+import pytest
+
+from semantic_code_intelligence.cli.router import register_commands
+
+
+class TestRouter:
+    """Tests for command registration."""
+
+    def test_register_commands_adds_all(self):
+        group = click.Group(name="test")
+        register_commands(group)
+
+        command_names = list(group.commands.keys())
+        assert "init" in command_names
+        assert "index" in command_names
+        assert "search" in command_names
+        assert "grep" in command_names
+        assert "benchmark" in command_names
+
+    def test_register_commands_count(self):
+        group = click.Group(name="test")
+        register_commands(group)
+        assert len(group.commands) == 39
+
+    def test_registered_commands_are_click_commands(self):
+        group = click.Group(name="test")
+        register_commands(group)
+
+        for name, cmd in group.commands.items():
+            assert isinstance(cmd, click.Command), f"{name} is not a click.Command"
+
+    def test_register_to_empty_group(self):
+        group = click.Group(name="empty")
+        assert len(group.commands) == 0
+        register_commands(group)
+        assert len(group.commands) > 0

semantic_code_intelligence/tests/test_scalability.py

@@ -0,0 +1,138 @@
+"""Tests for the scalability utilities."""
+
+from __future__ import annotations
+
+import pytest
+
+from semantic_code_intelligence.scalability import (
+    BatchProcessor,
+    BatchStats,
+    ParallelScanner,
+)
+from pathlib import Path
+
+
+# ---------------------------------------------------------------------------
+# BatchStats
+# ---------------------------------------------------------------------------
+
+class TestBatchStats:
+    def test_defaults(self):
+        stats = BatchStats()
+        assert stats.total_items == 0
+        assert stats.batches_processed == 0
+
+    def test_to_dict(self):
+        stats = BatchStats(
+            total_items=100,
+            batches_processed=10,
+            items_succeeded=95,
+            items_failed=5,
+            elapsed_seconds=2.0,
+        )
+        d = stats.to_dict()
+        assert d["total_items"] == 100
+        assert d["items_per_second"] == 47.5
+
+    def test_to_dict_zero_elapsed(self):
+        stats = BatchStats(elapsed_seconds=0)
+        d = stats.to_dict()
+        assert d["items_per_second"] == 0
+
+
+# ---------------------------------------------------------------------------
+# BatchProcessor
+# ---------------------------------------------------------------------------
+
+class TestBatchProcessor:
+    def test_empty_items(self):
+        proc = BatchProcessor(batch_size=10)
+        results, stats = proc.process([], lambda batch: batch)
+        assert results == []
+        assert stats.total_items == 0
+        assert stats.batches_processed == 0
+
+    def test_single_batch(self):
+        proc = BatchProcessor(batch_size=10)
+        items = list(range(5))
+        results, stats = proc.process(items, lambda batch: [x * 2 for x in batch])
+        assert results == [0, 2, 4, 6, 8]
+        assert stats.total_items == 5
+        assert stats.batches_processed == 1
+        assert stats.items_succeeded == 5
+
+    def test_multiple_batches(self):
+        proc = BatchProcessor(batch_size=3)
+        items = list(range(10))
+        results, stats = proc.process(items, lambda batch: batch)
+        assert results == list(range(10))
+        assert stats.batches_processed == 4  # ceil(10/3)
+
+    def test_batch_callback(self):
+        proc = BatchProcessor(batch_size=2)
+        calls = []
+        items = list(range(6))
+        proc.process(
+            items,
+            lambda batch: batch,
+            on_batch=lambda cur, total: calls.append((cur, total)),
+        )
+        assert calls == [(1, 3), (2, 3), (3, 3)]
+
+    def test_batch_size_minimum(self):
+        proc = BatchProcessor(batch_size=0)
+        assert proc.batch_size == 1
+
+    def test_failing_batch(self):
+        proc = BatchProcessor(batch_size=2)
+
+        def bad_processor(batch):
+            if batch[0] == 2:
+                raise ValueError("fail")
+            return batch
+
+        items = list(range(6))
+        results, stats = proc.process(items, bad_processor)
+        assert stats.items_failed == 2
+        assert stats.items_succeeded == 4
+
+
+# ---------------------------------------------------------------------------
+# ParallelScanner
+# ---------------------------------------------------------------------------
+
+class TestParallelScanner:
+    def test_scan_empty(self):
+        scanner = ParallelScanner(max_workers=2)
+        results, errors = scanner.scan_and_process([], lambda p: p)
+        assert results == []
+        assert errors == []
+
+    def test_scan_files(self, tmp_path):
+        for i in range(5):
+            (tmp_path / f"file{i}.txt").write_text(f"content {i}", encoding="utf-8")
+
+        paths = list(tmp_path.glob("*.txt"))
+        scanner = ParallelScanner(max_workers=2)
+        results, errors = scanner.scan_and_process(
+            paths,
+            lambda p: p.read_text(encoding="utf-8"),
+        )
+        assert len(results) == 5
+        assert len(errors) == 0
+
+    def test_scan_with_errors(self, tmp_path):
+        paths = [tmp_path / "exists.txt", tmp_path / "missing.txt"]
+        paths[0].write_text("ok", encoding="utf-8")
+
+        scanner = ParallelScanner(max_workers=2)
+        results, errors = scanner.scan_and_process(
+            paths,
+            lambda p: p.read_text(encoding="utf-8"),
+        )
+        assert len(results) == 1
+        assert len(errors) == 1
+
+    def test_max_workers_minimum(self):
+        scanner = ParallelScanner(max_workers=0)
+        assert scanner._max_workers == 1

semantic_code_intelligence/tests/test_scanner.py

@@ -0,0 +1,125 @@
+"""Tests for the repository scanner."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from semantic_code_intelligence.indexing.scanner import (
+    ScannedFile,
+    compute_file_hash,
+    scan_repository,
+    should_ignore,
+)
+from semantic_code_intelligence.config.settings import IndexConfig
+
+
+class TestComputeFileHash:
+    """Tests for file hashing."""
+
+    def test_hash_returns_hex_string(self, tmp_path: Path):
+        f = tmp_path / "test.py"
+        f.write_text("hello world", encoding="utf-8")
+        h = compute_file_hash(f)
+        assert isinstance(h, str)
+        assert len(h) == 64  # SHA-256 hex digest
+
+    def test_same_content_same_hash(self, tmp_path: Path):
+        f1 = tmp_path / "a.py"
+        f2 = tmp_path / "b.py"
+        f1.write_text("same content", encoding="utf-8")
+        f2.write_text("same content", encoding="utf-8")
+        assert compute_file_hash(f1) == compute_file_hash(f2)
+
+    def test_different_content_different_hash(self, tmp_path: Path):
+        f1 = tmp_path / "a.py"
+        f2 = tmp_path / "b.py"
+        f1.write_text("content A", encoding="utf-8")
+        f2.write_text("content B", encoding="utf-8")
+        assert compute_file_hash(f1) != compute_file_hash(f2)
+
+
+class TestShouldIgnore:
+    """Tests for directory ignore logic."""
+
+    def test_ignore_git_dir(self, tmp_path: Path):
+        p = tmp_path / ".git" / "config"
+        assert should_ignore(p, tmp_path, {".git"}) is True
+
+    def test_ignore_node_modules(self, tmp_path: Path):
+        p = tmp_path / "node_modules" / "pkg" / "index.js"
+        assert should_ignore(p, tmp_path, {"node_modules"}) is True
+
+    def test_allow_normal_file(self, tmp_path: Path):
+        p = tmp_path / "src" / "main.py"
+        assert should_ignore(p, tmp_path, {".git"}) is False
+
+    def test_nested_ignored_dir(self, tmp_path: Path):
+        p = tmp_path / "src" / "__pycache__" / "mod.cpython-312.pyc"
+        assert should_ignore(p, tmp_path, {"__pycache__"}) is True
+
+
+class TestScanRepository:
+    """Tests for repository scanning."""
+
+    def test_empty_directory(self, tmp_path: Path):
+        result = scan_repository(tmp_path)
+        assert result == []
+
+    def test_finds_python_files(self, tmp_path: Path):
+        (tmp_path / "main.py").write_text("print('hi')", encoding="utf-8")
+        (tmp_path / "utils.py").write_text("x = 1", encoding="utf-8")
+        result = scan_repository(tmp_path)
+        assert len(result) == 2
+
+    def test_ignores_non_code_files(self, tmp_path: Path):
+        (tmp_path / "main.py").write_text("x = 1", encoding="utf-8")
+        (tmp_path / "readme.md").write_text("# Readme", encoding="utf-8")
+        (tmp_path / "data.csv").write_text("a,b,c", encoding="utf-8")
+        result = scan_repository(tmp_path)
+        assert len(result) == 1
+        assert result[0].extension == ".py"
+
+    def test_ignores_excluded_dirs(self, tmp_path: Path):
+        (tmp_path / "main.py").write_text("x = 1", encoding="utf-8")
+        venv = tmp_path / "venv"
+        venv.mkdir()
+        (venv / "lib.py").write_text("y = 2", encoding="utf-8")
+        result = scan_repository(tmp_path)
+        assert len(result) == 1
+
+    def test_scanned_file_metadata(self, tmp_path: Path):
+        content = "def hello(): pass"
+        (tmp_path / "test.py").write_text(content, encoding="utf-8")
+        result = scan_repository(tmp_path)
+        assert len(result) == 1
+        sf = result[0]
+        assert sf.extension == ".py"
+        assert sf.relative_path == "test.py"
+        assert sf.size_bytes > 0
+        assert len(sf.content_hash) == 64
+
+    def test_finds_multiple_languages(self, tmp_path: Path):
+        (tmp_path / "main.py").write_text("x = 1", encoding="utf-8")
+        (tmp_path / "app.js").write_text("let x = 1;", encoding="utf-8")
+        (tmp_path / "Main.java").write_text("class Main {}", encoding="utf-8")
+        result = scan_repository(tmp_path)
+        extensions = {sf.extension for sf in result}
+        assert extensions == {".py", ".js", ".java"}
+
+    def test_custom_config(self, tmp_path: Path):
+        (tmp_path / "main.py").write_text("x = 1", encoding="utf-8")
+        (tmp_path / "app.js").write_text("let x = 1;", encoding="utf-8")
+        config = IndexConfig(extensions={".py"}, ignore_dirs=set())
+        result = scan_repository(tmp_path, config)
+        assert len(result) == 1
+        assert result[0].extension == ".py"
+
+    def test_results_sorted(self, tmp_path: Path):
+        (tmp_path / "z.py").write_text("z", encoding="utf-8")
+        (tmp_path / "a.py").write_text("a", encoding="utf-8")
+        (tmp_path / "m.py").write_text("m", encoding="utf-8")
+        result = scan_repository(tmp_path)
+        names = [sf.relative_path for sf in result]
+        assert names == sorted(names)

semantic_code_intelligence/tests/test_search.py

@@ -0,0 +1,160 @@
+"""Tests for the search service and formatter."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import numpy as np
+import pytest
+
+from semantic_code_intelligence.config.settings import init_project, save_config, AppConfig
+from semantic_code_intelligence.embeddings.generator import generate_embeddings
+from semantic_code_intelligence.services.search_service import SearchResult, search_codebase
+from semantic_code_intelligence.search.formatter import format_results_json, format_results_rich
+from semantic_code_intelligence.storage.vector_store import ChunkMetadata, VectorStore
+
+
+@pytest.fixture
+def indexed_project(tmp_path: Path) -> Path:
+    """Create a project with some indexed code chunks."""
+    config, _ = init_project(tmp_path)
+    index_dir = AppConfig.index_dir(tmp_path)
+
+    # Create code chunks and embed them
+    code_snippets = [
+        "def authenticate_user(username, password):\n    return check_credentials(username, password)\n",
+        "def connect_to_database(host, port):\n    return Database(host=host, port=port)\n",
+        "def handle_http_request(request):\n    response = process(request)\n    return response\n",
+        "def verify_jwt_token(token):\n    payload = jwt.decode(token, SECRET_KEY)\n    return payload\n",
+        "def calculate_statistics(data):\n    mean = sum(data) / len(data)\n    return mean\n",
+    ]
+
+    embeddings = generate_embeddings(code_snippets)
+    metadata = [
+        ChunkMetadata(
+            file_path=f"src/module_{i}.py",
+            start_line=1,
+            end_line=3,
+            chunk_index=0,
+            language="python",
+            content=snippet,
+            content_hash=f"hash_{i}",
+        )
+        for i, snippet in enumerate(code_snippets)
+    ]
+
+    store = VectorStore(embeddings.shape[1])
+    store.add(embeddings, metadata)
+    store.save(index_dir)
+
+    return tmp_path
+
+
+class TestSearchCodebase:
+    """Tests for the search_codebase function."""
+
+    def test_search_returns_results(self, indexed_project: Path):
+        results = search_codebase("authentication", indexed_project)
+        assert len(results) > 0
+
+    def test_search_result_type(self, indexed_project: Path):
+        results = search_codebase("database connection", indexed_project)
+        assert all(isinstance(r, SearchResult) for r in results)
+
+    def test_search_results_have_scores(self, indexed_project: Path):
+        results = search_codebase("jwt token verification", indexed_project)
+        for r in results:
+            assert isinstance(r.score, float)
+            assert r.score > 0
+
+    def test_search_results_sorted_by_score(self, indexed_project: Path):
+        results = search_codebase("authenticate user", indexed_project)
+        scores = [r.score for r in results]
+        assert scores == sorted(scores, reverse=True)
+
+    def test_search_respects_top_k(self, indexed_project: Path):
+        results = search_codebase("code", indexed_project, top_k=2)
+        assert len(results) <= 2
+
+    def test_search_relevance(self, indexed_project: Path):
+        results = search_codebase("jwt token", indexed_project, top_k=1)
+        assert len(results) == 1
+        assert "jwt" in results[0].content.lower() or "token" in results[0].content.lower()
+
+    def test_search_no_index_raises(self, tmp_path: Path):
+        init_project(tmp_path)
+        with pytest.raises(FileNotFoundError):
+            search_codebase("test", tmp_path)
+
+    def test_search_result_metadata(self, indexed_project: Path):
+        results = search_codebase("database", indexed_project, top_k=1)
+        r = results[0]
+        assert r.file_path.startswith("src/")
+        assert r.start_line > 0
+        assert r.end_line >= r.start_line
+        assert r.language == "python"
+        assert len(r.content) > 0
+
+
+class TestSearchResult:
+    """Tests for SearchResult data class."""
+
+    def test_to_dict(self):
+        r = SearchResult(
+            file_path="test.py",
+            start_line=1,
+            end_line=5,
+            language="python",
+            content="def foo(): pass",
+            score=0.9534,
+            chunk_index=0,
+        )
+        d = r.to_dict()
+        assert d["file_path"] == "test.py"
+        assert d["score"] == 0.9534
+        assert d["start_line"] == 1
+        assert d["language"] == "python"
+
+    def test_to_dict_score_rounding(self):
+        r = SearchResult(
+            file_path="x.py", start_line=1, end_line=1,
+            language="python", content="x", score=0.12345678, chunk_index=0,
+        )
+        assert r.to_dict()["score"] == 0.1235
+
+
+class TestFormatResultsJson:
+    """Tests for JSON formatter."""
+
+    def test_valid_json(self):
+        results = [
+            SearchResult("a.py", 1, 5, "python", "code", 0.95, 0),
+            SearchResult("b.py", 10, 20, "python", "more code", 0.80, 1),
+        ]
+        output = format_results_json("test query", results, 10)
+        data = json.loads(output)
+        assert data["query"] == "test query"
+        assert data["top_k"] == 10
+        assert data["result_count"] == 2
+        assert len(data["results"]) == 2
+
+    def test_empty_results(self):
+        output = format_results_json("nope", [], 5)
+        data = json.loads(output)
+        assert data["result_count"] == 0
+        assert data["results"] == []
+
+
+class TestFormatResultsRich:
+    """Tests for rich formatter (smoke tests — output to console)."""
+
+    def test_no_crash_with_results(self):
+        results = [
+            SearchResult("test.py", 1, 3, "python", "def hello(): pass", 0.9, 0),
+        ]
+        # Should not raise
+        format_results_rich("hello", results)
+
+    def test_no_crash_empty_results(self):
+        format_results_rich("nothing", [])