markitect-tool/tests/test_builtin_extension_catalog.py

from markitect_tool.extension import builtin_extension_registry


def test_builtin_extension_registry_lists_query_processors_and_backend():
    registry = builtin_extension_registry()

    ids = [descriptor.id for descriptor in registry.list()]

    assert "query.selector" not in ids
    assert "selector" in ids
    assert "jsonpath" in ids
    assert "processor.identity" in ids
    assert "processor.uppercase" in ids
    assert "processor.include" in ids
    assert "extension.catalog" in ids
    assert "docs.generated-reference" in ids
    assert "backend.local-sqlite" in ids
    assert "workflow.markdown-dataflow" in ids
    assert "runtime.context" in ids
    assert "runtime.form-state" in ids
    assert "runtime.assessment" in ids
    assert "policy.local-label" in ids
    assert "document.function" in ids
    assert "memory.graph-contract" in ids
    assert "memory.runtime-adapter-boundary" in ids
    assert "memory.context-package" in ids
    assert "render.export-registry" in ids
    assert "render.reference-manifest" in ids
    assert "render.fake" in ids
    assert "source.adapter-registry" in ids


def test_builtin_meta_descriptors_expose_extension_and_docs_accesspoints():
    registry = builtin_extension_registry()

    extension = registry.get("extension.catalog")
    docs = registry.get("docs.generated-reference")

    assert extension.kind == "extension-registry"
    assert "mkt extension commands" in extension.cli["commands"]
    assert docs.kind == "documentation"
    assert docs.safety["writes_files"] is True
    assert docs.cli["commands"] == ["mkt docs cli", "mkt docs api"]


def test_builtin_processor_descriptors_capture_safety_and_provenance():
    registry = builtin_extension_registry()

    include = registry.get("processor.include")
    uppercase = registry.get("processor.uppercase")

    assert include.kind == "processor"
    assert include.safety["reads_files"] is True
    assert include.provenance_prefix == "processor.include"
    assert uppercase.safety == {}
    assert uppercase.provenance_prefix == "processor.uppercase"


def test_builtin_local_sqlite_descriptor_exposes_backend_capabilities():
    registry = builtin_extension_registry()

    descriptor = registry.get("backend.local-sqlite")

    assert descriptor.kind == "backend"
    assert {capability.id for capability in descriptor.capabilities} >= {
        "snapshots",
        "ast",
        "json",
        "fts",
        "sql",
        "provenance",
    }
    assert descriptor.cli["commands"] == [
        "mkt cache init",
        "mkt cache index",
        "mkt cache query",
        "mkt search",
    ]


def test_builtin_workflow_descriptor_exposes_cli_and_safety():
    registry = builtin_extension_registry()

    descriptor = registry.get("workflow.markdown-dataflow")

    assert descriptor.kind == "workflow-engine"
    assert descriptor.safety["writes_output_files"] is True
    assert descriptor.safety["assisted_generation"] == "adapter-only"
    assert descriptor.cli["commands"] == [
        "mkt workflow inspect",
        "mkt workflow plan",
        "mkt workflow run",
    ]


def test_builtin_runtime_descriptors_expose_boundaries():
    registry = builtin_extension_registry()

    context = registry.get("runtime.context")
    form_state = registry.get("runtime.form-state")
    assessment = registry.get("runtime.assessment")

    assert context.safety["reads_files"] is True
    assert "mkt contract check --context" in context.cli["commands"]
    assert {capability.id for capability in form_state.capabilities} >= {"forms", "rules"}
    assert assessment.kind == "assessment-runner"
    assert assessment.safety["provider_calls"] == "adapter-only"


def test_builtin_policy_descriptor_exposes_cli_and_adapter_boundary():
    registry = builtin_extension_registry()

    descriptor = registry.get("policy.local-label")

    assert descriptor.kind == "policy-gateway"
    assert descriptor.safety["network"] is False
    assert {capability.id for capability in descriptor.capabilities} >= {
        "policy",
        "policy_filter",
        "identity_claims",
        "resource_manifest",
        "decision_log",
    }
    assert "mkt policy check" in descriptor.cli["commands"]
    assert "mkt policy subject" in descriptor.cli["commands"]
    assert "mkt policy resource-manifest" in descriptor.cli["commands"]
    assert "IdentityClaimsAdapter" in descriptor.metadata["external_adapters"]
    assert "RelationshipPolicyAdapter" in descriptor.metadata["external_adapters"]


def test_builtin_document_function_descriptor_exposes_deterministic_boundary():
    registry = builtin_extension_registry()

    descriptor = registry.get("document.function")

    assert descriptor.kind == "document-function"
    assert descriptor.safety["network"] is False
    assert descriptor.metadata["external_policy_services_required"] is False
    assert descriptor.metadata["typed_values"] is True
    assert "table" in descriptor.metadata["value_kinds"]
    assert descriptor.metadata["render_export_execution"] is False
    assert {capability.id for capability in descriptor.capabilities} >= {
        "document_function",
        "deterministic",
    }
    assert descriptor.cli["commands"] == [
        "mkt function list",
        "mkt function check",
        "mkt function render",
    ]


def test_builtin_memory_descriptor_exposes_local_optional_boundary():
    registry = builtin_extension_registry()

    descriptor = registry.get("memory.context-package")

    assert descriptor.kind == "memory-registry"
    assert descriptor.safety["network"] is False
    assert descriptor.safety["writes_local_context_registry"] is True
    assert descriptor.metadata["external_policy_services_required"] is False
    assert {capability.id for capability in descriptor.capabilities} >= {
        "context_packages",
        "context_activation",
        "policy_filter",
    }
    assert "mkt context pack" in descriptor.cli["commands"]
    assert "mkt context activate" in descriptor.cli["commands"]


def test_builtin_memory_graph_descriptor_exposes_runtime_handoff_boundaries():
    registry = builtin_extension_registry()

    graph = registry.get("memory.graph-contract")
    adapters = registry.get("memory.runtime-adapter-boundary")

    assert graph.kind == "memory-contract"
    assert graph.safety["external_memory_services"] is False
    assert "mkt memory graph pack" in graph.cli["commands"]
    assert "examples/memory/conversation-path.yaml" in graph.examples
    assert "examples/memory/knowledge-neighborhood.yaml" in graph.examples
    assert "memory.runtime.kontextual-engine" in graph.metadata["runtime_adapter_boundaries"]
    assert "memory.audit.sink" in graph.metadata["runtime_adapter_boundaries"]
    assert adapters.kind == "memory-runtime-adapter"
    assert adapters.safety["runtime_execution"] is False
    assert adapters.metadata["services_launched_by_markitect_tool"] is False
    assert "examples/memory/runtime-adapter-boundaries.yaml" in adapters.examples


def test_builtin_render_export_descriptors_expose_contract_boundary():
    registry = builtin_extension_registry()

    registry_descriptor = registry.get("render.export-registry")
    reference_manifest = registry.get("render.reference-manifest")
    fake = registry.get("render.fake")

    assert registry_descriptor.kind == "render-export-registry"
    assert registry_descriptor.safety["external_process"] is False
    assert registry_descriptor.metadata["concrete_renderer_execution_required"] is False
    assert reference_manifest.kind == "render-reference-contract"
    assert reference_manifest.safety["asset_copying"] is False
    assert reference_manifest.safety["final_numbering"] is False
    assert reference_manifest.metadata["core_performs_asset_copying"] is False
    assert fake.kind == "render-export"
    assert fake.safety["external_process"] is False
    assert fake.safety["filesystem_write"] is False
    assert fake.metadata["render_export_adapter"]["metadata"]["quarkdown_dependency"] is False