codexa 0.4.0__py3-none-any.whl

semantic_code_intelligence/tests/test_enhanced_embeddings.py

@@ -0,0 +1,92 @@
+"""Tests for the enhanced embedding pipeline."""
+
+from __future__ import annotations
+
+import pytest
+
+from semantic_code_intelligence.embeddings.enhanced import (
+    preprocess_code_for_embedding,
+    prepare_semantic_texts,
+)
+from semantic_code_intelligence.indexing.semantic_chunker import SemanticChunk
+
+
+# ---------------------------------------------------------------------------
+# Preprocessing
+# ---------------------------------------------------------------------------
+
+class TestPreprocessCodeForEmbedding:
+    def test_strips_trailing_whitespace(self):
+        text = "def foo():   \n    pass   \n"
+        result = preprocess_code_for_embedding(text)
+        for line in result.splitlines():
+            assert line == line.rstrip()
+
+    def test_collapses_blank_lines(self):
+        text = "a\n\n\n\n\nb\n"
+        result = preprocess_code_for_embedding(text)
+        assert "\n\n\n" not in result
+
+    def test_prepends_semantic_label(self):
+        result = preprocess_code_for_embedding("x = 1", "[python] function foo")
+        assert result.startswith("[python] function foo\n")
+
+    def test_empty_label(self):
+        result = preprocess_code_for_embedding("x = 1", "")
+        assert not result.startswith("\n")
+
+    def test_empty_content(self):
+        result = preprocess_code_for_embedding("")
+        assert result == ""
+
+    def test_preserves_meaningful_content(self):
+        code = "def hello():\n    return 'world'"
+        result = preprocess_code_for_embedding(code)
+        assert "def hello():" in result
+        assert "return 'world'" in result
+
+
+# ---------------------------------------------------------------------------
+# Batch preparation
+# ---------------------------------------------------------------------------
+
+class TestPrepareSemanticTexts:
+    def test_empty_list(self):
+        assert prepare_semantic_texts([]) == []
+
+    def test_single_chunk(self):
+        chunk = SemanticChunk(
+            file_path="t.py", content="def foo(): pass",
+            start_line=1, end_line=1, chunk_index=0,
+            language="python", symbol_name="foo",
+            symbol_kind="function",
+            semantic_label="[python] function foo",
+        )
+        texts = prepare_semantic_texts([chunk])
+        assert len(texts) == 1
+        assert "[python] function foo" in texts[0]
+
+    def test_multiple_chunks(self):
+        chunks = [
+            SemanticChunk(
+                file_path="t.py", content=f"line{i}",
+                start_line=i, end_line=i, chunk_index=i,
+                language="python",
+            )
+            for i in range(3)
+        ]
+        texts = prepare_semantic_texts(chunks)
+        assert len(texts) == 3
+
+    def test_preserves_content_order(self):
+        chunks = [
+            SemanticChunk(
+                file_path="t.py", content=f"content_{i}",
+                start_line=i, end_line=i, chunk_index=i,
+                language="python",
+            )
+            for i in range(3)
+        ]
+        texts = prepare_semantic_texts(chunks)
+        for i, text in enumerate(texts):
+            assert f"content_{i}" in text

semantic_code_intelligence/tests/test_hash_store.py

@@ -0,0 +1,79 @@
+"""Tests for the hash store."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from semantic_code_intelligence.storage.hash_store import HashStore
+
+
+class TestHashStore:
+    """Tests for HashStore operations."""
+
+    def test_empty_store(self):
+        store = HashStore()
+        assert store.count == 0
+        assert store.get("file.py") is None
+
+    def test_set_and_get(self):
+        store = HashStore()
+        store.set("file.py", "abc123")
+        assert store.get("file.py") == "abc123"
+
+    def test_has_changed_new_file(self):
+        store = HashStore()
+        assert store.has_changed("file.py", "hash1") is True
+
+    def test_has_changed_same_hash(self):
+        store = HashStore()
+        store.set("file.py", "hash1")
+        assert store.has_changed("file.py", "hash1") is False
+
+    def test_has_changed_different_hash(self):
+        store = HashStore()
+        store.set("file.py", "hash1")
+        assert store.has_changed("file.py", "hash2") is True
+
+    def test_remove(self):
+        store = HashStore()
+        store.set("file.py", "hash1")
+        store.remove("file.py")
+        assert store.get("file.py") is None
+        assert store.count == 0
+
+    def test_remove_nonexistent_no_error(self):
+        store = HashStore()
+        store.remove("nonexistent.py")  # should not raise
+
+    def test_count(self):
+        store = HashStore()
+        store.set("a.py", "h1")
+        store.set("b.py", "h2")
+        assert store.count == 2
+
+
+class TestHashStorePersistence:
+    """Tests for save/load."""
+
+    def test_save_creates_file(self, tmp_path: Path):
+        store = HashStore()
+        store.set("file.py", "hash1")
+        store.save(tmp_path)
+        assert (tmp_path / "file_hashes.json").exists()
+
+    def test_load_roundtrip(self, tmp_path: Path):
+        store = HashStore()
+        store.set("a.py", "h1")
+        store.set("b.py", "h2")
+        store.save(tmp_path)
+
+        loaded = HashStore.load(tmp_path)
+        assert loaded.count == 2
+        assert loaded.get("a.py") == "h1"
+        assert loaded.get("b.py") == "h2"
+
+    def test_load_nonexistent_returns_empty(self, tmp_path: Path):
+        loaded = HashStore.load(tmp_path / "nope")
+        assert loaded.count == 0

semantic_code_intelligence/tests/test_logging.py

@@ -0,0 +1,55 @@
+"""Tests for utils/logging module."""
+
+from __future__ import annotations
+
+import logging
+
+from semantic_code_intelligence.utils.logging import (
+    console,
+    error_console,
+    get_logger,
+    setup_logging,
+)
+
+
+class TestSetupLogging:
+    """Tests for logging setup."""
+
+    def test_setup_logging_default(self):
+        logger = setup_logging(verbose=False)
+        assert logger.level == logging.INFO
+
+    def test_setup_logging_verbose(self):
+        logger = setup_logging(verbose=True)
+        assert logger.level == logging.DEBUG
+
+    def test_setup_returns_logger(self):
+        logger = setup_logging()
+        assert isinstance(logger, logging.Logger)
+        assert logger.name == "codexa"
+
+
+class TestGetLogger:
+    """Tests for logger retrieval."""
+
+    def test_get_root_logger(self):
+        logger = get_logger()
+        assert logger.name == "codexa"
+
+    def test_get_child_logger(self):
+        logger = get_logger("test")
+        assert logger.name == "codexa.test"
+
+    def test_get_nested_child_logger(self):
+        logger = get_logger("cli.init")
+        assert logger.name == "codexa.cli.init"
+
+
+class TestConsoles:
+    """Tests for console instances."""
+
+    def test_console_exists(self):
+        assert console is not None
+
+    def test_error_console_uses_stderr(self):
+        assert error_console.stderr is True

semantic_code_intelligence/tests/test_new_cli.py

@@ -0,0 +1,138 @@
+"""Tests for the expanded CLI commands (explain, summary, watch, deps)."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from click.testing import CliRunner
+
+from semantic_code_intelligence.cli.main import cli
+
+
+SAMPLE_PYTHON = """\
+import os
+
+def greet(name):
+    return f"Hello, {name}!"
+
+class Service:
+    def __init__(self, url):
+        self.url = url
+"""
+
+
+@pytest.fixture
+def runner():
+    return CliRunner()
+
+
+@pytest.fixture
+def project_dir(tmp_path):
+    """Create a minimal initialized project."""
+    config_dir = tmp_path / ".codexa"
+    config_dir.mkdir()
+    (config_dir / "config.json").write_text("{}", encoding="utf-8")
+    (tmp_path / "main.py").write_text(SAMPLE_PYTHON, encoding="utf-8")
+    return tmp_path
+
+
+# ---------------------------------------------------------------------------
+# explain command
+# ---------------------------------------------------------------------------
+
+class TestExplainCmd:
+    def test_explain_file(self, runner, project_dir):
+        main_py = str(project_dir / "main.py")
+        result = runner.invoke(cli, ["explain", ".", "--file", main_py, "-p", str(project_dir)])
+        assert result.exit_code == 0
+
+    def test_explain_symbol_in_file(self, runner, project_dir):
+        main_py = str(project_dir / "main.py")
+        result = runner.invoke(cli, ["explain", "greet", "--file", main_py, "-p", str(project_dir)])
+        assert result.exit_code == 0
+        assert "greet" in result.output
+
+    def test_explain_symbol_not_found(self, runner, project_dir):
+        main_py = str(project_dir / "main.py")
+        result = runner.invoke(cli, ["explain", "nonexistent", "--file", main_py, "-p", str(project_dir)])
+        assert result.exit_code == 0
+        assert "not found" in result.output.lower()
+
+    def test_explain_json_mode(self, runner, project_dir):
+        main_py = str(project_dir / "main.py")
+        result = runner.invoke(cli, ["explain", ".", "--file", main_py, "--json", "-p", str(project_dir)])
+        assert result.exit_code == 0
+
+
+# ---------------------------------------------------------------------------
+# summary command
+# ---------------------------------------------------------------------------
+
+class TestSummaryCmd:
+    def test_summary_basic(self, runner, project_dir):
+        result = runner.invoke(cli, ["summary", "-p", str(project_dir)])
+        assert result.exit_code == 0
+
+    def test_summary_json(self, runner, project_dir):
+        result = runner.invoke(cli, ["summary", "--json", "-p", str(project_dir)])
+        assert result.exit_code == 0
+
+    def test_summary_empty_project(self, runner, tmp_path):
+        config_dir = tmp_path / ".codexa"
+        config_dir.mkdir()
+        (config_dir / "config.json").write_text("{}", encoding="utf-8")
+        result = runner.invoke(cli, ["summary", "-p", str(tmp_path)])
+        assert result.exit_code == 0
+
+
+# ---------------------------------------------------------------------------
+# deps command
+# ---------------------------------------------------------------------------
+
+class TestDepsCmd:
+    def test_deps_single_file(self, runner, project_dir):
+        result = runner.invoke(cli, ["deps", "main.py", "-p", str(project_dir)])
+        assert result.exit_code == 0
+
+    def test_deps_whole_project(self, runner, project_dir):
+        result = runner.invoke(cli, ["deps", ".", "-p", str(project_dir)])
+        assert result.exit_code == 0
+
+    def test_deps_json(self, runner, project_dir):
+        result = runner.invoke(cli, ["deps", ".", "--json", "-p", str(project_dir)])
+        assert result.exit_code == 0
+
+    def test_deps_nonexistent_file(self, runner, project_dir):
+        result = runner.invoke(cli, ["deps", "nope.py", "-p", str(project_dir)])
+        assert result.exit_code == 0
+        assert "not found" in result.output.lower()
+
+
+# ---------------------------------------------------------------------------
+# watch command
+# ---------------------------------------------------------------------------
+
+class TestWatchCmd:
+    def test_watch_no_init(self, runner, tmp_path):
+        result = runner.invoke(cli, ["watch", "-p", str(tmp_path)])
+        assert result.exit_code == 0
+        assert "not initialized" in result.output.lower()
+
+
+# ---------------------------------------------------------------------------
+# router verification
+# ---------------------------------------------------------------------------
+
+class TestRouter:
+    def test_all_commands_registered(self, runner):
+        result = runner.invoke(cli, ["--help"])
+        assert result.exit_code == 0
+        assert "explain" in result.output
+        assert "summary" in result.output
+        assert "watch" in result.output
+        assert "deps" in result.output
+        assert "init" in result.output
+        assert "index" in result.output
+        assert "search" in result.output