rewrite phase 1

2026-07-22 23:10:23 +02:00
parent 7527831af6
commit 98ac4abca1
89 changed files with 9179 additions and 2795 deletions
@@ -1,4 +1,6 @@
-from agentci.adapters.opencode_support import api_contract_ready, models_ready
+import pytest
+
+from agentci.opencode import api_contract_ready, models_ready


 def test_api_contract_requires_session_message_and_abort_routes() -> None:
@@ -17,7 +19,124 @@ def test_api_contract_requires_session_message_and_abort_routes() -> None:
    assert not api_contract_ready(valid)


-def test_model_readiness_requires_tools_and_configured_variant() -> None:
+@pytest.mark.parametrize(
+    "document",
+    [
+        None,
+        [],
+        {},
+        {"paths": []},
+        {
+            "paths": {
+                "/global/health": None,
+                "/provider": {"get": {}},
+                "/session": {"post": {}},
+            }
+        },
+        {
+            "paths": {
+                "/global/health": {"get": {}},
+                "/provider": {"get": {}},
+                "/session": {"post": {}},
+                7: {"post": {}},
+            }
+        },
+    ],
+)
+def test_api_contract_rejects_malformed_documents(document: object) -> None:
+    assert not api_contract_ready(document)
+
+
+def provider_payload(
+    *,
+    connected: object = None,
+    status: str = "active",
+    toolcall: object = True,
+    variants: object = None,
+) -> dict[str, object]:
+    selected_connected = ["openai"] if connected is None else connected
+    selected_variants = {"high": {}} if variants is None else variants
+    return {
+        "connected": selected_connected,
+        "all": [
+            {
+                "id": "openai",
+                "models": {
+                    "model": {
+                        "status": status,
+                        "capabilities": {"toolcall": toolcall},
+                        "variants": selected_variants,
+                    }
+                },
+            }
+        ],
+    }
+
+
+@pytest.mark.parametrize(
+    ("payload", "requirement", "expected"),
+    [
+        (provider_payload(), ("openai", "model", "high"), True),
+        (provider_payload(), ("openai", "model", None), True),
+        (provider_payload(connected=("anthropic",)), ("openai", "model", "high"), False),
+        (provider_payload(status="deprecated"), ("openai", "model", "high"), False),
+        (provider_payload(toolcall=False), ("openai", "model", "high"), False),
+        (provider_payload(variants={}), ("openai", "model", "high"), False),
+        (provider_payload(), ("openai", "missing", "high"), False),
+    ],
+)
+def test_model_readiness_matrix(
+    payload: object, requirement: tuple[str, str, str | None], expected: bool
+) -> None:
+    assert models_ready(payload, {requirement}) is expected
+
+
+@pytest.mark.parametrize(
+    "payload",
+    [
+        None,
+        [],
+        {},
+        {"connected": None, "all": []},
+        {"connected": ["openai"], "all": None},
+        {"connected": ["openai"], "all": [{"id": [], "models": {}}]},
+        {
+            "connected": ["openai"],
+            "all": [
+                {
+                    "id": "openai",
+                    "models": {
+                        "model": {
+                            "status": "active",
+                            "capabilities": None,
+                            "variants": {"high": {}},
+                        }
+                    },
+                }
+            ],
+        },
+        {
+            "connected": ["openai"],
+            "all": [
+                {
+                    "id": "openai",
+                    "models": {
+                        "model": {
+                            "status": "active",
+                            "capabilities": {"toolcall": True},
+                            "variants": None,
+                        }
+                    },
+                }
+            ],
+        },
+    ],
+)
+def test_model_readiness_rejects_malformed_payloads(payload: object) -> None:
+    assert not models_ready(payload, {("openai", "model", "high")})
+
+
+def test_model_readiness_requires_all_configured_models() -> None:
    payload = {
        "connected": ["openai"],
        "all": [
@@ -34,7 +153,10 @@ def test_model_readiness_requires_tools_and_configured_variant() -> None:
        ],
    }

-    assert models_ready(payload, {("openai", "model", "high")})
-    assert not models_ready(payload, {("openai", "model", "missing")})
-    payload["all"][0]["models"]["model"]["capabilities"]["toolcall"] = False
-    assert not models_ready(payload, {("openai", "model", "high")})
+    assert not models_ready(
+        payload,
+        {
+            ("openai", "model", "high"),
+            ("openai", "other", None),
+        },
+    )