researchowl/tests/test_shortsmith_client.py

"""ShortsmithClient — bucle de sondeo, errores y fallbacks.

Todo con un servidor falso; el test contra el servicio vivo es
`test_shortsmith_live.py`, que se salta salvo que se le apunte a uno.
"""
import asyncio
import json
from pathlib import Path

import pytest

from src.generator.shortsmith import (
    JobResult, ShortsmithClient, ShortsmithError, ShortsmithRejected,
    ShortsmithUnavailable, _templates_cache,
)

EXAMPLE = Path(__file__).resolve().parents[1] / "src/generator/examples/jal1628.json"


@pytest.fixture
def spec():
    return json.loads(EXAMPLE.read_text())


class FakeResp:
    def __init__(self, status, payload=None, body="", raw=b""):
        self.status = status
        self._payload = payload
        self._body = body
        self._raw = raw

    async def __aenter__(self):
        return self

    async def __aexit__(self, *a):
        return False

    async def json(self):
        if self._payload is None:
            raise ValueError("no json")
        return self._payload

    async def text(self):
        return self._body

    async def read(self):
        return self._raw


class FakeSession:
    """Sustituye a aiohttp.ClientSession: sirve respuestas de una cola por ruta."""

    def __init__(self, routes):
        self.routes = routes
        self.calls = []

    async def __aenter__(self):
        return self

    async def __aexit__(self, *a):
        return False

    def _next(self, method, url):
        self.calls.append((method, url))
        for pattern, responses in self.routes.items():
            if pattern in url:
                if isinstance(responses, list):
                    return responses.pop(0) if len(responses) > 1 else responses[0]
                return responses
        raise AssertionError(f"ruta no simulada: {method} {url}")

    def get(self, url, **kw):
        return self._next("GET", url)

    def post(self, url, **kw):
        return self._next("POST", url)


def patch_session(client, routes):
    session = FakeSession(routes)
    client._session = lambda total: session
    return session


@pytest.mark.asyncio
async def test_templates_cached_per_process():
    _templates_cache.clear()
    client = ShortsmithClient("http://fake:8080")
    session = patch_session(client, {"/templates": FakeResp(200, {"radar_sweep": {}})})

    first = await client.templates()
    second = await client.templates()

    assert first == second == {"radar_sweep": {}}
    assert len(session.calls) == 1, "la segunda llamada debe salir de la caché"

    # refresh=True vuelve a pedirlo: el renderizador puede haberse actualizado.
    patch_session(client, {"/templates": FakeResp(200, {"radar_sweep": {}, "nueva": {}})})
    assert "nueva" in await client.templates(refresh=True)
    _templates_cache.clear()


@pytest.mark.asyncio
async def test_render_returns_job_id(spec):
    client = ShortsmithClient("http://fake:8080")
    patch_session(client, {"/render": FakeResp(202, {"job_id": "abc123", "status": "queued"})})
    assert await client.render(spec) == "abc123"


@pytest.mark.asyncio
async def test_render_422_propagates_error_paths(spec):
    detail = [{
        "type": "extra_forbidden",
        "loc": ["shots", 0, "radar_sweep", "props", "sweeeps"],
        "msg": "Extra inputs are not permitted",
    }]
    client = ShortsmithClient("http://fake:8080")
    patch_session(client, {"/render": FakeResp(422, {"detail": detail})})

    with pytest.raises(ShortsmithRejected) as exc:
        await client.render(spec)
    assert exc.value.errors[0]["loc"][-1] == "sweeeps"


@pytest.mark.asyncio
async def test_poll_queued_then_running_then_done():
    client = ShortsmithClient("http://fake:8080")
    patch_session(client, {"/jobs/": [
        FakeResp(200, {"job_id": "j", "status": "queued", "progress": 0.0}),
        FakeResp(200, {"job_id": "j", "status": "running", "progress": 0.4}),
        FakeResp(200, {"job_id": "j", "status": "done", "progress": 1.0,
                       "warnings": [{"template": "data_card", "text": "x"}]}),
    ]})

    seen = []

    async def on_progress(fraction, status):
        seen.append((fraction, status))

    result = await client.poll("j", on_progress=on_progress, interval=0)

    assert result.ok and result.status == "done"
    assert result.warnings and result.warnings[0]["template"] == "data_card"
    assert seen == [(0.0, "queued"), (0.4, "running"), (1.0, "done")]


@pytest.mark.asyncio
async def test_poll_returns_error_status_without_raising():
    client = ShortsmithClient("http://fake:8080")
    patch_session(client, {"/jobs/": FakeResp(200, {
        "job_id": "j", "status": "error", "progress": 0.3,
        "error": "interrupted by a restart: the process did not survive this render",
    })})

    result = await client.poll("j", interval=0)
    assert not result.ok
    assert "interrupted" in result.error


@pytest.mark.asyncio
async def test_poll_gives_up_on_a_stuck_job():
    client = ShortsmithClient("http://fake:8080")
    patch_session(client, {"/jobs/": FakeResp(200, {
        "job_id": "j", "status": "running", "progress": 0.1})})

    with pytest.raises(ShortsmithError, match="atascado"):
        await client.poll("j", interval=0, ceiling=0)


@pytest.mark.asyncio
async def test_connection_refused_is_unavailable(spec):
    import aiohttp

    class Refusing(FakeSession):
        def post(self, url, **kw):
            raise aiohttp.ClientConnectionError(
                "Cannot connect to host shortsmith-svc:8080 [Connection refused]")

    client = ShortsmithClient("http://fake:8080")
    client._session = lambda total: Refusing({})

    with pytest.raises(ShortsmithUnavailable):
        await client.render(spec)


@pytest.mark.asyncio
async def test_fetch_video_returns_bytes():
    client = ShortsmithClient("http://fake:8080")
    patch_session(client, {"/video": FakeResp(200, raw=b"\x00\x00\x00 ftypisom")})
    assert (await client.fetch_video("j")).startswith(b"\x00\x00\x00 ftyp")


@pytest.mark.asyncio
async def test_progress_callback_failure_never_kills_the_render():
    client = ShortsmithClient("http://fake:8080")
    patch_session(client, {"/jobs/": FakeResp(200, {
        "job_id": "j", "status": "done", "progress": 1.0})})

    async def boom(fraction, status):
        raise RuntimeError("Telegram dijo que no")

    assert (await client.poll("j", on_progress=boom, interval=0)).ok


def test_jobresult_ok_only_when_done():
    assert JobResult("j", "done").ok
    assert not JobResult("j", "running").ok
    assert not JobResult("j", "error", error="boom").ok