"""Tests for the manifest parser module."""
import json
import tempfile
import time
from pathlib import Path
from local_deepwiki.generators.manifest import (
ManifestCacheEntry,
ProjectManifest,
_get_manifest_mtimes,
_is_cache_valid,
get_cached_manifest,
get_directory_tree,
parse_manifest,
)
class TestProjectManifest:
"""Tests for ProjectManifest dataclass."""
def test_has_data_empty(self):
"""Empty manifest has no data."""
manifest = ProjectManifest()
assert not manifest.has_data()
def test_has_data_with_name(self):
"""Manifest with name has data."""
manifest = ProjectManifest(name="test-project")
assert manifest.has_data()
def test_has_data_with_dependencies(self):
"""Manifest with dependencies has data."""
manifest = ProjectManifest(dependencies={"requests": "^2.0"})
assert manifest.has_data()
def test_get_tech_stack_summary_empty(self):
"""Empty manifest returns default message."""
manifest = ProjectManifest()
result = manifest.get_tech_stack_summary()
assert result == "No package manifest found."
def test_get_tech_stack_summary_with_language(self):
"""Manifest with language shows it in summary."""
manifest = ProjectManifest(language="Python", language_version=">=3.11")
result = manifest.get_tech_stack_summary()
assert "Python" in result
assert ">=3.11" in result
def test_get_dependency_list_formatted(self):
"""Dependencies are formatted correctly."""
manifest = ProjectManifest(
dependencies={"requests": "^2.0", "flask": ">=2.0"},
dev_dependencies={"pytest": "^7.0"},
)
result = manifest.get_dependency_list()
assert "### Dependencies" in result
assert "requests" in result
assert "flask" in result
assert "### Dev Dependencies" in result
assert "pytest" in result
class TestParsePyprojectToml:
"""Tests for parsing pyproject.toml files."""
def test_parse_basic_pyproject(self):
"""Parse a basic pyproject.toml."""
with tempfile.TemporaryDirectory() as tmpdir:
pyproject = Path(tmpdir) / "pyproject.toml"
pyproject.write_text(
"""
[project]
name = "test-project"
version = "1.0.0"
description = "A test project"
requires-python = ">=3.11"
dependencies = [
"requests>=2.0",
"flask",
]
[project.optional-dependencies]
dev = ["pytest>=7.0"]
[project.scripts]
test-cli = "test_project:main"
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "test-project"
assert manifest.version == "1.0.0"
assert manifest.description == "A test project"
assert manifest.language == "Python"
assert manifest.language_version == ">=3.11"
assert "requests" in manifest.dependencies
assert "flask" in manifest.dependencies
assert "pytest" in manifest.dev_dependencies
assert "test-cli" in manifest.entry_points
class TestParsePackageJson:
"""Tests for parsing package.json files."""
def test_parse_basic_package_json(self):
"""Parse a basic package.json."""
with tempfile.TemporaryDirectory() as tmpdir:
package_json = Path(tmpdir) / "package.json"
package_json.write_text(
json.dumps(
{
"name": "test-package",
"version": "1.0.0",
"description": "A test package",
"dependencies": {
"express": "^4.0.0",
"lodash": "^4.0.0",
},
"devDependencies": {
"typescript": "^5.0.0",
"jest": "^29.0.0",
},
"scripts": {
"build": "tsc",
"test": "jest",
},
"main": "index.js",
}
)
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "test-package"
assert manifest.version == "1.0.0"
assert manifest.language == "TypeScript" # Due to typescript dep
assert "express" in manifest.dependencies
assert "lodash" in manifest.dependencies
assert "typescript" in manifest.dev_dependencies
assert "jest" in manifest.dev_dependencies
assert "build" in manifest.scripts
assert "test" in manifest.scripts
class TestParseRequirementsTxt:
"""Tests for parsing requirements.txt files."""
def test_parse_basic_requirements(self):
"""Parse a basic requirements.txt."""
with tempfile.TemporaryDirectory() as tmpdir:
requirements = Path(tmpdir) / "requirements.txt"
requirements.write_text(
"""
# Main dependencies
requests>=2.0
flask==2.0.0
pydantic
# Skip these
-r other-requirements.txt
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.language == "Python"
assert "requests" in manifest.dependencies
assert "flask" in manifest.dependencies
assert "pydantic" in manifest.dependencies
class TestParseCargoToml:
"""Tests for parsing Cargo.toml files."""
def test_parse_basic_cargo(self):
"""Parse a basic Cargo.toml."""
with tempfile.TemporaryDirectory() as tmpdir:
cargo = Path(tmpdir) / "Cargo.toml"
cargo.write_text(
"""
[package]
name = "test-crate"
version = "0.1.0"
edition = "2021"
[dependencies]
serde = "1.0"
tokio = { version = "1.0", features = ["full"] }
[dev-dependencies]
criterion = "0.5"
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "test-crate"
assert manifest.version == "0.1.0"
assert manifest.language == "Rust"
assert manifest.language_version == "Edition 2021"
assert "serde" in manifest.dependencies
assert "tokio" in manifest.dependencies
assert "criterion" in manifest.dev_dependencies
class TestParseGoMod:
"""Tests for parsing go.mod files."""
def test_parse_basic_go_mod(self):
"""Parse a basic go.mod."""
with tempfile.TemporaryDirectory() as tmpdir:
go_mod = Path(tmpdir) / "go.mod"
go_mod.write_text(
"""
module github.com/user/test-project
go 1.21
require (
github.com/gin-gonic/gin v1.9.0
github.com/stretchr/testify v1.8.0
)
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "test-project"
assert manifest.language == "Go"
assert manifest.language_version == "1.21"
assert "gin" in manifest.dependencies
assert "testify" in manifest.dependencies
class TestGetDirectoryTree:
"""Tests for directory tree generation."""
def test_basic_tree(self):
"""Generate a basic directory tree."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / "src").mkdir()
(root / "src" / "main.py").touch()
(root / "tests").mkdir()
(root / "tests" / "test_main.py").touch()
(root / "README.md").touch()
tree = get_directory_tree(root, max_depth=2)
assert "src/" in tree
assert "main.py" in tree
assert "tests/" in tree
assert "test_main.py" in tree
assert "README.md" in tree
def test_skips_hidden_dirs(self):
"""Hidden directories are skipped."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / ".git").mkdir()
(root / ".git" / "config").touch()
(root / "src").mkdir()
(root / "src" / "main.py").touch()
tree = get_directory_tree(root, max_depth=2)
assert ".git" not in tree
assert "config" not in tree
assert "src/" in tree
assert "main.py" in tree
def test_skips_node_modules(self):
"""node_modules is skipped."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / "node_modules").mkdir()
(root / "node_modules" / "express").mkdir()
(root / "src").mkdir()
tree = get_directory_tree(root, max_depth=2)
assert "node_modules" not in tree
assert "src/" in tree
def test_respects_max_items(self):
"""Respects max_items limit."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
for i in range(20):
(root / f"file{i}.txt").touch()
tree = get_directory_tree(root, max_depth=1, max_items=5)
# Should have truncation indicator
assert "..." in tree
class TestMultipleManifests:
"""Tests for handling multiple manifest files."""
def test_pyproject_takes_precedence(self):
"""pyproject.toml takes precedence over requirements.txt."""
with tempfile.TemporaryDirectory() as tmpdir:
pyproject = Path(tmpdir) / "pyproject.toml"
pyproject.write_text(
"""
[project]
name = "from-pyproject"
dependencies = ["flask"]
"""
)
requirements = Path(tmpdir) / "requirements.txt"
requirements.write_text("requests")
manifest = parse_manifest(Path(tmpdir))
# Name comes from pyproject
assert manifest.name == "from-pyproject"
# But both deps are collected
assert "flask" in manifest.dependencies
assert "requests" in manifest.dependencies
# Both manifest files recorded
assert "pyproject.toml" in manifest.manifest_files
assert "requirements.txt" in manifest.manifest_files
class TestManifestCaching:
"""Tests for manifest caching functionality."""
def test_get_manifest_mtimes_empty_repo(self):
"""Empty repo returns no mtimes."""
with tempfile.TemporaryDirectory() as tmpdir:
mtimes = _get_manifest_mtimes(Path(tmpdir))
assert mtimes == {}
def test_get_manifest_mtimes_with_files(self):
"""Returns mtimes for existing manifest files."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / "pyproject.toml").write_text("[project]\nname = 'test'")
(root / "package.json").write_text('{"name": "test"}')
mtimes = _get_manifest_mtimes(root)
assert "pyproject.toml" in mtimes
assert "package.json" in mtimes
assert mtimes["pyproject.toml"] > 0
assert mtimes["package.json"] > 0
def test_cache_entry_serialization(self):
"""Cache entry can be serialized and deserialized."""
entry = ManifestCacheEntry(
manifest_data={"name": "test", "dependencies": {"flask": "^2.0"}},
file_mtimes={"pyproject.toml": 1234567890.0},
)
# Serialize
data = entry.to_dict()
assert "manifest_data" in data
assert "file_mtimes" in data
# Deserialize
restored = ManifestCacheEntry.from_dict(data)
assert restored.manifest_data == entry.manifest_data
assert restored.file_mtimes == entry.file_mtimes
def test_cache_valid_when_unchanged(self):
"""Cache is valid when files haven't changed."""
mtimes = {"pyproject.toml": 1234567890.0}
entry = ManifestCacheEntry(
manifest_data={"name": "test"},
file_mtimes=mtimes,
)
assert _is_cache_valid(entry, mtimes) is True
def test_cache_invalid_when_file_modified(self):
"""Cache is invalid when a file is modified."""
old_mtimes = {"pyproject.toml": 1234567890.0}
new_mtimes = {"pyproject.toml": 1234567899.0} # Different mtime
entry = ManifestCacheEntry(
manifest_data={"name": "test"},
file_mtimes=old_mtimes,
)
assert _is_cache_valid(entry, new_mtimes) is False
def test_cache_invalid_when_file_added(self):
"""Cache is invalid when a new manifest file is added."""
old_mtimes = {"pyproject.toml": 1234567890.0}
new_mtimes = {"pyproject.toml": 1234567890.0, "package.json": 1234567890.0}
entry = ManifestCacheEntry(
manifest_data={"name": "test"},
file_mtimes=old_mtimes,
)
assert _is_cache_valid(entry, new_mtimes) is False
def test_cache_invalid_when_file_removed(self):
"""Cache is invalid when a manifest file is removed."""
old_mtimes = {"pyproject.toml": 1234567890.0, "package.json": 1234567890.0}
new_mtimes = {"pyproject.toml": 1234567890.0}
entry = ManifestCacheEntry(
manifest_data={"name": "test"},
file_mtimes=old_mtimes,
)
assert _is_cache_valid(entry, new_mtimes) is False
def test_get_cached_manifest_creates_cache(self):
"""get_cached_manifest creates cache file on first call."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
cache_dir = root / ".deepwiki"
(root / "pyproject.toml").write_text(
"""
[project]
name = "cached-project"
dependencies = ["requests"]
"""
)
manifest = get_cached_manifest(root, cache_dir=cache_dir)
assert manifest.name == "cached-project"
assert (cache_dir / "manifest_cache.json").exists()
def test_get_cached_manifest_uses_cache(self):
"""get_cached_manifest uses cache on subsequent calls."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
cache_dir = root / ".deepwiki"
(root / "pyproject.toml").write_text(
"""
[project]
name = "cached-project"
dependencies = ["requests"]
"""
)
# First call creates cache
manifest1 = get_cached_manifest(root, cache_dir=cache_dir)
# Modify the file content but keep same mtime (simulate using cache)
# Since we can't easily control mtime, we verify cache file exists
assert (cache_dir / "manifest_cache.json").exists()
# Second call should use cache
manifest2 = get_cached_manifest(root, cache_dir=cache_dir)
assert manifest1.name == manifest2.name
assert manifest1.dependencies == manifest2.dependencies
def test_get_cached_manifest_invalidates_on_change(self):
"""get_cached_manifest re-parses when file changes."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
cache_dir = root / ".deepwiki"
pyproject = root / "pyproject.toml"
pyproject.write_text(
"""
[project]
name = "original-name"
"""
)
# First call
manifest1 = get_cached_manifest(root, cache_dir=cache_dir)
assert manifest1.name == "original-name"
# Wait a tiny bit to ensure different mtime
time.sleep(0.01)
# Modify the file
pyproject.write_text(
"""
[project]
name = "updated-name"
"""
)
# Second call should re-parse
manifest2 = get_cached_manifest(root, cache_dir=cache_dir)
assert manifest2.name == "updated-name"
def test_get_cached_manifest_default_cache_dir(self):
"""get_cached_manifest uses .deepwiki in repo by default."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / "package.json").write_text('{"name": "test-pkg"}')
# Call without explicit cache_dir
manifest = get_cached_manifest(root)
assert manifest.name == "test-pkg"
assert (root / ".deepwiki" / "manifest_cache.json").exists()
class TestTechStackSummary:
"""Tests for tech stack summary generation."""
def test_tech_stack_with_many_deps(self):
"""Tech stack summary truncates when many deps in category."""
manifest = ProjectManifest(
language="Python",
dependencies={
"flask": "^2.0",
"sqlalchemy": "^2.0",
"redis": "^4.0",
"pymongo": "^4.0",
"lancedb": "^0.1",
"chromadb": "^0.3",
"psycopg2": "^2.9",
},
)
result = manifest.get_tech_stack_summary()
# Should have "(+X more)" for categories with > 5 items
assert "Database" in result
# Check truncation happens
assert "+2 more" in result or "+1 more" in result or len(result.split(",")) <= 6
class TestDependencyCategorization:
"""Tests for dependency categorization."""
def test_categorizes_web_frameworks(self):
"""Web frameworks are categorized correctly."""
manifest = ProjectManifest(
language="Python",
dependencies={"flask": "^2.0", "fastapi": "^0.100"},
)
categories = manifest._categorize_dependencies()
assert "Web Framework" in categories
assert "flask" in categories["Web Framework"]
assert "fastapi" in categories["Web Framework"]
def test_categorizes_databases(self):
"""Databases are categorized correctly."""
manifest = ProjectManifest(
language="Python",
dependencies={"sqlalchemy": "^2.0", "redis": "^4.0", "pymongo": "^4.0"},
)
categories = manifest._categorize_dependencies()
assert "Database" in categories
assert "sqlalchemy" in categories["Database"]
assert "redis" in categories["Database"]
def test_categorizes_testing(self):
"""Testing packages are categorized correctly."""
manifest = ProjectManifest(
language="Python",
dependencies={"pytest": "^7.0", "unittest2": "^1.0"},
)
categories = manifest._categorize_dependencies()
assert "Testing" in categories
assert "pytest" in categories["Testing"]
def test_categorizes_cli(self):
"""CLI packages are categorized correctly."""
manifest = ProjectManifest(
language="Python",
dependencies={"click": "^8.0", "typer": "^0.9"},
)
categories = manifest._categorize_dependencies()
assert "CLI" in categories
assert "click" in categories["CLI"]
assert "typer" in categories["CLI"]
def test_categorizes_ai_ml(self):
"""AI/ML packages are categorized correctly."""
manifest = ProjectManifest(
language="Python",
dependencies={"openai": "^1.0", "anthropic": "^0.5", "langchain": "^0.1"},
)
categories = manifest._categorize_dependencies()
assert "AI/ML" in categories
assert "openai" in categories["AI/ML"]
assert "anthropic" in categories["AI/ML"]
def test_categorizes_other(self):
"""Unknown packages go to Other category."""
manifest = ProjectManifest(
language="Python",
dependencies={"some-random-package": "^1.0"},
)
categories = manifest._categorize_dependencies()
assert "Other" in categories
assert "some-random-package" in categories["Other"]
class TestEntryPointsSummary:
"""Tests for entry points summary generation."""
def test_entry_points_summary_with_cli_commands(self):
"""Entry points summary shows CLI commands."""
manifest = ProjectManifest(
entry_points={"mycli": "mypackage:main", "other-cmd": "mypackage.other:run"}
)
result = manifest.get_entry_points_summary()
assert "### CLI Commands" in result
assert "`mycli`" in result
assert "mypackage:main" in result
def test_entry_points_summary_with_scripts(self):
"""Entry points summary shows scripts."""
manifest = ProjectManifest(
scripts={"build": "npm run build", "test": "pytest tests/"}
)
result = manifest.get_entry_points_summary()
assert "### Scripts" in result
assert "`build`" in result
assert "`test`" in result
def test_entry_points_summary_truncates_long_commands(self):
"""Long script commands are truncated."""
long_cmd = "very-long-command " * 10
manifest = ProjectManifest(scripts={"build": long_cmd})
result = manifest.get_entry_points_summary()
assert "..." in result
def test_entry_points_summary_empty(self):
"""Empty entry points returns empty string."""
manifest = ProjectManifest()
result = manifest.get_entry_points_summary()
assert result == ""
class TestCacheExceptionHandling:
"""Tests for cache-related exception handling."""
def test_get_manifest_mtimes_handles_permission_error(self):
"""mtime lookup handles OSError gracefully."""
# This is hard to test directly without mocking, but we can verify
# the function doesn't crash with a valid path
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / "pyproject.toml").write_text("[project]\nname='test'")
mtimes = _get_manifest_mtimes(root)
assert "pyproject.toml" in mtimes
def test_load_manifest_cache_handles_invalid_json(self):
"""Loading cache handles invalid JSON gracefully."""
from local_deepwiki.generators.manifest import _load_manifest_cache
with tempfile.TemporaryDirectory() as tmpdir:
cache_path = Path(tmpdir) / "invalid_cache.json"
cache_path.write_text("not valid json {{{")
result = _load_manifest_cache(cache_path)
assert result is None
def test_load_manifest_cache_handles_missing_file(self):
"""Loading cache handles missing file gracefully."""
from local_deepwiki.generators.manifest import _load_manifest_cache
with tempfile.TemporaryDirectory() as tmpdir:
cache_path = Path(tmpdir) / "nonexistent.json"
result = _load_manifest_cache(cache_path)
assert result is None
def test_save_manifest_cache_creates_directory(self):
"""Saving cache creates parent directory if needed."""
from local_deepwiki.generators.manifest import _save_manifest_cache
with tempfile.TemporaryDirectory() as tmpdir:
cache_path = Path(tmpdir) / "subdir" / "cache.json"
entry = ManifestCacheEntry(
manifest_data={"name": "test"},
file_mtimes={"pyproject.toml": 123456.0},
)
_save_manifest_cache(cache_path, entry)
assert cache_path.exists()
loaded = json.loads(cache_path.read_text())
assert loaded["manifest_data"]["name"] == "test"
class TestParseManifestExceptionHandling:
"""Tests for parse_manifest exception handling."""
def test_parse_manifest_handles_invalid_toml(self):
"""Parsing handles invalid TOML gracefully."""
with tempfile.TemporaryDirectory() as tmpdir:
pyproject = Path(tmpdir) / "pyproject.toml"
pyproject.write_text("invalid toml content [[[")
manifest = parse_manifest(Path(tmpdir))
# Should not crash, but manifest will be mostly empty
assert "pyproject.toml" not in manifest.manifest_files
def test_parse_manifest_handles_invalid_json(self):
"""Parsing handles invalid JSON gracefully."""
with tempfile.TemporaryDirectory() as tmpdir:
package_json = Path(tmpdir) / "package.json"
package_json.write_text("not valid json {{{")
manifest = parse_manifest(Path(tmpdir))
# Should not crash
assert "package.json" not in manifest.manifest_files
class TestPoetryParsing:
"""Tests for Poetry-specific pyproject.toml parsing."""
def test_parse_poetry_project(self):
"""Parse a Poetry-style pyproject.toml."""
with tempfile.TemporaryDirectory() as tmpdir:
pyproject = Path(tmpdir) / "pyproject.toml"
pyproject.write_text(
"""
[tool.poetry]
name = "poetry-project"
description = "A poetry project"
[tool.poetry.dependencies]
python = "^3.11"
requests = "^2.0"
flask = {version = "^2.0", extras = ["async"]}
[tool.poetry.dev-dependencies]
pytest = "^7.0"
black = {version = "^23.0"}
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "poetry-project"
assert manifest.description == "A poetry project"
assert manifest.language == "Python"
assert "requests" in manifest.dependencies
assert "flask" in manifest.dependencies
assert "pytest" in manifest.dev_dependencies
assert "black" in manifest.dev_dependencies
# python should not be in dependencies
assert "python" not in manifest.dependencies
class TestSetupPyParsing:
"""Tests for setup.py parsing."""
def test_parse_setup_py_basic(self):
"""Parse a basic setup.py."""
with tempfile.TemporaryDirectory() as tmpdir:
setup_py = Path(tmpdir) / "setup.py"
setup_py.write_text(
"""
from setuptools import setup
setup(
name="legacy-project",
version="1.0.0",
install_requires=[
"requests>=2.0",
"flask",
],
)
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "legacy-project"
assert manifest.version == "1.0.0"
assert manifest.language == "Python"
assert "requests" in manifest.dependencies
assert "flask" in manifest.dependencies
class TestPomXmlParsing:
"""Tests for pom.xml (Maven) parsing."""
def test_parse_pom_xml_basic(self):
"""Parse a basic pom.xml."""
with tempfile.TemporaryDirectory() as tmpdir:
pom = Path(tmpdir) / "pom.xml"
# Use non-namespaced XML which the parser handles correctly
pom.write_text(
"""<?xml version="1.0" encoding="UTF-8"?>
<project>
<artifactId>maven-project</artifactId>
<version>1.0.0</version>
<description>A Maven project</description>
<properties>
<java.version>17</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>5.3.0</version>
</dependency>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.13</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "maven-project"
assert manifest.version == "1.0.0"
assert manifest.description == "A Maven project"
assert manifest.language == "Java"
assert manifest.language_version == "17"
assert "spring-core" in manifest.dependencies
assert "junit" in manifest.dev_dependencies # scope=test goes to dev
def test_parse_pom_xml_without_namespace(self):
"""Parse pom.xml without Maven namespace."""
with tempfile.TemporaryDirectory() as tmpdir:
pom = Path(tmpdir) / "pom.xml"
pom.write_text(
"""<?xml version="1.0" encoding="UTF-8"?>
<project>
<artifactId>simple-maven</artifactId>
<version>2.0.0</version>
<dependencies>
<dependency>
<artifactId>commons-io</artifactId>
</dependency>
</dependencies>
</project>
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "simple-maven"
assert manifest.version == "2.0.0"
assert manifest.language == "Java"
assert "commons-io" in manifest.dependencies
class TestBuildGradleParsing:
"""Tests for build.gradle parsing."""
def test_parse_build_gradle_java(self):
"""Parse a Java Gradle project."""
with tempfile.TemporaryDirectory() as tmpdir:
gradle = Path(tmpdir) / "build.gradle"
gradle.write_text(
"""
plugins {
id 'java'
}
dependencies {
implementation 'org.springframework:spring-core:5.3.0'
api 'com.google.guava:guava:31.0'
testImplementation 'junit:junit:4.13'
}
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.language == "Java"
assert "spring-core" in manifest.dependencies
assert "guava" in manifest.dependencies
assert "junit" in manifest.dev_dependencies
def test_parse_build_gradle_kotlin(self):
"""Parse a Kotlin Gradle project."""
with tempfile.TemporaryDirectory() as tmpdir:
gradle = Path(tmpdir) / "build.gradle"
gradle.write_text(
"""
plugins {
id 'org.jetbrains.kotlin.jvm'
}
dependencies {
implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.0"
testCompile "org.junit.jupiter:junit-jupiter:5.9.0"
}
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.language == "Kotlin"
assert "kotlin-stdlib" in manifest.dependencies
assert "junit-jupiter" in manifest.dev_dependencies
class TestGemfileParsing:
"""Tests for Gemfile (Ruby) parsing."""
def test_parse_gemfile_basic(self):
"""Parse a basic Gemfile."""
with tempfile.TemporaryDirectory() as tmpdir:
gemfile = Path(tmpdir) / "Gemfile"
gemfile.write_text(
"""
source 'https://rubygems.org'
gem 'rails', '~> 7.0'
gem 'pg'
gem 'puma', '~> 5.0'
gem 'rspec-rails', '~> 6.0'
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.language == "Ruby"
assert "rails" in manifest.dependencies
assert manifest.dependencies["rails"] == "~> 7.0"
assert "pg" in manifest.dependencies
assert manifest.dependencies["pg"] == "*"
assert "puma" in manifest.dependencies
assert "rspec-rails" in manifest.dependencies
class TestPackageJsonEdgeCases:
"""Tests for package.json edge cases."""
def test_parse_package_json_with_node_engine(self):
"""Parse package.json with Node engine version."""
with tempfile.TemporaryDirectory() as tmpdir:
package_json = Path(tmpdir) / "package.json"
package_json.write_text(
json.dumps(
{
"name": "node-project",
"engines": {"node": ">=18.0.0"},
"dependencies": {"express": "^4.0.0"},
}
)
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.language == "JavaScript"
assert manifest.language_version == "Node >=18.0.0"
def test_parse_package_json_with_bin_string(self):
"""Parse package.json with bin as string."""
with tempfile.TemporaryDirectory() as tmpdir:
package_json = Path(tmpdir) / "package.json"
package_json.write_text(
json.dumps(
{
"name": "cli-tool",
"bin": "./bin/cli.js",
}
)
)
manifest = parse_manifest(Path(tmpdir))
assert "cli-tool" in manifest.entry_points
assert manifest.entry_points["cli-tool"] == "./bin/cli.js"
def test_parse_package_json_with_bin_object(self):
"""Parse package.json with bin as object."""
with tempfile.TemporaryDirectory() as tmpdir:
package_json = Path(tmpdir) / "package.json"
package_json.write_text(
json.dumps(
{
"name": "multi-cli",
"bin": {
"cmd1": "./bin/cmd1.js",
"cmd2": "./bin/cmd2.js",
},
}
)
)
manifest = parse_manifest(Path(tmpdir))
assert "cmd1" in manifest.entry_points
assert "cmd2" in manifest.entry_points
def test_parse_package_json_with_repository_string(self):
"""Parse package.json with repository as string."""
with tempfile.TemporaryDirectory() as tmpdir:
package_json = Path(tmpdir) / "package.json"
package_json.write_text(
json.dumps(
{
"name": "repo-string",
"repository": "https://github.com/user/repo",
}
)
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.repository == "https://github.com/user/repo"
class TestCargoTomlEdgeCases:
"""Tests for Cargo.toml edge cases."""
def test_parse_cargo_toml_with_bin_targets(self):
"""Parse Cargo.toml with binary targets."""
with tempfile.TemporaryDirectory() as tmpdir:
cargo = Path(tmpdir) / "Cargo.toml"
cargo.write_text(
"""
[package]
name = "multi-bin"
version = "0.1.0"
[[bin]]
name = "server"
path = "src/bin/server.rs"
[[bin]]
name = "client"
path = "src/bin/client.rs"
[dependencies]
tokio = "1.0"
"""
)
manifest = parse_manifest(Path(tmpdir))
assert manifest.name == "multi-bin"
assert "server" in manifest.entry_points
assert "client" in manifest.entry_points
assert manifest.entry_points["server"] == "src/bin/server.rs"
class TestPythonDepParsing:
"""Tests for Python dependency string parsing."""
def test_parse_python_dep_no_version(self):
"""Parse dependency with no version."""
from local_deepwiki.generators.manifest import _parse_python_dep
name, version = _parse_python_dep("requests")
assert name == "requests"
assert version == "*"
def test_parse_python_dep_with_version(self):
"""Parse dependency with version."""
from local_deepwiki.generators.manifest import _parse_python_dep
name, version = _parse_python_dep("requests>=2.0.0")
assert name == "requests"
assert version == ">=2.0.0"
def test_parse_python_dep_with_extras(self):
"""Parse dependency with extras."""
from local_deepwiki.generators.manifest import _parse_python_dep
name, version = _parse_python_dep("requests[security]>=2.0")
assert name == "requests"
# Version includes the bracket part
assert "[security]" in version or name == "requests"
class TestDirectoryTreeEdgeCases:
"""Tests for directory tree edge cases."""
def test_directory_tree_handles_permission_error(self):
"""Directory tree handles permission errors gracefully."""
# This is hard to test directly, but we can verify no crash
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / "src").mkdir()
(root / "src" / "main.py").touch()
tree = get_directory_tree(root, max_depth=2)
assert "src/" in tree
def test_directory_tree_respects_max_depth(self):
"""Directory tree respects max_depth."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / "a").mkdir()
(root / "a" / "b").mkdir()
(root / "a" / "b" / "c").mkdir()
(root / "a" / "b" / "c" / "deep.txt").touch()
tree = get_directory_tree(root, max_depth=1)
lines = tree.splitlines()
assert any("a/" in line for line in lines)
# b should not appear with max_depth=1 (check per-line to avoid temp dir name matches)
assert not any("b/" in line for line in lines[1:])
def test_directory_tree_skips_pycache(self):
"""Directory tree skips __pycache__."""
with tempfile.TemporaryDirectory() as tmpdir:
root = Path(tmpdir)
(root / "__pycache__").mkdir()
(root / "__pycache__" / "module.cpython-311.pyc").touch()
(root / "src").mkdir()
tree = get_directory_tree(root, max_depth=2)
assert "__pycache__" not in tree
assert "src/" in tree
