create-windy 0.5.1 → 0.6.0

package/template/apps/speech-server/tests/test_readiness.py

@@ -0,0 +1,315 @@
+from __future__ import annotations
+
+from dataclasses import replace
+from datetime import UTC, datetime
+
+import httpx
+
+from southwind_speech_server.config import SpeechRuntimeConfig
+from southwind_speech_server.pin_cli import compute_pins
+from southwind_speech_server.readiness import SpeechReadinessProbe
+from southwind_speech_server.readiness_contracts import (
+    AdapterSpeechReadinessV1,
+    OutputArtifactSinkReadinessV1,
+    compute_offers_digest,
+    compute_release_digest,
+    final_offers,
+)
+from southwind_speech_server.readiness_local import (
+    LocalToolFact,
+    SpeechLocalReadiness,
+)
+
+IDENTITY = "windy-deployment-v1_7db61d8e-e50d-4f8a-9f3f-9b7a1d932e01"
+DIGEST_A = f"sha256:{'a' * 64}"
+DIGEST_B = f"sha256:{'b' * 64}"
+TOOLS = SpeechLocalReadiness(
+    ffmpeg=LocalToolFact("ffmpeg", "synthetic-wav/pcm_s16le/16000/1", DIGEST_A),
+    ffprobe=LocalToolFact("ffprobe", "pcm_s16le/16000/1", DIGEST_B),
+)
+
+
+async def local_probe(_timeout: float) -> SpeechLocalReadiness:
+    return TOOLS
+
+
+def adapter_payload(*variants: str) -> dict[str, object]:
+    capabilities = {
+        "transcribe": ["speech.transcribe.batch", "speech.timestamps"],
+        "translate": ["speech.translate", "speech.timestamps"],
+    }
+    return {
+        "contractVersion": 1,
+        "status": "ready",
+        "runtimeKind": "speech-adapter",
+        "deployment": {"identity": IDENTITY, "releaseDigest": DIGEST_A},
+        "offers": [
+            {
+                "variant": variant,
+                "capabilityVersion": f"provider.{variant}/v1",
+                "capabilities": capabilities[variant],
+                "inputModalities": ["audio"],
+                "outputModalities": ["text"],
+                "limits": limits(32 * 1024 * 1024),
+            }
+            for variant in variants
+        ],
+    }
+
+
+def sink_payload() -> dict[str, object]:
+    return {
+        "contractVersion": 1,
+        "status": "ready",
+        "capability": "document.output-artifact.v1",
+        "sink": {
+            "identity": IDENTITY,
+            "releaseDigest": DIGEST_B,
+            "protocolVersion": 1,
+        },
+    }
+
+
+def limits(max_output_bytes: int) -> dict[str, int]:
+    return {
+        "maxDurationSeconds": 1800,
+        "maxInputBytes": 512 * 1024 * 1024,
+        "maxOutputBytes": max_output_bytes,
+        "maxUnits": 50_000,
+        "maxMediaDurationSeconds": 7200,
+        "maxArtifacts": 1,
+        "maxConcurrentRuns": 2,
+        "maxQueueDepth": 4,
+    }
+
+
+def base_config(adapter: bool = True) -> SpeechRuntimeConfig:
+    return SpeechRuntimeConfig(
+        internal_token="internal",
+        store_path=":memory:",
+        artifact_url="http://server.internal/api/internal/ai/artifacts",
+        output_artifact_url="http://server.internal/api/internal/ai/output-artifacts",
+        adapter_url="http://adapter.internal" if adapter else None,
+        adapter_token="adapter-token" if adapter else None,
+        deployment_key="speech.primary",
+        deployment_identity=IDENTITY,
+        release_digest=DIGEST_A,
+        offers_digest=DIGEST_B,
+        capabilities=(
+            "speech.timestamps",
+            "speech.transcribe.batch",
+            "speech.translate",
+        ),
+    )
+
+
+def pinned_config(
+    adapter: dict[str, object] | None,
+    sink: dict[str, object] | None,
+) -> SpeechRuntimeConfig:
+    config = base_config(adapter is not None)
+    adapter_model = (
+        AdapterSpeechReadinessV1.model_validate(adapter) if adapter else None
+    )
+    sink_model = OutputArtifactSinkReadinessV1.model_validate(sink) if sink else None
+    offers = final_offers(config, adapter_model, sink_model, TOOLS)
+    return replace(
+        config,
+        offers_digest=compute_offers_digest(offers),
+        release_digest=compute_release_digest(adapter_model, sink_model, TOOLS),
+    )
+
+
+def transport(
+    adapter: dict[str, object] | None,
+    sink: dict[str, object] | None,
+) -> httpx.MockTransport:
+    def handle(request: httpx.Request) -> httpx.Response:
+        value = adapter if request.url.host == "adapter.internal" else sink
+        if value is None:
+            return httpx.Response(503, json={"status": "unavailable"})
+        return httpx.Response(200, json=value)
+
+    return httpx.MockTransport(handle)
+
+
+def probe(
+    config: SpeechRuntimeConfig,
+    adapter: dict[str, object] | None,
+    sink: dict[str, object] | None,
+) -> SpeechReadinessProbe:
+    remote = transport(adapter, sink)
+    return SpeechReadinessProbe(
+        config,
+        adapter_transport=remote,
+        sink_transport=remote,
+        local_probe=local_probe,
+        wall_clock=lambda: datetime(2026, 8, 6, 1, 2, 3, 4000, tzinfo=UTC),
+        monotonic_clock=lambda: 10.0,
+    )
+
+
+async def test_readiness_recomputes_full_atomic_offer_snapshot() -> None:
+    adapter = adapter_payload("transcribe", "translate")
+    sink = sink_payload()
+    config = pinned_config(adapter, sink)
+
+    inspection = await probe(config, adapter, sink).inspect()
+
+    assert inspection.ready
+    assert inspection.snapshot["observedAt"] == "2026-08-06T01:02:03.004Z"
+    assert [offer["variant"] for offer in inspection.offers] == [
+        "normalize",
+        "transcribe",
+        "translate",
+    ]
+    assert inspection.offers[0]["capabilities"] == [
+        "speech.normalize",
+        "speech.output-artifact.v1",
+    ]
+    assert inspection.offers[1]["capabilities"] != inspection.offers[2]["capabilities"]
+
+
+async def test_normalize_depends_on_sink_but_not_adapter() -> None:
+    sink = sink_payload()
+    config = pinned_config(None, sink)
+
+    inspection = await probe(config, None, sink).inspect()
+
+    assert inspection.ready
+    assert [offer["variant"] for offer in inspection.offers] == ["normalize"]
+
+
+async def test_transcribe_depends_on_adapter_but_not_sink() -> None:
+    adapter = adapter_payload("transcribe")
+    sink = sink_payload()
+    config = pinned_config(adapter, sink)
+    state: dict[str, dict[str, object] | None] = {
+        "adapter": adapter,
+        "sink": sink,
+    }
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        key = "adapter" if request.url.host == "adapter.internal" else "sink"
+        value = state[key]
+        return (
+            httpx.Response(200, json=value)
+            if value
+            else httpx.Response(503, json={"status": "unavailable"})
+        )
+
+    remote = httpx.MockTransport(handle)
+    readiness = SpeechReadinessProbe(
+        config,
+        adapter_transport=remote,
+        sink_transport=remote,
+        local_probe=local_probe,
+        wall_clock=lambda: datetime(2026, 8, 6, 1, 2, 3, 4000, tzinfo=UTC),
+        monotonic_clock=lambda: 10.0,
+    )
+
+    assert (await readiness.inspect()).ready
+    state["sink"] = None
+    inspection = await readiness.inspect()
+
+    assert inspection.ready
+    assert [offer["variant"] for offer in inspection.offers] == ["transcribe"]
+    deployment = inspection.snapshot["deployment"]
+    assert isinstance(deployment, dict)
+    assert deployment["offersDigest"] != config.offers_digest
+
+
+async def test_partial_probe_before_full_pin_attestation_is_unavailable() -> None:
+    adapter = adapter_payload("transcribe")
+    sink = sink_payload()
+    config = pinned_config(adapter, sink)
+
+    inspection = await probe(config, adapter, None).inspect()
+
+    assert not inspection.ready
+    downstream = inspection.snapshot["downstreamProbe"]
+    assert isinstance(downstream, dict)
+    assert downstream["failureCode"] == "RESOURCE_UNAVAILABLE"
+
+
+async def test_normalize_remains_ready_after_attested_adapter_failure() -> None:
+    adapter = adapter_payload("transcribe")
+    sink = sink_payload()
+    config = pinned_config(adapter, sink)
+    calls = 0
+
+    def handle(request: httpx.Request) -> httpx.Response:
+        nonlocal calls
+        if request.url.host != "adapter.internal":
+            return httpx.Response(200, json=sink)
+        calls += 1
+        return (
+            httpx.Response(200, json=adapter)
+            if calls == 1
+            else httpx.Response(503, json={"status": "unavailable"})
+        )
+
+    remote = httpx.MockTransport(handle)
+    readiness = SpeechReadinessProbe(
+        config,
+        adapter_transport=remote,
+        sink_transport=remote,
+        local_probe=local_probe,
+        wall_clock=lambda: datetime(2026, 8, 6, 1, 2, 3, 4000, tzinfo=UTC),
+        monotonic_clock=lambda: 10.0,
+    )
+
+    assert (await readiness.inspect()).ready
+    degraded = await readiness.inspect()
+    assert degraded.ready
+    assert [offer["variant"] for offer in degraded.offers] == ["normalize"]
+
+
+async def test_attestation_digest_mismatch_fails_closed() -> None:
+    adapter = adapter_payload("transcribe")
+    sink = sink_payload()
+    config = replace(pinned_config(adapter, sink), offers_digest=DIGEST_A)
+
+    inspection = await probe(config, adapter, sink).inspect()
+
+    assert not inspection.ready
+    downstream = inspection.snapshot["downstreamProbe"]
+    assert isinstance(downstream, dict)
+    assert downstream["failureCode"] == "INVALID_RESPONSE"
+    assert inspection.snapshot["offers"] == []
+
+
+def test_inline_and_artifact_output_caps_are_distinct() -> None:
+    adapter = AdapterSpeechReadinessV1.model_validate(adapter_payload("transcribe"))
+    sink = OutputArtifactSinkReadinessV1.model_validate(sink_payload())
+    config = replace(
+        base_config(),
+        max_inline_output_bytes=1024,
+        max_output_artifact_bytes=8192,
+    )
+
+    offers = final_offers(config, adapter, sink, TOOLS)
+    by_variant = {str(item["variant"]): item for item in offers}
+    normalize_limits = by_variant["normalize"]["limits"]
+    transcript_limits = by_variant["transcribe"]["limits"]
+    assert isinstance(normalize_limits, dict)
+    assert isinstance(transcript_limits, dict)
+    assert normalize_limits["maxOutputBytes"] == 8192
+    assert transcript_limits["maxOutputBytes"] == 1024
+
+
+async def test_supported_pin_cli_uses_full_real_probe_facts() -> None:
+    adapter = adapter_payload("transcribe", "translate")
+    sink = sink_payload()
+    remote = transport(adapter, sink)
+    config = base_config()
+
+    pins = await compute_pins(config, remote, remote, local_probe)
+
+    expected = pinned_config(adapter, sink)
+    assert pins == {
+        "deploymentKey": config.deployment_key,
+        "deploymentIdentity": config.deployment_identity,
+        "releaseDigest": expected.release_digest,
+        "offersDigest": expected.offers_digest,
+    }

package/template/apps/speech-server/tests/test_readiness_http.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+
+import json
+
+import httpx
+import pytest
+
+from southwind_speech_server.readiness_http import ProbeFailure, get_json
+
+
+async def test_http_probe_rejects_non_json_and_oversized_body() -> None:
+    wrong_type = httpx.MockTransport(
+        lambda _request: httpx.Response(
+            200, text="{}", headers={"content-type": "text/plain"}
+        )
+    )
+    with pytest.raises(ProbeFailure, match="INVALID_RESPONSE"):
+        await get_json("http://adapter.internal/ready", None, 1, wrong_type)
+
+    body = json.dumps({"padding": "x" * (64 * 1024)}).encode()
+    oversized = httpx.MockTransport(
+        lambda _request: httpx.Response(
+            200,
+            content=body,
+            headers={"content-type": "application/json"},
+        )
+    )
+    with pytest.raises(ProbeFailure, match="INVALID_RESPONSE"):
+        await get_json("http://adapter.internal/ready", None, 1, oversized)
+
+
+async def test_http_probe_maps_status_and_timeout_without_body_details() -> None:
+    unhealthy = httpx.MockTransport(
+        lambda _request: httpx.Response(503, json={"secret": "must-not-surface"})
+    )
+    with pytest.raises(ProbeFailure, match="RESOURCE_UNAVAILABLE"):
+        await get_json("http://adapter.internal/ready", None, 1, unhealthy)
+
+    def timed_out(request: httpx.Request) -> httpx.Response:
+        raise httpx.ReadTimeout("provider detail", request=request)
+
+    with pytest.raises(httpx.ReadTimeout):
+        await get_json(
+            "http://adapter.internal/ready",
+            None,
+            0.01,
+            httpx.MockTransport(timed_out),
+        )

package/template/apps/speech-server/tests/test_readiness_local.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import sys
+
+import pytest
+
+from southwind_speech_server.readiness_http import ProbeFailure
+from southwind_speech_server.readiness_local import probe_local_tools, run_bounded
+
+
+async def test_local_probe_executes_both_tools_and_attests_output() -> None:
+    invoked: list[str] = []
+
+    async def runner(
+        arguments: list[str], _stdin: bytes, _timeout: float, _limit: int
+    ) -> bytes:
+        invoked.append(arguments[0])
+        if arguments[0] == "ffmpeg":
+            return b"RIFF" + b"\0" * 4 + b"WAVE" + b"\0" * 64
+        return (
+            b'{"streams":[{"codec_name":"pcm_s16le",'
+            b'"sample_rate":"16000","channels":1}]}'
+        )
+
+    facts = await probe_local_tools(1, runner)
+
+    assert sorted(invoked) == ["ffmpeg", "ffprobe"]
+    assert facts.ffmpeg.probe_fact == "synthetic-wav/pcm_s16le/16000/1"
+    assert facts.ffprobe.output_digest.startswith("sha256:")
+
+
+async def test_local_process_stderr_is_hard_bounded() -> None:
+    with pytest.raises(ProbeFailure, match="INVALID_RESPONSE"):
+        await run_bounded(
+            [
+                sys.executable,
+                "-c",
+                "import sys;sys.stdout.write('ok');sys.stderr.write('x'*20000)",
+            ],
+            b"",
+            1,
+            16,
+        )