code-graph-builder 0.2.0__py3-none-any.whl

code_graph_builder/tests/test_api_find_integration.py

@@ -0,0 +1,226 @@
+"""Integration test: api-find (semantic search + API doc attachment) on tinycc.
+
+Tests the full find_api pipeline: query → embedding → vector search →
+API doc lookup → combined result. Validates relevance, doc attachment,
+and result structure.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import os
+from pathlib import Path
+
+import pytest
+
+TINYCC_PATH = Path(__file__).resolve().parents[3] / "tinycc"
+
+pytestmark = [
+    pytest.mark.skipif(
+        not TINYCC_PATH.exists(),
+        reason=f"tinycc source not found at {TINYCC_PATH}",
+    ),
+    pytest.mark.skipif(
+        not os.environ.get("DASHSCOPE_API_KEY"),
+        reason="DASHSCOPE_API_KEY not set",
+    ),
+]
+
+
+@pytest.fixture(scope="module")
+def mcp_registry(tmp_path_factory):
+    """Set up MCPToolsRegistry with fully indexed tinycc repo."""
+    from code_graph_builder.mcp.tools import MCPToolsRegistry
+
+    workspace = tmp_path_factory.mktemp("workspace")
+    registry = MCPToolsRegistry(workspace=workspace)
+
+    # Run full pipeline via initialize_repository handler
+    result = asyncio.get_event_loop().run_until_complete(
+        registry._handle_initialize_repository(
+            repo_path=str(TINYCC_PATH),
+            rebuild=True,
+            skip_wiki=True,
+            skip_embed=False,
+        )
+    )
+    assert result.get("status") == "success", f"Init failed: {result}"
+
+    yield registry
+    registry.close()
+
+
+def _find_api(registry, query: str, top_k: int = 5) -> dict:
+    """Helper to call find_api synchronously."""
+    return asyncio.get_event_loop().run_until_complete(
+        registry._handle_find_api(query=query, top_k=top_k)
+    )
+
+
+# ---------------------------------------------------------------------------
+# Result structure
+# ---------------------------------------------------------------------------
+
+
+class TestResultStructure:
+    """Verify find_api returns well-structured results."""
+
+    def test_returns_dict(self, mcp_registry):
+        result = _find_api(mcp_registry, "compile")
+        assert isinstance(result, dict)
+
+    def test_has_required_keys(self, mcp_registry):
+        result = _find_api(mcp_registry, "compile")
+        assert "query" in result
+        assert "result_count" in result
+        assert "api_docs_available" in result
+        assert "results" in result
+
+    def test_query_echoed(self, mcp_registry):
+        result = _find_api(mcp_registry, "parse expression")
+        assert result["query"] == "parse expression"
+
+    def test_result_count_matches(self, mcp_registry):
+        result = _find_api(mcp_registry, "compile", top_k=3)
+        assert result["result_count"] == len(result["results"])
+        assert result["result_count"] <= 3
+
+    def test_api_docs_available(self, mcp_registry):
+        result = _find_api(mcp_registry, "compile")
+        assert result["api_docs_available"] is True
+
+    def test_result_entry_keys(self, mcp_registry):
+        result = _find_api(mcp_registry, "compile")
+        assert len(result["results"]) > 0
+        entry = result["results"][0]
+        expected_keys = {
+            "qualified_name", "name", "type", "score",
+            "file_path", "start_line", "end_line",
+            "source_code", "api_doc",
+        }
+        assert expected_keys.issubset(entry.keys())
+
+
+# ---------------------------------------------------------------------------
+# Search relevance
+# ---------------------------------------------------------------------------
+
+
+class TestSearchRelevance:
+    """Verify find_api returns relevant results for various queries."""
+
+    def test_search_compile(self, mcp_registry):
+        result = _find_api(mcp_registry, "compile source code")
+        qns = [r["qualified_name"] for r in result["results"]]
+        found = any("compile" in qn.lower() or "tcc" in qn.lower() for qn in qns)
+        assert found, f"Expected compile-related results, got: {qns}"
+
+    def test_search_parse(self, mcp_registry):
+        result = _find_api(mcp_registry, "parse C expression")
+        qns = [r["qualified_name"] for r in result["results"]]
+        found = any("parse" in qn.lower() or "expr" in qn.lower() for qn in qns)
+        assert found, f"Expected parse-related results, got: {qns}"
+
+    def test_search_memory(self, mcp_registry):
+        result = _find_api(mcp_registry, "allocate memory")
+        qns = [r["qualified_name"] for r in result["results"]]
+        found = any(
+            "alloc" in qn.lower() or "malloc" in qn.lower() or "mem" in qn.lower()
+            for qn in qns
+        )
+        assert found, f"Expected memory-related results, got: {qns}"
+
+    def test_scores_are_valid(self, mcp_registry):
+        result = _find_api(mcp_registry, "generate assembly code")
+        for r in result["results"]:
+            assert isinstance(r["score"], float)
+            assert 0.0 <= r["score"] <= 1.0
+
+    def test_scores_descending(self, mcp_registry):
+        result = _find_api(mcp_registry, "output binary")
+        scores = [r["score"] for r in result["results"]]
+        assert scores == sorted(scores, reverse=True)
+
+
+# ---------------------------------------------------------------------------
+# API doc attachment
+# ---------------------------------------------------------------------------
+
+
+class TestApiDocAttachment:
+    """Verify L3 API docs are attached to search results."""
+
+    def test_some_results_have_api_doc(self, mcp_registry):
+        result = _find_api(mcp_registry, "compile source file", top_k=10)
+        with_doc = sum(1 for r in result["results"] if r["api_doc"])
+        assert with_doc > 0, "Some results should have API docs attached"
+
+    def test_api_doc_is_markdown(self, mcp_registry):
+        result = _find_api(mcp_registry, "parse tokens", top_k=10)
+        for r in result["results"]:
+            if r["api_doc"]:
+                assert r["api_doc"].startswith("# "), (
+                    f"API doc should start with markdown title, got: {r['api_doc'][:50]}"
+                )
+                break
+
+    def test_api_doc_has_signature(self, mcp_registry):
+        """Attached API docs should contain function signature."""
+        result = _find_api(mcp_registry, "lexer tokenizer", top_k=10)
+        for r in result["results"]:
+            if r["api_doc"] and "签名:" in r["api_doc"]:
+                return  # Found
+        # It's ok if some results don't have signatures (e.g., macros)
+        # Just check at least one doc was attached
+        with_doc = sum(1 for r in result["results"] if r["api_doc"])
+        if with_doc > 0:
+            return  # Docs attached, signature format may vary
+        pytest.fail("No API docs attached to any result")
+
+    def test_api_doc_has_call_info(self, mcp_registry):
+        """Attached API docs should contain call relationship info."""
+        result = _find_api(mcp_registry, "compile", top_k=10)
+        for r in result["results"]:
+            if r["api_doc"] and "被调用" in r["api_doc"]:
+                return
+        pytest.fail("No API doc has call relationship info")
+
+
+# ---------------------------------------------------------------------------
+# Edge cases
+# ---------------------------------------------------------------------------
+
+
+class TestEdgeCases:
+    """Test edge cases and boundary conditions."""
+
+    def test_empty_query(self, mcp_registry):
+        """Empty query should still return results (or handle gracefully)."""
+        try:
+            result = _find_api(mcp_registry, "")
+            # Either returns empty or some results
+            assert isinstance(result, dict)
+        except Exception:
+            pass  # Raising an error is also acceptable
+
+    def test_top_k_1(self, mcp_registry):
+        result = _find_api(mcp_registry, "main", top_k=1)
+        assert len(result["results"]) <= 1
+
+    def test_top_k_large(self, mcp_registry):
+        result = _find_api(mcp_registry, "function", top_k=50)
+        assert len(result["results"]) <= 50
+        assert len(result["results"]) > 0
+
+    def test_chinese_query(self, mcp_registry):
+        """Chinese natural language query should work."""
+        result = _find_api(mcp_registry, "编译源代码")
+        assert isinstance(result, dict)
+        assert result["result_count"] >= 0
+
+    def test_specific_function_name(self, mcp_registry):
+        """Querying an exact function name should find it."""
+        result = _find_api(mcp_registry, "tcc_compile", top_k=10)
+        qns = [r["qualified_name"] for r in result["results"]]
+        # Should find the function or something very related
+        assert len(qns) > 0

code_graph_builder/tests/test_basic.py

@@ -0,0 +1,78 @@
+"""Basic tests for code_graph_builder."""
+
+import pytest
+
+
+def test_import():
+    """Test basic imports."""
+    from code_graph_builder import CodeGraphBuilder, BuildResult
+    from code_graph_builder.constants import SupportedLanguage, NodeLabel
+    from code_graph_builder.types import GraphData, GraphSummary
+
+    assert CodeGraphBuilder is not None
+    assert BuildResult is not None
+    assert SupportedLanguage is not None
+    assert NodeLabel is not None
+    assert GraphData is not None
+    assert GraphSummary is not None
+
+
+def test_constants():
+    """Test constants are defined correctly."""
+    from code_graph_builder.constants import SupportedLanguage, NodeLabel, RelationshipType
+
+    # Test SupportedLanguage enum
+    assert SupportedLanguage.PYTHON.value == "python"
+    assert SupportedLanguage.JS.value == "javascript"
+
+    # Test NodeLabel enum
+    assert NodeLabel.FUNCTION.value == "Function"
+    assert NodeLabel.CLASS.value == "Class"
+
+    # Test RelationshipType enum
+    assert RelationshipType.CALLS.value == "CALLS"
+    assert RelationshipType.DEFINES.value == "DEFINES"
+
+
+def test_types():
+    """Test type definitions."""
+    from code_graph_builder.types import BuildResult, NodeType
+
+    # Test BuildResult
+    result = BuildResult(
+        project_name="test",
+        nodes_created=10,
+        relationships_created=5,
+        functions_found=3,
+        classes_found=2,
+        files_processed=1,
+        errors=[],
+    )
+    assert result.project_name == "test"
+    assert result.nodes_created == 10
+
+    # Test NodeType
+    assert NodeType.FUNCTION.value == "Function"
+    assert NodeType.METHOD.value == "Method"
+
+
+def test_models():
+    """Test data models."""
+    from code_graph_builder.models import LanguageSpec, Dependency
+    from code_graph_builder.constants import SupportedLanguage
+
+    # Test LanguageSpec
+    spec = LanguageSpec(
+        language=SupportedLanguage.PYTHON,
+        file_extensions=(".py",),
+        function_node_types=("function_definition",),
+        class_node_types=("class_definition",),
+        module_node_types=("module",),
+    )
+    assert spec.language == SupportedLanguage.PYTHON
+    assert ".py" in spec.file_extensions
+
+    # Test Dependency
+    dep = Dependency(name="requests", spec=">=2.0.0")
+    assert dep.name == "requests"
+    assert dep.spec == ">=2.0.0"

code_graph_builder/tests/test_c_api_extraction.py

@@ -0,0 +1,388 @@
+"""Tests for C language API interface extraction.
+
+Tests cover:
+- Function extraction with visibility (public/static/extern)
+- Struct/union/enum member extraction
+- Typedef extraction
+- Macro extraction
+- Header declaration tracking for visibility resolution
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+
+def _make_builder(project_path: Path):
+    """Create a CodeGraphBuilder with a project-specific DB path."""
+    from code_graph_builder.builder import CodeGraphBuilder
+
+    db_path = project_path / "test_graph.db"
+    return CodeGraphBuilder(
+        str(project_path),
+        backend_config={"db_path": str(db_path)},
+    )
+
+
+@pytest.fixture
+def c_project_with_header(tmp_path: Path) -> Path:
+    """Create a C project with header and source files."""
+    project_path = tmp_path / "c_api_project"
+    project_path.mkdir()
+
+    # Create a Makefile to be recognized as a C package
+    (project_path / "Makefile").write_text("all:\n\tgcc -o main main.c\n")
+
+    # Header file declaring public API
+    (project_path / "api.h").write_text(
+        """\
+#ifndef API_H
+#define API_H
+
+typedef int error_code;
+typedef struct point Point;
+
+struct point {
+    int x;
+    int y;
+};
+
+enum color {
+    RED,
+    GREEN,
+    BLUE
+};
+
+union value {
+    int i;
+    float f;
+    char c;
+};
+
+#define MAX_SIZE 1024
+#define VERSION "1.0.0"
+
+int api_init(void);
+void api_cleanup(void);
+int api_process(const char *input, int len);
+
+#endif
+"""
+    )
+
+    # Source file with implementations
+    (project_path / "api.c").write_text(
+        """\
+#include "api.h"
+
+static int _internal_helper(int x) {
+    return x * 2;
+}
+
+int api_init(void) {
+    return _internal_helper(0);
+}
+
+void api_cleanup(void) {
+    // cleanup
+}
+
+int api_process(const char *input, int len) {
+    return _internal_helper(len);
+}
+
+void undeclared_extern_func(void) {
+    // This function has external linkage but is not in a header
+}
+"""
+    )
+
+    return project_path
+
+
+@pytest.fixture
+def c_struct_project(tmp_path: Path) -> Path:
+    """Create a C project focused on struct/union/enum definitions."""
+    project_path = tmp_path / "c_struct_project"
+    project_path.mkdir()
+
+    (project_path / "types.h").write_text(
+        """\
+#ifndef TYPES_H
+#define TYPES_H
+
+typedef unsigned long size_t_alias;
+typedef int (*callback_fn)(int, int);
+
+struct config {
+    int width;
+    int height;
+    char *name;
+    float ratio;
+};
+
+enum log_level {
+    LOG_DEBUG,
+    LOG_INFO,
+    LOG_WARN,
+    LOG_ERROR
+};
+
+union data {
+    int integer;
+    double floating;
+    char string[32];
+};
+
+#define MAX_BUFSIZE 4096
+#define MIN(a, b) ((a) < (b) ? (a) : (b))
+
+#endif
+"""
+    )
+
+    return project_path
+
+
+def test_c_function_visibility_header(c_project_with_header: Path) -> None:
+    """Test that functions declared in headers get 'public' visibility."""
+    builder = _make_builder(c_project_with_header)
+    result = builder.build_graph(clean=True)
+
+    assert result.nodes_created > 0, "No nodes were created"
+
+    # Query functions and their visibility
+    func_query = """
+    MATCH (f:Function)
+    RETURN f.name AS name, f.visibility AS visibility, f.signature AS signature
+    """
+    functions = builder.query(func_query)
+
+    func_map = {}
+    for row in functions:
+        raw = row.get("result", row)
+        if isinstance(raw, (list, tuple)):
+            func_map[raw[0]] = {"visibility": raw[1], "signature": raw[2]}
+        elif isinstance(raw, dict):
+            func_map[raw.get("name", "")] = {
+                "visibility": raw.get("visibility"),
+                "signature": raw.get("signature"),
+            }
+
+    # Functions declared in api.h should be "public"
+    assert "api_init" in func_map, f"api_init not found. Available: {list(func_map.keys())}"
+    assert func_map["api_init"]["visibility"] == "public", (
+        f"api_init should be 'public', got '{func_map['api_init']['visibility']}'"
+    )
+
+    # Static function should be "static"
+    assert "_internal_helper" in func_map, (
+        f"_internal_helper not found. Available: {list(func_map.keys())}"
+    )
+    assert func_map["_internal_helper"]["visibility"] == "static", (
+        f"_internal_helper should be 'static', got '{func_map['_internal_helper']['visibility']}'"
+    )
+
+
+def test_c_function_visibility_extern(c_project_with_header: Path) -> None:
+    """Test that non-static functions not in headers get 'extern' visibility."""
+    builder = _make_builder(c_project_with_header)
+    result = builder.build_graph(clean=True)
+
+    func_query = """
+    MATCH (f:Function)
+    WHERE f.name = 'undeclared_extern_func'
+    RETURN f.name AS name, f.visibility AS visibility
+    """
+    functions = builder.query(func_query)
+
+    assert len(functions) > 0, "undeclared_extern_func not found"
+
+    raw = functions[0].get("result", functions[0])
+    if isinstance(raw, (list, tuple)):
+        visibility = raw[1]
+    else:
+        visibility = raw.get("visibility")
+
+    assert visibility == "extern", (
+        f"undeclared_extern_func should be 'extern', got '{visibility}'"
+    )
+
+
+def test_c_struct_member_extraction(c_struct_project: Path) -> None:
+    """Test that struct members are extracted."""
+    builder = _make_builder(c_struct_project)
+    result = builder.build_graph(clean=True)
+
+    class_query = """
+    MATCH (c:Class)
+    RETURN c.name AS name, c.kind AS kind, c.parameters AS members, c.signature AS signature
+    """
+    classes = builder.query(class_query)
+
+    class_map = {}
+    for row in classes:
+        raw = row.get("result", row)
+        if isinstance(raw, (list, tuple)):
+            class_map[raw[0]] = {
+                "kind": raw[1],
+                "members": raw[2],
+                "signature": raw[3],
+            }
+        elif isinstance(raw, dict):
+            class_map[raw.get("name", "")] = {
+                "kind": raw.get("kind"),
+                "members": raw.get("members"),
+                "signature": raw.get("signature"),
+            }
+
+    # Check struct
+    assert "config" in class_map, f"config struct not found. Available: {list(class_map.keys())}"
+    config = class_map["config"]
+    assert config["kind"] == "struct", f"Expected kind 'struct', got '{config['kind']}'"
+    assert config["members"] is not None, "config struct should have members"
+    assert len(config["members"]) >= 3, (
+        f"config struct should have at least 3 members, got {len(config['members'])}"
+    )
+
+    # Check enum
+    assert "log_level" in class_map, f"log_level enum not found. Available: {list(class_map.keys())}"
+    log_level = class_map["log_level"]
+    assert log_level["kind"] == "enum", f"Expected kind 'enum', got '{log_level['kind']}'"
+    assert log_level["members"] is not None, "log_level enum should have members"
+    # Should contain LOG_DEBUG, LOG_INFO, LOG_WARN, LOG_ERROR
+    assert len(log_level["members"]) == 4, (
+        f"log_level enum should have 4 members, got {len(log_level['members'])}"
+    )
+
+    # Check union
+    assert "data" in class_map, f"data union not found. Available: {list(class_map.keys())}"
+    data = class_map["data"]
+    assert data["kind"] == "union", f"Expected kind 'union', got '{data['kind']}'"
+
+
+def test_c_typedef_extraction(c_struct_project: Path) -> None:
+    """Test that typedef declarations are extracted as Type nodes."""
+    builder = _make_builder(c_struct_project)
+    result = builder.build_graph(clean=True)
+
+    type_query = """
+    MATCH (t:Type)
+    RETURN t.name AS name, t.kind AS kind, t.signature AS signature
+    """
+    types = builder.query(type_query)
+
+    type_map = {}
+    for row in types:
+        raw = row.get("result", row)
+        if isinstance(raw, (list, tuple)):
+            type_map[raw[0]] = {"kind": raw[1], "signature": raw[2]}
+        elif isinstance(raw, dict):
+            type_map[raw.get("name", "")] = {
+                "kind": raw.get("kind"),
+                "signature": raw.get("signature"),
+            }
+
+    assert "size_t_alias" in type_map, (
+        f"size_t_alias typedef not found. Available: {list(type_map.keys())}"
+    )
+    assert type_map["size_t_alias"]["kind"] == "typedef"
+
+
+def test_c_macro_extraction(c_struct_project: Path) -> None:
+    """Test that #define macros are extracted."""
+    builder = _make_builder(c_struct_project)
+    result = builder.build_graph(clean=True)
+
+    # Macros are stored as Function nodes with kind='macro'
+    macro_query = """
+    MATCH (f:Function)
+    WHERE f.kind = 'macro'
+    RETURN f.name AS name, f.signature AS signature, f.visibility AS visibility
+    """
+    macros = builder.query(macro_query)
+
+    macro_names = set()
+    for row in macros:
+        raw = row.get("result", row)
+        if isinstance(raw, (list, tuple)):
+            macro_names.add(raw[0])
+        elif isinstance(raw, dict):
+            macro_names.add(raw.get("name"))
+
+    assert "MAX_BUFSIZE" in macro_names, (
+        f"MAX_BUFSIZE macro not found. Available: {macro_names}"
+    )
+    assert "MIN" in macro_names, (
+        f"MIN macro not found. Available: {macro_names}"
+    )
+
+
+def test_c_function_signature_extraction(c_project_with_header: Path) -> None:
+    """Test that C function signatures are correctly built."""
+    builder = _make_builder(c_project_with_header)
+    result = builder.build_graph(clean=True)
+
+    func_query = """
+    MATCH (f:Function)
+    WHERE f.name = 'api_process'
+    RETURN f.name AS name, f.signature AS signature, f.return_type AS return_type,
+           f.parameters AS parameters
+    """
+    functions = builder.query(func_query)
+
+    assert len(functions) > 0, "api_process not found"
+
+    raw = functions[0].get("result", functions[0])
+    if isinstance(raw, (list, tuple)):
+        signature = raw[1]
+        return_type = raw[2]
+        parameters = raw[3]
+    else:
+        signature = raw.get("signature")
+        return_type = raw.get("return_type")
+        parameters = raw.get("parameters")
+
+    assert signature is not None, "api_process should have a signature"
+    assert "api_process" in signature, f"Signature should contain function name: {signature}"
+    assert return_type is not None, "api_process should have a return type"
+
+
+def test_c_header_declarations_tracked(c_project_with_header: Path) -> None:
+    """Test that header declarations are tracked for visibility resolution."""
+    builder = _make_builder(c_project_with_header)
+    result = builder.build_graph(clean=True)
+
+    # Query all functions from the .c file
+    func_query = """
+    MATCH (m:Module)-[:DEFINES]->(f:Function)
+    RETURN m.name AS module, f.name AS name, f.visibility AS visibility
+    """
+    functions = builder.query(func_query)
+
+    c_file_funcs = {}
+    for row in functions:
+        raw = row.get("result", row)
+        if isinstance(raw, (list, tuple)):
+            mod_name = raw[0]
+            func_name = raw[1]
+            vis = raw[2]
+        elif isinstance(raw, dict):
+            mod_name = raw.get("module", "")
+            func_name = raw.get("name", "")
+            vis = raw.get("visibility")
+        else:
+            continue
+
+        if mod_name and mod_name.endswith(".c"):
+            c_file_funcs[func_name] = vis
+
+    # Functions also in header should be public
+    for fname in ("api_init", "api_cleanup", "api_process"):
+        if fname in c_file_funcs:
+            assert c_file_funcs[fname] == "public", (
+                f"{fname} in .c file should be 'public' (declared in header), "
+                f"got '{c_file_funcs[fname]}'"
+            )