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
"""Tests for the breaking-change guard — diff rules, impact, negatives, IO.
The negative cases (added optional field, widened set, brand-new endpoint) are
the load-bearing ones: the guard must stay silent on non-breaking changes.
"""
from __future__ import annotations
from repowise.core.workspace.breaking_change import (
SEVERITY_BREAKING,
SEVERITY_WARNING,
BreakingChangeReport,
detect_breaking_changes,
load_breaking_change_report,
run_breaking_change_detection,
save_breaking_change_report,
)
from repowise.core.workspace.contract_schema import ContractSchema, SchemaField
from repowise.core.workspace.contracts import Contract, ContractLink, ContractStore
# ---------------------------------------------------------------------------
# Fixture builders
# ---------------------------------------------------------------------------
def _provider(cid, ctype="http", repo="api", file="src/handler.py", service=None, schema=None):
return Contract(
repo=repo,
contract_id=cid,
contract_type=ctype,
role="provider",
file_path=file,
symbol_name="handler",
confidence=0.9,
service=service,
schema=schema,
)
def _link(cid, ctype="http", c_repo="web", c_file="src/client.ts", c_service=None, match="exact"):
return ContractLink(
contract_id=cid,
contract_type=ctype,
match_type=match,
confidence=0.9,
provider_repo="api",
provider_file="src/handler.py",
provider_symbol="handler",
provider_service=None,
consumer_repo=c_repo,
consumer_file=c_file,
consumer_symbol="call",
consumer_service=c_service,
)
def _store(contracts=None, links=None):
return ContractStore(contracts=contracts or [], contract_links=links or [])
def _schema(request=None, response=None):
return ContractSchema(
source="proto", request_fields=request or [], response_fields=response or []
)
def test_schema_diff_reports_uncertainty_until_source_declares_comparison_ready():
before = ContractSchema(
source="openapi",
request_fields=[SchemaField("id", "string", required=True)],
comparison_ready=False,
)
after = ContractSchema(source="openapi", comparison_ready=False)
report = detect_breaking_changes(
_store([_provider("http::POST::/orders", schema=before)]),
_store([_provider("http::POST::/orders", schema=after)]),
)
assert _kinds(report) == ["schema_comparison_uncertain"]
assert report.changes[0].severity == SEVERITY_WARNING
def test_schema_diff_reports_uncertainty_for_mismatched_comparison_fidelity():
before = ContractSchema(
source="openapi",
comparison_key="openapi-wire-v1",
request_fields=[SchemaField("id", "string", required=True)],
)
after = ContractSchema(source="openapi", comparison_key="openapi-wire-v2")
report = detect_breaking_changes(
_store([_provider("http::POST::/orders", schema=before)]),
_store([_provider("http::POST::/orders", schema=after)]),
)
assert _kinds(report) == ["schema_comparison_uncertain"]
assert report.changes[0].comparison_key == "openapi-wire-v2"
def _kinds(report):
return sorted(c.kind for c in report.changes)
# ---------------------------------------------------------------------------
# Contract-level rule: removed endpoint
# ---------------------------------------------------------------------------
def test_removed_endpoint_with_consumer_is_breaking():
prev = _store([_provider("http::GET::/users")], [_link("http::GET::/users")])
report = detect_breaking_changes(prev, _store())
assert _kinds(report) == ["removed_endpoint"]
change = report.changes[0]
assert change.severity == SEVERITY_BREAKING
assert change.contract_type == "http"
assert [c.file for c in change.impacted_consumers] == ["src/client.ts"]
assert change.impacted_consumers[0].node_id == "web"
def test_removed_endpoint_without_consumer_still_flags_but_no_impact():
prev = _store([_provider("http::GET::/internal")]) # no links
report = detect_breaking_changes(prev, _store())
assert _kinds(report) == ["removed_endpoint"]
assert report.changes[0].impacted_consumers == []
def test_added_endpoint_does_not_flag():
curr = _store([_provider("http::GET::/new")], [_link("http::GET::/new")])
report = detect_breaking_changes(_store(), curr)
assert report.changes == []
def test_unchanged_endpoint_does_not_flag():
store = _store([_provider("http::GET::/users")], [_link("http::GET::/users")])
# Distinct objects, same content.
other = _store([_provider("http::GET::/users")], [_link("http::GET::/users")])
report = detect_breaking_changes(store, other)
assert report.changes == []
def test_grpc_removed_method_is_breaking():
prev = _store(
[_provider("grpc::auth.AuthService/Login", ctype="grpc")],
[_link("grpc::auth.AuthService/Login", ctype="grpc")],
)
report = detect_breaking_changes(prev, _store())
assert _kinds(report) == ["removed_endpoint"]
# ---------------------------------------------------------------------------
# Field-level rules
# ---------------------------------------------------------------------------
def test_added_optional_field_does_not_flag():
prev_s = _schema(request=[SchemaField("a", "string", number=1)])
curr_s = _schema(
request=[SchemaField("a", "string", number=1), SchemaField("b", "int32", number=2)]
)
prev = _store([_provider("grpc::S/M", "grpc", schema=prev_s)])
curr = _store([_provider("grpc::S/M", "grpc", schema=curr_s)])
report = detect_breaking_changes(prev, curr)
assert report.changes == []
def test_added_required_field_is_breaking():
prev_s = _schema(request=[SchemaField("a", "string", number=1)])
curr_s = _schema(
request=[
SchemaField("a", "string", number=1),
SchemaField("b", "int32", number=2, required=True),
]
)
report = detect_breaking_changes(
_store([_provider("grpc::S/M", "grpc", schema=prev_s)]),
_store([_provider("grpc::S/M", "grpc", schema=curr_s)]),
)
assert _kinds(report) == ["field_required"]
assert report.changes[0].field_name == "b"
assert report.changes[0].severity == SEVERITY_BREAKING
def test_optional_to_required_is_breaking():
prev_s = _schema(request=[SchemaField("a", "string", number=1)])
curr_s = _schema(request=[SchemaField("a", "string", number=1, required=True)])
report = detect_breaking_changes(
_store([_provider("grpc::S/M", "grpc", schema=prev_s)]),
_store([_provider("grpc::S/M", "grpc", schema=curr_s)]),
)
assert _kinds(report) == ["field_required"]
def test_removed_response_field_is_breaking_request_field_is_warning():
prev_s = _schema(
request=[SchemaField("a", "string", number=1)],
response=[SchemaField("r", "string", number=1)],
)
curr_s = _schema(request=[], response=[])
report = detect_breaking_changes(
_store([_provider("grpc::S/M", "grpc", schema=prev_s)]),
_store([_provider("grpc::S/M", "grpc", schema=curr_s)]),
)
by_sev = {c.severity for c in report.changes}
assert _kinds(report) == ["removed_field", "removed_field"]
assert by_sev == {SEVERITY_BREAKING, SEVERITY_WARNING}
def test_field_type_change_is_breaking():
prev_s = _schema(request=[SchemaField("a", "string", number=1)])
curr_s = _schema(request=[SchemaField("a", "int64", number=1)])
report = detect_breaking_changes(
_store([_provider("grpc::S/M", "grpc", schema=prev_s)]),
_store([_provider("grpc::S/M", "grpc", schema=curr_s)]),
)
assert _kinds(report) == ["field_type_changed"]
assert report.changes[0].old_value == "string"
assert report.changes[0].new_value == "int64"
def test_field_number_change_is_breaking():
prev_s = _schema(request=[SchemaField("a", "string", number=1)])
curr_s = _schema(request=[SchemaField("a", "string", number=7)])
report = detect_breaking_changes(
_store([_provider("grpc::S/M", "grpc", schema=prev_s)]),
_store([_provider("grpc::S/M", "grpc", schema=curr_s)]),
)
assert _kinds(report) == ["field_number_changed"]
def test_no_schema_means_no_field_rules():
# Both sides present but neither carries a schema → only contract-level rules.
prev = _store([_provider("http::GET::/users")], [_link("http::GET::/users")])
curr = _store([_provider("http::GET::/users")], [_link("http::GET::/users")])
report = detect_breaking_changes(prev, curr)
assert report.changes == []
# ---------------------------------------------------------------------------
# Impact resolution + rollups
# ---------------------------------------------------------------------------
def test_impact_resolves_service_node_id_from_consumer_service():
prev = _store(
[_provider("http::GET::/users")],
[
_link(
"http::GET::/users", c_repo="web", c_file="apps/store/c.ts", c_service="apps/store"
)
],
)
report = detect_breaking_changes(prev, _store())
consumer = report.changes[0].impacted_consumers[0]
assert consumer.node_id == "web::apps/store"
assert consumer.service == "apps/store"
def test_report_rollups_count_breaking_and_impact():
prev = _store(
[_provider("http::GET::/a"), _provider("http::GET::/b")],
[_link("http::GET::/a", c_repo="web"), _link("http::GET::/b", c_repo="mobile")],
)
report = detect_breaking_changes(prev, _store())
d = report.to_dict()
assert d["total"] == 2
assert d["breaking_count"] == 2
assert d["warning_count"] == 0
assert d["impacted_repos"] == ["mobile", "web"]
assert d["total_impacted_consumers"] == 2
def test_changes_sorted_breaking_before_warning():
prev_s = _schema(
request=[SchemaField("req", "string", number=1)],
response=[SchemaField("res", "string", number=1)],
)
curr_s = _schema(request=[], response=[]) # removed both → 1 warning + 1 breaking
report = detect_breaking_changes(
_store([_provider("grpc::S/M", "grpc", schema=prev_s)]),
_store([_provider("grpc::S/M", "grpc", schema=curr_s)]),
)
assert report.changes[0].severity == SEVERITY_BREAKING
assert report.changes[-1].severity == SEVERITY_WARNING
def test_empty_stores_produce_empty_report():
report = detect_breaking_changes(_store(), _store())
assert not report.has_changes
assert report.to_dict()["total"] == 0
# ---------------------------------------------------------------------------
# Persistence
# ---------------------------------------------------------------------------
def test_report_round_trips_through_dict():
prev = _store([_provider("http::GET::/users")], [_link("http::GET::/users")])
report = detect_breaking_changes(prev, _store(), generated_at="2026-06-19T00:00:00Z")
restored = BreakingChangeReport.from_dict(report.to_dict())
assert restored.generated_at == "2026-06-19T00:00:00Z"
assert _kinds(restored) == _kinds(report)
assert restored.changes[0].impacted_consumers[0].node_id == "web"
assert restored.changes[0].provider_node_id == "api"
def test_comparison_evidence_round_trips_through_report() -> None:
change = BreakingChangeReport.from_dict(
{
"changes": [
{
"kind": "field_enum_changed",
"severity": "breaking",
"contract_id": "http::POST::/orders",
"contract_type": "http",
"provider_repo": "api",
"provider_file": "openapi.yaml",
"provider_symbol": "openapi:POST /orders",
"provider_service": None,
"detail": "request enum narrowed",
"side": "request",
"comparison_source": "openapi",
"comparison_key": "openapi-wire-v1",
}
]
}
).to_dict()["changes"][0]
assert change["side"] == "request"
assert change["comparison_source"] == "openapi"
assert change["comparison_key"] == "openapi-wire-v1"
def test_save_and_load_report(tmp_path):
prev = _store([_provider("http::GET::/users")], [_link("http::GET::/users")])
run_breaking_change_detection(tmp_path, prev, _store())
assert (tmp_path / ".repowise-workspace" / "breaking_changes.json").is_file()
loaded = load_breaking_change_report(tmp_path)
assert loaded is not None
assert _kinds(loaded) == ["removed_endpoint"]
def test_load_missing_report_returns_none(tmp_path):
assert load_breaking_change_report(tmp_path) is None
def test_save_returns_path(tmp_path):
out = save_breaking_change_report(BreakingChangeReport(), tmp_path)
assert out.name == "breaking_changes.json"
# ---------------------------------------------------------------------------
# Never-ran vs found-nothing
# ---------------------------------------------------------------------------
def test_detection_stamps_its_own_report():
"""Before this, run_breaking_change_detection never passed a timestamp, so
every persisted report claimed to have never run."""
report = detect_breaking_changes(ContractStore(), ContractStore())
assert report.ran
assert report.to_dict()["generated_at"]
def test_an_unbuilt_report_is_not_a_clean_one():
report = BreakingChangeReport()
assert not report.ran
assert report.generated_at is None
assert not report.has_changes
assert report.to_dict()["generated_at"] is None
def test_legacy_empty_string_stamp_reads_as_never_ran():
restored = BreakingChangeReport.from_dict({"generated_at": "", "changes": []})
assert restored.generated_at is None
assert not restored.ran