govoplan-ops/tests/test_governance_inventory.py

from __future__ import annotations

import unittest

from govoplan_core.core.modules import (
    CapabilityDocumentation,
    DocumentationTopic,
    MigrationSpec,
    ModuleManifest,
    PermissionDefinition,
    RoleTemplate,
)
from govoplan_core.core.registry import PlatformRegistry
from govoplan_core.core.provider_governance import (
    ExternalProviderDeclaration,
    ModuleArchitectureDeclaration,
    ModuleArchitectureDocumentation,
    ModuleMaturityEvidence,
    ProviderBehaviorDeclaration,
    ProviderObjectDeclaration,
)

from govoplan_ops.backend.api.v1.routes import _governance_inventory


class GovernanceInventoryTests(unittest.TestCase):
    def test_inventory_projects_manifest_governance_without_provider_internals(self) -> None:
        registry = PlatformRegistry()
        registry.register(ModuleManifest(
            id="example",
            name="Example",
            version="1.2.3",
            permissions=(
                PermissionDefinition(
                    scope="example:item:read",
                    label="Read examples",
                    description="Read example records.",
                    category="Examples",
                    level="tenant",
                    module_id="example",
                    resource="item",
                    action="read",
                ),
            ),
            role_templates=(
                RoleTemplate(
                    slug="example_reader",
                    name="Example reader",
                    description="Reads examples.",
                    permissions=("example:item:read",),
                ),
            ),
            capability_factories={
                "example.lookup": lambda _context: object(),
                "policy.example": lambda _context: object(),
            },
            capability_documentation={
                "example.lookup": CapabilityDocumentation(
                    label="Example lookup",
                    summary="Resolves examples.",
                ),
            },
            documentation=(
                DocumentationTopic(
                    id="example.reference",
                    title="Example reference",
                    summary="Documents the example module.",
                ),
            ),
            migration_spec=MigrationSpec(module_id="example"),
            architecture=ModuleArchitectureDeclaration(
                layer="governance_accountability",
                kind="governance",
                maturity="vertical_slice",
                evidence=(
                    ModuleMaturityEvidence(
                        kind="test",
                        reference="tests/test_governance_inventory.py",
                        summary="Exercises the governance projection.",
                    ),
                    ModuleMaturityEvidence(
                        kind="documentation",
                        reference="example.reference",
                        summary="Documents the example provider.",
                    ),
                ),
                known_limits=("The example has no runtime implementation.",),
                supported_authority_modes=("external_mirror",),
                owned_concepts=("example projections",),
                documentation=ModuleArchitectureDocumentation(
                    operations=("example.reference",),
                ),
            ),
            external_providers=(
                ExternalProviderDeclaration(
                    id="example.read",
                    module_id="example",
                    label="Example reader",
                    maturity="read",
                    operations=("read", "search"),
                    objects=(
                        ProviderObjectDeclaration(
                            object_type="example.record",
                            field_groups=("identity", "summary"),
                            authority_modes=("external_mirror",),
                            default_authority_mode="external_mirror",
                        ),
                    ),
                    behavior=ProviderBehaviorDeclaration(
                        freshness="Request-time read with a five-minute cache.",
                        health="Reported through example.health.",
                        max_read_items=100,
                        outage="Reads fail closed and retain the last inspected snapshot.",
                        classifications=("internal",),
                        purposes=("operations",),
                        retention="No provider-owned payload is retained.",
                    ),
                    documentation_topic_ids=("example.reference",),
                ),
            ),
        ))

        payload = _governance_inventory(
            registry,
            external_provider_states={
                "example.read": {
                    "configured": True,
                    "active": True,
                    "health": "warning",
                    "freshness": "stale",
                    "recovery": "attention",
                }
            },
        )

        self.assertEqual(payload["summary"]["module_count"], 1)
        self.assertEqual(payload["summary"]["permission_count"], 1)
        self.assertEqual(payload["summary"]["role_template_count"], 1)
        self.assertEqual(payload["summary"]["capability_count"], 2)
        self.assertEqual(payload["summary"]["policy_count"], 1)
        self.assertEqual(payload["summary"]["documented_module_count"], 1)
        self.assertEqual(payload["summary"]["migration_module_count"], 1)
        self.assertEqual(payload["summary"]["architecture_declared_module_count"], 1)
        self.assertEqual(payload["summary"]["external_provider_count"], 1)
        self.assertEqual(
            payload["summary"]["configured_external_provider_count"],
            1,
        )
        self.assertEqual(payload["summary"]["provider_attention_count"], 1)
        self.assertEqual(payload["modules"][0]["architecture"]["maturity"], "vertical_slice")
        self.assertEqual(payload["modules"][0]["external_providers"][0]["id"], "example.read")
        self.assertEqual(
            payload["modules"][0]["external_providers"][0]["runtime_state"][
                "freshness"
            ],
            "stale",
        )
        self.assertEqual(payload["modules"][0]["module_id"], "example")
        self.assertNotIn("capability_factories", payload["modules"][0])
        self.assertFalse(any(
            callable(value)
            for value in payload["modules"][0].values()
        ))


if __name__ == "__main__":
    unittest.main()