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 ContractConfig and ManualContractLink in workspace config."""
from __future__ import annotations
from repowise.core.workspace.config import (
ContractConfig,
ManualContractLink,
RepoEntry,
WorkspaceConfig,
)
class TestContractConfig:
def test_default_values(self) -> None:
cfg = ContractConfig()
assert cfg.detect_http is True
assert cfg.detect_grpc is True
assert cfg.detect_socket is True
assert cfg.detect_topics is True
assert cfg.manual_links == []
def test_from_dict_partial_overrides(self) -> None:
cfg = ContractConfig.from_dict({"detect_http": False})
assert cfg.detect_http is False
assert cfg.detect_grpc is True
assert cfg.detect_socket is True
assert cfg.detect_topics is True
def test_round_trip(self) -> None:
cfg = ContractConfig(
detect_http=True,
detect_grpc=False,
detect_socket=True,
detect_topics=True,
manual_links=[
ManualContractLink(
from_repo="worker",
to_repo="api",
contract_type="http",
contract_id="http::GET::/api/jobs",
from_role="consumer",
),
],
)
d = cfg.to_dict()
loaded = ContractConfig.from_dict(d)
assert loaded.detect_grpc is False
assert len(loaded.manual_links) == 1
assert loaded.manual_links[0].from_repo == "worker"
class TestManualContractLink:
def test_from_dict(self) -> None:
data = {
"from_repo": "frontend",
"to_repo": "backend",
"contract_type": "http",
"contract_id": "http::POST::/api/auth",
"from_role": "consumer",
}
ml = ManualContractLink.from_dict(data)
assert ml.from_repo == "frontend"
assert ml.to_repo == "backend"
assert ml.from_role == "consumer"
def test_default_role(self) -> None:
ml = ManualContractLink.from_dict({
"from_repo": "a",
"to_repo": "b",
"contract_type": "topic",
"contract_id": "topic::events",
})
assert ml.from_role == "consumer"
def test_round_trip(self) -> None:
ml = ManualContractLink(
from_repo="a", to_repo="b",
contract_type="grpc", contract_id="grpc::Auth/*",
from_role="provider",
)
loaded = ManualContractLink.from_dict(ml.to_dict())
assert loaded.from_repo == "a"
assert loaded.from_role == "provider"
class TestWorkspaceConfigWithContracts:
def test_from_dict_no_contracts_key(self) -> None:
data = {
"version": 1,
"repos": [{"path": "api", "alias": "api"}],
"default_repo": "api",
}
cfg = WorkspaceConfig.from_dict(data)
assert cfg.contracts.detect_http is True
assert cfg.contracts.detect_grpc is True
def test_from_dict_with_contracts(self) -> None:
data = {
"version": 1,
"repos": [{"path": "api", "alias": "api"}],
"default_repo": "api",
"contracts": {
"detect_http": True,
"detect_grpc": False,
"detect_socket": False,
"detect_topics": True,
},
}
cfg = WorkspaceConfig.from_dict(data)
assert cfg.contracts.detect_grpc is False
assert cfg.contracts.detect_socket is False
def test_round_trip_with_manual_links(self, tmp_path) -> None:
cfg = WorkspaceConfig(
version=1,
repos=[RepoEntry(path="api", alias="api")],
default_repo="api",
contracts=ContractConfig(
detect_http=True,
detect_grpc=True,
detect_socket=False,
detect_topics=False,
manual_links=[
ManualContractLink(
from_repo="worker",
to_repo="api",
contract_type="http",
contract_id="http::GET::/jobs",
),
],
),
)
cfg.save(tmp_path)
loaded = WorkspaceConfig.load(tmp_path)
assert loaded.contracts.detect_socket is False
assert loaded.contracts.detect_topics is False
assert len(loaded.contracts.manual_links) == 1
assert loaded.contracts.manual_links[0].contract_id == "http::GET::/jobs"
class TestContractProjectPattern:
def test_default_is_omitted_from_the_dict(self) -> None:
assert "contract_project_pattern" not in ContractConfig().to_dict()
def test_round_trip(self) -> None:
cfg = ContractConfig(contract_project_pattern=r".+\.messages")
loaded = ContractConfig.from_dict(cfg.to_dict())
assert loaded.contract_project_pattern == r".+\.messages"
def test_pattern_changes_the_fingerprinted_dict(self) -> None:
changed = ContractConfig(contract_project_pattern="messages")
assert ContractConfig().to_dict() != changed.to_dict()
def test_invalid_regex_falls_back_to_the_default(self) -> None:
cfg = ContractConfig.from_dict({"contract_project_pattern": "(unclosed"})
assert cfg.contract_project_pattern == ContractConfig().contract_project_pattern
class TestSettingStages:
"""Each contract setting says whether it feeds extraction or only matching."""
def test_every_setting_declares_its_stage(self) -> None:
from dataclasses import fields
from repowise.core.workspace.config import STAGE_EXTRACTION, STAGE_MATCHING
undeclared = [
f.name
for f in fields(ContractConfig)
if f.metadata.get("stage") not in {STAGE_EXTRACTION, STAGE_MATCHING}
]
assert undeclared == []
def test_matching_settings_stay_out_of_the_extraction_half(self) -> None:
from repowise.core.workspace.config import STAGE_EXTRACTION, STAGE_MATCHING
cfg = ContractConfig(
service_bases={"API_BASE": "api"},
manual_links=[ManualContractLink("a", "b", "http", "http::GET::/x")],
)
assert cfg.stage_dict(STAGE_EXTRACTION) == ContractConfig().to_dict()
assert set(cfg.stage_dict(STAGE_MATCHING)) == {"service_bases", "manual_links"}
def test_a_lone_non_default_setting_survives_save(self, tmp_path) -> None:
ws = WorkspaceConfig(
repos=[RepoEntry(path="a", alias="a")],
contracts=ContractConfig(detect_code_api=False),
)
ws.save(tmp_path)
assert WorkspaceConfig.load(tmp_path).contracts.detect_code_api is False
def test_analysis_fingerprint_follows_settings_not_repos(self) -> None:
base = WorkspaceConfig(repos=[RepoEntry(path="a", alias="a")])
moved = WorkspaceConfig(repos=[RepoEntry(path="a", alias="a", last_commit_at_index="f00")])
edited = WorkspaceConfig(
repos=[RepoEntry(path="a", alias="a")],
contracts=ContractConfig(service_bases={"API_BASE": "a"}),
)
assert base.analysis_fingerprint() == moved.analysis_fingerprint()
assert base.analysis_fingerprint() != edited.analysis_fingerprint()
def test_analysis_fingerprint_follows_declared_groups_only(self) -> None:
import hashlib
import json
def ws(*tags: str) -> WorkspaceConfig:
return WorkspaceConfig(repos=[RepoEntry(path="a", alias="a", tags=list(tags))])
base = ws()
# Without a group tag the payload is the one stamped before groups
# counted, so existing stamps (conformance tags included) stay valid.
old = [base.contracts.to_dict(), base.conformance.to_dict()]
expected = hashlib.sha256(json.dumps(old, sort_keys=True).encode()).hexdigest()[:16]
assert base.analysis_fingerprint() == expected
assert ws("backend", "team:x").analysis_fingerprint() == expected
assert ws("group:core").analysis_fingerprint() != expected
assert ws("backend", "group:core").analysis_fingerprint() == ws(
"group:core", "python"
).analysis_fingerprint()
assert ws("group:core").analysis_fingerprint() != ws("group:edge").analysis_fingerprint()