138 lines
6.0 KiB
Python
138 lines
6.0 KiB
Python
import unittest
|
|
from datetime import datetime
|
|
from unittest.mock import patch
|
|
|
|
from fastapi import HTTPException
|
|
from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
|
|
|
|
from database import Base
|
|
from models.audit import ViewerSession
|
|
from models.stream import StreamStatus
|
|
from routes.streams import (
|
|
ViewerHeartbeat,
|
|
_parse_scheduled_at,
|
|
poll_remote_command,
|
|
viewer_heartbeat,
|
|
)
|
|
from services import stream_service as stream_service_module
|
|
from services.stream_service import StreamService
|
|
|
|
|
|
def _multicast_off():
|
|
"""Keep the watch-URL tests off the network; the probe is a real socket call."""
|
|
return patch.object(stream_service_module.multicast_detector, "is_available", return_value=False)
|
|
|
|
|
|
class StreamTestBase(unittest.IsolatedAsyncioTestCase):
|
|
async def asyncSetUp(self):
|
|
self.engine = create_async_engine("sqlite+aiosqlite:///:memory:")
|
|
async with self.engine.begin() as connection:
|
|
await connection.run_sync(Base.metadata.create_all)
|
|
self.session_factory = async_sessionmaker(self.engine, expire_on_commit=False)
|
|
|
|
async def asyncTearDown(self):
|
|
await self.engine.dispose()
|
|
|
|
async def make_stream(self, **fields):
|
|
async with self.session_factory() as session:
|
|
stream = await StreamService(session).create_stream(title="Programme")
|
|
if fields:
|
|
await StreamService(session).update_stream(stream.id, **fields)
|
|
return stream.id, stream.stream_key
|
|
|
|
|
|
class WatchUrlScopeTest(StreamTestBase):
|
|
"""The watch API must not mix live HLS into a programme that is not on air."""
|
|
|
|
async def test_ended_programme_exposes_no_live_hls_lines(self):
|
|
_, key = await self.make_stream(status=StreamStatus.ended, replay_url="https://cdn.example.com/vod.mp4")
|
|
with _multicast_off():
|
|
async with self.session_factory() as session:
|
|
urls = await StreamService(session).get_watch_urls(key, None)
|
|
self.assertEqual(urls["lines"], [])
|
|
self.assertEqual(urls["qualities"], [])
|
|
self.assertIsNone(urls["selected_node"])
|
|
|
|
async def test_pending_programme_exposes_no_live_hls_lines_yet(self):
|
|
_, key = await self.make_stream(status=StreamStatus.pending)
|
|
with _multicast_off():
|
|
async with self.session_factory() as session:
|
|
urls = await StreamService(session).get_watch_urls(key, None)
|
|
self.assertEqual(urls["lines"], [])
|
|
self.assertEqual(urls["qualities"], [])
|
|
|
|
async def test_live_programme_still_exposes_hls_lines_and_renditions(self):
|
|
_, key = await self.make_stream(status=StreamStatus.live)
|
|
with _multicast_off():
|
|
async with self.session_factory() as session:
|
|
urls = await StreamService(session).get_watch_urls(key, None)
|
|
self.assertEqual(len(urls["lines"]), 1)
|
|
line = urls["lines"][0]
|
|
self.assertEqual(line["url"], f"/hls/{key}/index.m3u8")
|
|
self.assertTrue(line["qualities"])
|
|
self.assertTrue(urls["qualities"])
|
|
# The stream-copy rendition leads the ladder and is served from its slug.
|
|
self.assertEqual(line["qualities"][0]["url"], f"/hls/{key}/source/index.m3u8")
|
|
self.assertIsNotNone(urls["selected_node"])
|
|
|
|
|
|
class ViewerAuditScopeTest(StreamTestBase):
|
|
"""Viewer heartbeats and remote control exist for live playback only."""
|
|
|
|
async def test_heartbeat_is_a_noop_for_a_replay_programme(self):
|
|
stream_id, _ = await self.make_stream(status=StreamStatus.ended)
|
|
async with self.session_factory() as session:
|
|
payload = await viewer_heartbeat(
|
|
stream_id, ViewerHeartbeat(session_id="viewer-replay"), session
|
|
)
|
|
self.assertTrue(payload["ok"])
|
|
self.assertFalse(payload["remote_adjusted"])
|
|
self.assertFalse(payload["audit_active"])
|
|
async with self.session_factory() as session:
|
|
self.assertIsNone(await session.get(ViewerSession, "viewer-replay"))
|
|
|
|
async def test_heartbeat_registers_a_session_for_a_live_programme(self):
|
|
stream_id, _ = await self.make_stream(status=StreamStatus.live, remote_control_enabled=True)
|
|
async with self.session_factory() as session:
|
|
payload = await viewer_heartbeat(
|
|
stream_id, ViewerHeartbeat(session_id="viewer-live", quality="720p"), session
|
|
)
|
|
self.assertTrue(payload["ok"])
|
|
async with self.session_factory() as session:
|
|
viewer = await session.get(ViewerSession, "viewer-live")
|
|
self.assertIsNotNone(viewer)
|
|
self.assertEqual(viewer.quality, "720p")
|
|
|
|
async def test_remote_command_poll_stays_closed_for_a_replay_programme(self):
|
|
stream_id, _ = await self.make_stream(status=StreamStatus.ended, remote_control_enabled=True)
|
|
async with self.session_factory() as session:
|
|
self.assertIsNone(await poll_remote_command(stream_id, "viewer-replay", session))
|
|
|
|
async def test_remote_command_poll_stays_closed_without_an_opt_in(self):
|
|
stream_id, _ = await self.make_stream(status=StreamStatus.live, remote_control_enabled=False)
|
|
async with self.session_factory() as session:
|
|
self.assertIsNone(await poll_remote_command(stream_id, "viewer-live", session))
|
|
|
|
|
|
class ScheduledAtParseTest(unittest.TestCase):
|
|
"""The PUT route has to turn the client's ISO string into a datetime itself."""
|
|
|
|
def test_iso_z_suffix_is_stored_as_naive_utc(self):
|
|
self.assertEqual(
|
|
_parse_scheduled_at("2026-08-12T21:49:12.000Z"),
|
|
datetime(2026, 8, 12, 21, 49, 12),
|
|
)
|
|
|
|
def test_empty_values_clear_the_schedule(self):
|
|
self.assertIsNone(_parse_scheduled_at(None))
|
|
self.assertIsNone(_parse_scheduled_at(" "))
|
|
|
|
def test_invalid_value_is_rejected_with_422(self):
|
|
with self.assertRaises(HTTPException) as caught:
|
|
_parse_scheduled_at("not-a-date")
|
|
self.assertEqual(caught.exception.status_code, 422)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|