refactor: Introduce new module-specific unit tests for various components and remove outdated general test files.

Author: deepakdgupta1

tests/unit/test_signals.py tests/unit/analysis/test_signals.pytests/unit/test_signals.py renamed to tests/unit/analysis/test_signals.py

@@ -0,0 +1,107 @@
+"""Unit tests for FastAPI endpoints using TestClient."""
+
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from knowcode.api import api
+from knowcode.models import CodeChunk
+
+
+class DummySearchEngine:
+    def search(self, _query, limit=5, expand_deps=True):
+        return [CodeChunk(id="c1", entity_id="e1", content="hi", tokens=["hi"])]
+
+
+class DummyService:
+    def __init__(self) -> None:
+        self.reload_called = False
+
+    def get_stats(self):
+        return {"total_entities": 1}
+
+    def search(self, _pattern):
+        return [
+            {
+                "id": "e1",
+                "kind": "function",
+                "name": "foo",
+                "qualified_name": "foo",
+                "file": "file.py",
+                "line": 1,
+            }
+        ]
+
+    def get_context(self, _target, max_tokens=2000):
+        return {
+            "entity_id": "e1",
+            "context_text": "ctx",
+            "total_tokens": 1,
+            "truncated": False,
+            "included_entities": ["e1"],
+        }
+
+    def get_entity_details(self, _entity_id):
+        return {"id": "e1", "source_code": "pass", "location": {"file_path": "file.py"}}
+
+    def get_callers(self, _entity_id):
+        return []
+
+    def get_callees(self, _entity_id):
+        return []
+
+    def get_search_engine(self, _index_path=None):
+        return DummySearchEngine()
+
+    def reload(self):
+        self.reload_called = True
+
+
+def _make_client():
+    app = FastAPI()
+    app.include_router(api.router)
+    return TestClient(app)
+
+
+def test_health_and_stats_endpoints():
+    api._service = DummyService()
+    client = _make_client()
+
+    assert client.get("/api/v1/health").json() == {"status": "ok"}
+    assert client.get("/api/v1/stats").json()["total_entities"] == 1
+
+
+def test_search_and_context_endpoints():
+    api._service = DummyService()
+    client = _make_client()
+
+    search_resp = client.get("/api/v1/search", params={"q": "foo"})
+    assert search_resp.status_code == 200
+    assert search_resp.json()[0]["id"] == "e1"
+
+    context_resp = client.get("/api/v1/context", params={"target": "e1"})
+    assert context_resp.status_code == 200
+    assert context_resp.json()["context_text"] == "ctx"
+
+
+def test_query_and_entity_endpoints():
+    api._service = DummyService()
+    client = _make_client()
+
+    query_resp = client.post("/api/v1/context/query", json={"query": "hi", "limit": 1})
+    assert query_resp.status_code == 200
+    assert query_resp.json()["chunks"][0]["id"] == "c1"
+
+    entity_resp = client.get("/api/v1/entities/e1")
+    assert entity_resp.status_code == 200
+    assert entity_resp.json()["id"] == "e1"
+
+
+def test_reload_endpoint():
+    service = DummyService()
+    api._service = service
+    client = _make_client()
+
+    resp = client.post("/api/v1/reload")
+    assert resp.status_code == 200
+    assert resp.json()["status"] == "reloaded"
+    assert service.reload_called is True

tests/unit/test_temporal.py tests/unit/analysis/test_temporal.pytests/unit/test_temporal.py renamed to tests/unit/analysis/test_temporal.py

@@ -0,0 +1,31 @@
+"""Unit tests for CLI commands."""
+
+import json
+
+from click.testing import CliRunner
+
+from knowcode.cli import cli
+
+
+def test_cli_analyze_query_stats_context(tmp_path):
+    """Basic CLI commands should run against a temporary project."""
+    (tmp_path / "sample.py").write_text("def foo():\n    return 1\n", encoding="utf-8")
+
+    runner = CliRunner()
+    analyze = runner.invoke(cli, ["analyze", str(tmp_path), "--output", str(tmp_path)])
+    assert analyze.exit_code == 0
+
+    store_path = tmp_path / "knowcode_knowledge.json"
+    data = json.loads(store_path.read_text(encoding="utf-8"))
+    entity_id = next(iter(data["entities"].keys()))
+
+    query = runner.invoke(cli, ["query", "search", "foo", "--store", str(tmp_path)])
+    assert query.exit_code == 0
+    assert "foo" in query.output
+
+    stats = runner.invoke(cli, ["stats", "--store", str(tmp_path)])
+    assert stats.exit_code == 0
+    assert "Total Entities" in stats.output
+
+    context = runner.invoke(cli, ["context", entity_id, "--store", str(tmp_path), "--max-tokens", "200"])
+    assert context.exit_code == 0

tests/unit/test_token_optimization.py …unit/analysis/test_token_optimization.pytests/unit/test_token_optimization.py renamed to tests/unit/analysis/test_token_optimization.py tests/unit/test_token_optimization.py renamed to tests/unit/analysis/test_token_optimization.py

@@ -0,0 +1,35 @@
+"""Unit tests for background indexing."""
+
+import time
+from pathlib import Path
+
+from knowcode.indexing.background_indexer import BackgroundIndexer
+
+
+class DummyIndexer:
+    def __init__(self) -> None:
+        self.calls: list[Path] = []
+
+    def index_file(self, path: Path) -> int:
+        self.calls.append(path)
+        return 1
+
+
+def test_background_indexer_processes_queue(tmp_path: Path) -> None:
+    """Queued files should be processed by the worker thread."""
+    indexer = DummyIndexer()
+    bg = BackgroundIndexer(indexer)
+    bg.start()
+
+    target = tmp_path / "file.py"
+    target.write_text("print('hi')", encoding="utf-8")
+    bg.queue_file(target)
+
+    for _ in range(20):
+        if indexer.calls:
+            break
+        time.sleep(0.05)
+
+    bg.stop()
+
+    assert indexer.calls == [target]

tests/unit/api/test_api_endpoints.py

@@ -0,0 +1,77 @@
+"""Unit tests for the chunker."""
+
+from pathlib import Path
+
+from knowcode.indexing.chunker import Chunker
+from knowcode.models import ChunkingConfig, Entity, EntityKind, Location, ParseResult
+
+
+def test_chunker_module_extraction() -> None:
+    """Module header and imports should be extracted."""
+    chunker = Chunker()
+    source = '"""Module docstring."""\nimport os\n\ndef foo(): pass'
+
+    header = chunker._extract_module_header(source)
+    assert '"""Module docstring."""' in header
+
+    imports = chunker._extract_imports(source)
+    assert "import os" in imports
+
+
+def test_chunker_metadata_has_docstring_and_last_modified(tmp_path: Path) -> None:
+    """Chunk metadata should include docstring and timestamp flags."""
+    source = '"""Module docstring."""\n\ndef foo():\n    """Doc."""\n    return 1\n'
+    file_path = tmp_path / "mod.py"
+    file_path.write_text(source, encoding="utf-8")
+
+    module_entity = Entity(
+        id=f"{file_path}::mod",
+        kind=EntityKind.MODULE,
+        name="mod",
+        qualified_name="mod",
+        location=Location(str(file_path), 1, 5),
+        source_code=source,
+    )
+    func_entity = Entity(
+        id=f"{file_path}::foo",
+        kind=EntityKind.FUNCTION,
+        name="foo",
+        qualified_name="foo",
+        location=Location(str(file_path), 3, 5),
+        docstring="Doc.",
+        signature="def foo()",
+        source_code="def foo():\n    return 1\n",
+    )
+
+    result = ParseResult(
+        file_path=str(file_path),
+        entities=[module_entity, func_entity],
+        relationships=[],
+    )
+    chunker = Chunker()
+    chunks = chunker.process_parse_result(result)
+
+    func_chunks = [c for c in chunks if c.entity_id == func_entity.id]
+    assert func_chunks
+    assert func_chunks[0].metadata["has_docstring"] == "true"
+    assert "last_modified" in func_chunks[0].metadata
+
+
+def test_chunker_overlap_chunking() -> None:
+    """Large entities should be split into overlapping chunks."""
+    content = "a" * 120
+    entity = Entity(
+        id="file.py::big",
+        kind=EntityKind.FUNCTION,
+        name="big",
+        qualified_name="big",
+        location=Location("file.py", 1, 10),
+        source_code=content,
+    )
+    result = ParseResult(file_path="file.py", entities=[entity], relationships=[])
+
+    chunker = Chunker(ChunkingConfig(max_chunk_size=50, overlap=10))
+    chunks = chunker.process_parse_result(result)
+
+    assert len(chunks) > 1
+    assert chunks[0].metadata["chunk_index"] == "0"

tests/unit/cli/test_cli.py

@@ -0,0 +1,28 @@
+"""Unit tests for graph builder reference resolution."""
+
+from knowcode.indexing.graph_builder import GraphBuilder
+from knowcode.models import Entity, EntityKind, Location, Relationship, RelationshipKind
+
+
+def test_reference_resolution() -> None:
+    """ref:: targets should resolve to known entities when possible."""
+    builder = GraphBuilder()
+    entity = Entity(
+        id="file.py::Foo",
+        kind=EntityKind.CLASS,
+        name="Foo",
+        qualified_name="Foo",
+        location=Location("file.py", 1, 5),
+    )
+    builder.entities = {entity.id: entity}
+    builder.relationships = [
+        Relationship(
+            source_id="file.py::Caller",
+            target_id="ref::Foo",
+            kind=RelationshipKind.REFERENCES,
+        )
+    ]
+
+    builder._resolve_references()
+
+    assert builder.relationships[0].target_id == entity.id

tests/unit/indexing/test_background_indexer.py

@@ -0,0 +1,23 @@
+"""Unit tests for the file scanner."""
+
+from pathlib import Path
+
+from knowcode.indexing.scanner import Scanner
+
+
+def test_scanner_respects_gitignore_and_extensions(tmp_path: Path) -> None:
+    """Scanner should respect ignore rules and extensions."""
+    (tmp_path / ".gitignore").write_text("ignored.py\n", encoding="utf-8")
+    (tmp_path / "ignored.py").write_text("print('ignore')", encoding="utf-8")
+    (tmp_path / "skip.py").write_text("print('skip')", encoding="utf-8")
+    (tmp_path / "keep.py").write_text("print('keep')", encoding="utf-8")
+    (tmp_path / "note.txt").write_text("text", encoding="utf-8")
+
+    scanner = Scanner(tmp_path, additional_ignores=["skip.py"])
+    files = scanner.scan_all()
+    paths = {f.relative_path for f in files}
+
+    assert "keep.py" in paths
+    assert "ignored.py" not in paths
+    assert "skip.py" not in paths
+    assert "note.txt" not in paths