Codebase intelligence for AI and humans: code health scores, auto-generated docs, git analytics, dead code detection, and architectural decisions via MCP.
Python aicode-complexitycode-healthcode-intelligencecode-qualitydead-codedeveloper-toolsdocumentationgit-analyticsmcpopen-sourcepythonrefactoringstatic-analysistechnical-debt
"""Unit tests for the unified ASTParser.
Tests parse inline byte strings so no filesystem I/O is needed.
Covers Python, TypeScript, Go, Rust, Java, C++ — one test class per language.
"""
from __future__ import annotations
from repowise.core.ingestion.parser import ASTParser
from tests.unit.ingestion.parser._helpers import _make_file_info
JAVA_SOURCE = b"""package com.repowise.sample;
import java.util.ArrayList;
import java.util.List;
/**
* Stateful calculator with history.
*/
public class Calculator {
private final List<Object> history = new ArrayList<>();
/**
* Adds x and y.
*/
public double add(double x, double y) {
return x + y;
}
/** Private helper. */
private void record(Object entry) {
history.add(entry);
}
}
"""
FIELD_RECEIVER_SOURCE = b"""package com.repowise.sample;
public class Clinic {
private final OwnerRepository owners;
private final Basket basket;
public void report() {
this.owners.findAll();
super.audit.record();
this.basket.items.size();
}
class Inner {
void run() {
Clinic.this.reset();
}
}
void reset() {
}
}
"""
class TestJavaParser:
def test_finds_class(self, parser: ASTParser) -> None:
fi = _make_file_info("java_pkg/Calculator.java", "java")
result = parser.parse_file(fi, JAVA_SOURCE)
classes = [s for s in result.symbols if s.kind == "class"]
assert any(s.name == "Calculator" for s in classes)
def test_finds_methods(self, parser: ASTParser) -> None:
fi = _make_file_info("java_pkg/Calculator.java", "java")
result = parser.parse_file(fi, JAVA_SOURCE)
methods = [s for s in result.symbols if s.kind == "method"]
method_names = [m.name for m in methods]
assert "add" in method_names
assert "record" in method_names
def test_parses_imports(self, parser: ASTParser) -> None:
fi = _make_file_info("java_pkg/Calculator.java", "java")
result = parser.parse_file(fi, JAVA_SOURCE)
assert len(result.imports) >= 2
module_paths = [i.module_path for i in result.imports]
assert any("ArrayList" in p for p in module_paths)
def test_annotation_type_elements_are_its_methods(self, parser: ASTParser) -> None:
source = (
b"package p;\npublic @interface Since {\n double value();\n"
b" String[] names() default {};\n}\n"
)
result = parser.parse_file(_make_file_info("p/Since.java", "java"), source)
assert sorted((s.id, s.kind, s.signature) for s in result.symbols) == [
("p/Since.java::Since", "interface", "@interface Since"),
("p/Since.java::Since::names", "method", "names() -> String[]"),
("p/Since.java::Since::value", "method", "value() -> double"),
]
def test_own_field_receiver_is_captured(self, parser: ASTParser) -> None:
"""``this.field.m()`` must carry ``field``, not arrive receiver-less.
The bare-call pattern matches every invocation, so a shape no
receiver-carrying pattern claims reads as an implicit receiver on the
caller's own class and binds by bare name.
"""
fi = _make_file_info("java_pkg/Calculator.java", "java")
result = parser.parse_file(fi, FIELD_RECEIVER_SOURCE)
by_target = {c.target_name: c for c in result.calls if c.receiver_name}
assert by_target["findAll"].receiver_name == "owners"
assert by_target["record"].receiver_name == "audit"
def test_other_objects_field_is_not_a_receiver(self, parser: ASTParser) -> None:
"""Only a name in the caller's own scope may be captured.
``items`` in ``this.basket.items.size()`` is a field of ``Basket``, and
the receiver strategies type a field against the *caller's* class — so
capturing it would offer it to be bound to a same-named field of the
caller. ``Outer.this.m()`` is a real implicit receiver and keeps none.
"""
fi = _make_file_info("java_pkg/Calculator.java", "java")
result = parser.parse_file(fi, FIELD_RECEIVER_SOURCE)
for target in ("size", "reset"):
assert all(
c.receiver_name is None for c in result.calls if c.target_name == target
), target
TWIN_SOURCE = b"""package com.repowise.sample;
import static java.lang.Math.max;
public class Token extends Base {
private final TokenData data = new TokenData();
void data(String str) {
data.set(str);
this.reset();
reset();
super.reset();
max(1, 2);
set(data.set(str));
}
void reset() {
}
}
"""
class TestReceiverlessTwin:
"""The bare-call pattern leaves ``object`` unconstrained, so it also matches
``obj.m()``. That copy folds into the member call as its bare-name fallback;
a call with no receiver pattern is kept as it is."""
def _sites(self, parser: ASTParser, target: str) -> list[tuple[int, str | None]]:
fi = _make_file_info("java_pkg/Token.java", "java")
result = parser.parse_file(fi, TWIN_SOURCE)
return sorted(
((c.line, c.receiver_name) for c in result.calls if c.target_name == target),
key=lambda s: (s[0], s[1] or ""),
)
def test_a_member_call_arrives_once_with_its_receiver(self, parser: ASTParser) -> None:
assert (10, "data") in self._sites(parser, "set")
assert (10, None) not in self._sites(parser, "set")
assert (11, "this") in self._sites(parser, "reset")
assert (11, None) not in self._sites(parser, "reset")
assert (13, "super") in self._sites(parser, "reset")
assert (13, None) not in self._sites(parser, "reset")
fi = _make_file_info("java_pkg/Token.java", "java")
calls = parser.parse_file(fi, TWIN_SOURCE).calls
assert all(c.bare_name_fallback for c in calls if c.receiver_name)
assert not any(c.bare_name_fallback for c in calls if not c.receiver_name)
def test_genuine_receiverless_calls_are_kept(self, parser: ASTParser) -> None:
resets = self._sites(parser, "reset")
assert (12, None) in resets, "a bare reset()"
assert self._sites(parser, "max") == [(14, None)], "a static-imported call"
def test_a_bare_call_sharing_a_line_with_its_member_twin_is_kept(
self, parser: ASTParser
) -> None:
assert self._sites(parser, "set")[-2:] == [(15, None), (15, "data")]
def test_a_qualified_super_call_keeps_its_qualifier(parser: ASTParser) -> None:
"""``Sub.super.m()`` arrives as a ``super`` call scoped by ``Sub``, never as ``Sub.m()``."""
source = b"package b;\nclass Sub extends Base {\n class In { void q() { Sub.super.m(); } }\n}\n"
calls = parser.parse_file(_make_file_info("b/Sub.java", "java"), source).calls
assert [(c.receiver_name, c.scope_name, c.target_name) for c in calls] == [("super", "Sub", "m")]