376 lines
12 KiB
Python
376 lines
12 KiB
Python
from __future__ import annotations
|
|
|
|
import ast
|
|
import importlib.util
|
|
import json
|
|
from pathlib import Path
|
|
import tempfile
|
|
import unittest
|
|
|
|
|
|
SCRIPT = (
|
|
Path(__file__).resolve().parents[1]
|
|
/ "tools"
|
|
/ "inventory"
|
|
/ "platform-interface-inventory.py"
|
|
)
|
|
SPEC = importlib.util.spec_from_file_location("platform_interface_inventory", SCRIPT)
|
|
assert SPEC is not None and SPEC.loader is not None
|
|
inventory = importlib.util.module_from_spec(SPEC)
|
|
SPEC.loader.exec_module(inventory)
|
|
|
|
|
|
class PlatformInterfaceInventoryTests(unittest.TestCase):
|
|
def test_workspace_resolution_prefers_populated_checkout_siblings(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
root = Path(directory)
|
|
sibling = root / "checkout"
|
|
meta = sibling / "govoplan"
|
|
configured = root / "configured"
|
|
(sibling / "govoplan-core" / "src").mkdir(parents=True)
|
|
(configured / "govoplan-core").mkdir(parents=True)
|
|
previous = inventory.META_ROOT
|
|
inventory.META_ROOT = meta
|
|
try:
|
|
resolved = inventory._resolve_workspace_root(
|
|
{
|
|
"default_parent": str(configured),
|
|
"repositories": [{"path": "govoplan-core"}],
|
|
}
|
|
)
|
|
finally:
|
|
inventory.META_ROOT = previous
|
|
|
|
self.assertEqual(sibling.resolve(), resolved)
|
|
|
|
def test_canonical_api_path_normalizes_versions_and_parameters(self) -> None:
|
|
self.assertEqual(
|
|
inventory.canonical_api_path(
|
|
"http://localhost/api/v1/campaigns/${campaignId}?limit=10"
|
|
),
|
|
"/campaigns/{}",
|
|
)
|
|
self.assertEqual(
|
|
inventory.canonical_api_path("/api/v2/campaigns/{campaign_id}"),
|
|
"/campaigns/{}",
|
|
)
|
|
self.assertEqual(
|
|
inventory.canonical_api_path("/api/v1/calendar/events/delta${querySuffix}"),
|
|
"/calendar/events/delta",
|
|
)
|
|
self.assertEqual(
|
|
inventory.canonical_api_path("/api/v1/calendar/events/${eventId}"),
|
|
"/calendar/events/{}",
|
|
)
|
|
|
|
def test_endpoint_declarations_are_exact_and_require_missing_ui_issue(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path = Path(directory) / "endpoints.json"
|
|
path.write_text(
|
|
json.dumps(
|
|
{
|
|
"schema_version": 1,
|
|
"endpoints": [
|
|
{
|
|
"repository": "govoplan-example",
|
|
"method": "GET",
|
|
"path": "/example/items/{}",
|
|
"category": "public_integration",
|
|
"rationale": "Published integration API.",
|
|
}
|
|
],
|
|
}
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
|
|
declarations = inventory._load_endpoint_declarations(path)
|
|
|
|
self.assertIn(
|
|
("govoplan-example", "GET", "/example/items/{}"),
|
|
declarations,
|
|
)
|
|
payload = json.loads(path.read_text(encoding="utf-8"))
|
|
payload["endpoints"][0]["category"] = "missing_ui"
|
|
path.write_text(json.dumps(payload), encoding="utf-8")
|
|
with self.assertRaisesRegex(ValueError, "tracking_issue"):
|
|
inventory._load_endpoint_declarations(path)
|
|
|
|
def test_inventory_reports_unclassified_and_stale_endpoint_declarations(
|
|
self,
|
|
) -> None:
|
|
webui = {
|
|
"frontendApiReferences": [],
|
|
"translationUsages": [],
|
|
"translationCatalog": {"en": {}, "de": {}},
|
|
"fields": [],
|
|
"labels": [],
|
|
"visibleText": [],
|
|
"routes": [],
|
|
"navigation": [],
|
|
"uiCapabilities": [],
|
|
"dynamicTranslationUsages": [],
|
|
}
|
|
endpoint = {
|
|
"repository": "govoplan-example",
|
|
"method": "GET",
|
|
"path": "/api/v1/example/items",
|
|
"file": "src/example.py",
|
|
"line": 1,
|
|
"handler": "items",
|
|
"router": "router",
|
|
}
|
|
stale = {
|
|
"repository": "govoplan-example",
|
|
"method": "GET",
|
|
"path": "/example/removed",
|
|
"category": "removable",
|
|
"rationale": "Removal is pending.",
|
|
}
|
|
|
|
result = inventory._assemble_inventory(
|
|
webui=webui,
|
|
backend_endpoints=[endpoint],
|
|
manifests=[],
|
|
endpoint_declarations={
|
|
("govoplan-example", "GET", "/example/removed"): stale,
|
|
},
|
|
)
|
|
|
|
self.assertEqual(1, result["summary"]["unclassified_backend_endpoints"])
|
|
self.assertEqual(1, result["summary"]["stale_endpoint_declarations"])
|
|
self.assertIsNone(result["api"]["backend_endpoints"][0]["surface"])
|
|
|
|
def test_endpoint_only_strict_mode_does_not_fail_on_translation_debt(
|
|
self,
|
|
) -> None:
|
|
result = {
|
|
"translation_health": {"missing_catalog_entries": ["missing.key"]},
|
|
"api": {
|
|
"unclassified_endpoints": [],
|
|
"stale_endpoint_declarations": [],
|
|
},
|
|
}
|
|
|
|
self.assertEqual(
|
|
[],
|
|
inventory._strict_failures(
|
|
result,
|
|
check_translations=False,
|
|
check_endpoints=True,
|
|
),
|
|
)
|
|
self.assertEqual(
|
|
["used translation keys are missing from generated catalogs"],
|
|
inventory._strict_failures(
|
|
result,
|
|
check_translations=True,
|
|
check_endpoints=True,
|
|
),
|
|
)
|
|
|
|
def test_high_risk_help_baseline_is_validated(self) -> None:
|
|
with tempfile.TemporaryDirectory() as directory:
|
|
path = Path(directory) / "help-baseline.json"
|
|
path.write_text(
|
|
json.dumps(
|
|
{
|
|
"schema_version": 1,
|
|
"maximum_missing_exact_help": 3,
|
|
}
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
|
|
self.assertEqual(
|
|
3,
|
|
inventory._load_high_risk_help_baseline(path)[
|
|
"maximum_missing_exact_help"
|
|
],
|
|
)
|
|
path.write_text(
|
|
json.dumps(
|
|
{
|
|
"schema_version": 1,
|
|
"maximum_missing_exact_help": -1,
|
|
}
|
|
),
|
|
encoding="utf-8",
|
|
)
|
|
with self.assertRaisesRegex(ValueError, "non-negative integer"):
|
|
inventory._load_high_risk_help_baseline(path)
|
|
|
|
def test_declaration_strict_mode_rejects_high_risk_help_regression(
|
|
self,
|
|
) -> None:
|
|
result = {
|
|
"translation_health": {"missing_catalog_entries": []},
|
|
"api": {
|
|
"unclassified_endpoints": [],
|
|
"stale_endpoint_declarations": [],
|
|
},
|
|
"declaration_health": {},
|
|
"help_health": {
|
|
"invalid_risk_annotations": [],
|
|
"unresolved_exact_high_risk_help": [],
|
|
"high_risk_help_without_german": [],
|
|
"missing_exact_high_risk_help": [{"id": "example.delete"}],
|
|
"baseline_maximum_missing": 0,
|
|
"baseline_regression": True,
|
|
},
|
|
}
|
|
|
|
self.assertEqual(
|
|
[
|
|
"1 high-risk controls lack exact F1 help; baseline permits at most 0"
|
|
],
|
|
inventory._strict_failures(
|
|
result,
|
|
check_translations=False,
|
|
check_endpoints=False,
|
|
check_declarations=True,
|
|
),
|
|
)
|
|
|
|
def test_fastapi_route_scanner_includes_router_prefix(self) -> None:
|
|
tree = ast.parse(
|
|
"""
|
|
from fastapi import APIRouter
|
|
router = APIRouter(prefix="/api/v1/items")
|
|
|
|
@router.get("/{item_id}")
|
|
def read_item(item_id: str):
|
|
return item_id
|
|
"""
|
|
)
|
|
prefixes = inventory._router_prefixes(tree)
|
|
function = next(
|
|
node for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)
|
|
)
|
|
|
|
route = inventory._endpoint_from_decorator(
|
|
function.decorator_list[0],
|
|
prefixes=prefixes,
|
|
)
|
|
|
|
self.assertEqual(
|
|
route,
|
|
{
|
|
"method": "GET",
|
|
"path": "/api/v1/items/{item_id}",
|
|
"router": "router",
|
|
},
|
|
)
|
|
|
|
def test_source_declarations_normalize_stable_control_and_contribution_ids(
|
|
self,
|
|
) -> None:
|
|
webui = {
|
|
"fields": [
|
|
{
|
|
"repository": "govoplan-example",
|
|
"file": "webui/src/Example.tsx",
|
|
"line": 12,
|
|
"column": 3,
|
|
"id": "govoplan-example.field.example.name.abc123",
|
|
"idSource": "source_anchor",
|
|
"explicitId": None,
|
|
"context": "Example",
|
|
"helpId": "govoplan-example.field.example.name.abc123.help",
|
|
"helpDynamic": False,
|
|
}
|
|
],
|
|
"actions": [],
|
|
"contributions": [
|
|
{
|
|
"repository": "govoplan-example",
|
|
"file": "webui/src/module.ts",
|
|
"line": 20,
|
|
"column": 5,
|
|
"kind": "frontend_route",
|
|
"id": "/examples/:exampleId",
|
|
"path": "/examples/:exampleId",
|
|
}
|
|
],
|
|
"translationCatalog": {"en": {}, "de": {}},
|
|
}
|
|
manifests = [{"repository": "govoplan-example", "id": "examples"}]
|
|
|
|
declarations = inventory._source_interface_declarations(webui, manifests)
|
|
keys = {item["key"] for item in declarations}
|
|
|
|
self.assertIn("field:examples.field.example.name.abc123", keys)
|
|
self.assertIn(
|
|
"help:examples.field.example.name.abc123.help",
|
|
keys,
|
|
)
|
|
self.assertIn(
|
|
"frontend_route:examples.route.examples.exampleid",
|
|
keys,
|
|
)
|
|
|
|
def test_declaration_health_rejects_duplicate_and_undeclared_source_ids(
|
|
self,
|
|
) -> None:
|
|
declaration = {
|
|
"key": "frontend_route:example.route.unlisted",
|
|
"id": "example.route.unlisted",
|
|
"module_id": "example",
|
|
"kind": "frontend_route",
|
|
"origin": "webui_contribution",
|
|
}
|
|
manifests = [
|
|
{
|
|
"id": "example",
|
|
"repository": "govoplan-example",
|
|
"interface_catalog": {"declarations": []},
|
|
}
|
|
]
|
|
|
|
health = inventory._declaration_health(
|
|
[declaration, dict(declaration)],
|
|
manifests,
|
|
)
|
|
|
|
self.assertEqual(1, len(health["duplicate_ids"]))
|
|
self.assertEqual(1, len(health["undeclared_source_surfaces"]))
|
|
|
|
def test_runtime_snapshot_comparison_accepts_an_installed_subset(self) -> None:
|
|
manifests = [
|
|
{
|
|
"id": "one",
|
|
"interface_catalog": {
|
|
"contract_version": "1",
|
|
"module_id": "one",
|
|
"module_version": "1.0.0",
|
|
"digest": "sha256:one",
|
|
},
|
|
},
|
|
{
|
|
"id": "two",
|
|
"interface_catalog": {
|
|
"contract_version": "1",
|
|
"module_id": "two",
|
|
"module_version": "1.0.0",
|
|
"digest": "sha256:two",
|
|
},
|
|
},
|
|
]
|
|
snapshot = {
|
|
"contract_version": "1",
|
|
"modules": [dict(manifests[1]["interface_catalog"])],
|
|
}
|
|
|
|
comparison = inventory._compare_runtime_snapshot(snapshot, manifests)
|
|
|
|
self.assertEqual(["two"], comparison["matched_modules"])
|
|
self.assertEqual([], comparison["mismatches"])
|
|
|
|
snapshot["modules"][0]["digest"] = "sha256:changed"
|
|
comparison = inventory._compare_runtime_snapshot(snapshot, manifests)
|
|
self.assertEqual("digest_mismatch", comparison["mismatches"][0]["reason"])
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|