Publish curated ITWorx-ModelForge source from 990401737f96c8d46a9f7b0d84994516cadcb6a0

backend/tests/test_project_registry.py

@@ -1,4 +1,5 @@
-from sqlalchemy import create_engine
+import pytest
+from sqlalchemy import create_engine, select
 from sqlalchemy.orm import Session
 
 from modelforge_api.persistence.models import (
@@ -16,28 +17,120 @@ def test_project_registry_materializes_only_real_contracts_and_is_idempotent() -
     engine = create_engine("sqlite+pysqlite:///:memory:")
     Base.metadata.create_all(engine)
     with Session(engine) as session:
-        capability = Capability(key="rag.embedding", description="test")
-        session.add(capability)
-        session.flush()
-        session.add(
-            CapabilityContract(
-                capability_id=capability.id,
-                version=1,
-                input_schema={},
-                output_schema={},
-                contract={},
-                upgrade_class="requires_reindex",
+        manifests = ManifestRegistry()
+        enabled_capabilities = {"rag.embedding", "rag.reranking", "vision.embedding"}
+        for manifest in manifests.capabilities():
+            if manifest.capability not in enabled_capabilities:
+                continue
+            capability = Capability(key=manifest.capability, description=manifest.description)
+            session.add(capability)
+            session.flush()
+            session.add(
+                CapabilityContract(
+                    capability_id=capability.id,
+                    version=manifest.version,
+                    input_schema=manifest.input_schema,
+                    output_schema=manifest.output_schema,
+                    contract=manifest.model_dump(mode="json"),
+                    upgrade_class=manifest.upgrade_class.value,
+                )
             )
-        )
         session.commit()
 
-        first = sync_project_registry(session, ManifestRegistry())
-        second = sync_project_registry(session, ManifestRegistry())
+        first = sync_project_registry(session, manifests)
+        second = sync_project_registry(session, manifests)
 
         assert first.projects_created == 3
-        assert first.bindings_created == 1
+        assert first.bindings_created == 3
         assert first.unavailable_contracts
         assert second.projects_created == 0
         assert second.bindings_created == 0
         assert session.query(Project).count() == 3
-        assert session.query(ProjectBinding).count() == 1
+        bindings = session.execute(
+            select(Project.key, Capability.key)
+            .join(ProjectBinding, ProjectBinding.project_id == Project.id)
+            .join(
+                CapabilityContract,
+                CapabilityContract.id == ProjectBinding.capability_contract_id,
+            )
+            .join(Capability, Capability.id == CapabilityContract.capability_id)
+        ).all()
+        assert set(bindings) == {
+            ("examplerag", "rag.embedding"),
+            ("examplerag", "rag.reranking"),
+            ("examplevision", "vision.embedding"),
+        }
+
+
+@pytest.mark.parametrize("declared_stability", ["planned", "blocked"])
+def test_project_registry_skips_unavailable_capabilities_and_preserves_operator_bindings(
+    declared_stability: str, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    engine = create_engine("sqlite+pysqlite:///:memory:")
+    Base.metadata.create_all(engine)
+    with Session(engine) as session:
+        manifests = ManifestRegistry()
+        capability_manifest = next(
+            item
+            for item in manifests.capabilities()
+            if item.capability == "assistant.general" and item.version == 1
+        )
+        project_manifest = next(
+            item for item in manifests.projects() if item.project.id == "example-ops"
+        )
+        capability_manifest = capability_manifest.model_copy(
+            update={
+                "estate": capability_manifest.estate.model_copy(
+                    update={"stability": declared_stability}
+                )
+            }
+        )
+        monkeypatch.setattr(manifests, "capabilities", lambda: [capability_manifest])
+        monkeypatch.setattr(manifests, "projects", lambda: [project_manifest])
+
+        capability = Capability(
+            key=capability_manifest.capability, description=capability_manifest.description
+        )
+        session.add(capability)
+        session.flush()
+        contract = CapabilityContract(
+            capability_id=capability.id,
+            version=capability_manifest.version,
+            input_schema=capability_manifest.input_schema,
+            output_schema=capability_manifest.output_schema,
+            contract=capability_manifest.model_dump(mode="json"),
+            upgrade_class=capability_manifest.upgrade_class.value,
+        )
+        session.add(contract)
+        session.commit()
+
+        first = sync_project_registry(session, manifests)
+
+        assert first.bindings_created == 0
+        assert session.scalar(select(ProjectBinding.id)) is None
+        assert [
+            (
+                item.project_key,
+                item.capability,
+                item.contract_version,
+                item.declared_stability,
+            )
+            for item in first.unavailable_bindings
+        ] == [("example-ops", "assistant.general", 1, declared_stability)]
+
+        project = session.scalar(select(Project).where(Project.key == "example-ops"))
+        assert project is not None
+        operator_binding = ProjectBinding(
+            project_id=project.id,
+            capability_contract_id=contract.id,
+            channel="stable",
+            priority="interactive",
+        )
+        session.add(operator_binding)
+        session.commit()
+        operator_binding_id = operator_binding.id
+
+        second = sync_project_registry(session, manifests)
+
+        assert second.bindings_created == 0
+        assert session.scalar(select(ProjectBinding.id)) == operator_binding_id