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
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
"""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()