Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

14.2 KB
Raw Blame
"""Offline Reactor capture boundary tests; no SDK, network, or encoder required."""
import asyncio
import importlib.util
import io
import json
import sys
import tempfile
import unittest
from contextlib import redirect_stdout
from pathlib import Path
from types import SimpleNamespace
from unittest.mock import AsyncMock, patch


def load_runner():
    spec = importlib.util.spec_from_file_location("reactor_render_test_target", Path(__file__).with_name("reactor-render.py"))
    module = importlib.util.module_from_spec(spec)
    with patch.dict(sys.modules, {"reactor_sdk": SimpleNamespace(Reactor=None)}):
        spec.loader.exec_module(module)
    return module


class FakeReactor:
    def __init__(self, complete=True):
        self.commands = []
        self.callbacks = {}
        self.tracks = self
        self.skipped = set(range(2, 138, 5))
        self.delivered = [index for index in range(144) if index not in self.skipped]
        if not complete:
            self.delivered.pop()  # 115/144 is just below the 80% admission threshold.
        self.disconnected = False

    def on(self, kind, callback):
        self.message = callback

    async def connect(self):
        pass

    async def disconnect(self):
        self.disconnected = True

    def with_direction(self, direction):
        return self

    def with_kind(self, kind):
        self.kind = kind
        return self

    def one(self):
        return self

    def on_raw_frame(self, callback):
        self.callbacks[self.kind] = callback

    def frame(self, index, size=(2, 2)):
        # Nonzero PTS origin, and integer microseconds like the decoded SDK track.
        timestamp = 9_000_000 + int(index * 1_000_000 / 24)
        width, height = size
        self.callbacks["video"](bytes([index]) * (width * height * 4), width, height, index, timestamp, None)

    async def send_command(self, name, data):
        self.commands.append((name, data))
        if name == "enqueue":
            self.frame(255)  # Idle preview must not become a paid clip frame.
            self.message({"type": "clip_generated"})
            return {"data": {"clip": {"clip_id": "example-clip", "frames": 144.0, "seconds": 6}}}
        if name == "play":
            self.frame(0)  # Track delivery may precede the clip_started message.
            self.message({"type": "clip_started"})
            self.frame(1)
            self.callbacks["audio"](b"\x01\x00" * 144000, 144000, 24000, 1)
            self.message({"type": "clip_finished"})
        return {}

    async def drain(self, delay):
        for index in self.delivered[2:]:
            self.frame(index)  # Decoder output can trail clip_finished.


class CaptureLifecycleTest(unittest.IsolatedAsyncioTestCase):
    def setUp(self):
        self.runner = load_runner()
        self.temp = tempfile.TemporaryDirectory()
        self.addCleanup(self.temp.cleanup)
        self.output = Path(self.temp.name) / "render.mp4"
        self.params = {"prompt": "A paper boat drifts.", "seconds": 6, "jwt": "example-token", "outputPath": str(self.output)}

    async def run_capture(self, reactor, spawn):
        log = io.StringIO()
        with patch.object(self.runner, "Reactor", return_value=reactor), \
                patch.object(self.runner.asyncio, "sleep", reactor.drain), \
                patch.object(self.runner.asyncio, "create_subprocess_exec", spawn), redirect_stdout(log):
            await self.runner.render(self.params)
        return [json.loads(line) for line in log.getvalue().splitlines()]

    async def test_timestamp_gaps_hold_previous_frame_without_shortening_video_or_audio(self):
        reactor = FakeReactor()

        async def encode(*command, **kwargs):
            video = Path(command[command.index("-i") + 1]).read_bytes()
            expected = [index - 1 if index in reactor.skipped else index for index in range(144)]
            self.assertEqual(video, b"".join(bytes([index]) * 16 for index in expected))
            self.assertEqual(Path(str(self.output) + ".capture/audio.pcm").read_bytes(), b"\x01\x00" * 144000)
            self.assertEqual(command[command.index("-t") + 1], "6.0")
            self.assertEqual(command[command.index("-framerate") + 1], "24")
            capture = json.loads(Path(str(self.output) + ".capture/capture.json").read_text())
            self.assertEqual(capture["frames"], 116)
            self.assertEqual(capture["expected"], 144)
            self.output.write_bytes(b"example-mp4")
            return SimpleNamespace(returncode=0, wait=AsyncMock(return_value=0))

        spawn = AsyncMock(side_effect=encode)
        events = await self.run_capture(reactor, spawn)
        self.assertEqual([name for name, _ in reactor.commands], ["set_canvas", "enqueue", "play"])
        self.assertEqual(events[-1], {"type": "complete", "clipId": "example-clip", "seconds": 6.0, "frames": 116})
        self.assertTrue(reactor.disconnected)
        self.assertFalse(Path(str(self.output) + ".capture").exists())
        spawn.assert_awaited_once()

    async def test_slow_session_setup_can_finish_before_enqueuing_once(self):
        reactor = FakeReactor()
        wait_for = asyncio.wait_for

        async def simulated_wait(awaitable, timeout):
            # Model a connection taking 90 seconds without production sleeps.
            if not reactor.commands and not reactor.callbacks:
                if timeout <= 90:
                    awaitable.close()
                    raise asyncio.TimeoutError()
                self.assertLessEqual(timeout, 180)
            return await wait_for(awaitable, timeout)

        async def encode(*command, **kwargs):
            self.output.write_bytes(b"example-mp4")
            return SimpleNamespace(returncode=0, wait=AsyncMock(return_value=0))

        with patch.object(self.runner.asyncio, "wait_for", simulated_wait):
            await self.run_capture(reactor, AsyncMock(side_effect=encode))
        self.assertEqual([name for name, _ in reactor.commands], ["set_canvas", "enqueue", "play"])
        self.assertTrue(reactor.disconnected)

    async def test_connection_timeout_or_cancellation_disconnects_without_submitting(self):
        for failure in (asyncio.TimeoutError, asyncio.CancelledError):
            with self.subTest(failure=failure.__name__):
                reactor = FakeReactor()
                reactor.connect = (AsyncMock(side_effect=asyncio.Event().wait)
                                   if failure is asyncio.TimeoutError else AsyncMock(side_effect=failure))
                spawn = AsyncMock()
                with patch.object(self.runner, "CONNECT_TIMEOUT_SECONDS", 0.001), self.assertRaises(failure):
                    await self.run_capture(reactor, spawn)
                self.assertTrue(reactor.disconnected)
                self.assertEqual(reactor.commands, [])
                self.assertFalse(Path(str(self.output) + ".capture").exists())
                spawn.assert_not_awaited()

    async def test_connection_rejection_reports_only_safe_http_status_without_submitting(self):
        for status in (400, 402, 503, None, "private-status", True, 200, 600):
            with self.subTest(status=status):
                reactor = FakeReactor()
                error = type("BadRequestError", (Exception,), {})("private response body")
                error.status = status
                reactor.connect = AsyncMock(side_effect=error)
                log = io.StringIO()
                with patch.object(self.runner, "Reactor", return_value=reactor), redirect_stdout(log):
                    with self.assertRaises(type(error)):
                        await self.runner.render(self.params)
                events = [json.loads(line) for line in log.getvalue().splitlines()]
                expected = {"type": "error", "phase": "connecting", "errorType": "BadRequestError"}
                if type(status) is int and 400 <= status <= 599:
                    expected["httpStatus"] = status
                self.assertEqual(events[-1], expected)
                self.assertNotIn("private", log.getvalue())
                self.assertEqual(reactor.commands, [])
                self.assertTrue(reactor.disconnected)
                self.assertFalse(Path(str(self.output) + ".capture").exists())

    async def test_canvas_opens_on_the_requested_aspect_and_rejects_one_fast_h3_cannot_render(self):
        reactor = FakeReactor()

        async def encode(*command, **kwargs):
            self.output.write_bytes(b"example-mp4")
            return SimpleNamespace(returncode=0, wait=AsyncMock(return_value=0))

        self.params["aspect"] = "9:16"
        await self.run_capture(reactor, AsyncMock(side_effect=encode))
        self.assertEqual(reactor.commands[0], ("set_canvas", {"aspect": "9:16"}))
        # An unrenderable aspect must fail before a paid session is constructed.
        with patch.object(self.runner, "Reactor") as factory:
            with self.assertRaises(ValueError):
                await self.runner.render({**self.params, "aspect": "21:9"})
            factory.assert_not_called()

    async def test_mid_stream_resolution_change_never_reaches_the_encoder(self):
        # A renegotiated WebRTC track delivers a differently-sized BGRA buffer.
        # ffmpeg is told ONE -video_size, so keeping both shifts the stride for
        # every later frame and the clip decodes as noise (or black) while its
        # audio plays fine — the "audio but no visuals" report.
        reactor = FakeReactor()

        async def drain_with_resize(delay):
            for index in reactor.delivered[2:]:
                reactor.frame(index)
                if index in (60, 61):
                    # A renegotiated track: a differently-sized buffer landing
                    # between two good frames, at a timestamp inside the clip,
                    # so the hold-across-gaps loop would otherwise select it.
                    timestamp = 9_000_000 + int(index * 1_000_000 / 24) + 20_000
                    reactor.callbacks["video"](bytes([200]) * 64, 4, 4, index, timestamp, None)

        reactor.drain = drain_with_resize

        async def encode(*command, **kwargs):
            self.assertEqual(command[command.index("-video_size") + 1], "2x2")
            video = Path(command[command.index("-i") + 1]).read_bytes()
            self.assertEqual(len(video), 144 * 2 * 2 * 4)
            self.assertNotIn(bytes([200]) * 64, video)
            # The scratch dir is removed on success, so read it here.
            capture = json.loads(Path(str(self.output) + ".capture/capture.json").read_text())
            self.assertEqual(capture["size"], [2, 2])
            self.assertEqual(capture["frames"], 116)
            self.output.write_bytes(b"example-mp4")
            return SimpleNamespace(returncode=0, wait=AsyncMock(return_value=0))

        spawn = AsyncMock(side_effect=encode)
        events = await self.run_capture(reactor, spawn)
        self.assertEqual(events[-1]["type"], "complete")
        spawn.assert_awaited_once()

    async def test_capture_just_below_eighty_percent_disconnects_without_encoding_or_retrying(self):
        reactor = FakeReactor(complete=False)
        spawn = AsyncMock()
        with self.assertRaisesRegex(RuntimeError, "115 of 144"):
            await self.run_capture(reactor, spawn)
        self.assertTrue(reactor.disconnected)
        self.assertEqual(sum(name == "enqueue" for name, _ in reactor.commands), 1)
        spawn.assert_not_awaited()
        self.assertTrue(Path(str(self.output) + ".capture/video.bgra").is_file())

    async def test_cancelled_encoder_is_terminated_then_killed_and_reaped(self):
        reactor = FakeReactor()
        encoder = SimpleNamespace(returncode=None)
        encoder.wait = AsyncMock(side_effect=[asyncio.CancelledError(), asyncio.TimeoutError(), -9])
        encoder.terminate = unittest.mock.Mock()
        encoder.kill = unittest.mock.Mock()
        with self.assertRaises(asyncio.CancelledError):
            await self.run_capture(reactor, AsyncMock(return_value=encoder))
        encoder.terminate.assert_called_once()
        encoder.kill.assert_called_once()
        self.assertEqual(encoder.wait.await_count, 3)
        self.assertTrue(reactor.disconnected)

    async def test_absent_timestamps_use_receive_time_instead_of_repeating_the_final_frame(self):
        reactor = FakeReactor()
        original = reactor.frame
        clock = [0]

        def frame(index, size=(2, 2)):
            clock[0] = 9_000_000_000 + round(index * 1_000_000_000 / 24)
            callback = reactor.callbacks["video"]
            reactor.callbacks["video"] = lambda data, w, h, fid, pts, ud: callback(data, w, h, fid, 0, ud)
            original(index, size)
            reactor.callbacks["video"] = callback

        reactor.frame = frame

        async def encode(*command, **kwargs):
            video = Path(command[command.index("-i") + 1]).read_bytes()
            self.assertEqual(video[:16], bytes(16))
            self.assertGreater(len(set(video[::16])), 100)
            self.output.write_bytes(b"example-mp4")
            return SimpleNamespace(returncode=0, wait=AsyncMock(return_value=0))

        with patch.object(self.runner.time, "monotonic_ns", side_effect=lambda: clock[0]):
            await self.run_capture(reactor, AsyncMock(side_effect=encode))

    async def test_invalid_buffers_fail_without_encoding_even_when_an_integer_matches_the_size(self):
        for buffer in (16, bytes(15), bytes(20)):
            with self.subTest(buffer=type(buffer).__name__):
                reactor = FakeReactor()
                reactor.frame = lambda index, size=(2, 2): reactor.callbacks["video"](buffer, 2, 2, index, 0, None)
                spawn = AsyncMock()
                with self.assertRaisesRegex(RuntimeError, "Invalid Reactor video frame buffer"):
                    await self.run_capture(reactor, spawn)
                spawn.assert_not_awaited()
                self.assertTrue(reactor.disconnected)

    async def test_invalid_request_never_constructs_a_session(self):
        with patch.object(self.runner, "Reactor") as factory:
            for change in ({"prompt": ""}, {"seconds": float("nan")}, {"sourceImagePath": str(Path(self.temp.name) / "missing.png")}):
                with self.subTest(change=change), self.assertRaises(ValueError):
                    await self.runner.render({**self.params, **change})
            factory.assert_not_called()


if __name__ == "__main__":
    unittest.main()