yamlgraph 0.3.9__py3-none-any.whl

examples/codegen/tests/test_code_context.py

@@ -0,0 +1,301 @@
+"""Tests for code context tools."""
+
+import tempfile
+from pathlib import Path
+
+from examples.codegen.tools.code_context import (
+    find_related_tests,
+    read_lines,
+    search_codebase,
+    search_in_file,
+)
+
+
+class TestReadLines:
+    """Tests for read_lines function."""
+
+    def test_reads_specific_lines(self):
+        """Reads the specified line range."""
+        # Read known lines from a project file
+        result = read_lines("yamlgraph/executor.py", 1, 10)
+
+        assert isinstance(result, str)
+        assert len(result) > 0
+        # First line should be docstring or comment
+        lines = result.split("\n")
+        assert len(lines) >= 10
+
+    def test_returns_error_for_missing_file(self):
+        """Returns error dict for non-existent file."""
+        result = read_lines("nonexistent_file_12345.py", 1, 10)
+
+        assert isinstance(result, dict)
+        assert "error" in result
+
+    def test_handles_line_range_beyond_file(self):
+        """Handles line numbers beyond file length gracefully."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("line1\nline2\nline3\n")
+            temp_path = f.name
+
+        try:
+            result = read_lines(temp_path, 1, 100)
+            assert isinstance(result, str)
+            assert "line1" in result
+            assert "line3" in result
+        finally:
+            Path(temp_path).unlink()
+
+    def test_one_indexed_lines(self):
+        """Line numbers are 1-indexed."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("first\nsecond\nthird\n")
+            temp_path = f.name
+
+        try:
+            result = read_lines(temp_path, 2, 2)
+            assert "second" in result
+            assert "first" not in result
+        finally:
+            Path(temp_path).unlink()
+
+    def test_handles_invalid_line_range(self):
+        """Handles start > end gracefully."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("line1\nline2\n")
+            temp_path = f.name
+
+        try:
+            result = read_lines(temp_path, 5, 3)
+            # Should return empty or handle gracefully
+            assert isinstance(result, str)
+        finally:
+            Path(temp_path).unlink()
+
+
+class TestFindRelatedTests:
+    """Tests for find_related_tests function."""
+
+    def test_finds_tests_mentioning_symbol(self):
+        """Finds test functions that mention the symbol."""
+        result = find_related_tests("execute_prompt", "tests")
+
+        assert isinstance(result, list)
+        # Should find some tests
+        assert len(result) > 0
+
+        for test in result:
+            assert "file" in test
+            assert "line" in test
+            assert "test_name" in test
+            assert test["test_name"].startswith("test_")
+
+    def test_returns_empty_for_unknown_symbol(self):
+        """Returns empty list for symbol not in tests."""
+        # Create a temp directory with a test file that doesn't have our symbol
+        with tempfile.TemporaryDirectory() as tmpdir:
+            test_file = Path(tmpdir) / "test_sample.py"
+            test_file.write_text("""
+def test_something():
+    assert True
+""")
+            result = find_related_tests("nonexistent", tmpdir)
+
+            assert isinstance(result, list)
+            assert len(result) == 0
+
+    def test_returns_empty_for_nonexistent_path(self):
+        """Returns empty list for non-existent tests path."""
+        result = find_related_tests("anything", "nonexistent_tests_dir")
+
+        assert isinstance(result, list)
+        assert len(result) == 0
+
+    def test_finds_tests_in_subdirectories(self):
+        """Finds tests in nested test directories."""
+        result = find_related_tests("graph", "tests")
+
+        # Should find tests in unit/ and possibly integration/
+        files = [t["file"] for t in result]
+        assert any("unit" in f for f in files)
+
+    def test_case_insensitive_search(self):
+        """Symbol search is case-insensitive."""
+        # Search for something that exists in different cases
+        result_lower = find_related_tests("execute", "tests")
+        result_upper = find_related_tests("EXECUTE", "tests")
+
+        # Both should find some results
+        assert len(result_lower) > 0
+        assert len(result_upper) > 0
+
+    def test_skips_non_test_functions(self):
+        """Only returns functions starting with test_."""
+        result = find_related_tests("execute_prompt", "tests")
+
+        for test in result:
+            assert test["test_name"].startswith("test_")
+
+
+class TestSearchInFile:
+    """Tests for search_in_file function."""
+
+    def test_finds_matching_lines(self):
+        """Finds lines containing the search pattern."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("def foo():\n    timeout = 30\n    return timeout\n")
+            temp_path = f.name
+
+        try:
+            result = search_in_file(temp_path, "timeout")
+
+            assert isinstance(result, list)
+            assert len(result) == 2
+            # Line 2 and 3 contain "timeout"
+            assert result[0]["line"] == 2
+            assert "timeout = 30" in result[0]["text"]
+            assert result[1]["line"] == 3
+        finally:
+            Path(temp_path).unlink()
+
+    def test_returns_error_for_missing_file(self):
+        """Returns error dict for non-existent file."""
+        result = search_in_file("nonexistent_12345.py", "pattern")
+
+        assert isinstance(result, dict)
+        assert "error" in result
+
+    def test_returns_empty_for_no_matches(self):
+        """Returns empty list when pattern not found."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("def foo():\n    return 42\n")
+            temp_path = f.name
+
+        try:
+            result = search_in_file(temp_path, "nonexistent_pattern")
+
+            assert isinstance(result, list)
+            assert len(result) == 0
+        finally:
+            Path(temp_path).unlink()
+
+    def test_case_insensitive_by_default(self):
+        """Search is case-insensitive by default."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("TIMEOUT = 30\ntimeout = 10\nTimeOut = 20\n")
+            temp_path = f.name
+
+        try:
+            result = search_in_file(temp_path, "timeout")
+
+            assert len(result) == 3
+        finally:
+            Path(temp_path).unlink()
+
+    def test_case_sensitive_option(self):
+        """Can enable case-sensitive search."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("TIMEOUT = 30\ntimeout = 10\n")
+            temp_path = f.name
+
+        try:
+            result = search_in_file(temp_path, "timeout", case_sensitive=True)
+
+            assert len(result) == 1
+            assert result[0]["line"] == 2
+        finally:
+            Path(temp_path).unlink()
+
+    def test_limits_context(self):
+        """Returns only matching lines, not context."""
+        with tempfile.NamedTemporaryFile(mode="w", suffix=".py", delete=False) as f:
+            f.write("line1\ntarget\nline3\n")
+            temp_path = f.name
+
+        try:
+            result = search_in_file(temp_path, "target")
+
+            assert len(result) == 1
+            assert "line1" not in result[0]["text"]
+            assert "target" in result[0]["text"]
+        finally:
+            Path(temp_path).unlink()
+
+
+class TestSearchCodebase:
+    """Tests for search_codebase function."""
+
+    def test_finds_matches_across_files(self):
+        """Finds pattern matches in multiple files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create test files
+            (Path(tmpdir) / "file1.py").write_text("timeout = 30\n")
+            (Path(tmpdir) / "file2.py").write_text("max_timeout = 60\n")
+            (Path(tmpdir) / "file3.py").write_text("no match here\n")
+
+            result = search_codebase(tmpdir, "timeout")
+
+            assert isinstance(result, list)
+            assert len(result) == 2  # file1 and file2
+
+            # Each result should have file and matches
+            for r in result:
+                assert "file" in r
+                assert "matches" in r
+                assert len(r["matches"]) > 0
+
+    def test_respects_file_pattern(self):
+        """Only searches files matching the pattern."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            (Path(tmpdir) / "code.py").write_text("timeout = 30\n")
+            (Path(tmpdir) / "config.yaml").write_text("timeout: 60\n")
+
+            result = search_codebase(tmpdir, "timeout", pattern="*.py")
+
+            assert len(result) == 1
+            assert "code.py" in result[0]["file"]
+
+    def test_returns_empty_for_no_matches(self):
+        """Returns empty list when no matches found."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            (Path(tmpdir) / "file.py").write_text("def foo(): pass\n")
+
+            result = search_codebase(tmpdir, "nonexistent_xyz")
+
+            assert isinstance(result, list)
+            assert len(result) == 0
+
+    def test_searches_subdirectories(self):
+        """Recursively searches subdirectories."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            subdir = Path(tmpdir) / "sub" / "dir"
+            subdir.mkdir(parents=True)
+            (subdir / "nested.py").write_text("timeout = 99\n")
+
+            result = search_codebase(tmpdir, "timeout")
+
+            assert len(result) == 1
+            assert "nested.py" in result[0]["file"]
+
+    def test_skips_pycache(self):
+        """Skips __pycache__ directories."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            cache = Path(tmpdir) / "__pycache__"
+            cache.mkdir()
+            (cache / "cached.pyc").write_text("timeout = 30\n")
+            (Path(tmpdir) / "real.py").write_text("timeout = 30\n")
+
+            result = search_codebase(tmpdir, "timeout")
+
+            assert len(result) == 1
+            assert "__pycache__" not in result[0]["file"]
+
+    def test_returns_line_numbers(self):
+        """Each match includes line number."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            (Path(tmpdir) / "test.py").write_text("line1\ntimeout = 30\nline3\n")
+
+            result = search_codebase(tmpdir, "timeout")
+
+            assert len(result) == 1
+            assert result[0]["matches"][0]["line"] == 2

examples/codegen/tests/test_code_nav.py

@@ -0,0 +1,89 @@
+"""Tests for code navigation tools."""
+
+import tempfile
+from pathlib import Path
+
+from examples.codegen.tools.code_nav import list_package_modules
+
+
+class TestListPackageModules:
+    """Tests for list_package_modules function."""
+
+    def test_finds_all_python_files_in_package(self):
+        """Returns all .py files in the package."""
+        result = list_package_modules("yamlgraph/tools")
+
+        assert isinstance(result, list)
+        assert len(result) > 0
+
+        # Should find known files
+        files = [r["file"] for r in result]
+        assert any("shell.py" in f for f in files)
+        assert any("websearch.py" in f for f in files)
+
+    def test_includes_module_summaries(self):
+        """Each module has docstring, classes, functions."""
+        result = list_package_modules("yamlgraph/tools")
+
+        for module in result:
+            assert "file" in module
+            assert "docstring" in module
+            assert "classes" in module
+            assert "functions" in module
+            assert isinstance(module["classes"], list)
+            assert isinstance(module["functions"], list)
+
+    def test_skips_files_with_syntax_errors(self):
+        """Files with syntax errors are skipped."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            # Create a valid file
+            valid_file = Path(tmpdir) / "valid.py"
+            valid_file.write_text('"""Valid module."""\ndef foo(): pass')
+
+            # Create an invalid file
+            invalid_file = Path(tmpdir) / "invalid.py"
+            invalid_file.write_text("def broken(\n")
+
+            result = list_package_modules(tmpdir)
+
+            # Should have only the valid file
+            assert len(result) == 1
+            assert "valid.py" in result[0]["file"]
+
+    def test_returns_empty_list_for_nonexistent_path(self):
+        """Returns empty list for non-existent directory."""
+        result = list_package_modules("nonexistent_directory_12345")
+
+        assert result == []
+
+    def test_returns_empty_list_for_empty_directory(self):
+        """Returns empty list for directory with no Python files."""
+        with tempfile.TemporaryDirectory() as tmpdir:
+            result = list_package_modules(tmpdir)
+            assert result == []
+
+    def test_finds_nested_modules(self):
+        """Finds Python files in subdirectories."""
+        result = list_package_modules("yamlgraph")
+
+        files = [r["file"] for r in result]
+        # Should find files in subdirectories
+        assert any("utils" in f for f in files)
+        assert any("models" in f for f in files)
+        assert any("tools" in f for f in files)
+
+    def test_class_names_are_strings(self):
+        """Class names are extracted as strings, not dicts."""
+        result = list_package_modules("yamlgraph/models")
+
+        for module in result:
+            for cls_name in module["classes"]:
+                assert isinstance(cls_name, str)
+
+    def test_function_names_are_strings(self):
+        """Function names are extracted as strings, not dicts."""
+        result = list_package_modules("yamlgraph/tools")
+
+        for module in result:
+            for func_name in module["functions"]:
+                assert isinstance(func_name, str)

examples/codegen/tests/test_dependency_tools.py

@@ -0,0 +1,119 @@
+"""Tests for dependency analysis tools."""
+
+import tempfile
+from pathlib import Path
+
+from examples.codegen.tools.dependency_tools import get_dependents, get_imports
+
+
+class TestGetImports:
+    """Tests for get_imports function."""
+
+    def test_extracts_import_statements(self):
+        """Standard import statements are extracted."""
+        result = get_imports("yamlgraph/__init__.py")
+
+        assert "error" not in result
+        assert "imports" in result
+        assert isinstance(result["imports"], list)
+
+    def test_extracts_from_imports(self):
+        """From X import Y statements are extracted."""
+        result = get_imports("yamlgraph/executor.py")
+
+        assert "error" not in result
+        assert "imports" in result
+        # executor.py has from imports
+        assert len(result["imports"]) > 0
+
+    def test_import_has_module_and_names(self):
+        """Each import has module and imported names."""
+        result = get_imports("yamlgraph/executor.py")
+
+        assert "error" not in result
+        for imp in result["imports"]:
+            assert "module" in imp
+            # Names may be None for 'import X' vs 'from X import Y'
+            assert "names" in imp
+
+    def test_returns_error_for_invalid_file(self):
+        """Returns error for non-existent file."""
+        result = get_imports("nonexistent/file.py")
+
+        assert "error" in result
+
+    def test_returns_error_for_syntax_error(self):
+        """Returns error for file with syntax errors."""
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode="w") as f:
+            f.write("def broken(\n    return")
+            temp_path = f.name
+
+        try:
+            result = get_imports(temp_path)
+            assert "error" in result
+        finally:
+            Path(temp_path).unlink()
+
+    def test_handles_aliased_imports(self):
+        """Handles 'import X as Y' and 'from X import Y as Z'."""
+        with tempfile.NamedTemporaryFile(suffix=".py", delete=False, mode="w") as f:
+            f.write("import numpy as np\nfrom pathlib import Path as P")
+            temp_path = f.name
+
+        try:
+            result = get_imports(temp_path)
+            assert "error" not in result
+            assert len(result["imports"]) >= 2
+        finally:
+            Path(temp_path).unlink()
+
+
+class TestGetDependents:
+    """Tests for get_dependents function."""
+
+    def test_finds_files_that_import_module(self):
+        """Finds files that import a given module."""
+        # yamlgraph.executor is imported by many files
+        result = get_dependents("yamlgraph.executor", "yamlgraph")
+
+        assert "error" not in result
+        assert "dependents" in result
+        assert isinstance(result["dependents"], list)
+
+    def test_returns_file_paths(self):
+        """Returns list of file paths."""
+        result = get_dependents("yamlgraph.config", "yamlgraph")
+
+        assert "error" not in result
+        for dep in result["dependents"]:
+            assert isinstance(dep, str)
+            assert dep.endswith(".py")
+
+    def test_empty_for_unused_module(self):
+        """Returns empty list for module with no dependents."""
+        result = get_dependents("nonexistent.module.that.nobody.imports", "yamlgraph")
+
+        assert "error" not in result
+        assert result["dependents"] == []
+
+    def test_returns_error_for_invalid_project(self):
+        """Returns error for non-existent project path."""
+        result = get_dependents("some.module", "/nonexistent/path")
+
+        assert "error" in result
+
+    def test_finds_from_import_style(self):
+        """Finds 'from X import Y' style imports."""
+        result = get_dependents("yamlgraph.utils.prompts", "yamlgraph")
+
+        assert "error" not in result
+        # prompts is used in multiple places
+        assert len(result["dependents"]) >= 0  # May be 0 if not imported directly
+
+    def test_finds_import_module_style(self):
+        """Finds 'import X' style imports."""
+        # logging is imported in many places
+        result = get_dependents("logging", "yamlgraph")
+
+        # This searches for 'import logging' or 'from logging import'
+        assert "error" not in result

examples/codegen/tests/test_example_tools.py

@@ -0,0 +1,185 @@
+"""Tests for example discovery tools."""
+
+from pathlib import Path
+
+from examples.codegen.tools.example_tools import (
+    find_error_handling,
+    find_example,
+)
+
+# ============================================================================
+# find_example tests
+# ============================================================================
+
+
+class TestFindExample:
+    """Tests for find_example."""
+
+    def test_finds_function_usage(self, tmp_path: Path):
+        """Find usage examples of a function."""
+        # Create a source file
+        src = tmp_path / "mymodule.py"
+        src.write_text('''
+def greet(name: str) -> str:
+    """Say hello."""
+    return f"Hello, {name}!"
+''')
+        # Create a file that uses it
+        user = tmp_path / "main.py"
+        user.write_text("""
+from mymodule import greet
+
+def run():
+    result = greet("World")
+    print(result)
+""")
+        result = find_example("greet", str(tmp_path))
+
+        assert "examples" in result
+        assert len(result["examples"]) >= 1
+        example = result["examples"][0]
+        assert "file" in example
+        assert "line" in example
+        assert "snippet" in example
+        assert "greet" in example["snippet"]
+
+    def test_prioritizes_test_files(self, tmp_path: Path):
+        """Test files should appear first in examples."""
+        # Source
+        src = tmp_path / "utils.py"
+        src.write_text("def helper(): pass")
+
+        # Regular usage
+        main = tmp_path / "main.py"
+        main.write_text("from utils import helper\nhelper()")
+
+        # Test usage
+        tests = tmp_path / "tests"
+        tests.mkdir()
+        test_file = tests / "test_utils.py"
+        test_file.write_text("""
+from utils import helper
+
+def test_helper():
+    result = helper()
+    assert result is None
+""")
+        result = find_example("helper", str(tmp_path))
+
+        assert "examples" in result
+        # First example should be from test file
+        if result["examples"]:
+            first = result["examples"][0]
+            assert "test" in first["file"].lower()
+
+    def test_limits_max_examples(self, tmp_path: Path):
+        """Respects max_examples parameter."""
+        src = tmp_path / "funcs.py"
+        src.write_text("def foo(): pass")
+
+        for i in range(5):
+            f = tmp_path / f"user{i}.py"
+            f.write_text(f"from funcs import foo\nfoo()  # usage {i}")
+
+        result = find_example("foo", str(tmp_path), max_examples=2)
+
+        assert "examples" in result
+        assert len(result["examples"]) <= 2
+
+    def test_handles_no_examples(self, tmp_path: Path):
+        """Returns empty list when no examples found."""
+        src = tmp_path / "module.py"
+        src.write_text("def unused(): pass")
+
+        result = find_example("unused", str(tmp_path))
+
+        assert "examples" in result
+        assert len(result["examples"]) == 0
+
+    def test_handles_missing_project(self):
+        """Returns error for missing project path."""
+        result = find_example("symbol", "/nonexistent/path")
+        assert "error" in result
+
+
+# ============================================================================
+# find_error_handling tests
+# ============================================================================
+
+
+class TestFindErrorHandling:
+    """Tests for find_error_handling."""
+
+    def test_finds_exception_types(self, tmp_path: Path):
+        """Discovers exception types used in project."""
+        src = tmp_path / "handler.py"
+        src.write_text("""
+try:
+    risky_operation()
+except ValueError as e:
+    print(f"Value error: {e}")
+except KeyError:
+    pass
+except (TypeError, AttributeError):
+    pass
+""")
+        result = find_error_handling(str(tmp_path))
+
+        assert "exceptions" in result
+        exceptions = result["exceptions"]
+        assert "ValueError" in exceptions
+        assert "KeyError" in exceptions
+
+    def test_finds_dict_error_pattern(self, tmp_path: Path):
+        """Detects dict-based error returns."""
+        src = tmp_path / "tool.py"
+        src.write_text("""
+def process(data):
+    if not data:
+        return {"error": "No data provided"}
+    try:
+        result = compute(data)
+        return {"result": result}
+    except Exception as e:
+        return {"error": str(e)}
+""")
+        result = find_error_handling(str(tmp_path))
+
+        assert "patterns" in result
+        patterns = result["patterns"]
+        assert "dict_error" in patterns or any("dict" in p.lower() for p in patterns)
+
+    def test_finds_logging_patterns(self, tmp_path: Path):
+        """Detects error logging patterns."""
+        src = tmp_path / "service.py"
+        src.write_text("""
+import logging
+
+logger = logging.getLogger(__name__)
+
+def do_work():
+    try:
+        work()
+    except Exception as e:
+        logger.error(f"Failed: {e}")
+        raise
+""")
+        result = find_error_handling(str(tmp_path))
+
+        assert "logging" in result
+        assert result["logging"]["uses_logging"] is True
+
+    def test_handles_no_error_handling(self, tmp_path: Path):
+        """Returns empty patterns for code without error handling."""
+        src = tmp_path / "simple.py"
+        src.write_text("x = 1 + 1\nprint(x)")
+
+        result = find_error_handling(str(tmp_path))
+
+        assert "exceptions" in result
+        assert len(result["exceptions"]) == 0
+
+    def test_handles_missing_project(self):
+        """Returns error for missing project path."""
+        result = find_error_handling("/nonexistent/path")
+        assert "error" in result