\nWarning" + aligned = b"\x47" + b"\x00" * 187 + b"\x47" + b"\x00" * 187 + b"\x47" + b"\x00" * 187 + self.assertEqual(_find_ts_sync(preamble + aligned), len(preamble)) + + def test_returns_minus_one_when_no_chain_exists(self): + # Three lone 0x47 bytes that are NOT spaced at 188 — must not be + # mistaken for a sync chain. + self.assertEqual(_find_ts_sync(b"\x47\x00\x00\x47\x00\x00\x47" * 50), -1) + + def test_returns_minus_one_for_short_buffer(self): + self.assertEqual(_find_ts_sync(b"\x47" * 10), -1) + + + +def _make_ts_payload(size=1024): + """Build a minimal valid MPEG-TS byte sequence with 0x47 sync markers.""" + packet = b"\x47" + b"\x00" * 187 + return (packet * ((size // 188) + 1))[:size] + + +def _fake_upstream(status_code, *, content_type="video/mp2t", body=b""): + resp = MagicMock() + resp.status_code = status_code + resp.headers = {"Content-Type": content_type} + resp.iter_content = MagicMock(return_value=iter([body] if body else [])) + resp.close = MagicMock() + # Simulate raw.read() for the TS sync peek in _stream_from_provider. + # For 200 responses, return valid TS bytes so the peek check passes. + if status_code in (200, 206) and not body: + ts_peek = _make_ts_payload() + resp.raw = MagicMock() + resp.raw.read = MagicMock(return_value=ts_peek) + elif status_code in (200, 206): + resp.raw = MagicMock() + resp.raw.read = MagicMock(return_value=body) + return resp + + +class StreamFromProviderStatusMappingTests(TestCase): + """`_stream_from_provider` must translate upstream HTTP status codes into + semantically correct Django responses so downstream IPTV clients react + the right way (notably: stop retrying on 404).""" + + def setUp(self): + self.factory = RequestFactory() + self.kwargs = dict( + candidate_urls=[ + "http://example.test/streaming/timeshift.php?stream=1&start=2026-05-12:17-00", + "http://example.test/streaming/timeshift.php?stream=1&start=2026-05-12 17:00:00", + "http://example.test/timeshift/u/p/60/2026-05-12:17-00/1.ts", + ], + user_agent="test-agent", + range_header=None, + virtual_channel_id="timeshift_1_2026-05-12-17-00_1", + client_id="timeshift_test123", + client_ip="127.0.0.1", + user=None, + channel_display_name="Test", + timestamp_utc="2026-05-12:17-00", + channel_logo_id=None, + m3u_profile_id=None, + debug=False, + ) + + @patch.object(views, "_open_upstream") + def test_all_candidates_404_returns_404(self, mocked_open): + mocked_open.return_value = _fake_upstream(404) + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 404) + # Every candidate is attempted before giving up. + self.assertEqual(mocked_open.call_count, 3) + + @patch.object(views, "_open_upstream") + def test_upstream_403_short_circuits_loop(self, mocked_open): + # 403 is decisive (auth) — no retry of further candidates. + mocked_open.return_value = _fake_upstream(403) + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 403) + self.assertEqual(mocked_open.call_count, 1) + + @patch.object(views, "_open_upstream") + def test_upstream_302_short_circuits_loop(self, mocked_open): + # Any 3xx is decisive: for XC providers a 302 is the first sign of + # an IP ban, so the cascade must STOP hammering immediately instead + # of retrying other URL shapes (which escalates the ban). + mocked_open.return_value = _fake_upstream(302) + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 400) + self.assertEqual(mocked_open.call_count, 1) + + @patch.object(views, "_open_upstream") + def test_upstream_500_continues_to_next_candidate(self, mocked_open): + # A 5xx is format-specific on many XC servers (PHP fatal with + # display_errors off turns an "Undefined array key" warning into a + # hard 500), so the cascade must keep trying — the next timestamp + # shape often succeeds. Regression: providers that 500 on the first + # shape used to fail outright because the loop short-circuited. + mocked_open.side_effect = [ + _fake_upstream(500), + _fake_upstream(200, body=_make_ts_payload()), + ] + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 200) + self.assertEqual(mocked_open.call_count, 2) + + @patch.object(views, "_open_upstream") + def test_all_candidates_500_returns_error(self, mocked_open): + # Every shape 500s → all candidates attempted, then a clean error. + mocked_open.return_value = _fake_upstream(500) + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 400) + self.assertEqual(mocked_open.call_count, 3) + + @patch.object(views, "_open_upstream") + def test_first_candidate_succeeds(self, mocked_open): + mocked_open.side_effect = [_fake_upstream(200, body=_make_ts_payload())] + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 200) + self.assertEqual(mocked_open.call_count, 1) + + @patch.object(views, "_open_upstream") + def test_second_candidate_succeeds_after_404(self, mocked_open): + # Primary 404 → second candidate 200 → streams successfully. + mocked_open.side_effect = [ + _fake_upstream(404), + _fake_upstream(200, body=_make_ts_payload()), + ] + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 200) + self.assertEqual(mocked_open.call_count, 2) + + @patch.object(views, "_open_upstream") + def test_third_candidate_succeeds_after_400_then_404(self, mocked_open): + mocked_open.side_effect = [ + _fake_upstream(400), + _fake_upstream(404), + _fake_upstream(200, body=_make_ts_payload()), + ] + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 200) + self.assertEqual(mocked_open.call_count, 3) + + @override_settings(CACHES={ + "default": {"BACKEND": "django.core.cache.backends.locmem.LocMemCache"} + }) + @patch.object(views, "_open_upstream") + def test_cache_promotes_winning_index_to_first(self, mocked_open): + """Once a candidate succeeds for an account, the next request reorders + the list so the cached winner is tried first — saving cascade + overhead on fast-forward.""" + # locmem cache: isolates this test from the shared Redis-backed django + # cache (which persists across runs and parallel test sessions). + from django.core.cache import cache as django_cache + django_cache.delete(views._FORMAT_CACHE_KEY.format(999)) + + # First request: candidate index 1 wins after index 0 returns 404. + mocked_open.side_effect = [ + _fake_upstream(404), + _fake_upstream(200, body=_make_ts_payload()), + ] + kwargs = dict(self.kwargs, account_id=999) + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + r1 = views._stream_from_provider(**kwargs) + self.assertEqual(r1.status_code, 200) + self.assertEqual(mocked_open.call_count, 2) + + # Second request: cached winner (index 1) is tried first, succeeds + # immediately — no cascade. + mocked_open.reset_mock() + mocked_open.side_effect = [_fake_upstream(200, body=_make_ts_payload())] + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + r2 = views._stream_from_provider(**kwargs) + self.assertEqual(r2.status_code, 200) + self.assertEqual(mocked_open.call_count, 1) + # Confirm the URL used is the SQL-datetime candidate (index 1 in the + # original list set up in setUp), not the dash-only one (index 0). + self.assertIn("17:00:00", mocked_open.call_args_list[0][0][0]) + + @patch.object(views, "_open_upstream") + def test_php_error_200_cascades_to_next_candidate(self, mocked_open): + """When the provider returns HTTP 200 but the body is PHP error text + (no TS sync), the cascade should try the next candidate URL.""" + php_error = b'
\nWarning: Invalid argument supplied for foreach()' + php_resp = _fake_upstream(200, body=php_error) + php_resp.raw = MagicMock() + php_resp.raw.read = MagicMock(return_value=php_error) + + ts_resp = _fake_upstream(200, body=_make_ts_payload()) + + mocked_open.side_effect = [php_resp, ts_resp] + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 200) + # PHP response was rejected, second candidate accepted + self.assertEqual(mocked_open.call_count, 2) + + @patch.object(views, "_open_upstream") + def test_416_range_not_satisfiable_passes_through(self, mocked_open): + # A tail/seek probe past EOF must go back to the client verbatim, + # never cascaded to other URL shapes (byte offsets are file-specific, + # so cascading only multiplies upstream connections). + resp = _fake_upstream(416) + resp.headers = {"Content-Type": "video/mp2t", "Content-Range": "bytes */1000"} + mocked_open.return_value = resp + kwargs = dict(self.kwargs, range_header="bytes=999999-") + response = views._stream_from_provider(**kwargs) + self.assertEqual(response.status_code, 416) + self.assertEqual(response["Content-Range"], "bytes */1000") + self.assertTrue(getattr(response, "timeshift_passthrough", False)) + # No cascade: the first (and only) candidate decided the outcome. + self.assertEqual(mocked_open.call_count, 1) + + @patch.object(views, "_open_upstream") + def test_partial_206_to_range_request_accepted_mid_packet(self, mocked_open): + # A 206 answering a Range request legitimately starts mid-TS-packet + # (no 0x47 sync at offset 0). It must be served, not rejected as a + # PHP error and cascaded across every URL shape and provider account. + mid_packet = b"\x00" * 300 + self.assertEqual(_find_ts_sync(mid_packet), -1) + resp = _fake_upstream(206, body=mid_packet) + resp.raw = MagicMock() + resp.raw.read = MagicMock(return_value=mid_packet) + mocked_open.return_value = resp + kwargs = dict(self.kwargs, range_header="bytes=1000-") + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + response = views._stream_from_provider(**kwargs) + self.assertEqual(response.status_code, 206) + self.assertEqual(mocked_open.call_count, 1) + + @patch.object(views, "_open_upstream") + def test_partial_206_html_error_still_rejected(self, mocked_open): + # The mid-packet allowance is gated on content type: a 206 whose body + # is an HTML/PHP error page must still be rejected and cascaded. + html = b"error" + bad = _fake_upstream(206, content_type="text/html", body=html) + bad.raw = MagicMock() + bad.raw.read = MagicMock(return_value=html) + good = _fake_upstream(206, body=_make_ts_payload()) + mocked_open.side_effect = [bad, good] + kwargs = dict(self.kwargs, range_header="bytes=0-") + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + response = views._stream_from_provider(**kwargs) + self.assertEqual(response.status_code, 206) + self.assertEqual(mocked_open.call_count, 2) + + @patch.object(views, "_open_upstream") + def test_206_without_range_header_still_requires_sync(self, mocked_open): + # Without a Range header a 206 is unexpected; it must still pass the + # TS-sync probe (the mid-packet allowance is range-only). + mid_packet = b"\x00" * 300 + bad = _fake_upstream(206, body=mid_packet) + bad.raw = MagicMock() + bad.raw.read = MagicMock(return_value=mid_packet) + good = _fake_upstream(206, body=_make_ts_payload()) + mocked_open.side_effect = [bad, good] + with patch.object(views, "RedisClient"), \ + patch.object(views, "_register_stats_client"), \ + patch.object(views, "_unregister_stats_client"): + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 206) + self.assertEqual(mocked_open.call_count, 2) + + +class RedactUrlTests(TestCase): + """`_redact_url` is the guard that keeps XC credentials out of logs — + both URL forms carry them (query params in format A, path segments in + format B).""" + + def test_redacts_query_credentials(self): + url = "http://example.test/streaming/timeshift.php?username=u&password=p&stream=1" + self.assertEqual(views._redact_url(url), "http://example.test/...") + + def test_redacts_path_credentials(self): + url = "http://example.test/timeshift/user/pass/60/2026-05-12:17-00/1.ts" + self.assertEqual(views._redact_url(url), "http://example.test/...") + + def test_redacts_userinfo_credentials(self): + url = "http://user:pass@example.test/timeshift/1.ts" + self.assertEqual(views._redact_url(url), "http://example.test/...") + + def test_passes_through_non_urls(self): + self.assertEqual(views._redact_url("not a url"), "not a url") + self.assertIsNone(views._redact_url(None)) + + +def _make_catchup_stream(provider_tz="Europe/Brussels", *, account_id=9, + stream_id="22372", account_type="XC", profile_id=31, + extra_profiles=()): + """Build a mocked catch-up Stream with its own provider context. + + The default (tz-bearing) profile leads the active-profile list the view + walks; ``extra_profiles`` appends alternate (non-default) profiles for + capacity-walk tests. + """ + profile = MagicMock() + profile.id = profile_id + profile.is_default = True + profile.custom_properties = {"server_info": {"timezone": provider_tz}} + m3u_account = MagicMock() + m3u_account.account_type = account_type + m3u_account.id = account_id + m3u_account.profiles.filter.return_value = [profile, *extra_profiles] + stream = MagicMock() + stream.m3u_account = m3u_account + stream.custom_properties = {"stream_id": stream_id} if stream_id else {} + return stream + + +def _make_alt_profile(profile_id): + """A non-default active profile for the capacity walk.""" + profile = MagicMock() + profile.id = profile_id + profile.is_default = False + profile.custom_properties = {} + return profile + + +class _FakeRedis: + """Just enough of the redis-py surface for the idle-session pool: setex/get/ + delete plus a transactional pipeline doing GET+DEL, and the hash, set and + lock primitives the pool entries rely on.""" + + def __init__(self): + self.store = {} + + def setex(self, key, ttl, value): + self.store[key] = str(value) + + def set(self, key, value): + self.store[key] = str(value) + + def get(self, key): + return self.store.get(key) + + def delete(self, *keys): + return sum(1 for k in keys if self.store.pop(k, None) is not None) + + def exists(self, key): + return 1 if key in self.store else 0 + + def pipeline(self, transaction=False): + return _FakeRedisPipeline(self) + + # --- hash + lock surface for the session slot --- + def hgetall(self, key): + value = self.store.get(key) + return dict(value) if isinstance(value, dict) else {} + + def hset(self, key, field=None, value=None, mapping=None, **kwargs): + hash_value = self.store.get(key) + if not isinstance(hash_value, dict): + hash_value = {} + self.store[key] = hash_value + if field is not None and value is not None: + hash_value[str(field)] = str(value) + for f, v in (mapping or {}).items(): + hash_value[str(f)] = str(v) + for f, v in kwargs.items(): + hash_value[str(f)] = str(v) + return len(hash_value) + + def hincrby(self, key, field, amount=1): + hash_value = self.store.get(key) + if not isinstance(hash_value, dict): + hash_value = {} + self.store[key] = hash_value + new_value = int(hash_value.get(field, 0)) + amount + hash_value[field] = str(new_value) + return new_value + + def hget(self, key, field): + hash_value = self.store.get(key) + return hash_value.get(field) if isinstance(hash_value, dict) else None + + def expire(self, key, ttl): + return 1 if key in self.store else 0 + + # --- set surface for the idle-session pool --- + def sadd(self, key, *members): + existing = self.store.get(key) + if not isinstance(existing, set): + existing = set() + self.store[key] = existing + before = len(existing) + existing.update(str(m) for m in members) + return len(existing) - before + + def srem(self, key, *members): + existing = self.store.get(key) + if not isinstance(existing, set): + return 0 + removed = 0 + for member in members: + if str(member) in existing: + existing.discard(str(member)) + removed += 1 + return removed + + def smembers(self, key): + existing = self.store.get(key) + return set(existing) if isinstance(existing, set) else set() + + def scard(self, key): + existing = self.store.get(key) + return len(existing) if isinstance(existing, set) else 0 + + def lock(self, name, timeout=None, blocking_timeout=None): + return _FakeRedisLock() + + def scan(self, cursor=0, match=None, count=100): + keys = sorted( + k for k in self.store + if match is None or fnmatch.fnmatch(k, match) + ) + if cursor >= len(keys): + return 0, [] + batch = keys[cursor:cursor + count] + next_cursor = cursor + len(batch) + if next_cursor >= len(keys): + return 0, batch + return next_cursor, batch + + +class _FakeRedisLock: + def __enter__(self): + return self + + def __exit__(self, *exc): + return False + + +class _FakeRedisPipeline: + def __init__(self, redis): + self._redis = redis + self._ops = [] + + def get(self, key): + self._ops.append(("get", key)) + + def delete(self, key): + self._ops.append(("delete", key)) + + def execute(self): + results = [] + for op, key in self._ops: + if op == "get": + results.append(self._redis.get(key)) + else: + results.append(self._redis.delete(key)) + self._ops = [] + return results + + +def _fake_creds(acc, prof): + """Distinguishable per-account credentials, mirroring what + get_transformed_credentials returns for the reserved profile.""" + return (f"http://a{acc.id}.test", f"u{acc.id}", "p") + + +class TimeshiftProxyTimestampWiringTests(TestCase): + """`timeshift_proxy` must convert the client's UTC timestamp to the + serving provider's zone for the upstream URL, while keeping the ORIGINAL + UTC timestamp for the EPG duration lookup — the only timezone conversion + in the chain.""" + + def setUp(self): + self.factory = RequestFactory() + + def _call(self, timestamp, provider_tz="Europe/Brussels"): + request = self.factory.get(f"/timeshift/u/p/8/{timestamp}/8.ts?session_id={TEST_SESSION_ID}") + sentinel = MagicMock(status_code=200) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", + return_value=[_make_catchup_stream(provider_tz)]), \ + patch.object(views, "get_programme_duration", return_value=40) as duration_mock, \ + patch.object(views, "build_timeshift_candidate_urls", + return_value=["http://example.test/x.ts"]) as build_mock, \ + patch.object(views, "check_user_stream_limits", return_value=True), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \ + patch.object(views, "release_profile_slot"), \ + patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \ + patch.object(views, "get_user_active_connections", return_value=[]), \ + patch.object(views, "_stream_from_provider", return_value=sentinel) as stream_mock: + redis_cls.get_client.return_value = _FakeRedis() + channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None) + response = views.timeshift_proxy(request, "u", "p", "8", timestamp, "8.ts") + return response, sentinel, build_mock, duration_mock, stream_mock + + def test_candidates_get_provider_local_timestamp(self): + # June → CEST: 17:00 UTC must reach the URL builder as 19:00 Brussels. + response, sentinel, build_mock, duration_mock, _ = self._call("2026-06-08:17-00") + self.assertIs(response, sentinel) + self.assertEqual(build_mock.call_args[0][2], "2026-06-08:19-00") + + def test_duration_lookup_keeps_original_utc_timestamp(self): + # The EPG is stored in UTC — the duration lookup must NOT receive the + # provider-converted value. + _, _, _, duration_mock, _ = self._call("2026-06-08:17-00") + self.assertEqual(duration_mock.call_args[0][1], "2026-06-08:17-00") + + def test_utc_provider_passes_timestamp_unchanged(self): + _, _, build_mock, _, _ = self._call("2026-06-08:17-00", provider_tz="UTC") + self.assertEqual(build_mock.call_args[0][2], "2026-06-08:17-00") + + def test_colon_seconds_timestamp_accepted(self): + response, sentinel, build_mock, duration_mock, _ = self._call( + "2026-06-23:04:00:00" + ) + self.assertIs(response, sentinel) + self.assertEqual(duration_mock.call_args[0][1], "2026-06-23:04:00:00") + + def test_invalid_timestamp_rejected_before_upstream(self): + request = self.factory.get("/timeshift/u/p/8/garbage/8.ts") + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams") as catchup_mock, \ + patch.object(views, "_stream_from_provider") as stream_mock: + channel_cls.objects.get.return_value = MagicMock(id=8) + response = views.timeshift_proxy(request, "u", "p", "8", "garbage", "8.ts") + self.assertEqual(response.status_code, 400) + catchup_mock.assert_not_called() + stream_mock.assert_not_called() + + def test_network_access_denied_returns_403(self): + # Same network gate as other XC API endpoints (player_api, xmltv, etc.). + request = self.factory.get(_proxy_url()) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=False) as gate, \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_stream_from_provider") as stream_mock: + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts" + ) + self.assertEqual(response.status_code, 403) + self.assertEqual(gate.call_args[0][1], "XC_API") + channel_cls.objects.get.assert_not_called() + stream_mock.assert_not_called() + + +class TimeshiftProxyFailoverTests(TestCase): + """When the first catch-up stream's provider cannot serve the archive, + the proxy must fail over to the channel's next catch-up stream — each + attempt with its own provider context.""" + + def setUp(self): + self.factory = RequestFactory() + + def _call(self, streams, provider_responses): + request = self.factory.get(_proxy_url()) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", return_value=streams), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "build_timeshift_candidate_urls", + return_value=["http://example.test/x.ts"]) as build_mock, \ + patch.object(views, "check_user_stream_limits", return_value=True) as limits_mock, \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \ + patch.object(views, "release_profile_slot"), \ + patch.object(views, "get_transformed_credentials", + side_effect=_fake_creds) as creds_mock, \ + patch.object(views, "get_user_active_connections", return_value=[]), \ + patch.object(views, "_stream_from_provider", + side_effect=provider_responses) as stream_mock: + redis_cls.get_client.return_value = _FakeRedis() + channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts" + ) + self.creds_mock = creds_mock + return response, stream_mock, build_mock, limits_mock + + def test_second_stream_serves_after_first_fails(self): + streams = [ + _make_catchup_stream(account_id=1, stream_id="111"), + _make_catchup_stream(account_id=2, stream_id="222"), + ] + ok = MagicMock(status_code=200) + response, stream_mock, build_mock, _ = self._call( + streams, [MagicMock(status_code=404), ok] + ) + self.assertIs(response, ok) + self.assertEqual(stream_mock.call_count, 2) + # Each attempt used its own provider context: credentials resolved per + # account/profile (via get_transformed_credentials) and its stream id. + self.assertEqual( + [c.args[0] for c in build_mock.call_args_list], + [("http://a1.test", "u1", "p"), ("http://a2.test", "u2", "p")], + ) + self.assertEqual( + [c.args[0] for c in self.creds_mock.call_args_list], + [streams[0].m3u_account, streams[1].m3u_account], + ) + self.assertEqual( + [c.args[1] for c in build_mock.call_args_list], ["111", "222"] + ) + self.assertEqual( + [c.kwargs["account_id"] for c in stream_mock.call_args_list], [1, 2] + ) + + def test_all_streams_fail_returns_last_failure(self): + streams = [ + _make_catchup_stream(account_id=1, stream_id="111"), + _make_catchup_stream(account_id=2, stream_id="222"), + ] + last = MagicMock(status_code=404) + response, stream_mock, _, _ = self._call( + streams, [MagicMock(status_code=400), last] + ) + self.assertIs(response, last) + self.assertEqual(stream_mock.call_count, 2) + + def test_non_xc_and_missing_stream_id_are_skipped(self): + streams = [ + _make_catchup_stream(account_id=1, account_type="M3U"), + _make_catchup_stream(account_id=2, stream_id=None), + _make_catchup_stream(account_id=3, stream_id="333"), + ] + ok = MagicMock(status_code=200) + response, stream_mock, _, _ = self._call(streams, [ok]) + self.assertIs(response, ok) + # Only the eligible third stream produced an upstream attempt. + self.assertEqual(stream_mock.call_count, 1) + self.assertEqual(stream_mock.call_args.kwargs["account_id"], 3) + + def test_stream_limits_checked_once_for_the_request(self): + streams = [ + _make_catchup_stream(account_id=1, stream_id="111"), + _make_catchup_stream(account_id=2, stream_id="222"), + ] + _, _, _, limits_mock = self._call( + streams, [MagicMock(status_code=404), MagicMock(status_code=200)] + ) + self.assertEqual(limits_mock.call_count, 1) + + def test_passthrough_is_not_failed_over_to_other_accounts(self): + # A terminal range answer (e.g. 416 past EOF) must be returned as-is; + # the loop must NOT try the next account, whose byte offsets would not + # match this file and which would just burn another provider slot. + streams = [ + _make_catchup_stream(account_id=1, stream_id="111"), + _make_catchup_stream(account_id=2, stream_id="222"), + ] + passthrough = MagicMock(status_code=416) + passthrough.timeshift_passthrough = True + response, stream_mock, _, _ = self._call(streams, [passthrough]) + self.assertIs(response, passthrough) + self.assertEqual(stream_mock.call_count, 1) + + +class _ProxyLoopTestMixin: + """Shared driver for tests exercising the failover loop end to end — + pool reservation, credential resolution and Redis are all controlled.""" + + def setUp(self): + self.factory = RequestFactory() + + def _call(self, streams, provider_responses, limits=True, reserve_results=None, + build_side_effect=None): + request = self.factory.get(_proxy_url()) + self.fake_redis = _FakeRedis() + reserve_kwargs = ( + {"side_effect": reserve_results} + if reserve_results is not None + else {"return_value": (True, 1, None)} + ) + build_kwargs = ( + {"side_effect": build_side_effect} + if build_side_effect is not None + else {"return_value": ["http://example.test/x.ts"]} + ) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", return_value=streams), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "build_timeshift_candidate_urls", + **build_kwargs) as build_mock, \ + patch.object(views, "check_user_stream_limits", return_value=limits), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "reserve_profile_slot", **reserve_kwargs) as reserve_mock, \ + patch.object(views, "release_profile_slot") as release_mock, \ + patch.object(views, "get_transformed_credentials", + side_effect=_fake_creds) as creds_mock, \ + patch.object(views, "get_user_active_connections", return_value=[]), \ + patch.object(views, "_stream_from_provider", + side_effect=provider_responses) as stream_mock: + redis_cls.get_client.return_value = self.fake_redis + channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None) + # Exposed before the call so raising tests can still assert on them. + self.reserve_mock = reserve_mock + self.release_mock = release_mock + self.creds_mock = creds_mock + self.stream_mock = stream_mock + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts" + ) + return response, stream_mock, build_mock + + +class TimeshiftProxyFailoverHardeningTests(_ProxyLoopTestMixin, TestCase): + """Ban-safety and per-provider context guarantees of the failover loop.""" + + def test_decisive_failure_skips_same_accounts_other_streams(self): + # Account 1 carries two variants (e.g. FHD + HD). A decisive + # (auth/ban-class) failure on the first must NOT retry account 1's + # second stream — that would hammer a banning provider — but a + # DIFFERENT account stays fair game. + streams = [ + _make_catchup_stream(account_id=1, stream_id="111"), + _make_catchup_stream(account_id=1, stream_id="112"), + _make_catchup_stream(account_id=2, stream_id="222"), + ] + decisive = MagicMock(status_code=403, timeshift_decisive=True) + ok = MagicMock(status_code=200) + response, stream_mock, _ = self._call(streams, [decisive, ok]) + self.assertIs(response, ok) + self.assertEqual(stream_mock.call_count, 2) + self.assertEqual( + [c.kwargs["account_id"] for c in stream_mock.call_args_list], [1, 2] + ) + + def test_soft_failure_still_tries_same_accounts_other_streams(self): + # A soft failure (404: this stream's archive missing) is stream- + # specific — the same account's other variant may still have it. + streams = [ + _make_catchup_stream(account_id=1, stream_id="111"), + _make_catchup_stream(account_id=1, stream_id="112"), + ] + soft = MagicMock(status_code=404, timeshift_decisive=False) + ok = MagicMock(status_code=200) + response, stream_mock, _ = self._call(streams, [soft, ok]) + self.assertIs(response, ok) + self.assertEqual(stream_mock.call_count, 2) + self.assertEqual( + [c.kwargs["account_id"] for c in stream_mock.call_args_list], [1, 1] + ) + + def test_each_stream_uses_its_own_provider_timezone(self): + # June: 17:00 UTC = 19:00 Brussels (CEST) but 13:00 New York (EDT). + # The converted timestamp must be recomputed per attempt. + streams = [ + _make_catchup_stream(account_id=1, stream_id="111", + provider_tz="Europe/Brussels"), + _make_catchup_stream(account_id=2, stream_id="222", + provider_tz="America/New_York"), + ] + response, _, build_mock = self._call( + streams, + [MagicMock(status_code=404, timeshift_decisive=False), + MagicMock(status_code=200)], + ) + self.assertEqual(response.status_code, 200) + self.assertEqual( + [c.args[2] for c in build_mock.call_args_list], + ["2026-06-08:19-00", "2026-06-08:13-00"], + ) + + def test_stream_limit_exceeded_returns_403_before_upstream(self): + streams = [_make_catchup_stream(account_id=1, stream_id="111")] + response, stream_mock, _ = self._call(streams, [], limits=False) + self.assertEqual(response.status_code, 403) + stream_mock.assert_not_called() + + def test_no_catchup_streams_returns_400(self): + response, stream_mock, _ = self._call([], []) + self.assertEqual(response.status_code, 400) + stream_mock.assert_not_called() + + def test_all_streams_ineligible_returns_400(self): + streams = [ + _make_catchup_stream(account_id=1, account_type="M3U"), + _make_catchup_stream(account_id=2, stream_id=None), + ] + response, stream_mock, _ = self._call(streams, []) + self.assertEqual(response.status_code, 400) + stream_mock.assert_not_called() + + +class XcServerInfoUtcTests(TestCase): + """The XC server_info 'timezone triple' guarantee the timeshift chain + relies on: server_info.timezone is always UTC and time_now is UTC + wall-clock. (Tested here because catch-up seek correctness depends on + it: clients build the timeshift URL from this declared zone.)""" + + def test_server_info_is_strictly_utc(self): + from datetime import datetime, timezone as dt_timezone + from apps.output.views import _build_xc_server_info + + request = MagicMock(scheme="http") + info = _build_xc_server_info(request, "example.test", "9191") + self.assertEqual(info["timezone"], "UTC") + reported = datetime.strptime(info["time_now"], "%Y-%m-%d %H:%M:%S") + now_utc = datetime.now(dt_timezone.utc).replace(tzinfo=None) + self.assertLess(abs((now_utc - reported).total_seconds()), 60) + self.assertIsInstance(info["timestamp_now"], int) + + +class StreamFromProviderDecisiveEdgeTests(TestCase): + """Remaining decisive-status and transport-error paths of the cascade.""" + + def setUp(self): + self.kwargs = dict( + candidate_urls=[ + "http://example.test/timeshift/u/p/60/2026-05-12:17-00/1.ts", + "http://example.test/streaming/timeshift.php?stream=1&start=2026-05-12_17-00", + ], + user_agent="test-agent", + range_header=None, + virtual_channel_id="timeshift_1_2026-05-12-17-00_1", + client_id="timeshift_test456", + client_ip="127.0.0.1", + user=None, + channel_display_name="Test", + timestamp_utc="2026-05-12:17-00", + channel_logo_id=None, + m3u_profile_id=None, + debug=False, + ) + + @patch.object(views, "_open_upstream") + def test_406_is_decisive_and_marks_response(self, mocked_open): + # 406 = IP-wide block in the XC ban escalation — single attempt, + # generic 400 to the client, and the failover loop must see the + # decisive marker so it skips this account's other streams. + mocked_open.return_value = _fake_upstream(406) + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 400) + self.assertEqual(mocked_open.call_count, 1) + self.assertTrue(response.timeshift_decisive) + + @patch.object(views, "_open_upstream") + def test_404_failure_is_not_decisive(self, mocked_open): + mocked_open.return_value = _fake_upstream(404) + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 404) + self.assertFalse(response.timeshift_decisive) + + @patch.object(views, "_open_upstream") + def test_connection_error_returns_400_after_single_attempt(self, mocked_open): + import requests as _requests + mocked_open.side_effect = _requests.exceptions.ConnectionError("boom") + response = views._stream_from_provider(**self.kwargs) + self.assertEqual(response.status_code, 400) + self.assertEqual(mocked_open.call_count, 1) + # Transport errors are host-level, not auth/ban-class: the failover + # loop may still try a different account. + self.assertFalse(getattr(response, "timeshift_decisive", False)) + + +class CatchupStreamsDbTests(TestCase): + """get_channel_catchup_streams: the function that defines the failover + order — channelstream order, catch-up streams only, active accounts only.""" + + @classmethod + def setUpTestData(cls): + from apps.channels.models import Channel, ChannelStream, Stream + from apps.m3u.models import M3UAccount + + cls.active = M3UAccount.objects.create( + name="ts-test-active", server_url="http://example.test", + account_type="XC", is_active=True, + ) + cls.inactive = M3UAccount.objects.create( + name="ts-test-inactive", server_url="http://example.test", + account_type="XC", is_active=False, + ) + cls.channel = Channel.objects.create(name="ts-test-channel", is_catchup=True) + + def add(name, account, *, catchup, order): + s = Stream.objects.create( + name=name, url=f"http://example.test/{name}", + m3u_account=account, is_catchup=catchup, + ) + ChannelStream.objects.create(channel=cls.channel, stream=s, order=order) + return s + + cls.s_inactive = add("s-inactive", cls.inactive, catchup=True, order=0) + cls.s_second = add("s-second", cls.active, catchup=True, order=2) + cls.s_first = add("s-first", cls.active, catchup=True, order=1) + cls.s_live_only = add("s-live-only", cls.active, catchup=False, order=3) + + def test_ordered_active_catchup_streams_only(self): + from apps.channels.utils import get_channel_catchup_streams + + result = get_channel_catchup_streams(self.channel) + # Inactive-account and non-catchup streams excluded; channelstream order. + self.assertEqual([s.id for s in result], [self.s_first.id, self.s_second.id]) + + def test_channel_without_catchup_flag_returns_empty(self): + from apps.channels.models import Channel + from apps.channels.utils import get_channel_catchup_streams + + ch = Channel.objects.create(name="ts-test-nocatchup", is_catchup=False) + self.assertEqual(get_channel_catchup_streams(ch), []) + + +class AuthHelpersDbTests(TestCase): + """_authenticate_user (xc_password custom property) and + _user_can_access_channel (user_level gate) — exercised against real models + instead of being mocked away.""" + + @classmethod + def setUpTestData(cls): + from apps.accounts.models import User + from apps.channels.models import Channel + + cls.viewer = User.objects.create( + username="ts-test-viewer", user_level=0, + custom_properties={"xc_password": "right-pass"}, + ) + cls.no_xc = User.objects.create( + username="ts-test-noxc", user_level=10, + custom_properties={}, + ) + cls.basic_channel = Channel.objects.create(name="ts-test-basic", user_level=0) + cls.admin_channel = Channel.objects.create(name="ts-test-adult", user_level=10) + + def test_valid_xc_password_authenticates(self): + user = views._authenticate_user("ts-test-viewer", "right-pass") + self.assertIsNotNone(user) + self.assertEqual(user.id, self.viewer.id) + + def test_wrong_xc_password_rejected(self): + self.assertIsNone(views._authenticate_user("ts-test-viewer", "wrong")) + + def test_user_without_xc_password_rejected(self): + # Accounts with no xc_password set (e.g. admins) must be denied even + # if the caller guesses any string — there is nothing to compare to. + self.assertIsNone(views._authenticate_user("ts-test-noxc", "")) + self.assertIsNone(views._authenticate_user("ts-test-noxc", "anything")) + + def test_unknown_username_rejected(self): + self.assertIsNone(views._authenticate_user("ts-test-ghost", "x")) + + def test_user_level_gate(self): + # Level-0 viewer with no profiles: allowed on level-0, denied on level-10. + self.assertTrue(views._user_can_access_channel(self.viewer, self.basic_channel)) + self.assertFalse(views._user_can_access_channel(self.viewer, self.admin_channel)) + + +class TimeshiftSlotPoolTests(_ProxyLoopTestMixin, TestCase): + """Provider pool participation: a profile slot is reserved before any + upstream attempt and released exactly once afterwards, the same accounting + contract live (Channel.get_stream) and VOD follow. Each active stream + reserves its own slot so concurrent provider connections stay capped by + max_streams.""" + + POOL_KEY = f"timeshift_pool:{TEST_SESSION_ID}" + + def _pool_entry_ids(self): + return [k for k in self.fake_redis.store if k.startswith("timeshift_pool:")] + + def test_reserve_called_with_default_profile_before_upstream(self): + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + response, stream_mock, _ = self._call(streams, [MagicMock(status_code=200)]) + self.assertEqual(response.status_code, 200) + self.reserve_mock.assert_called_once() + reserved_profile = self.reserve_mock.call_args.args[0] + self.assertEqual(reserved_profile.id, 31) + # The reserved profile's id is what reaches the stats metadata. + self.assertEqual(stream_mock.call_args.kwargs["m3u_profile_id"], 31) + + def test_slot_released_after_failed_attempt(self): + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + response, _, _ = self._call( + streams, [MagicMock(status_code=404, timeshift_decisive=False)] + ) + self.assertEqual(response.status_code, 404) + # The failed attempt's slot was released and its pool entry removed. + self.release_mock.assert_called_once_with(31, self.fake_redis) + self.assertEqual(self._pool_entry_ids(), []) + + def test_slot_kept_on_success_for_the_streaming_session(self): + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + response, _, _ = self._call(streams, [MagicMock(status_code=200)]) + self.assertEqual(response.status_code, 200) + # Slot still owned by the (mocked) streaming session: a busy pool entry + # remains for the next request to reuse, nothing released yet. + self.release_mock.assert_not_called() + self.assertEqual(len(self._pool_entry_ids()), 1) + + def test_decisive_failure_releases_slot_and_skips_account(self): + streams = [ + _make_catchup_stream(account_id=1, stream_id="111", profile_id=31), + _make_catchup_stream(account_id=1, stream_id="112", profile_id=31), + ] + response, stream_mock, _ = self._call( + streams, [MagicMock(status_code=403, timeshift_decisive=True)] + ) + self.assertEqual(response.status_code, 403) + self.assertEqual(stream_mock.call_count, 1) + self.release_mock.assert_called_once_with(31, self.fake_redis) + # Decisive skip means the second stream never reserved a slot. + self.assertEqual(self.reserve_mock.call_count, 1) + + def test_profile_full_walks_to_next_profile_same_account(self): + alt = _make_alt_profile(32) + streams = [_make_catchup_stream( + account_id=1, stream_id="111", profile_id=31, extra_profiles=(alt,) + )] + response, stream_mock, _ = self._call( + streams, [MagicMock(status_code=200)], + reserve_results=[(False, 1, "profile_full"), (True, 1, None)], + ) + self.assertEqual(response.status_code, 200) + # Default profile full -> alternate profile reserved and used. + self.assertEqual( + [c.args[0].id for c in self.reserve_mock.call_args_list], [31, 32] + ) + self.assertEqual(stream_mock.call_args.kwargs["m3u_profile_id"], 32) + # Credentials were resolved for the RESERVED (alternate) profile. + self.assertIs(self.creds_mock.call_args.args[1], alt) + + def test_all_profiles_full_returns_503_without_upstream_attempt(self): + streams = [ + _make_catchup_stream(account_id=1, stream_id="111", profile_id=31), + _make_catchup_stream(account_id=2, stream_id="222", profile_id=41), + ] + response, stream_mock, _ = self._call( + streams, [], + reserve_results=[ + (False, 1, "profile_full"), + (False, 1, "credential_full"), + ], + ) + # Pool capacity exhausted everywhere: 503 (VOD's pool-exhausted + # status), and crucially the provider was never contacted. + self.assertEqual(response.status_code, 503) + stream_mock.assert_not_called() + self.release_mock.assert_not_called() + + def test_capacity_failure_is_not_decisive_for_the_account(self): + # profile_full on account 1's first stream must NOT mark account 1 + # decisive — capacity is transient, unlike a ban-class status. + streams = [ + _make_catchup_stream(account_id=1, stream_id="111", profile_id=31), + _make_catchup_stream(account_id=1, stream_id="112", profile_id=31), + ] + response, stream_mock, _ = self._call( + streams, [MagicMock(status_code=200)], + reserve_results=[(False, 1, "profile_full"), (True, 1, None)], + ) + self.assertEqual(response.status_code, 200) + # Second stream of the SAME account still got its reservation attempt. + self.assertEqual(self.reserve_mock.call_count, 2) + self.assertEqual(stream_mock.call_count, 1) + + def test_account_without_active_default_profile_is_skipped(self): + # Mirrors live dispatch: no active default profile -> skip the account + # without reserving anything. + stream = _make_catchup_stream(account_id=1, stream_id="111") + stream.m3u_account.profiles.filter.return_value = [_make_alt_profile(32)] + response, stream_mock, _ = self._call([stream], []) + self.assertEqual(response.status_code, 400) + self.reserve_mock.assert_not_called() + stream_mock.assert_not_called() + + def test_exception_from_provider_releases_slot(self): + # An unexpected exception between reserve and response construction + # must release the slot before propagating — otherwise the counter + # (no TTL) leaks until the next Redis flush. + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + with self.assertRaises(RuntimeError): + self._call(streams, RuntimeError("boom")) + self.release_mock.assert_called_once_with(31, self.fake_redis) + self.assertEqual(self._pool_entry_ids(), []) + + def test_exception_before_upstream_releases_slot(self): + # Same guarantee for failures BEFORE the upstream call (URL building, + # credential resolution, user-agent lookup) — the guarded window + # starts right after the reservation. + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + with self.assertRaises(RuntimeError): + self._call(streams, [], build_side_effect=RuntimeError("boom")) + self.stream_mock.assert_not_called() + self.release_mock.assert_called_once_with(31, self.fake_redis) + self.assertEqual(self._pool_entry_ids(), []) + + def test_mixed_capacity_then_upstream_failure_returns_failure(self): + # Mixed outcome: one stream capacity-blocked, another actually tried + # upstream and failed -> the REAL upstream failure wins over 503 + # (capacity was not the sole blocker). + streams = [ + _make_catchup_stream(account_id=1, stream_id="111", profile_id=31), + _make_catchup_stream(account_id=2, stream_id="222", profile_id=41), + ] + response, _, _ = self._call( + streams, + [MagicMock(status_code=404, timeshift_decisive=False)], + reserve_results=[(False, 1, "profile_full"), (True, 1, None)], + ) + self.assertEqual(response.status_code, 404) + + def test_mixed_upstream_failure_then_capacity_returns_failure(self): + # Same in the opposite order. + streams = [ + _make_catchup_stream(account_id=1, stream_id="111", profile_id=31), + _make_catchup_stream(account_id=2, stream_id="222", profile_id=41), + ] + response, _, _ = self._call( + streams, + [MagicMock(status_code=404, timeshift_decisive=False)], + reserve_results=[(True, 1, None), (False, 1, "profile_full")], + ) + self.assertEqual(response.status_code, 404) + + +class TimeshiftPoolReleaseTests(TestCase): + """Pool slot release and response close paths for a pooled session.""" + + def setUp(self): + self.redis = _FakeRedis() + self.session_id = TEST_SESSION_ID + + def _pool_key(self): + return f"timeshift_pool:{self.session_id}" + + def test_release_callback_frees_slot_exactly_once(self): + _seed_pool_session(self.redis, session_id=self.session_id) + release = views._make_release_once(self.redis, self.session_id, 31) + with patch.object(views, "release_profile_slot") as release_mock: + release() + release() + release_mock.assert_called_once_with(31, self.redis) + self.assertEqual(self.redis.hget(self._pool_key(), "busy"), "0") + self.assertTrue(self.redis.exists(self._pool_key())) + + def test_discard_frees_slot_and_removes_entry(self): + _seed_pool_session(self.redis, session_id=self.session_id) + with patch.object(views, "release_profile_slot") as release_mock: + views._discard_pool_session(self.redis, self.session_id, 31) + release_mock.assert_called_once_with(31, self.redis) + self.assertFalse(self.redis.exists(self._pool_key())) + + def test_release_without_redis_is_noop(self): + release = views._make_release_once(None, self.session_id, 31) + with patch.object(views, "release_profile_slot") as release_mock: + release() + release_mock.assert_not_called() + + def test_wrapper_close_releases_even_when_generator_never_started(self): + # The WSGI layer can close the response before the first chunk is + # pulled; closing a never-started generator runs NO body code, so the + # generator's own finally cannot be the only release point. + finally_ran = [] + + def gen(): + try: + yield b"x" + finally: + finally_ran.append(True) + + on_close = MagicMock() + wrapper = views._SlotReleasingStream(gen(), on_close) + wrapper.close() + on_close.assert_called_once() + self.assertEqual(finally_ran, []) # proves the leak this wrapper fixes + + def test_streaming_response_close_invokes_wrapper_close(self): + # Locks the Django contract the wrapper relies on: an iterator with a + # close() method is registered as a resource closer of the response. + from django.http import StreamingHttpResponse + + on_close = MagicMock() + wrapper = views._SlotReleasingStream(iter([b"x"]), on_close) + response = StreamingHttpResponse(wrapper, content_type="video/mp2t") + response.close() + on_close.assert_called_once() + + +class TimeshiftTakeoverTests(TestCase): + """A new request displaces the user's previous catch-up session(s) on the + same channel at a DIFFERENT position (stats unregister + stop key, leaving + the displaced generator to free its own slot), while leaving sibling range + requests of the same playback alone, and never touching other users, + channels, or live.""" + + def setUp(self): + self.redis = _FakeRedis() + self.user = MagicMock(id=5) + + def _conn(self, media_id, client_id, conn_type="timeshift"): + return { + "media_id": media_id, + "client_id": client_id, + "connected_at": 0.0, + "type": conn_type, + } + + def test_displaces_other_positions_on_same_channel(self): + connections = [ + self._conn("timeshift_8_2026-06-08-17-00_111", "timeshift_old1"), + self._conn("timeshift_9_2026-06-08-17-00_222", "timeshift_other"), + self._conn("42", "live_client", conn_type="live"), + ] + with patch.object(views, "get_user_active_connections", + return_value=connections) as conns_mock, \ + patch.object(views, "release_profile_slot") as release_mock, \ + patch.object(views, "_unregister_stats_client") as unregister_mock: + views._terminate_previous_timeshift_sessions( + self.redis, self.user, 8, "timeshift_8_2026-06-09-20-00", "timeshift_current", + ) + conns_mock.assert_called_once_with(5) + # Takeover defers slot release to the displaced generator's stop path; + # it only drops stats and signals the stop key. + release_mock.assert_not_called() + unregister_mock.assert_called_once_with( + self.redis, "timeshift_8_2026-06-08-17-00_111", "timeshift_old1" + ) + from apps.proxy.live_proxy.redis_keys import RedisKeys + stop_key = RedisKeys.client_stop( + "timeshift_8_2026-06-08-17-00_111", "timeshift_old1" + ) + self.assertIn(stop_key, self.redis.store) + # Channel 9's session untouched: no stop key set for it. + other_stop = RedisKeys.client_stop( + "timeshift_9_2026-06-08-17-00_222", "timeshift_other" + ) + self.assertNotIn(other_stop, self.redis.store) + + def test_leaves_sibling_requests_of_current_playback(self): + # Concurrent range/probe requests of the SAME playback must not + # displace one another. + connections = [ + self._conn("timeshift_8_2026-06-08-17-00_111", "timeshift_sibling"), + ] + with patch.object(views, "get_user_active_connections", + return_value=connections), \ + patch.object(views, "release_profile_slot") as release_mock, \ + patch.object(views, "_unregister_stats_client") as unregister_mock: + views._terminate_previous_timeshift_sessions( + self.redis, self.user, 8, "timeshift_8_2026-06-08-17-00", + "timeshift_sibling", + ) + release_mock.assert_not_called() + unregister_mock.assert_not_called() + + def test_channel_id_prefix_cannot_match_other_channels(self): + # Channel 8 must not displace channel 80/81 sessions (prefix ends + # with an underscore). + connections = [ + self._conn("timeshift_80_2026-06-08-17-00_111", "timeshift_c80"), + ] + with patch.object(views, "get_user_active_connections", + return_value=connections), \ + patch.object(views, "release_profile_slot") as release_mock, \ + patch.object(views, "_unregister_stats_client") as unregister_mock: + views._terminate_previous_timeshift_sessions( + self.redis, self.user, 8, "timeshift_8_2026-06-08-17-00", + "timeshift_new", + ) + release_mock.assert_not_called() + unregister_mock.assert_not_called() + + def test_noop_without_redis_or_user(self): + with patch.object(views, "get_user_active_connections") as conns_mock: + views._terminate_previous_timeshift_sessions( + None, self.user, 8, "timeshift_8_ts", "timeshift_s" + ) + views._terminate_previous_timeshift_sessions( + self.redis, None, 8, "timeshift_8_ts", "timeshift_s" + ) + conns_mock.assert_not_called() + + def test_proxy_runs_takeover_before_stream_limit_check(self): + # Order matters: with terminate_on_limit_exceeded=False a seek must + # displace its own predecessor BEFORE the limit check counts it, or + # the user's own seek gets denied. + call_order = [] + request = RequestFactory().get(_proxy_url()) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", + return_value=[_make_catchup_stream()]), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "_terminate_previous_timeshift_sessions", + side_effect=lambda *a: call_order.append("takeover")) as takeover_mock, \ + patch.object(views, "check_user_stream_limits", + side_effect=lambda *a, **k: call_order.append("limits") or False): + redis_cls.get_client.return_value = self.redis + channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts" + ) + self.assertEqual(response.status_code, 403) + self.assertEqual(call_order, ["takeover", "limits"]) + self.assertEqual(takeover_mock.call_args.args[2], 8) + + +class TimeshiftSessionReuseTests(TestCase): + """Per-client session pool acquire/reuse paths.""" + + SESSION = TEST_SESSION_ID + + def setUp(self): + self.redis = _FakeRedis() + self.factory = RequestFactory() + self.channel = MagicMock(id=8, name="Test") + self.user = MagicMock(id=5) + + def _pool_key(self): + return f"timeshift_pool:{self.SESSION}" + + def _make_idle_entry(self): + _seed_pool_session(self.redis, session_id=self.SESSION) + with patch.object(views, "release_profile_slot"): + views._release_pool_session(self.redis, self.SESSION, 31) + + def test_wait_returns_none_without_blocking_when_pool_empty(self): + start = time.monotonic() + acquired = views._wait_for_idle_pool_session(self.redis, self.SESSION) + self.assertIsNone(acquired) + self.assertLess(time.monotonic() - start, 0.5) + + def test_acquire_reuses_idle_entry_and_reserves_slot(self): + self._make_idle_entry() + profile = MagicMock(id=31) + with patch.object(views.M3UAccountProfile.objects, "get", + return_value=profile), \ + patch.object(views, "reserve_profile_slot", + return_value=(True, 1, None)) as reserve_mock: + acquired = views._acquire_idle_pool_session( + self.redis, self.SESSION, user_id=5, + ) + self.assertIsNotNone(acquired) + descriptor, got_profile = acquired + self.assertEqual(descriptor["stream_id"], "111") + self.assertIs(got_profile, profile) + reserve_mock.assert_called_once_with(profile, self.redis) + self.assertEqual(self.redis.hget(self._pool_key(), "busy"), "1") + + def test_acquire_skips_busy_entry(self): + _seed_pool_session(self.redis, session_id=self.SESSION, busy="1") + with patch.object(views.M3UAccountProfile.objects, "get") as prof_mock, \ + patch.object(views, "reserve_profile_slot") as reserve_mock: + acquired = views._acquire_idle_pool_session( + self.redis, self.SESSION, user_id=5, + ) + self.assertIsNone(acquired) + prof_mock.assert_not_called() + reserve_mock.assert_not_called() + + def test_acquire_rejects_foreign_user(self): + self._make_idle_entry() + profile = MagicMock(id=31) + with patch.object(views.M3UAccountProfile.objects, "get", + return_value=profile), \ + patch.object(views, "reserve_profile_slot", + return_value=(True, 1, None)) as reserve_mock: + acquired = views._acquire_idle_pool_session( + self.redis, self.SESSION, user_id=99, + ) + self.assertIsNone(acquired) + reserve_mock.assert_not_called() + + def test_foreign_session_id_redirects_instead_of_reusing_pool(self): + victim_session = "timeshift_victim_session" + _seed_pool_session(self.redis, session_id=victim_session, user_id=99) + request = self.factory.get(_proxy_url(victim_session)) + attacker = MagicMock(id=5) + with patch.object(views, "_authenticate_user", return_value=attacker), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", + return_value=[_make_catchup_stream()]), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "parse_catchup_timestamp", return_value=True), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "_acquire_idle_pool_session") as acquire_mock, \ + patch.object(views, "_attempt_timeshift_stream") as attempt_mock: + redis_cls.get_client.return_value = self.redis + channel_cls.objects.get.return_value = MagicMock(id=8) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts", + ) + self.assertEqual(response.status_code, 301) + self.assertIn("session_id=timeshift_", response["Location"]) + self.assertNotIn(victim_session, response["Location"]) + acquire_mock.assert_not_called() + attempt_mock.assert_not_called() + + def test_find_matching_idle_session_requires_ip_and_user_agent(self): + _seed_pool_session( + self.redis, session_id="timeshift_other", + user_id=5, client_ip="1.2.3.4", client_user_agent="test-agent", + ) + with patch.object(views, "release_profile_slot"): + views._release_pool_session(self.redis, "timeshift_other", 31) + matched = views._find_matching_idle_session( + self.redis, + media_id=TEST_MEDIA_ID, + user_id=5, + client_ip="1.2.3.4", + client_user_agent="test-agent", + ) + self.assertEqual(matched, "timeshift_other") + + def test_find_matching_idle_session_rejects_ip_only_partial_fingerprint(self): + _seed_pool_session( + self.redis, session_id="timeshift_other", + user_id=5, client_ip="1.2.3.4", client_user_agent="other-agent", + ) + with patch.object(views, "release_profile_slot"): + views._release_pool_session(self.redis, "timeshift_other", 31) + matched = views._find_matching_idle_session( + self.redis, + media_id=TEST_MEDIA_ID, + user_id=5, + client_ip="1.2.3.4", + client_user_agent="test-agent", + ) + self.assertIsNone(matched) + + def test_find_matching_idle_session_rejects_different_user(self): + _seed_pool_session( + self.redis, session_id="timeshift_other", + user_id=99, client_ip="1.2.3.4", client_user_agent="test-agent", + ) + with patch.object(views, "release_profile_slot"): + views._release_pool_session(self.redis, "timeshift_other", 31) + matched = views._find_matching_idle_session( + self.redis, + media_id=TEST_MEDIA_ID, + user_id=5, + client_ip="1.2.3.4", + client_user_agent="test-agent", + ) + self.assertIsNone(matched) + + def test_legacy_pool_entry_exists_helper_removed(self): + self.assertFalse(hasattr(views, "_pool_entry_exists")) + + def test_new_session_uses_single_hgetall_before_pool_create(self): + redis = _FakeRedis() + request = self.factory.get(_proxy_url("timeshift_newsession1")) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", + return_value=[_make_catchup_stream()]), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "check_user_stream_limits", return_value=True), \ + patch.object(views, "_find_matching_idle_session", return_value=None), \ + patch.object(views, "_attempt_timeshift_stream", + return_value=MagicMock(status_code=200)), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \ + patch.object(views, "release_profile_slot"), \ + patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \ + patch.object(views, "get_user_active_connections", return_value=[]): + redis_cls.get_client.return_value = redis + channel_cls.objects.get.return_value = MagicMock(id=8, name="Test", logo_id=None) + with patch.object(redis, "hgetall", wraps=redis.hgetall) as hgetall_mock: + views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts", + ) + pool_key = "timeshift_pool:timeshift_newsession1" + self.assertEqual( + sum(1 for c in hgetall_mock.call_args_list if c.args == (pool_key,)), + 1, + ) + + +class TimeshiftSessionRedirectTests(TestCase): + """First request must establish a session via 301 redirect (VOD-style).""" + + def setUp(self): + self.factory = RequestFactory() + + def test_missing_session_id_redirects(self): + request = self.factory.get(_proxy_url(session_id=None)) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=1)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", + return_value=[_make_catchup_stream()]), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "parse_catchup_timestamp", return_value=True), \ + patch.object(views, "RedisClient") as redis_cls: + redis_cls.get_client.return_value = _FakeRedis() + channel_cls.objects.get.return_value = MagicMock(id=8) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts", + ) + self.assertEqual(response.status_code, 301) + self.assertIn("session_id=timeshift_", response["Location"]) + + def test_redirect_preserves_existing_query_params(self): + request = self.factory.get( + "/timeshift/u/p/8/2026-06-08:17-00/8.ts?foo=bar&baz=1", + ) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=1)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", + return_value=[_make_catchup_stream()]), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "parse_catchup_timestamp", return_value=True), \ + patch.object(views, "RedisClient") as redis_cls: + redis_cls.get_client.return_value = _FakeRedis() + channel_cls.objects.get.return_value = MagicMock(id=8) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts", + ) + self.assertEqual(response.status_code, 301) + location = response["Location"] + self.assertIn("session_id=timeshift_", location) + self.assertIn("foo=bar", location) + self.assertIn("baz=1", location) + + +class TimeshiftStreamLimitExemptionTests(TestCase): + """Timeshift stream-limit bypass requires the same client session.""" + + MEDIA = TEST_MEDIA_ID + + def setUp(self): + self.user = MagicMock(id=5, username="viewer", stream_limit=1) + + def _limits_settings(self, ignore_same_channel=True): + return { + "ignore_same_channel_connections": ignore_same_channel, + "terminate_on_limit_exceeded": False, + } + + def test_same_session_probe_allowed_at_limit(self): + connections = [{ + "media_id": f"{self.MEDIA}_111", + "client_id": TEST_SESSION_ID, + "connected_at": 0.0, + "type": "timeshift", + }] + with patch("apps.proxy.utils.get_user_active_connections", + return_value=connections), \ + patch("apps.proxy.utils.CoreSettings.get_user_limits_settings", + return_value=self._limits_settings()): + allowed = _check_user_stream_limits( + self.user, TEST_SESSION_ID, media_id=self.MEDIA, + ) + self.assertTrue(allowed) + + def test_different_session_same_programme_counts_against_limit(self): + connections = [{ + "media_id": f"{self.MEDIA}_111", + "client_id": "timeshift_other_session", + "connected_at": 0.0, + "type": "timeshift", + }] + with patch("apps.proxy.utils.get_user_active_connections", + return_value=connections), \ + patch("apps.proxy.utils.CoreSettings.get_user_limits_settings", + return_value=self._limits_settings()): + allowed = _check_user_stream_limits( + self.user, TEST_SESSION_ID, media_id=self.MEDIA, + ) + self.assertFalse(allowed) + + +class FakeRedisScanTests(TestCase): + """FakeRedis SCAN matches redis-py glob semantics used by the pool scanner.""" + + def setUp(self): + self.redis = _FakeRedis() + self.redis.store["timeshift_pool:timeshift_a"] = {"busy": "0"} + self.redis.store["timeshift_pool:timeshift_b"] = {"busy": "0"} + self.redis.store["timeshift_pool:other_c"] = {"busy": "0"} + self.redis.store["vod_persistent_connection:x"] = {} + + def test_scan_glob_filters_pool_keys(self): + cursor = 0 + seen = [] + while True: + cursor, keys = self.redis.scan( + cursor, match="timeshift_pool:timeshift_*", count=1, + ) + seen.extend(keys) + if cursor == 0: + break + self.assertEqual( + seen, + ["timeshift_pool:timeshift_a", "timeshift_pool:timeshift_b"], + ) + + +class TimeshiftRangeClassificationTests(TestCase): + """Startup probes must not be treated as scrubs.""" + + def test_full_file_request_is_not_displacing(self): + self.assertFalse(views._should_displace_busy_playback(None)) + + def test_bytes_zero_displaces_full_file_probe(self): + self.assertTrue( + views._should_displace_busy_playback("bytes=0-", busy_serving_range="none") + ) + + def test_bytes_zero_does_not_displace_active_start_stream(self): + self.assertFalse( + views._should_displace_busy_playback("bytes=0-", busy_serving_range="start") + ) + + def test_bytes_zero_without_busy_context_is_not_displacing(self): + self.assertFalse(views._should_displace_busy_playback("bytes=0-")) + + def test_near_eof_probe_is_not_displacing(self): + self.assertTrue(views._is_near_eof_probe("bytes=2527702896-")) + self.assertFalse(views._should_displace_busy_playback("bytes=2527702896-")) + + def test_near_eof_probe_uses_cached_content_length(self): + # 5 MB into a 10 MB file is a scrub, not a tail probe. + self.assertFalse( + views._is_near_eof_probe("bytes=5000000-", content_length="10000000") + ) + self.assertTrue( + views._should_displace_busy_playback("bytes=5000000-", content_length="10000000") + ) + # Within 512 KB of EOF is a tail probe once length is known. + self.assertTrue( + views._is_near_eof_probe("bytes=9990000-", content_length="10000000") + ) + + def test_midfile_seek_is_displacing(self): + self.assertTrue(views._should_displace_busy_playback("bytes=5000000-")) + + def test_small_nonzero_range_is_displacing(self): + self.assertTrue(views._should_displace_busy_playback("bytes=1000-")) + + +class TimeshiftScrubPreemptTests(TestCase): + """Scrub/range requests must stop the in-flight stream and reuse the pooled + provider slot instead of opening parallel upstream connections.""" + + def setUp(self): + self.redis = _FakeRedis() + self.user = MagicMock(id=5) + self.factory = RequestFactory() + + def _conn(self, media_id, client_id): + return { + "media_id": media_id, + "client_id": client_id, + "connected_at": 0.0, + "type": "timeshift", + } + + def test_preempt_stops_sibling_clients_of_same_playback(self): + connections = [ + self._conn(f"{TEST_MEDIA_ID}_111", TEST_SESSION_ID), + self._conn("timeshift_9_2026-06-08-17-00_222", "timeshift_other"), + ] + with patch.object(views, "get_user_active_connections", + return_value=connections), \ + patch.object(views, "_unregister_stats_client") as unregister_mock: + views._preempt_playback_streams(self.redis, TEST_SESSION_ID, self.user) + unregister_mock.assert_called_once_with( + self.redis, f"{TEST_MEDIA_ID}_111", TEST_SESSION_ID, + ) + from apps.proxy.live_proxy.redis_keys import RedisKeys + stop_key = RedisKeys.client_stop(f"{TEST_MEDIA_ID}_111", TEST_SESSION_ID) + self.assertIn(stop_key, self.redis.store) + + def test_preempt_leaves_other_playbacks_alone(self): + connections = [ + self._conn("timeshift_8_2026-06-09-20-00_111", "timeshift_other_pos"), + ] + with patch.object(views, "get_user_active_connections", + return_value=connections), \ + patch.object(views, "_unregister_stats_client") as unregister_mock: + views._preempt_playback_streams(self.redis, TEST_SESSION_ID, self.user) + unregister_mock.assert_not_called() + + def test_busy_pool_returns_503_instead_of_second_provider_connection(self): + _seed_pool_session(self.redis, session_id=TEST_SESSION_ID) + request = self.factory.get( + _proxy_url(TEST_SESSION_ID), + HTTP_RANGE="bytes=1000-", + ) + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", return_value=streams), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "check_user_stream_limits", return_value=True), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \ + patch.object(views, "release_profile_slot"), \ + patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \ + patch.object(views, "get_user_active_connections", return_value=[]), \ + patch.object(views, "_preempt_playback_streams") as preempt_mock, \ + patch.object(views, "_wait_for_idle_pool_session", return_value=None), \ + patch.object(views, "_attempt_timeshift_stream") as attempt_mock: + redis_cls.get_client.return_value = self.redis + channel_cls.objects.get.return_value = MagicMock( + id=8, name="Test", logo_id=None, + ) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts", + ) + self.assertEqual(response.status_code, 503) + preempt_mock.assert_called_once() + attempt_mock.assert_not_called() + self.assertEqual(len(self._pool_entry_ids()), 1) + + def _pool_entry_ids(self): + return [k for k in self.redis.store if k.startswith("timeshift_pool:")] + + def test_startup_bytes_zero_deferred_without_preempt(self): + _seed_pool_session( + self.redis, session_id=TEST_SESSION_ID, serving_range="start", + ) + request = self.factory.get( + _proxy_url(TEST_SESSION_ID), + HTTP_RANGE="bytes=0-", + ) + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", return_value=streams), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "check_user_stream_limits", return_value=True), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \ + patch.object(views, "release_profile_slot"), \ + patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \ + patch.object(views, "get_user_active_connections", return_value=[]), \ + patch.object(views, "_preempt_playback_streams") as preempt_mock, \ + patch.object(views, "_attempt_timeshift_stream") as attempt_mock: + redis_cls.get_client.return_value = self.redis + channel_cls.objects.get.return_value = MagicMock( + id=8, name="Test", logo_id=None, + ) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts", + ) + self.assertEqual(response.status_code, 503) + preempt_mock.assert_not_called() + attempt_mock.assert_not_called() + + def test_eof_probe_deferred_without_preempt(self): + _seed_pool_session(self.redis, session_id=TEST_SESSION_ID) + request = self.factory.get( + _proxy_url(TEST_SESSION_ID), + HTTP_RANGE="bytes=2527702896-", + ) + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", return_value=streams), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "check_user_stream_limits", return_value=True), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "reserve_profile_slot", return_value=(True, 1, None)), \ + patch.object(views, "release_profile_slot"), \ + patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \ + patch.object(views, "get_user_active_connections", return_value=[]), \ + patch.object(views, "_preempt_playback_streams") as preempt_mock, \ + patch.object(views, "_attempt_timeshift_stream") as attempt_mock: + redis_cls.get_client.return_value = self.redis + channel_cls.objects.get.return_value = MagicMock( + id=8, name="Test", logo_id=None, + ) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts", + ) + self.assertEqual(response.status_code, 503) + preempt_mock.assert_not_called() + attempt_mock.assert_not_called() + + def test_create_pool_session_rejects_duplicate_entry(self): + first = views._create_pool_session( + self.redis, + session_id=TEST_SESSION_ID, + media_id=TEST_MEDIA_ID, + user_id=5, + client_ip="1.2.3.4", + client_user_agent="test-agent", + account_id=1, + profile_id=31, + stream_id="111", + provider_timestamp="2026", + ) + second = views._create_pool_session( + self.redis, + session_id=TEST_SESSION_ID, + media_id=TEST_MEDIA_ID, + user_id=5, + client_ip="1.2.3.4", + client_user_agent="test-agent", + account_id=2, + profile_id=41, + stream_id="222", + provider_timestamp="2026", + ) + self.assertTrue(first) + self.assertFalse(second) + self.assertTrue(self.redis.exists(f"timeshift_pool:{TEST_SESSION_ID}")) + + def test_scrub_reuses_idle_pool_without_opening_failover(self): + _seed_pool_session(self.redis, session_id=TEST_SESSION_ID) + with patch.object(views, "release_profile_slot"): + views._release_pool_session(self.redis, TEST_SESSION_ID, 31) + + request = self.factory.get( + _proxy_url(TEST_SESSION_ID), + HTTP_RANGE="bytes=5000-", + ) + streams = [_make_catchup_stream(account_id=1, stream_id="111", profile_id=31)] + profile = MagicMock(id=31) + ok = MagicMock(status_code=206) + with patch.object(views, "_authenticate_user", return_value=MagicMock(id=5)), \ + patch.object(views, "network_access_allowed", return_value=True), \ + patch.object(views, "Channel") as channel_cls, \ + patch.object(views, "_user_can_access_channel", return_value=True), \ + patch.object(views, "get_channel_catchup_streams", return_value=streams), \ + patch.object(views, "get_programme_duration", return_value=40), \ + patch.object(views, "check_user_stream_limits", return_value=True), \ + patch.object(views, "RedisClient") as redis_cls, \ + patch.object(views, "reserve_profile_slot", + return_value=(True, 1, None)) as reserve_mock, \ + patch.object(views, "release_profile_slot"), \ + patch.object(views.M3UAccountProfile.objects, "get", + return_value=profile), \ + patch.object(views, "get_transformed_credentials", side_effect=_fake_creds), \ + patch.object(views, "get_user_active_connections", return_value=[]), \ + patch.object(views, "_preempt_playback_streams") as preempt_mock, \ + patch.object(views, "_stream_reused_session", return_value=ok) as reuse_mock, \ + patch.object(views, "_attempt_timeshift_stream") as attempt_mock: + redis_cls.get_client.return_value = self.redis + channel_cls.objects.get.return_value = MagicMock( + id=8, name="Test", logo_id=None, + ) + response = views.timeshift_proxy( + request, "u", "p", "8", "2026-06-08:17-00", "8.ts", + ) + self.assertIs(response, ok) + preempt_mock.assert_not_called() + reuse_mock.assert_called_once() + attempt_mock.assert_not_called() + # Pool acquire re-reserves the idle slot once; failover must not add another. + reserve_mock.assert_called_once_with(profile, self.redis) + + + +class RollupSelfHealDbTests(TestCase): + """Catch-up flag consistency after stream removal. + + The ChannelStream signal handles bulk deletes (locked by a regression test). + The account-scoped rollup self-heals stale flags on channels still linked + to that account. + """ + + @classmethod + def setUpTestData(cls): + from apps.m3u.models import M3UAccount + + cls.account = M3UAccount.objects.create( + name="ts-rollup-account", server_url="http://example.test", + account_type="XC", is_active=True, + ) + + def _make_channel_with_catchup_stream(self, name, days=5): + from apps.channels.models import Channel, ChannelStream, Stream + + channel = Channel.objects.create(name=name) + stream = Stream.objects.create( + name=f"{name}-stream", url=f"http://example.test/{name}", + m3u_account=self.account, is_catchup=True, catchup_days=days, + ) + ChannelStream.objects.create(channel=channel, stream=stream, order=0) + return channel, stream + + def test_bulk_stream_delete_resets_channel_flags_via_signal(self): + # cleanup_streams() removes stale streams with a queryset bulk delete; + # the cascaded ChannelStream rows still fire post_delete (signal + # listeners disable Django's fast-delete path), which must reset the + # channel's denormalized catch-up fields. + from apps.channels.models import Stream + + channel, stream = self._make_channel_with_catchup_stream("ts-rollup-bulk") + channel.refresh_from_db() + self.assertTrue(channel.is_catchup) + self.assertEqual(channel.catchup_days, 5) + + Stream.objects.filter(id=stream.id).delete() + + channel.refresh_from_db() + self.assertFalse(channel.is_catchup) + self.assertEqual(channel.catchup_days, 0) + + def test_rollup_self_heals_stale_channel_with_non_catchup_stream(self): + # Channel still linked to the account but no active catch-up streams + # (e.g. catch-up flag cleared on import). Rollup must reset stale flags. + from apps.channels.models import Channel, ChannelStream, Stream + from apps.m3u.tasks import rollup_channel_catchup_fields + + channel = Channel.objects.create(name="ts-rollup-stale") + stream = Stream.objects.create( + name="ts-rollup-stale-stream", + url="http://example.test/ts-rollup-stale", + m3u_account=self.account, + is_catchup=False, + catchup_days=0, + ) + ChannelStream.objects.create(channel=channel, stream=stream, order=0) + Channel.objects.filter(pk=channel.pk).update(is_catchup=True, catchup_days=9) + + rollup_channel_catchup_fields(self.account.id) + + channel.refresh_from_db() + self.assertFalse(channel.is_catchup) + self.assertEqual(channel.catchup_days, 0) + + def test_rollup_self_heal_skips_channels_not_linked_to_account(self): + from apps.channels.models import Channel + from apps.m3u.models import M3UAccount + from apps.m3u.tasks import rollup_channel_catchup_fields + + other_account = M3UAccount.objects.create( + name="ts-rollup-other", + server_url="http://example.test/other", + account_type="XC", + is_active=True, + ) + channel = Channel.objects.create(name="ts-rollup-unrelated") + Channel.objects.filter(pk=channel.pk).update(is_catchup=True, catchup_days=9) + + rollup_channel_catchup_fields(other_account.id) + + channel.refresh_from_db() + self.assertTrue(channel.is_catchup) + self.assertEqual(channel.catchup_days, 9) + + def test_rollup_keeps_and_corrects_channels_with_catchup_streams(self): + # The self-heal pass must not touch channels that legitimately have + # catch-up streams. The account-scoped pass still corrects their values. + from apps.channels.models import Channel + from apps.m3u.tasks import rollup_channel_catchup_fields + + channel, _ = self._make_channel_with_catchup_stream("ts-rollup-valid", days=7) + # Knock the denormalized values out of sync (bypasses signals). + Channel.objects.filter(pk=channel.pk).update(is_catchup=False, catchup_days=0) + + rollup_channel_catchup_fields(self.account.id) + + channel.refresh_from_db() + self.assertTrue(channel.is_catchup) + self.assertEqual(channel.catchup_days, 7) diff --git a/apps/timeshift/views.py b/apps/timeshift/views.py new file mode 100644 index 00000000..0ba3a5a7 --- /dev/null +++ b/apps/timeshift/views.py @@ -0,0 +1,1355 @@ +"""XC catch-up (timeshift) proxy with multi-provider failover.""" + +import hmac +import itertools +import logging +import secrets +import time +from urllib.parse import urlencode + +import requests +from django.core.cache import cache +from django.http import ( + Http404, + HttpResponse, + HttpResponseBadRequest, + HttpResponseForbidden, + HttpResponseNotFound, + StreamingHttpResponse, +) + +from apps.accounts.models import User +from apps.channels.models import Channel +from apps.channels.utils import get_channel_catchup_streams +from apps.m3u.connection_pool import release_profile_slot, reserve_profile_slot +from apps.m3u.models import M3UAccount, M3UAccountProfile +from apps.m3u.tasks import get_transformed_credentials +from apps.proxy.live_proxy.config_helper import ConfigHelper +from apps.proxy.live_proxy.constants import ChannelMetadataField, ChannelState +from apps.proxy.live_proxy.redis_keys import RedisKeys +from apps.proxy.live_proxy.utils import get_client_ip +from apps.proxy.utils import ( + check_user_stream_limits, + find_ts_sync, + get_user_active_connections, +) +from core.utils import RedisClient +from dispatcharr.utils import network_access_allowed + +from .helpers import ( + TimeshiftCredentials, + build_timeshift_candidate_urls, + convert_timestamp_to_provider_tz, + get_programme_duration, + parse_catchup_timestamp, +) + +logger = logging.getLogger(__name__) + +CLIENT_TTL_SECONDS = 60 +_MATCH_SCORE_THRESHOLD = 8 # client_ip (5) + client_user_agent (3) + + +def timeshift_proxy(request, username, password, stream_id, timestamp, duration): # noqa: ARG001 stream_id + """Proxy an XC catch-up request to the provider with multi-stream failover. + + URL shape (iPlayTV / TiviMate): + ``stream_id``: EPG channel number (ignored here). + ``duration``: Dispatcharr ``Channel.id`` (XC API exposes channel.id as stream_id). + ``timestamp``: UTC programme start (``YYYY-MM-DD:HH-MM`` or XC colon form + ``YYYY-MM-DD:HH:MM:SS``). + """ + raw_id = duration[:-3] if duration.endswith(".ts") else duration + + user = _authenticate_user(username, password) + if user is None: + return HttpResponseForbidden("Invalid credentials") + + if not network_access_allowed(request, "XC_API", user): + return HttpResponseForbidden("Access denied") + + try: + channel = Channel.objects.get(id=int(raw_id)) + except (Channel.DoesNotExist, ValueError, TypeError): + raise Http404("Channel not found") from None + + if not _user_can_access_channel(user, channel): + return HttpResponseForbidden("Access denied") + + # Shape helpers pass through on parse failure; reject bad input before upstream. + if parse_catchup_timestamp(timestamp) is None: + return HttpResponseBadRequest("Invalid timestamp") + + catchup_streams = get_channel_catchup_streams(channel) + if not catchup_streams: + return HttpResponseBadRequest("Timeshift not supported for this channel") + + debug = logger.isEnabledFor(logging.DEBUG) + + # EPG duration lookup stays in UTC; provider TZ conversion is per-attempt below. + duration_minutes = get_programme_duration(channel, timestamp) + + safe_ts = timestamp.replace(":", "-").replace("/", "-") + client_ip = get_client_ip(request) + client_user_agent = request.META.get("HTTP_USER_AGENT", "") or "" + range_header = request.META.get("HTTP_RANGE") + channel_logo_id = getattr(channel, "logo_id", None) + + redis_client = RedisClient.get_client() + + # Content identity (channel + catch-up position). Provider slot sharing is + # scoped per client session; never assume all requests for the same + # programme belong to one viewer. + media_id = f"timeshift_{channel.id}_{safe_ts}" + + session_id = request.GET.get("session_id") + if not session_id: + logger.debug("Timeshift session redirect: %s (new session)", request.path) + return _redirect_with_new_session(request) + + session_entry = _get_pool_entry(redis_client, session_id) + if session_entry and not _pool_entry_owned_by_user(session_entry, user.id): + logger.info( + "Timeshift: rejecting foreign session_id for user %s", user.id, + ) + return _redirect_with_new_session(request) + + # Stable client identity for stats, stop keys, and the provider pool. + effective_session_id = session_id + client_id = session_id + + # Reuse an idle pool owned by this session, or fingerprint-match a prior + # idle session from the same client (VOD-style) before opening upstream. + if not session_entry: + matched = _find_matching_idle_session( + redis_client, + media_id=media_id, + user_id=user.id, + client_ip=client_ip, + client_user_agent=client_user_agent, + ) + if matched: + logger.info( + "Timeshift fingerprint matched idle session %s for %s", + matched, session_id, + ) + effective_session_id = matched + client_id = matched + + if debug: + if effective_session_id != session_id: + logger.debug( + "Timeshift request: channel=%s media=%s session=%s " + "effective=%s user=%s range=%s ip=%s", + channel.name, media_id, session_id, effective_session_id, + user.id, range_header or "(none)", client_ip, + ) + else: + logger.debug( + "Timeshift request: channel=%s media=%s session=%s " + "user=%s range=%s ip=%s", + channel.name, media_id, effective_session_id, user.id, + range_header or "(none)", client_ip, + ) + + # Displace this user's prior catch-up on other positions of this channel. + _terminate_previous_timeshift_sessions( + redis_client, user, channel.id, media_id, effective_session_id, + ) + + if not check_user_stream_limits(user, client_id, media_id=media_id): + return HttpResponseForbidden("Stream limit exceeded") + + if effective_session_id == session_id: + pool = _snapshot_from_entry(session_entry) + else: + pool = _pool_snapshot(redis_client, effective_session_id) + pool_exists = pool is not None + pool_busy = pool["busy"] if pool else False + pool_content_length = pool["content_length"] if pool else None + busy_serving_range = pool["serving_range"] if pool else None + + acquired = None + if pool_exists: + if pool_busy: + if _should_displace_busy_playback( + range_header, pool_content_length, busy_serving_range, + ): + _preempt_playback_streams(redis_client, effective_session_id, user) + acquired = _wait_for_idle_pool_session( + redis_client, + effective_session_id, + user_id=user.id, + wait_seconds=_POOL_PREEMPT_WAIT_SECONDS, + ) + else: + acquired = _acquire_idle_pool_session( + redis_client, effective_session_id, user_id=user.id, + ) + + if acquired is not None: + descriptor, profile = acquired + reuse_response = _stream_reused_session( + redis_client, + session_id=effective_session_id, + descriptor=descriptor, + profile=profile, + channel=channel, + safe_ts=safe_ts, + timestamp=timestamp, + duration_minutes=duration_minutes, + client_id=client_id, + client_ip=client_ip, + range_header=range_header, + channel_logo_id=channel_logo_id, + user=user, + debug=debug, + ) + if reuse_response is not None: + return reuse_response + + if pool_exists and pool_busy and not _should_displace_busy_playback( + range_header, pool_content_length, busy_serving_range, + ): + logger.debug( + "Timeshift: deferring non-displacing request for session %s range=%s", + effective_session_id, range_header or "(none)", + ) + return HttpResponse("Stream slot busy", status=503) + + if pool_exists and pool_busy: + logger.warning( + "Timeshift: session %s did not become idle in time", + effective_session_id, + ) + return HttpResponse("Stream slot busy", status=503) + + last_response = None + decisive_accounts = set() + capacity_blocked = False + for catchup_stream in catchup_streams: + m3u_account = catchup_stream.m3u_account + if m3u_account is None or m3u_account.account_type != "XC": + continue + if m3u_account.id in decisive_accounts: + continue + + stream_id_value = (catchup_stream.custom_properties or {}).get("stream_id") + if stream_id_value is None: + continue + + m3u_profiles = list(m3u_account.profiles.filter(is_active=True)) + default_profile = next((p for p in m3u_profiles if p.is_default), None) + if default_profile is None: + logger.debug( + "Timeshift: account %s has no active default profile, skipping", + m3u_account.id, + ) + continue + profile_walk = [default_profile] + [ + p for p in m3u_profiles if not p.is_default + ] + + # Providers index archives in their own timezone (from server_info on auth). + provider_tz_name = None + _server_info = (default_profile.custom_properties or {}).get("server_info") or {} + if isinstance(_server_info, dict): + provider_tz_name = _server_info.get("timezone") + provider_timestamp = convert_timestamp_to_provider_tz(timestamp, provider_tz_name) + + # Reserve a provider profile slot before connecting (same contract as live/VOD). + reserved_profile = None + for profile in profile_walk: + if redis_client is None: + reserved_profile = profile + break + reserved, _count, reason = reserve_profile_slot(profile, redis_client) + if reserved: + reserved_profile = profile + break + logger.info( + "Timeshift: profile %s %s on account %s, trying next profile", + profile.id, reason or "unavailable", m3u_account.id, + ) + if reserved_profile is None: + capacity_blocked = True + logger.warning( + "Timeshift: all profiles at capacity on account %s for channel %s", + m3u_account.id, channel.name, + ) + continue + + if not _create_pool_session( + redis_client, + session_id=effective_session_id, + media_id=media_id, + user_id=user.id, + client_ip=client_ip, + client_user_agent=client_user_agent, + account_id=m3u_account.id, + profile_id=reserved_profile.id, + stream_id=stream_id_value, + provider_timestamp=provider_timestamp, + ): + try: + release_profile_slot(reserved_profile.id, redis_client) + except Exception as exc: + logger.warning( + "Timeshift slot release failed after pool race on profile %s: %s", + reserved_profile.id, exc, + ) + logger.debug( + "Timeshift: pool entry already exists for session %s, deferring", + effective_session_id, + ) + return HttpResponse("Stream slot busy", status=503) + release_cb = _make_release_once( + redis_client, effective_session_id, reserved_profile.id + ) + + try: + response = _attempt_timeshift_stream( + m3u_account=m3u_account, + profile=reserved_profile, + stream_id_value=stream_id_value, + provider_timestamp=provider_timestamp, + provider_tz_name=provider_tz_name, + duration_minutes=duration_minutes, + channel=channel, + safe_ts=safe_ts, + timestamp=timestamp, + client_id=client_id, + client_ip=client_ip, + range_header=range_header, + channel_logo_id=channel_logo_id, + user=user, + redis_client=redis_client, + debug=debug, + release_cb=release_cb, + pool_session_id=effective_session_id, + ) + except Exception: + _discard_pool_session(redis_client, effective_session_id, reserved_profile.id) + raise + if response.status_code < 400: + # Streaming: the generator's close path frees the slot via release_cb. + return response + + if getattr(response, "timeshift_passthrough", False) is True: + # Terminal range answer (e.g. 416 past EOF): the upstream session is + # healthy, so free the slot but keep the entry idle for the next + # probe, and return verbatim without failing over to other accounts. + release_cb() + return response + + # Real failure: drop this session entirely and fail over. + _discard_pool_session(redis_client, effective_session_id, reserved_profile.id) + last_response = response + if getattr(response, "timeshift_decisive", False): + decisive_accounts.add(m3u_account.id) + logger.warning( + "Timeshift attempt failed (HTTP %d%s) on account %s for channel %s, " + "trying next catch-up stream", + response.status_code, + ", decisive: skipping this account's other streams" + if m3u_account.id in decisive_accounts else "", + m3u_account.id, channel.name, + ) + + if last_response is not None: + return last_response + if capacity_blocked: + return HttpResponse("No available stream slot", status=503) + return HttpResponseBadRequest("Cannot build timeshift URL") + + +def _authenticate_user(username, password): + try: + user = User.objects.get(username=username) + except User.DoesNotExist: + return None + expected = (user.custom_properties or {}).get("xc_password") + if not expected: + return None + if not hmac.compare_digest(str(expected), str(password)): + return None + return user + + +def _user_can_access_channel(user, channel): + if user.user_level < channel.user_level: + return False + if user.user_level >= User.UserLevel.ADMIN: + return True + profile_count = user.channel_profiles.count() + if profile_count == 0: + return True + return ( + type(channel).objects.filter( + id=channel.id, + channelprofilemembership__enabled=True, + channelprofilemembership__channel_profile__in=user.channel_profiles.all(), + ) + .exists() + ) + + +# Per-client session pool (keyed by session_id from the 301 redirect). Each +# viewer gets their own provider slot even when watching the same catch-up +# programme. Idle sessions can be fingerprint-matched (VOD-style) when a client +# returns without its prior session_id. +_POOL_KEY = "timeshift_pool:{session_id}" +_POOL_LOCK_KEY = "timeshift_pool_lock:{session_id}" +_POOL_ENTRY_TTL = 6 * 3600 +_POOL_IDLE_TTL = 30 +_POOL_WAIT_SECONDS = 1.0 +_POOL_PREEMPT_WAIT_SECONDS = 5.0 +_POOL_POLL_INTERVAL = 0.05 +_EOF_PROBE_TAIL_BYTES = 512_000 +_EOF_PROBE_UNKNOWN_LENGTH_MIN = 100_000_000 + + +def _pool_key(session_id): + return _POOL_KEY.format(session_id=session_id) + + +def _parse_range_start(range_header): + """Return the byte offset from a ``Range: bytes=START-`` header, or None.""" + if not range_header or not range_header.startswith("bytes="): + return None + start_part = range_header[6:].split("-", 1)[0] + if not start_part: + return None + try: + return int(start_part) + except (TypeError, ValueError): + return None + + +def _is_near_eof_probe(range_header, content_length=None): + """True for tail/duration probes IPTV clients fire during startup.""" + start = _parse_range_start(range_header) + if start is None: + return False + if content_length is not None: + try: + total = int(content_length) + except (TypeError, ValueError): + total = None + else: + return start >= max(0, total - _EOF_PROBE_TAIL_BYTES) + return start >= _EOF_PROBE_UNKNOWN_LENGTH_MIN + + +def _should_displace_busy_playback( + range_header, content_length=None, busy_serving_range=None, +): + """True when this request should stop the in-flight stream (actual scrub).""" + if not range_header: + return False + start = _parse_range_start(range_header) + if start is None: + return False + if _is_near_eof_probe(range_header, content_length): + return False + if start == 0: + # Only displace a known full-file probe; unknown busy context is not a scrub. + return busy_serving_range == "none" + return True + + +def _score_pool_fingerprint(entry, client_ip, client_user_agent): + """Score IP/UA overlap for fingerprint adoption (user and media pre-filtered).""" + score = 0 + if entry.get("client_ip") and entry.get("client_ip") == client_ip: + score += 5 + if entry.get("client_user_agent") and entry.get("client_user_agent") == client_user_agent: + score += 3 + return score + + +def _mint_timeshift_session_id(): + return f"timeshift_{secrets.token_urlsafe(16)}" + + +def _redirect_with_new_session(request): + session_id = _mint_timeshift_session_id() + query_params = {k: request.GET.getlist(k) for k in request.GET} + query_params["session_id"] = [session_id] + redirect_url = f"{request.path}?{urlencode(query_params, doseq=True)}" + return HttpResponse(status=301, headers={"Location": redirect_url}) + + +def _pool_entry_owned_by_user(entry, user_id): + """True when *entry* is unclaimed or owned by *user_id*.""" + if not entry or not entry.get("profile_id"): + return True + owner = entry.get("user_id") + if owner is None or owner == "": + return False + return str(owner) == str(user_id) + + +def _find_matching_idle_session( + redis_client, *, media_id, user_id, client_ip, client_user_agent, +): + """Find an idle pooled session that likely belongs to the same client.""" + if redis_client is None: + return None + matches = [] + try: + cursor = 0 + while True: + cursor, keys = redis_client.scan( + cursor, match="timeshift_pool:timeshift_*", count=100, + ) + for key in keys: + try: + data = redis_client.hgetall(key) + if not data or data.get("busy") == "1": + continue + if str(data.get("user_id") or "") != str(user_id): + continue + if str(data.get("media_id") or "") != str(media_id): + continue + session_id = key.rsplit(":", 1)[-1] + score = _score_pool_fingerprint( + data, client_ip, client_user_agent, + ) + if score >= _MATCH_SCORE_THRESHOLD: + last_activity = float(data.get("last_activity") or "0") + matches.append((session_id, score, last_activity)) + except Exception as exc: + logger.debug("Timeshift pool scan skip %s: %s", key, exc) + if cursor == 0: + break + except Exception as exc: + logger.warning("Timeshift idle session search failed: %s", exc) + return None + + if not matches: + return None + matches.sort(key=lambda item: (item[1], item[2]), reverse=True) + best = matches[0][0] + logger.debug( + "Timeshift idle match: session=%s score=%s media=%s", + best, matches[0][1], media_id, + ) + return best + + +def _get_pool_entry(redis_client, session_id): + if redis_client is None or not session_id: + return {} + try: + return redis_client.hgetall(_pool_key(session_id)) or {} + except Exception: + return {} + + +def _snapshot_from_entry(entry): + if not entry: + return None + busy = entry.get("busy") == "1" + return { + "entry": entry, + "busy": busy, + "serving_range": (entry.get("serving_range") or "none") if busy else None, + "content_length": entry.get("content_length"), + } + + +def _pool_snapshot(redis_client, session_id): + """Single HGETALL view of pool state for request handling.""" + return _snapshot_from_entry(_get_pool_entry(redis_client, session_id)) + + +def _store_pool_serving_range(redis_client, session_id, range_header): + if redis_client is None or not session_id: + return + start = _parse_range_start(range_header) + if not range_header: + serving_range = "none" + elif start == 0: + serving_range = "start" + else: + serving_range = "range" + try: + redis_client.hset(_pool_key(session_id), "serving_range", serving_range) + except Exception as exc: + logger.debug("Timeshift pool serving_range store failed: %s", exc) + + +def _store_pool_content_length(redis_client, session_id, upstream_response): + if redis_client is None or not session_id or upstream_response is None: + return + content_length = upstream_response.headers.get("Content-Length") + content_range = upstream_response.headers.get("Content-Range", "") + if content_range and "/" in content_range: + total = content_range.rsplit("/", 1)[-1] + if total != "*": + content_length = total + if not content_length: + return + try: + redis_client.hset( + _pool_key(session_id), "content_length", str(content_length), + ) + except Exception as exc: + logger.debug("Timeshift pool content_length store failed: %s", exc) + + +def _pool_lock(redis_client, session_id): + return redis_client.lock( + _POOL_LOCK_KEY.format(session_id=session_id), + timeout=10, + blocking_timeout=5, + ) + + +def _acquire_idle_pool_session(redis_client, session_id, *, user_id=None): + """Re-reserve an idle session's profile slot and mark it busy.""" + if redis_client is None or not session_id: + return None + key = _pool_key(session_id) + try: + with _pool_lock(redis_client, session_id): + data = redis_client.hgetall(key) + if not data or not data.get("profile_id"): + return None + if user_id is not None and not _pool_entry_owned_by_user(data, user_id): + return None + if data.get("busy") == "1": + return None + try: + profile = M3UAccountProfile.objects.get(id=int(data["profile_id"])) + except M3UAccountProfile.DoesNotExist: + redis_client.delete(key) + return None + reserved, _count, _reason = reserve_profile_slot(profile, redis_client) + if not reserved: + return None + redis_client.hset(key, mapping={ + "busy": "1", + "last_activity": str(time.time()), + }) + redis_client.expire(key, _POOL_ENTRY_TTL) + return dict(data), profile + except Exception as exc: + logger.warning("Timeshift pool acquire failed for %s: %s", session_id, exc) + return None + + +def _wait_for_idle_pool_session( + redis_client, session_id, *, user_id=None, wait_seconds=_POOL_WAIT_SECONDS, +): + if redis_client is None or not session_id: + return None + deadline = time.time() + wait_seconds + while True: + acquired = _acquire_idle_pool_session( + redis_client, session_id, user_id=user_id, + ) + if acquired is not None: + return acquired + if not _get_pool_entry(redis_client, session_id): + return None + if time.time() >= deadline: + return None + time.sleep(_POOL_POLL_INTERVAL) + + +def _create_pool_session( + redis_client, + *, + session_id, + media_id, + user_id, + client_ip, + client_user_agent, + account_id, + profile_id, + stream_id, + provider_timestamp, +): + """Register an already-reserved slot for this client session.""" + if redis_client is None or not session_id: + return False + key = _pool_key(session_id) + now = str(time.time()) + try: + with _pool_lock(redis_client, session_id): + if redis_client.exists(key): + return False + redis_client.hset(key, mapping={ + "media_id": str(media_id), + "user_id": str(user_id), + "client_ip": str(client_ip or ""), + "client_user_agent": str(client_user_agent or ""), + "account_id": str(account_id), + "profile_id": str(profile_id), + "stream_id": str(stream_id), + "provider_timestamp": str(provider_timestamp), + "busy": "1", + "last_activity": now, + }) + redis_client.expire(key, _POOL_ENTRY_TTL) + return True + except Exception as exc: + logger.warning("Timeshift pool create failed for %s: %s", session_id, exc) + return False + + +def _release_pool_session(redis_client, session_id, profile_id): + if redis_client is None: + return + if profile_id is not None: + try: + release_profile_slot(int(profile_id), redis_client) + except Exception as exc: + logger.warning( + "Timeshift slot release failed for profile %s: %s", profile_id, exc + ) + if not session_id: + return + key = _pool_key(session_id) + try: + with _pool_lock(redis_client, session_id): + if redis_client.exists(key): + redis_client.hset(key, mapping={ + "busy": "0", + "last_activity": str(time.time()), + }) + redis_client.expire(key, _POOL_IDLE_TTL) + except Exception as exc: + logger.warning("Timeshift pool release failed for %s: %s", session_id, exc) + + +def _discard_pool_session(redis_client, session_id, profile_id): + if redis_client is None: + return + if profile_id is not None: + try: + release_profile_slot(int(profile_id), redis_client) + except Exception as exc: + logger.warning( + "Timeshift slot release failed for profile %s: %s", profile_id, exc + ) + if not session_id: + return + try: + with _pool_lock(redis_client, session_id): + redis_client.delete(_pool_key(session_id)) + except Exception as exc: + logger.warning("Timeshift pool discard failed for %s: %s", session_id, exc) + + +def _make_release_once(redis_client, session_id, profile_id): + state = {"done": False} + + def _release(): + if state["done"]: + return + state["done"] = True + _release_pool_session(redis_client, session_id, profile_id) + + return _release + + +def _preempt_playback_streams(redis_client, session_id, user): + """Stop in-flight streams for this client session only.""" + if redis_client is None or not session_id or user is None: + return + try: + for conn in get_user_active_connections(user.id): + if conn.get("type") != "timeshift": + continue + if conn.get("client_id") != session_id: + continue + conn_media_id = str(conn.get("media_id") or "") + old_client_id = conn.get("client_id") + logger.debug( + "Timeshift preempt: stopping client %s on %s for reuse", + old_client_id, conn_media_id, + ) + _unregister_stats_client(redis_client, conn_media_id, old_client_id) + stop_key = RedisKeys.client_stop(conn_media_id, old_client_id) + redis_client.setex(stop_key, 60, "true") + except Exception as exc: + logger.warning("Timeshift preempt failed: %s", exc) + + +def _terminate_previous_timeshift_sessions( + redis_client, user, channel_id, current_media_id, current_session_id, +): + """Displace this user's other catch-up positions on the same channel.""" + if redis_client is None or user is None: + return + prefix = f"timeshift_{channel_id}_" + try: + for conn in get_user_active_connections(user.id): + if conn.get("type") != "timeshift": + continue + if conn.get("client_id") == current_session_id: + continue + conn_media_id = str(conn.get("media_id") or "") + if not conn_media_id.startswith(prefix): + continue + if conn_media_id.startswith(f"{current_media_id}_") or conn_media_id == current_media_id: + continue + old_client_id = conn.get("client_id") + logger.info( + "Timeshift takeover: displacing session %s on %s", + old_client_id, conn_media_id, + ) + _unregister_stats_client(redis_client, conn_media_id, old_client_id) + stop_key = RedisKeys.client_stop(conn_media_id, old_client_id) + redis_client.setex(stop_key, 60, "true") + except Exception as exc: + logger.warning("Timeshift takeover check failed: %s", exc) + + +def _attempt_timeshift_stream( + *, + m3u_account, + profile, + stream_id_value, + provider_timestamp, + provider_tz_name, + duration_minutes, + channel, + safe_ts, + timestamp, + client_id, + client_ip, + range_header, + channel_logo_id, + user, + redis_client, + debug, + release_cb=None, + pool_session_id=None, +): + """Build the provider URL set for one (account, profile, stream) and stream it.""" + server_url, xc_username, xc_password = get_transformed_credentials( + m3u_account, profile + ) + creds = TimeshiftCredentials(server_url, xc_username, xc_password) + candidate_urls = build_timeshift_candidate_urls( + creds, stream_id_value, provider_timestamp, duration_minutes + ) + + try: + user_agent = m3u_account.get_user_agent().user_agent + except AttributeError: + user_agent = "" + + virtual_channel_id = f"timeshift_{channel.id}_{safe_ts}_{stream_id_value}" + + if debug: + logger.debug( + "Timeshift attempt: channel=%s ts=%s (provider tz=%s -> %s) " + "account=%s profile=%s provider_sid=%s vid=%s client=%s range=%s", + channel.name, timestamp, provider_tz_name, provider_timestamp, + m3u_account.id, profile.id, stream_id_value, + virtual_channel_id, client_id, range_header or "(none)", + ) + + return _stream_from_provider( + candidate_urls=candidate_urls, + user_agent=user_agent, + range_header=range_header, + virtual_channel_id=virtual_channel_id, + client_id=client_id, + client_ip=client_ip, + user=user, + channel_display_name=channel.name, + timestamp_utc=timestamp, + channel_logo_id=channel_logo_id, + m3u_profile_id=profile.id, + debug=debug, + account_id=m3u_account.id, + redis_client=redis_client, + release_cb=release_cb, + pool_session_id=pool_session_id, + ) + + +def _stream_reused_session( + redis_client, + *, + session_id, + descriptor, + profile, + channel, + safe_ts, + timestamp, + duration_minutes, + client_id, + client_ip, + range_header, + channel_logo_id, + user, + debug, +): + """Stream an idle pooled session that was just re-reserved for this request.""" + try: + m3u_account = M3UAccount.objects.get(id=int(descriptor["account_id"])) + except (M3UAccount.DoesNotExist, ValueError, TypeError): + _discard_pool_session(redis_client, session_id, profile.id) + return None + + provider_timestamp = descriptor.get("provider_timestamp") + if not provider_timestamp: + provider_tz_name = None + server_info = (profile.custom_properties or {}).get("server_info") or {} + if isinstance(server_info, dict): + provider_tz_name = server_info.get("timezone") + provider_timestamp = convert_timestamp_to_provider_tz( + timestamp, provider_tz_name + ) + + release_cb = _make_release_once(redis_client, session_id, profile.id) + try: + response = _attempt_timeshift_stream( + m3u_account=m3u_account, + profile=profile, + stream_id_value=descriptor["stream_id"], + provider_timestamp=provider_timestamp, + provider_tz_name=None, + duration_minutes=duration_minutes, + channel=channel, + safe_ts=safe_ts, + timestamp=timestamp, + client_id=client_id, + client_ip=client_ip, + range_header=range_header, + channel_logo_id=channel_logo_id, + user=user, + redis_client=redis_client, + debug=debug, + release_cb=release_cb, + pool_session_id=session_id, + ) + except Exception: + _discard_pool_session(redis_client, session_id, profile.id) + raise + + if response.status_code < 400: + return response + + if getattr(response, "timeshift_passthrough", False) is True: + release_cb() + return response + + _discard_pool_session(redis_client, session_id, profile.id) + return None + + +class _SlotReleasingStream: + """Iterator wrapper that releases the pool slot when WSGI closes the response.""" + + def __init__(self, generator, on_close): + self._generator = generator + self._on_close = on_close + + def __iter__(self): + return self + + def __next__(self): + return next(self._generator) + + def close(self): + try: + self._generator.close() + finally: + self._on_close() + + +def _register_stats_client( + redis_client, + virtual_channel_id, + client_id, + client_ip, + user_agent, + user, + *, + channel_display_name, + timestamp_utc, + primary_url, + channel_logo_id=None, + m3u_profile_id=None, +): + """Write Redis keys so catch-up viewers appear on ``/stats``.""" + if redis_client is None: + return + client_set_key = RedisKeys.clients(virtual_channel_id) + client_key = RedisKeys.client_metadata(virtual_channel_id, client_id) + metadata_key = RedisKeys.channel_metadata(virtual_channel_id) + now = str(time.time()) + client_payload = { + "user_agent": user_agent or "unknown", + "ip_address": client_ip, + "connected_at": now, + "last_active": now, + "user_id": str(user.id) if user is not None else "0", + "username": user.username if user is not None else "unknown", + } + metadata_payload = { + ChannelMetadataField.STATE: ChannelState.ACTIVE, + ChannelMetadataField.INIT_TIME: now, + ChannelMetadataField.OWNER: "timeshift", + ChannelMetadataField.CHANNEL_NAME: channel_display_name or "Timeshift", + ChannelMetadataField.STREAM_NAME: f"Catch-up @ {timestamp_utc} UTC" if timestamp_utc else "Catch-up", + ChannelMetadataField.URL: _redact_url(primary_url) if primary_url else "", + ChannelMetadataField.IS_TIMESHIFT: "1", + } + if channel_logo_id is not None: + metadata_payload[ChannelMetadataField.LOGO_ID] = str(channel_logo_id) + if m3u_profile_id is not None: + metadata_payload[ChannelMetadataField.M3U_PROFILE] = str(m3u_profile_id) + try: + pipe = redis_client.pipeline(transaction=False) + pipe.hset(client_key, mapping=client_payload) + pipe.expire(client_key, CLIENT_TTL_SECONDS) + pipe.sadd(client_set_key, client_id) + pipe.expire(client_set_key, CLIENT_TTL_SECONDS) + pipe.hset(metadata_key, mapping=metadata_payload) + pipe.expire(metadata_key, CLIENT_TTL_SECONDS) + pipe.execute() + except Exception as exc: + logger.warning("Timeshift stats register failed: %s", exc) + + +def _heartbeat_stats_client(redis_client, virtual_channel_id, client_id, bytes_delta=0): + if redis_client is None: + return + client_set_key = RedisKeys.clients(virtual_channel_id) + client_key = RedisKeys.client_metadata(virtual_channel_id, client_id) + metadata_key = RedisKeys.channel_metadata(virtual_channel_id) + try: + pipe = redis_client.pipeline(transaction=False) + pipe.hset(client_key, "last_active", str(time.time())) + pipe.expire(client_key, CLIENT_TTL_SECONDS) + pipe.expire(client_set_key, CLIENT_TTL_SECONDS) + if bytes_delta > 0: + pipe.hincrby(metadata_key, ChannelMetadataField.TOTAL_BYTES, bytes_delta) + pipe.expire(metadata_key, CLIENT_TTL_SECONDS) + pipe.execute() + except Exception as exc: + logger.debug("Timeshift stats heartbeat failed: %s", exc) + + +def _unregister_stats_client(redis_client, virtual_channel_id, client_id): + if redis_client is None: + return + client_set_key = RedisKeys.clients(virtual_channel_id) + client_key = RedisKeys.client_metadata(virtual_channel_id, client_id) + metadata_key = RedisKeys.channel_metadata(virtual_channel_id) + try: + redis_client.srem(client_set_key, client_id) + redis_client.delete(client_key) + if (redis_client.scard(client_set_key) or 0) == 0: + redis_client.delete(client_set_key) + redis_client.delete(metadata_key) + except Exception as exc: + logger.warning("Timeshift stats unregister failed: %s", exc) + + +def _open_upstream(url, user_agent, range_header): + """Open upstream HTTP; redirects are followed (XC load-balancer nodes).""" + # identity: raw peek bytes are not gzip-transparent. + headers = {"Accept-Encoding": "identity"} + if user_agent: + headers["User-Agent"] = user_agent + if range_header: + headers["Range"] = range_header + return requests.get( + url, + headers=headers, + stream=True, + timeout=ConfigHelper.connection_timeout(), + ) + + +_FORMAT_CACHE_KEY = "timeshift:format_idx:{}" +_FORMAT_CACHE_TTL = 3600 # 1 hour + + +def _get_cached_format_index(account_id): + """Index of the URL shape that last worked for this account, or None.""" + if account_id is None: + return None + return cache.get(_FORMAT_CACHE_KEY.format(account_id)) + + +def _set_cached_format_index(account_id, index): + if account_id is None: + return + cache.set(_FORMAT_CACHE_KEY.format(account_id), index, _FORMAT_CACHE_TTL) + + +def _passthrough_response(status, content_range=None): + """A terminal response handed straight to the client (no streaming). + + Marked so the failover loop and reuse path return it verbatim instead of + cascading other URL shapes or failing over to another provider. + """ + response = HttpResponse(status=status) + if content_range: + response["Content-Range"] = content_range + response.timeshift_passthrough = True + return response + + +def _stream_from_provider( + *, + candidate_urls, + user_agent, + range_header, + virtual_channel_id, + client_id, + client_ip, + user, + channel_display_name, + timestamp_utc, + channel_logo_id, + m3u_profile_id, + debug, + account_id=None, + redis_client=None, + release_cb=None, + pool_session_id=None, +): + """Try each upstream URL until one returns streamable MPEG-TS. + + Sets ``timeshift_decisive`` on auth/ban-class failures (401/403/406) so the + failover loop skips the rest of that account's streams. ``release_cb`` frees + the provider slot when the streaming response is closed. + """ + chunk_size = max(ConfigHelper.chunk_size(), 262144) + if release_cb is None: + release_cb = lambda: None # noqa: E731 + + cached_index = _get_cached_format_index(account_id) + if cached_index is not None and 0 <= cached_index < len(candidate_urls): + ordered_urls = [candidate_urls[cached_index]] + [ + u for i, u in enumerate(candidate_urls) if i != cached_index + ] + original_indices = [cached_index] + [ + i for i in range(len(candidate_urls)) if i != cached_index + ] + else: + ordered_urls = list(candidate_urls) + original_indices = list(range(len(candidate_urls))) + + # Peek for MPEG-TS sync; some providers return HTTP 200 with PHP/HTML errors. + upstream = None + last_status = None + last_url = ordered_urls[0] + winning_index = None + decisive_failure = False + for url, orig_idx in zip(ordered_urls, original_indices): + try: + response = _open_upstream(url, user_agent, range_header) + except requests.exceptions.RequestException as exc: + logger.error( + "Timeshift provider unreachable (%s): %s", + _redact_url(url), type(exc).__name__, + ) + return HttpResponseBadRequest("Provider connection error") + last_status = response.status_code + last_url = url + if debug: + logger.debug( + "Timeshift cascade[%d]: status=%d type=%s url=%s", + orig_idx, response.status_code, + response.headers.get("Content-Type", "?"), + _redact_url(url), + ) + if response.status_code == 416: + # Range Not Satisfiable: a seek/tail probe past EOF. Hand it back to + # the client verbatim. Byte offsets are file-specific, so trying + # other URL shapes or failing over to another provider is pointless + # and only multiplies upstream connections. + content_range = response.headers.get("Content-Range") + response.close() + return _passthrough_response(416, content_range) + if response.status_code in (200, 206): + peek = response.raw.read(1024) + sync_offset = find_ts_sync(peek) if peek else -1 + if sync_offset >= 0: + response._peek_data = peek[sync_offset:] + upstream = response + winning_index = orig_idx + break + # A 206 to a Range request legitimately starts mid-packet, so the + # sync byte rarely lands at offset 0. Trust the partial status and + # content type rather than the sync probe; only a full 200 carrying + # a PHP/HTML error page must be rejected here. + content_type = response.headers.get("Content-Type", "") + is_partial = response.status_code == 206 and bool(range_header) + if is_partial and peek and "html" not in content_type and "json" not in content_type: + response._peek_data = peek + upstream = response + winning_index = orig_idx + break + snippet = peek[:200].decode("utf-8", errors="replace") if peek else "(empty)" + logger.warning( + "Timeshift upstream returned %d but no TS sync in first %d " + "bytes (likely PHP error): %s, url=%s", + response.status_code, + len(peek) if peek else 0, + snippet.replace("\n", " ")[:120], + _redact_url(url), + ) + response.close() + last_status = 404 # Treat as soft rejection for cascade + continue + response.close() + # Auth/ban-class statuses stop trying more shapes on this account; 5xx does not. + code = response.status_code + if code in (401, 403, 406) or 300 <= code < 400: + decisive_failure = True + break + + if winning_index is not None: + _set_cached_format_index(account_id, winning_index) + + if upstream is None: + logger.error("Timeshift upstream rejected: status=%s url=%s", + last_status, _redact_url(last_url)) + # Map 404/403 to meaningful client responses; other failures stay 400. + if last_status == 404: + failure = HttpResponseNotFound("Catch-up not available yet") + elif last_status == 403: + failure = HttpResponseForbidden("Provider denied access") + else: + failure = HttpResponseBadRequest("Provider error") + failure.timeshift_decisive = decisive_failure + return failure + + content_type = upstream.headers.get("Content-Type", "video/mp2t") + content_range = upstream.headers.get("Content-Range", "") + status = upstream.status_code + + _store_pool_content_length(redis_client, pool_session_id, upstream) + _store_pool_serving_range(redis_client, pool_session_id, range_header) + + _register_stats_client( + redis_client, + virtual_channel_id, + client_id, + client_ip, + user_agent, + user, + channel_display_name=channel_display_name, + timestamp_utc=timestamp_utc, + primary_url=last_url, + channel_logo_id=channel_logo_id, + m3u_profile_id=m3u_profile_id, + ) + + peek_data = getattr(upstream, "_peek_data", None) + chunks_iter = upstream.iter_content(chunk_size=chunk_size) + if peek_data: + chunks_iter = itertools.chain([peek_data], chunks_iter) + + session_closed = {"done": False} + + def _finish_session(*, close_upstream=False): + if session_closed["done"]: + return + session_closed["done"] = True + if close_upstream: + try: + upstream.close() + except Exception: + pass + _unregister_stats_client(redis_client, virtual_channel_id, client_id) + release_cb() + + def stream_generator(): + last_heartbeat = time.time() + bytes_since_heartbeat = 0 + total_yielded = 0 + loop_start = time.time() + stop_key = RedisKeys.client_stop(virtual_channel_id, client_id) + stream_started_logged = False + try: + for data in chunks_iter: + if not data: + continue + if debug and not stream_started_logged: + stream_started_logged = True + logger.debug( + "Timeshift stream started: client=%s vid=%s range=%s status=%d", + client_id, virtual_channel_id, range_header or "(none)", status, + ) + yield data + bytes_since_heartbeat += len(data) + total_yielded += len(data) + + now = time.time() + if redis_client and redis_client.exists(stop_key): + logger.info("Timeshift client %s received stop signal", client_id) + redis_client.delete(stop_key) + break + # Refresh stats every 5 seconds. + if now - last_heartbeat >= 5: + if debug and total_yielded > 0: + elapsed = now - loop_start + mbps = (total_yielded * 8) / elapsed / 1_000_000 if elapsed > 0 else 0 + logger.debug( + "Timeshift streaming: client=%s range=%s total=%d bytes " + "in %.1fs (%.2f Mbps avg)", + client_id, range_header or "(none)", + total_yielded, elapsed, mbps, + ) + _heartbeat_stats_client( + redis_client, virtual_channel_id, client_id, + bytes_delta=bytes_since_heartbeat, + ) + last_heartbeat = now + bytes_since_heartbeat = 0 + except GeneratorExit: + pass + except Exception: + logger.exception("Timeshift stream loop error") + finally: + elapsed = time.time() - loop_start + if bytes_since_heartbeat > 0: + _heartbeat_stats_client( + redis_client, virtual_channel_id, client_id, + bytes_delta=bytes_since_heartbeat, + ) + if debug and total_yielded > 0: + mbps = (total_yielded * 8) / elapsed / 1_000_000 if elapsed > 0 else 0 + logger.debug( + "Timeshift disconnect: vid=%s client=%s yielded=%d bytes in %.1fs (%.2f Mbps avg)", + virtual_channel_id, client_id, total_yielded, elapsed, mbps, + ) + _finish_session(close_upstream=True) + + stream_iter = _SlotReleasingStream(stream_generator(), _finish_session) + response = StreamingHttpResponse( + stream_iter, + content_type=content_type, + status=status, + ) + response["X-Accel-Buffering"] = "no" # avoid nginx throttling the stream + if content_range: + response["Content-Range"] = content_range + response["Accept-Ranges"] = "bytes" + return response + + +def _redact_url(url): + """Truncate *url* to ``scheme://host/...`` for safe logging (drops credentials).""" + if not url or "://" not in url: + return url + scheme, rest = url.split("://", 1) + if "@" in rest: + rest = rest.split("@", 1)[1] + host = rest.split("/", 1)[0] + return f"{scheme}://{host}/..." diff --git a/core/api_views.py b/core/api_views.py index ec66d69a..ee7d1db1 100644 --- a/core/api_views.py +++ b/core/api_views.py @@ -225,7 +225,8 @@ class ProxySettingsViewSet(viewsets.ViewSet): "buffering_speed": 1.0, "redis_chunk_ttl": 60, "channel_shutdown_delay": 0, - "channel_init_grace_period": 5, + "channel_init_grace_period": 60, + "channel_client_wait_period": 5, "new_client_behind_seconds": 5, } settings_obj, created = CoreSettings.objects.get_or_create( diff --git a/core/migrations/0026_add_channel_client_wait_period.py b/core/migrations/0026_add_channel_client_wait_period.py new file mode 100644 index 00000000..6119eb66 --- /dev/null +++ b/core/migrations/0026_add_channel_client_wait_period.py @@ -0,0 +1,51 @@ +from django.db import migrations + +PROXY_SETTINGS_KEY = "proxy_settings" + + +def add_channel_client_wait_period(apps, schema_editor): + CoreSettings = apps.get_model("core", "CoreSettings") + + try: + obj = CoreSettings.objects.get(key=PROXY_SETTINGS_KEY) + except CoreSettings.DoesNotExist: + return + + value = obj.value if isinstance(obj.value, dict) else {} + + # Add the new client-connect grace period default. + value.setdefault("channel_client_wait_period", 5) + + # channel_init_grace_period was repurposed in 0.27.1 as the channel startup + # timeout (replacing a hardcoded 10s). Values below the new 60s default are + # too short when a channel has many failover streams to cycle through. + current_init = value.get("channel_init_grace_period", 5) + if current_init < 60: + value["channel_init_grace_period"] = 60 + + obj.value = value + obj.save() + + +def remove_channel_client_wait_period(apps, schema_editor): + CoreSettings = apps.get_model("core", "CoreSettings") + + try: + obj = CoreSettings.objects.get(key=PROXY_SETTINGS_KEY) + except CoreSettings.DoesNotExist: + return + + value = obj.value if isinstance(obj.value, dict) else {} + value.pop("channel_client_wait_period", None) + obj.value = value + obj.save() + + +class Migration(migrations.Migration): + dependencies = [ + ("core", "0025_move_preferred_region_and_auto_import_to_system_settings"), + ] + + operations = [ + migrations.RunPython(add_channel_client_wait_period, remove_channel_client_wait_period), + ] diff --git a/core/models.py b/core/models.py index 60be2f0e..676ef02d 100644 --- a/core/models.py +++ b/core/models.py @@ -280,8 +280,18 @@ class CoreSettings(models.Model): "epg_match_ignore_prefixes": [], "epg_match_ignore_suffixes": [], "epg_match_ignore_custom": [], + # XC catch-up: forced XMLTV lookback (0 = auto-detect, capped at 30). + "xmltv_prev_days_override": 0, }) + @classmethod + def get_xmltv_prev_days_override(cls): + """Global XC XMLTV prev_days default (0 = auto-detect from provider archives).""" + try: + return int(cls.get_epg_settings().get("xmltv_prev_days_override", 0) or 0) + except (TypeError, ValueError): + return 0 + @classmethod def _safe_string_list(cls, value): """Return a list of strings, filtering out non-list or non-string values.""" @@ -394,7 +404,8 @@ class CoreSettings(models.Model): "buffering_speed": 1.0, "redis_chunk_ttl": 60, "channel_shutdown_delay": 0, - "channel_init_grace_period": 5, + "channel_init_grace_period": 60, + "channel_client_wait_period": 5, "new_client_behind_seconds": 5, }) diff --git a/core/serializers.py b/core/serializers.py index a0f27baf..1398b194 100644 --- a/core/serializers.py +++ b/core/serializers.py @@ -96,7 +96,8 @@ class ProxySettingsSerializer(serializers.Serializer): buffering_speed = serializers.FloatField(min_value=0.1, max_value=10.0) redis_chunk_ttl = serializers.IntegerField(min_value=10, max_value=3600) channel_shutdown_delay = serializers.IntegerField(min_value=0, max_value=300) - channel_init_grace_period = serializers.IntegerField(min_value=0, max_value=60) + channel_init_grace_period = serializers.IntegerField(min_value=0, max_value=300) + channel_client_wait_period = serializers.IntegerField(min_value=0, max_value=300, required=False, default=5) new_client_behind_seconds = serializers.IntegerField(min_value=0, max_value=120, required=False, default=5) def validate_buffering_timeout(self, value): @@ -120,9 +121,16 @@ class ProxySettingsSerializer(serializers.Serializer): return value def validate_channel_init_grace_period(self, value): - if value < 0 or value > 60: + if value < 0 or value > 300: raise serializers.ValidationError( - "Channel initialization timeout must be between 0 and 60 seconds" + "Channel initialization timeout must be between 0 and 300 seconds" + ) + return value + + def validate_channel_client_wait_period(self, value): + if value < 0 or value > 300: + raise serializers.ValidationError( + "Client connect grace period must be between 0 and 300 seconds" ) return value diff --git a/core/utils.py b/core/utils.py index 44504b6a..16d9ed85 100644 --- a/core/utils.py +++ b/core/utils.py @@ -565,13 +565,15 @@ def trim_c_allocator_heap(): return False -def cleanup_memory(log_usage=False, force_collection=True): +def cleanup_memory(log_usage=False, force_collection=True, trim_heap=False): """ Comprehensive memory cleanup function to reduce memory footprint Args: log_usage: Whether to log memory usage before and after cleanup force_collection: Whether to force garbage collection + trim_heap: Return freed C heap pages to the OS. Only use after DB + connections are closed (e.g. Celery task_postrun). """ logger.trace("Starting memory cleanup django memory cleanup") # Skip logging if log level is not set to debug or more verbose (like trace) @@ -606,6 +608,8 @@ def cleanup_memory(log_usage=False, force_collection=True): logger.debug(f"Memory after cleanup: {after_mem:.2f} MB (change: {after_mem-before_mem:.2f} MB)") except (ImportError, Exception): pass + if trim_heap: + trim_c_allocator_heap() logger.trace("Memory cleanup complete for django") @@ -618,8 +622,7 @@ def spawn_memory_trim(close_connections=False): so the pooled DB connection is released first. """ def _run(): - cleanup_memory(force_collection=True) - trim_c_allocator_heap() + cleanup_memory(force_collection=True, trim_heap=True) if close_connections: from django.db import close_old_connections diff --git a/dispatcharr/celery.py b/dispatcharr/celery.py index 18be81eb..69bb1221 100644 --- a/dispatcharr/celery.py +++ b/dispatcharr/celery.py @@ -2,7 +2,7 @@ import os from celery import Celery import logging -from celery.signals import task_postrun, task_prerun, worker_ready +from celery.signals import task_postrun, task_prerun, worker_process_init, worker_ready logger = logging.getLogger(__name__) @@ -42,13 +42,26 @@ app.autodiscover_tasks() # Plugins live outside INSTALLED_APPS, so autodiscover_tasks() never imports # them. Without an eager import, workers reject plugin @shared_tasks with # "Received unregistered task" until a lazy event import warms the module. -@worker_ready.connect(weak=False) -def discover_plugins_on_worker_ready(**_kwargs): +# Discovery runs in worker_process_init (each prefork child / thread worker) +# rather than worker_ready (the long-lived arbiter) so the parent process +# never opens DB connections that autoscale children would inherit via fork(). +@worker_process_init.connect(weak=False) +def init_worker_process(**_kwargs): + from django.db import connections + + # Standard Celery + Django guidance for prefork pools: discard any + # connection state inherited from the parent across fork(). + try: + connections.close_all() + except Exception: + logger.warning("Failed to close inherited DB connections after fork", exc_info=True) + try: from apps.plugins.loader import PluginManager PluginManager.get().discover_plugins(sync_db=False) except Exception: - logger.exception("plugin discovery on worker_ready failed") + logger.exception("plugin discovery on worker_process_init failed") + # Use environment variable for log level with fallback to INFO CELERY_LOG_LEVEL = os.environ.get('DISPATCHARR_LOG_LEVEL', 'INFO').upper() @@ -99,6 +112,7 @@ def cleanup_task_memory(**kwargs): memory_intensive_tasks = [ 'apps.m3u.tasks.refresh_single_m3u_account', 'apps.m3u.tasks.refresh_m3u_accounts', + 'apps.m3u.tasks.refresh_m3u_groups', 'apps.m3u.tasks.process_m3u_batch', 'apps.m3u.tasks.process_xc_category', 'apps.m3u.tasks.sync_auto_channels', @@ -121,7 +135,7 @@ def cleanup_task_memory(**kwargs): from core.utils import cleanup_memory # Use the comprehensive cleanup function - cleanup_memory(log_usage=True, force_collection=True) + cleanup_memory(log_usage=True, force_collection=True, trim_heap=True) # Log memory usage if psutil is installed try: diff --git a/dispatcharr/db/process_label.py b/dispatcharr/db/process_label.py index 209ad291..137d3b21 100644 --- a/dispatcharr/db/process_label.py +++ b/dispatcharr/db/process_label.py @@ -39,5 +39,16 @@ def get_process_role(argv: list[str] | None = None) -> str: return "django" +def uses_geventpool_database_backend(argv: list[str] | None = None) -> bool: + """ + True for uWSGI/Daphne/manage (gevent or request-scoped pooling). + + Celery prefork/thread workers must use Django's standard PostgreSQL backend: + django-db-geventpool keeps a process-wide warm-connection pool that fork() + duplicates across autoscale children, which corrupts Postgres session state. + """ + return get_process_role(argv) not in ("celery-worker", "celery-dvr", "celery-beat") + + def db_application_name() -> str: return f"Dispatcharr-{get_process_role()}-{os.getpid()}" diff --git a/dispatcharr/settings.py b/dispatcharr/settings.py index a22e5f9c..5b8de973 100644 --- a/dispatcharr/settings.py +++ b/dispatcharr/settings.py @@ -5,6 +5,8 @@ from datetime import timedelta from urllib.parse import quote_plus from django.core.exceptions import ImproperlyConfigured +from dispatcharr.db.process_label import db_application_name, uses_geventpool_database_backend + def _validate_tls_cert_paths(paths, service_name): """Validate that configured TLS certificate file paths exist on disk. @@ -99,6 +101,7 @@ INSTALLED_APPS = [ "django_filters", "django_celery_beat", "apps.plugins", + "apps.timeshift.apps.TimeshiftConfig", ] # EPG Processing optimization settings @@ -227,24 +230,39 @@ if os.getenv("DB_ENGINE", None) == "sqlite": } } else: + _use_geventpool_db = uses_geventpool_database_backend() + _pg_options = {"pool": False} if _use_geventpool_db else { + "application_name": db_application_name(), + } + if _use_geventpool_db: + _pg_options.update({ + "MAX_CONNS": 8, # Per-worker pool size; 4 workers × 8 = 32 total < pg max_connections=100 + "REUSE_CONNS": 3, # Connections to keep warm between requests + "CONN_MAX_LIFETIME": DATABASE_POOL_CONN_MAX_LIFETIME or None, + }) + DATABASES = { "default": { - "ENGINE": "dispatcharr.db.backends.postgresql_psycopg3", + "ENGINE": ( + "dispatcharr.db.backends.postgresql_psycopg3" + if _use_geventpool_db + else "django.db.backends.postgresql" + ), "NAME": os.environ.get("POSTGRES_DB", "dispatcharr"), "USER": os.environ.get("POSTGRES_USER", "dispatch"), "PASSWORD": os.environ.get("POSTGRES_PASSWORD", "secret"), "HOST": os.environ.get("POSTGRES_HOST", "localhost"), "PORT": int(os.environ.get("POSTGRES_PORT", 5432)), "CONN_MAX_AGE": DATABASE_CONN_MAX_AGE, - "OPTIONS": { - "MAX_CONNS": 8, # Per-worker pool size; 4 workers × 8 = 32 total < pg max_connections=100 - "REUSE_CONNS": 3, # Connections to keep warm between requests - "pool": False, # Disable Django's native psycopg3 pool; geventpool manages connections - "CONN_MAX_LIFETIME": DATABASE_POOL_CONN_MAX_LIFETIME or None, - }, + "OPTIONS": _pg_options, } } + if not _use_geventpool_db: + print( + f"PostgreSQL: standard backend for Celery ({_pg_options.get('application_name')})" + ) + if POSTGRES_SSL: _validate_tls_cert_paths([ ("POSTGRES_SSL_CA_CERT", POSTGRES_SSL_CA_CERT), diff --git a/dispatcharr/urls.py b/dispatcharr/urls.py index 9123f3da..cdedb0c4 100644 --- a/dispatcharr/urls.py +++ b/dispatcharr/urls.py @@ -7,6 +7,7 @@ from .routing import websocket_urlpatterns from apps.output.views import xc_player_api, xc_panel_api, xc_get, xc_xmltv from apps.proxy.live_proxy.views import stream_xc from apps.proxy.vod_proxy.views import stream_xc_movie, stream_xc_episode +from apps.timeshift.views import timeshift_proxy urlpatterns = [ # API Routes @@ -41,6 +42,11 @@ urlpatterns = [ stream_xc, name="xc_stream_endpoint", ), + path( + "timeshift/
{children}
,
+ Collapse: ({ in: isOpen, children }) =>
+ isOpen ? {children}
: null,
TextInput: ({ label, description, ...rest }) => (
@@ -353,11 +370,38 @@ describe('ProxySettingsForm', () => {
// ── ProxySettingsOptions field routing ─────────────────────────────────────
describe('ProxySettingsOptions field routing', () => {
- it('calls getInputProps for each PROXY_SETTINGS_OPTIONS key', () => {
+ it('binds main settings on initial render', () => {
render(
-
-
- {flexRender(cell.column.columnDef.cell, cell.getContext())}
-
-
-
- );
- })}
+ {row.getVisibleCells().map((cell) => (
+
+
+
+ {flexRender(cell.column.columnDef.cell, cell.getContext())}
+
+
+
+ ))}
);
},
@@ -260,7 +146,7 @@ const StatsCategory = ({ categoryName, stats }) => {
{Object.entries(stats).map(([key, value]) => (
- {key.replace(/_/g, ' ').replace(/\b\w/g, (l) => l.toUpperCase())}:{' '}
+ {formatStatKey(key)}:{' '}
{formatStatValue(key, value)}
@@ -549,7 +435,7 @@ const ChannelStreams = ({ channel }) => {
if (t && (since === null || t > since)) since = t;
}
const ids = opts && opts.ids;
- API.getChannelStreamStats(channelId, since, ids).then((updates) => {
+ getChannelStreamStats(channelId, since, ids).then((updates) => {
if (!updates || updates.length === 0) return;
patchChannelStreamStats(channelId, updates);
});
@@ -596,7 +482,7 @@ const ChannelStreams = ({ channel }) => {
const removeStream = useCallback(async (stream) => {
const newStreamList = dataRef.current.filter((s) => s.id !== stream.id);
setData(newStreamList);
- await API.reorderChannelStreams(
+ await reorderChannelStreams(
channelRef.current.id,
newStreamList.map((s) => s.id)
);
@@ -709,7 +595,7 @@ const ChannelStreams = ({ channel }) => {
const newIndex = currentIds.indexOf(over.id);
const retval = arrayMove(prevData, oldIndex, newIndex);
- API.reorderChannelStreams(
+ reorderChannelStreams(
channel.id,
retval.map((row) => row.id)
);
diff --git a/frontend/src/components/tables/ChannelsTable.jsx b/frontend/src/components/tables/ChannelsTable.jsx
index 797471ae..e21a003c 100644
--- a/frontend/src/components/tables/ChannelsTable.jsx
+++ b/frontend/src/components/tables/ChannelsTable.jsx
@@ -1,71 +1,59 @@
-import React, {
- useEffect,
- useMemo,
- useState,
- useCallback,
- useRef,
-} from 'react';
-import {
- DndContext,
- closestCenter,
- PointerSensor,
- useSensor,
- useSensors,
-} from '@dnd-kit/core';
-import {
- SortableContext,
- verticalListSortingStrategy,
-} from '@dnd-kit/sortable';
+import React, { useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { closestCenter, DndContext, PointerSensor, useSensor, useSensors, } from '@dnd-kit/core';
+import { SortableContext, verticalListSortingStrategy, } from '@dnd-kit/sortable';
import useChannelsStore from '../../store/channels';
-import API from '../../api';
import ChannelForm from '../forms/Channel';
import ChannelBatchForm from '../forms/ChannelBatch';
import RecordingForm from '../forms/Recording';
-import { useDebounce, copyToClipboard } from '../../utils';
+import { copyToClipboard, useDebounce } from '../../utils';
import useVideoStore from '../../store/useVideoStore';
import useSettingsStore from '../../store/settings';
import {
- Tv2,
- ScreenShare,
- Scroll,
- SquareMinus,
- CirclePlay,
- SquarePen,
- Copy,
- ScanEye,
- EllipsisVertical,
- ArrowUpNarrowWide,
- ArrowUpDown,
ArrowDownWideNarrow,
- Search,
+ ArrowUpDown,
+ ArrowUpNarrowWide,
+ CirclePlay,
+ Copy,
+ EllipsisVertical,
EyeOff,
Pencil,
+ ScanEye,
+ ScreenShare,
+ Scroll,
+ Search,
+ SquareMinus,
+ SquarePen,
+ Tv2,
} from 'lucide-react';
-import { listOverriddenFields } from '../../utils/forms/ChannelUtils.js';
+import { listOverriddenFields, requeryChannels, } from '../../utils/forms/ChannelUtils.js';
import { buildLiveStreamUrl } from '../../utils/components/FloatingVideoUtils.js';
import {
- Box,
- TextInput,
- Popover,
ActionIcon,
+ Box,
Button,
- Paper,
- Flex,
- Text,
- Group,
- useMantineTheme,
Center,
- Switch,
+ Flex,
+ Group,
Menu,
+ MenuDropdown,
+ MenuItem,
+ MenuTarget,
MultiSelect,
- Pagination,
NativeSelect,
- UnstyledButton,
- Stack,
- Select,
NumberInput,
+ Pagination,
+ Paper,
+ Popover,
+ PopoverDropdown,
+ PopoverTarget,
+ Select,
+ Stack,
+ Switch,
+ Text,
+ TextInput,
Tooltip,
- Skeleton,
+ UnstyledButton,
+ useMantineTheme,
} from '@mantine/core';
import './table.css';
import useChannelsTableStore from '../../store/channelsTable';
@@ -79,21 +67,33 @@ import ChannelsTableOnboarding from './ChannelsTable/ChannelsTableOnboarding';
import ChannelTableHeader from './ChannelsTable/ChannelTableHeader';
import useOutputProfilesStore from '../../store/outputProfiles';
import {
- EditableTextCell,
- EditableNumberCell,
- EditableGroupCell,
EditableEPGCell,
+ EditableGroupCell,
EditableLogoCell,
+ EditableNumberCell,
+ EditableTextCell,
} from './ChannelsTable/EditableCell';
-import { DraggableRow } from './ChannelsTable/DraggableRow';
import useWarningsStore from '../../store/warnings';
import ConfirmationDialog from '../ConfirmationDialog';
import useAuthStore from '../../store/auth';
import { USER_LEVELS } from '../../constants';
-
-const m3uUrlBase = `${window.location.protocol}//${window.location.host}/output/m3u`;
-const epgUrlBase = `${window.location.protocol}//${window.location.host}/output/epg`;
-const hdhrUrlBase = `${window.location.protocol}//${window.location.host}/hdhr`;
+import { getShowVideoUrl } from '../../utils/cards/RecordingCardUtils.js';
+import {
+ buildEPGUrl,
+ buildFetchParams,
+ buildHDHRUrl,
+ buildM3UUrl,
+ deleteChannel,
+ deleteChannels,
+ epgUrlBase,
+ getAllChannelIds,
+ hdhrUrlBase,
+ m3uUrlBase,
+ queryChannels,
+ reorderChannel,
+ updateProfileChannel,
+ updateProfileChannels,
+} from '../../utils/tables/ChannelsTableUtils.js';
const ChannelEnabledSwitch = React.memo(
({ rowId, selectedProfileId, selectedTableIds }) => {
@@ -109,13 +109,13 @@ const ChannelEnabledSwitch = React.memo(
const handleToggle = () => {
if (selectedTableIds.length > 1) {
- API.updateProfileChannels(
+ updateProfileChannels(
selectedTableIds,
selectedProfileId,
!isEnabled
);
} else {
- API.updateProfileChannel(rowId, selectedProfileId, !isEnabled);
+ updateProfileChannel(rowId, selectedProfileId, !isEnabled);
}
};
@@ -208,22 +208,22 @@ const ChannelRowActions = React.memo(
@@ -421,130 +421,47 @@ const ChannelsTable = ({ onReady }) => {
/**
* Functions
*/
+ const handleFetchSuccess = useCallback((ids) => {
+ setTablePrefs((prev) => ({ ...prev, pageSize: pagination.pageSize }));
+ setAllRowIds(ids);
+ hasFetchedData.current = true;
+ if (!hasSignaledReady.current && onReady && tvgsLoaded) {
+ hasSignaledReady.current = true;
+ onReady();
+ }
+ }, [pagination.pageSize, setTablePrefs, setAllRowIds, onReady, tvgsLoaded]);
+
const fetchData = useCallback(async () => {
- // Build params first to check for duplicates
- const params = new URLSearchParams();
- params.append('page', pagination.pageIndex + 1);
- params.append('page_size', pagination.pageSize);
- params.append('include_streams', 'true');
- if (selectedProfileId !== '0') {
- params.append('channel_profile_id', selectedProfileId);
- }
- if (showDisabled === true) {
- params.append('show_disabled', true);
- }
- if (showOnlyStreamlessChannels === true) {
- params.append('only_streamless', true);
- }
- if (showOnlyStaleChannels === true) {
- params.append('only_stale', true);
- }
- if (showOnlyOverriddenChannels === true) {
- params.append('only_has_overrides', true);
- }
- // The backend defaults to "active"; send other choices explicitly so
- // hidden rows surface when the user opts into "Hidden Only" or "Show All".
- if (visibilityFilter && visibilityFilter !== 'active') {
- params.append('visibility_filter', visibilityFilter);
- }
-
- // Apply sorting
- if (sorting.length > 0) {
- let sortField = sorting[0].id;
- // Map frontend column ids to backend ordering field names
- const fieldMapping = {
- channel_group: 'channel_group__name',
- epg: 'epg_data__name',
- };
- if (fieldMapping[sortField]) {
- sortField = fieldMapping[sortField];
- }
- const sortDirection = sorting[0].desc ? '-' : '';
- params.append('ordering', `${sortDirection}${sortField}`);
- }
-
- // Apply debounced filters
- Object.entries(debouncedFilters).forEach(([key, value]) => {
- if (value) {
- if (Array.isArray(value)) {
- // Convert null values to "null" string for URL parameter
- const processedValue = value
- .map((v) => (v === null ? 'null' : v))
- .join(',');
- params.append(key, processedValue);
- } else {
- params.append(key, value);
- }
- }
+ const params = buildFetchParams({
+ pagination, sorting, debouncedFilters, selectedProfileId,
+ showDisabled, showOnlyStreamlessChannels, showOnlyStaleChannels,
+ showOnlyOverriddenChannels, visibilityFilter,
});
-
const paramsString = params.toString();
- // Skip if same fetch is already in progress (prevents StrictMode double-fetch)
- if (
- fetchInProgressRef.current &&
- lastFetchParamsRef.current === paramsString
- ) {
- return;
- }
+ if (fetchInProgressRef.current && lastFetchParamsRef.current === paramsString) return;
- // Increment fetch version to track this specific fetch request
const currentFetchVersion = ++fetchVersionRef.current;
lastFetchParamsRef.current = paramsString;
fetchInProgressRef.current = true;
-
setIsLoading(true);
try {
- const [, ids] = await Promise.all([
- API.queryChannels(params),
- API.getAllChannelIds(params),
- ]);
-
+ const [, ids] = await Promise.all([queryChannels(params), getAllChannelIds(params)]);
fetchInProgressRef.current = false;
-
- // Skip state updates if a newer fetch has been initiated
- if (currentFetchVersion !== fetchVersionRef.current) {
- return;
- }
-
+ if (currentFetchVersion !== fetchVersionRef.current) return;
setIsLoading(false);
- hasFetchedData.current = true;
-
- setTablePrefs((prev) => ({
- ...prev,
- pageSize: pagination.pageSize,
- }));
- setAllRowIds(ids);
-
- // Signal ready after first successful data fetch AND EPG data is loaded
- // This prevents the EPG column from showing "Not Assigned" while EPG data is still loading
- if (!hasSignaledReady.current && onReady && tvgsLoaded) {
- hasSignaledReady.current = true;
- onReady();
- }
+ handleFetchSuccess(ids);
} catch (error) {
fetchInProgressRef.current = false;
-
- // Skip state updates if a newer fetch has been initiated
- if (currentFetchVersion !== fetchVersionRef.current) {
- return;
- }
+ if (currentFetchVersion !== fetchVersionRef.current) return;
setIsLoading(false);
- // API layer handles "Invalid page" errors by resetting and retrying
- // Just re-throw to show notification for actual errors
throw error;
}
}, [
- pagination,
- sorting,
- debouncedFilters,
- showDisabled,
- selectedProfileId,
- showOnlyStreamlessChannels,
- showOnlyStaleChannels,
- showOnlyOverriddenChannels,
- visibilityFilter,
+ pagination, sorting, debouncedFilters, selectedProfileId,
+ showDisabled, showOnlyStreamlessChannels, showOnlyStaleChannels,
+ showOnlyOverriddenChannels, visibilityFilter, handleFetchSuccess,
]);
const stopPropagation = useCallback((e) => {
@@ -604,7 +521,7 @@ const ChannelsTable = ({ onReady }) => {
}
}, []);
- const deleteChannel = async (id) => {
+ const handleDeleteChannel = async (id) => {
console.log(`Deleting channel with ID: ${id}`);
const rows = table.getRowModel().rows;
@@ -642,15 +559,15 @@ const ChannelsTable = ({ onReady }) => {
const executeDeleteChannel = async (id) => {
setDeleting(true);
try {
- await API.deleteChannel(id);
- API.requeryChannels();
+ await deleteChannel(id);
+ requeryChannels();
} finally {
setDeleting(false);
setConfirmDeleteOpen(false);
}
};
- const deleteChannels = async () => {
+ const handleDeleteChannels = async () => {
if (isWarningSuppressed('delete-channels')) {
// Skip warning if suppressed
return executeDeleteChannels();
@@ -664,8 +581,8 @@ const ChannelsTable = ({ onReady }) => {
setIsLoading(true);
setDeleting(true);
try {
- await API.deleteChannels(table.selectedTableIds);
- await API.requeryChannels();
+ await deleteChannels(table.selectedTableIds);
+ await requeryChannels();
setSelectedChannelIds([]);
table.setSelectedTableIds([]);
} finally {
@@ -688,9 +605,9 @@ const ChannelsTable = ({ onReady }) => {
return '';
}
- const path = `/proxy/ts/stream/${channel.uuid}`;
+ const path = getShowVideoUrl(channel, env_mode);
if (env_mode == 'dev') {
- return `${window.location.protocol}//${window.location.hostname}:5656${path}`;
+ return path;
}
return `${window.location.protocol}//${window.location.host}${path}`;
},
@@ -754,51 +671,23 @@ const ChannelsTable = ({ onReady }) => {
setRecordingModalOpen(false);
};
- // Build URLs with parameters
- const buildM3UUrl = () => {
- const params = new URLSearchParams();
- if (!m3uParams.cachedlogos) params.append('cachedlogos', 'false');
- if (m3uParams.direct) params.append('direct', 'true');
- if (m3uParams.tvg_id_source !== 'channel_number')
- params.append('tvg_id_source', m3uParams.tvg_id_source);
- if (m3uParams.output_format)
- params.append('output_format', m3uParams.output_format);
- if (m3uParams.output_profile)
- params.append('output_profile', m3uParams.output_profile);
-
- const baseUrl = m3uUrl;
- return params.toString() ? `${baseUrl}?${params.toString()}` : baseUrl;
- };
-
- const buildEPGUrl = () => {
- const params = new URLSearchParams();
- if (!epgParams.cachedlogos) params.append('cachedlogos', 'false');
- if (epgParams.tvg_id_source !== 'channel_number')
- params.append('tvg_id_source', epgParams.tvg_id_source);
- if (epgParams.days > 0) params.append('days', epgParams.days.toString());
- if (epgParams.prev_days > 0)
- params.append('prev_days', epgParams.prev_days.toString());
-
- const baseUrl = epgUrl;
- return params.toString() ? `${baseUrl}?${params.toString()}` : baseUrl;
- };
// Example copy URLs
const copyM3UUrl = async () => {
- await copyToClipboard(buildM3UUrl(), {
+ await copyToClipboard(buildM3UUrl(m3uParams, m3uUrl), {
successTitle: 'M3U URL Copied!',
successMessage: 'The M3U URL has been copied to your clipboard.',
});
};
const copyEPGUrl = async () => {
- await copyToClipboard(buildEPGUrl(), {
+ await copyToClipboard(buildEPGUrl(epgParams, epgUrl), {
successTitle: 'EPG URL Copied!',
successMessage: 'The EPG URL has been copied to your clipboard.',
});
};
const copyHDHRUrl = async () => {
- await copyToClipboard(buildHDHRUrl(), {
+ await copyToClipboard(buildHDHRUrl(hdhrOutputProfileId, hdhrUrl), {
successTitle: 'HDHR URL Copied!',
successMessage: 'The HDHR URL has been copied to your clipboard.',
});
@@ -854,7 +743,7 @@ const ChannelsTable = ({ onReady }) => {
useChannelsTableStore.setState({ channels: reorderedData });
// Call backend to reorder
- await API.reorderChannel(
+ await reorderChannel(
activeChannel.id,
overIndex > activeIndex
? overChannel.id
@@ -862,11 +751,11 @@ const ChannelsTable = ({ onReady }) => {
);
// Refetch to get updated channel numbers
- await API.requeryChannels();
+ await requeryChannels();
} catch (error) {
// Revert on error
console.error('Failed to reorder channel:', error);
- await API.requeryChannels();
+ await requeryChannels();
}
};
@@ -885,13 +774,6 @@ const ChannelsTable = ({ onReady }) => {
setM3UUrl(`${m3uUrlBase}${profileString}`);
}, [selectedProfileId, profiles]);
- const buildHDHRUrl = () => {
- if (!hdhrOutputProfileId) return hdhrUrl;
- // Insert output_profile segment before the trailing slash (or at end)
- const base = hdhrUrl.replace(/\/$/, '');
- return `${base}/output_profile/${hdhrOutputProfileId}`;
- };
-
useEffect(() => {
const startItem = pagination.pageIndex * pagination.pageSize + 1; // +1 to start from 1, not 0
const endItem = Math.min(
@@ -1053,7 +935,7 @@ const ChannelsTable = ({ onReady }) => {
row={row}
table={table}
editChannel={editChannel}
- deleteChannel={deleteChannel}
+ deleteChannel={handleDeleteChannel}
handleWatchStream={handleWatchStream}
createRecording={createRecording}
getChannelURL={getChannelURL}
@@ -1298,7 +1180,7 @@ const ChannelsTable = ({ onReady }) => {
position="bottom-start"
withinPortal
>
-
+
}
size="compact-sm"
@@ -1312,8 +1194,8 @@ const ChannelsTable = ({ onReady }) => {
>
HDHR
-
-
+
+
{
clients.
{
.map((p) => ({ value: `${p.id}`, label: p.name }))}
/>
-
+
{
position="bottom-start"
withinPortal
>
-
+
}
size="compact-sm"
@@ -1381,8 +1263,8 @@ const ChannelsTable = ({ onReady }) => {
>
M3U
-
-
+
+
{
channel list.
{
.map((p) => ({ value: `${p.id}`, label: p.name }))}
/>
-
+
{
position="bottom-start"
withinPortal
>
-
+
}
size="compact-sm"
@@ -1515,8 +1397,8 @@ const ChannelsTable = ({ onReady }) => {
>
EPG
-
-
+
+
{
clients.
{
}
/>
-
+
@@ -1626,7 +1508,7 @@ const ChannelsTable = ({ onReady }) => {
{
const [opened, setOpened] = useState(false);
@@ -59,7 +67,7 @@ const CreateProfilePopover = React.memo(() => {
};
const submit = async () => {
- await API.addChannelProfile({ name });
+ await addChannelProfile({ name });
setName('');
setOpened(false);
};
@@ -72,7 +80,7 @@ const CreateProfilePopover = React.memo(() => {
withArrow
shadow="md"
>
-
+
{
>
-
+
-
+
{
-
+
);
});
@@ -125,7 +133,6 @@ const ChannelTableHeader = ({
}) => {
const theme = useMantineTheme();
- const [channelNumAssignmentStart, setChannelNumAssignmentStart] = useState(1);
const [assignNumbersModalOpen, setAssignNumbersModalOpen] = useState(false);
const [groupManagerOpen, setGroupManagerOpen] = useState(false);
const [epgMatchModalOpen, setEpgMatchModalOpen] = useState(false);
@@ -179,38 +186,13 @@ const ChannelTableHeader = ({
const executeDeleteProfile = async (id) => {
setDeletingProfile(true);
try {
- await API.deleteChannelProfile(id);
+ await deleteChannelProfile(id);
} finally {
setDeletingProfile(false);
setConfirmDeleteProfileOpen(false);
}
};
- const assignChannels = async () => {
- try {
- // Call our custom API endpoint
- const result = await API.assignChannelNumbers(
- selectedTableIds,
- channelNumAssignmentStart
- );
-
- // We might get { message: "Channels have been auto-assigned!" }
- notifications.show({
- title: result.message || 'Channels assigned',
- color: 'green.5',
- });
-
- // Refresh the channel list
- API.requeryChannels();
- } catch (err) {
- console.error(err);
- notifications.show({
- title: 'Failed to assign channels',
- color: 'red.5',
- });
- }
- };
-
const renderModalOption = renderProfileOption(
theme,
profiles,
@@ -302,14 +284,14 @@ const ChannelTableHeader = ({
>
diff --git a/frontend/src/components/tables/ChannelsTable/EditableCell.jsx b/frontend/src/components/tables/ChannelsTable/EditableCell.jsx
index 55bd44e3..3d0394a4 100644
--- a/frontend/src/components/tables/ChannelsTable/EditableCell.jsx
+++ b/frontend/src/components/tables/ChannelsTable/EditableCell.jsx
@@ -1,28 +1,14 @@
-import React, {
- useState,
- useCallback,
- useEffect,
- useRef,
- useMemo,
- memo,
-} from 'react';
-import {
- Box,
- TextInput,
- Select,
- NumberInput,
- Tooltip,
- Center,
- Skeleton,
-} from '@mantine/core';
-import API from '../../../api';
+import React, { memo, useCallback, useEffect, useMemo, useRef, useState, } from 'react';
+import { Box, NumberInput, Select, Skeleton, TextInput, Tooltip, } from '@mantine/core';
import useChannelsTableStore from '../../../store/channelsTable';
import useLogosStore from '../../../store/logos';
-import {
- OVERRIDABLE_FIELDS,
- normalizeFieldValue,
-} from '../../../utils/forms/ChannelUtils.js';
+import { requeryChannels, updateChannel, } from '../../../utils/forms/ChannelUtils.js';
import { showNotification } from '../../../utils/notificationUtils.js';
+import {
+ buildInlinePatch,
+ getEpgOptions,
+ getLogoOptions,
+} from '../../../utils/tables/ChannelsTableUtils.js';
// Surfaces server-side validation failures so the user knows the
// inline edit was rejected (otherwise the cell silently reverts).
@@ -43,30 +29,6 @@ export const notifyInlineSaveError = (columnId, error) => {
});
};
-// Inline edits on auto-synced channels route into the override row so
-// sync cannot overwrite them. If the new value matches the provider's,
-// clear that field's override instead of writing a duplicate. Manual
-// channels keep direct Channel.* writes.
-const buildInlinePatch = (rowOriginal, fieldId, newValue) => {
- if (rowOriginal?.auto_created && OVERRIDABLE_FIELDS.includes(fieldId)) {
- // Normalize both sides so a stringified form value compares
- // cleanly against the typed provider value.
- const formValue = normalizeFieldValue(fieldId, newValue);
- const providerValue = normalizeFieldValue(fieldId, rowOriginal[fieldId]);
- const overrideFieldValue = formValue === providerValue ? null : formValue;
- return {
- id: rowOriginal.id,
- override: { [fieldId]: overrideFieldValue },
- };
- }
- const normalized =
- newValue === undefined || newValue === '' ? null : newValue;
- return {
- id: rowOriginal.id,
- [fieldId]: normalized,
- };
-};
-
// Lightweight wrapper that only renders full editable cell when unlocked
// This prevents 250+ heavy component instances when table is locked
const EditableCellWrapper = memo(
@@ -151,7 +113,7 @@ const EditableTextCellInner = ({ row, column, getValue, onBlur }) => {
}
try {
- const response = await API.updateChannel(
+ const response = await updateChannel(
buildInlinePatch(row.original, column.id, newValue)
);
previousValue.current = newValue;
@@ -298,7 +260,7 @@ const EditableNumberCellInner = ({ row, column, getValue, onBlur }) => {
}
try {
- const response = await API.updateChannel(
+ const response = await updateChannel(
buildInlinePatch(row.original, column.id, newValue)
);
previousValue.current = newValue;
@@ -309,7 +271,7 @@ const EditableNumberCellInner = ({ row, column, getValue, onBlur }) => {
// If channel_number was changed, refetch to reorder the table
if (column.id === 'channel_number') {
- await API.requeryChannels();
+ await requeryChannels();
onBlur();
}
}
@@ -416,7 +378,7 @@ const EditableGroupCellInner = ({
}
try {
- const response = await API.updateChannel(
+ const response = await updateChannel(
buildInlinePatch(
row.original,
'channel_group_id',
@@ -591,7 +553,7 @@ const EditableEPGCellInner = ({
}
try {
- const response = await API.updateChannel(
+ const response = await updateChannel(
buildInlinePatch(
row.original,
'epg_data_id',
@@ -620,51 +582,7 @@ const EditableEPGCellInner = ({
// Build EPG options
const epgOptions = useMemo(() => {
- const options = [{ value: 'null', label: 'Not Assigned' }];
-
- // Convert tvgsById to an array and sort by EPG source name, then by tvg_id
- const tvgsArray = Object.values(tvgsById);
- tvgsArray.sort((a, b) => {
- const aEpgName =
- a.epg_source && epgs[a.epg_source]
- ? epgs[a.epg_source].name
- : a.epg_source || '';
- const bEpgName =
- b.epg_source && epgs[b.epg_source]
- ? epgs[b.epg_source].name
- : b.epg_source || '';
- const epgCompare = aEpgName.localeCompare(bEpgName);
- if (epgCompare !== 0) return epgCompare;
- // Secondary sort by tvg_id
- return (a.tvg_id || '').localeCompare(b.tvg_id || '');
- });
-
- tvgsArray.forEach((tvg) => {
- const epgSourceName =
- tvg.epg_source && epgs[tvg.epg_source]
- ? epgs[tvg.epg_source].name
- : tvg.epg_source;
- const tvgName = tvg.name;
- // Create a comprehensive label: "EPG Name | TVG-ID | TVG Name"
- let label;
- if (epgSourceName && tvg.tvg_id) {
- label = `${epgSourceName} | ${tvg.tvg_id}`;
- if (tvgName && tvgName !== tvg.tvg_id) {
- label += ` | ${tvgName}`;
- }
- } else if (tvgName) {
- label = tvgName;
- } else {
- label = `ID: ${tvg.id}`;
- }
-
- options.push({
- value: String(tvg.id),
- label: label,
- });
- });
-
- return options;
+ return getEpgOptions(tvgsById, epgs);
}, [tvgsById, epgs]);
return (
@@ -761,7 +679,7 @@ const EditableLogoCellInner = ({ row, logoId, onBlur }) => {
}
try {
- const response = await API.updateChannel(
+ const response = await updateChannel(
buildInlinePatch(
row.original,
'logo_id',
@@ -790,27 +708,7 @@ const EditableLogoCellInner = ({ row, logoId, onBlur }) => {
// Build logo options with logo data
const logoOptions = useMemo(() => {
- const options = [
- {
- value: 'null',
- label: 'Default',
- logo: null,
- },
- ];
-
- // Convert channelLogos object to array and sort by name
- const logosArray = Object.values(channelLogos);
- logosArray.sort((a, b) => (a.name || '').localeCompare(b.name || ''));
-
- logosArray.forEach((logo) => {
- options.push({
- value: String(logo.id),
- label: logo.name || `Logo ${logo.id}`,
- logo: logo,
- });
- });
-
- return options;
+ return getLogoOptions(channelLogos);
}, [channelLogos]);
// Get display text for the current logo
diff --git a/frontend/src/components/tables/ChannelsTable/__tests__/ChannelTableHeader.test.jsx b/frontend/src/components/tables/ChannelsTable/__tests__/ChannelTableHeader.test.jsx
new file mode 100644
index 00000000..6979046b
--- /dev/null
+++ b/frontend/src/components/tables/ChannelsTable/__tests__/ChannelTableHeader.test.jsx
@@ -0,0 +1,693 @@
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// ── Store mocks ────────────────────────────────────────────────────────────────
+vi.mock('../../../../store/channels', () => ({ default: vi.fn() }));
+vi.mock('../../../../store/channelsTable', () => ({ default: vi.fn() }));
+vi.mock('../../../../store/auth', () => ({ default: vi.fn() }));
+vi.mock('../../../../store/warnings', () => ({ default: vi.fn() }));
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../../utils/tables/ChannelsTableUtils.js', () => ({
+ addChannelProfile: vi.fn(),
+ deleteChannelProfile: vi.fn(),
+}));
+
+// ── Child component mocks ──────────────────────────────────────────────────────
+vi.mock('../../../forms/AssignChannelNumbers', () => ({
+ default: ({ isOpen, onClose }) =>
+ isOpen ? (
+
, + Label: ({ children }) =>
, + MenuDropdown: ({ children }) => ( +{content} ;
};
- // Get header groups for dependency tracking
- const headerGroups = getHeaderGroups();
-
- // Calculate minimum width based only on fixed-size columns
- const minTableWidth = useMemo(() => {
- if (!headerGroups || headerGroups.length === 0) return 0;
-
- const width =
- headerGroups[0]?.headers.reduce((total, header) => {
- // Only count columns with fixed sizes, flexible columns will expand
- const columnSize = header.column.columnDef.size
- ? header.getSize()
- : header.column.columnDef.minSize || 150; // Default min for flexible columns
- return total + columnSize;
- }, 0) || 0;
-
- return width;
- }, [headerGroups]);
-
// Memoize the style object to ensure it updates when headerPinned changes
const headerStyle = useMemo(
() => ({
@@ -122,7 +103,6 @@ const CustomTableHeader = ({
maxWidth: `var(--header-${header.id}-size)`,
}),
position: 'relative',
- // ...(tableCellProps && tableCellProps({ cell: header })),
}}
>
({
+ default: ({ headerPinned, enableDragDrop }) => (
+
+ ),
+}));
+
+vi.mock('../CustomTableBody', () => ({
+ default: ({ enableDragDrop }) => (
+
+ ),
+}));
+
+// ── @mantine/core ──────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ Box: ({ children, className, style }) => (
+
+ makeHeaderGroups([makeHeader('name'), makeHeader('status')]),
+ })}
+ />
+ );
+ // flexRender returns the header string (id.toUpperCase()) for unknown headers
+ expect(screen.getByText('NAME')).toBeInTheDocument();
+ expect(screen.getByText('STATUS')).toBeInTheDocument();
+ });
+
+ it('wraps each cell in MultiSelectHeaderWrapper', () => {
+ render( selectHeaderGroups(),
+ })}
+ />
+ );
+ expect(screen.getByTestId('select-all-checkbox')).toBeInTheDocument();
+ });
+
+ it('checkbox is unchecked when no rows are selected', () => {
+ render(
+ selectHeaderGroups(),
+ allRowIds: ['1', '2'],
+ selectedTableIds: [],
+ })}
+ />
+ );
+ expect(screen.getByTestId('select-all-checkbox')).not.toBeChecked();
+ });
+
+ it('checkbox is unchecked when allRowIds is empty', () => {
+ render(
+ selectHeaderGroups(),
+ allRowIds: [],
+ selectedTableIds: [],
+ })}
+ />
+ );
+ expect(screen.getByTestId('select-all-checkbox')).not.toBeChecked();
+ });
+
+ it('checkbox is checked when all rows are selected', () => {
+ render(
+ selectHeaderGroups(),
+ allRowIds: ['1', '2'],
+ selectedTableIds: ['1', '2'],
+ })}
+ />
+ );
+ expect(screen.getByTestId('select-all-checkbox')).toBeChecked();
+ });
+
+ it('calls onSelectAllChange when checkbox is changed', () => {
+ const onSelectAllChange = vi.fn();
+ render(
+ selectHeaderGroups(),
+ onSelectAllChange,
+ })}
+ />
+ );
+ fireEvent.click(screen.getByTestId('select-all-checkbox'));
+ expect(onSelectAllChange).toHaveBeenCalled();
+ });
+ });
+
+ // ── custom headerCellRenderFns ─────────────────────────────────────────────
+
+ describe('headerCellRenderFns', () => {
+ it('uses custom render function when provided for a column id', () => {
+ const customRender = vi.fn(() => (
+ Custom Name
+ ));
+ render(
+ makeHeaderGroups([makeHeader('name')]),
+ headerCellRenderFns: { name: customRender },
+ })}
+ />
+ );
+ expect(customRender).toHaveBeenCalled();
+ expect(screen.getByTestId('custom-header')).toBeInTheDocument();
+ });
+
+ it('falls back to flexRender when no custom render fn provided', () => {
+ render(
+ makeHeaderGroups([makeHeader('name')]),
+ headerCellRenderFns: {},
+ })}
+ />
+ );
+ expect(screen.getByText('NAME')).toBeInTheDocument();
+ });
+ });
+
+ // ── resize handle ─────────────────────────────────────────────────────────
+
+ describe('resize handle', () => {
+ it('renders resize handle when column canResize is true', () => {
+ render(
+
+ makeHeaderGroups([makeHeader('name', { canResize: true })]),
+ })}
+ />
+ );
+ // The resizer div is rendered — check for the class
+ const resizers = document.querySelectorAll('.resizer');
+ expect(resizers.length).toBeGreaterThan(0);
+ });
+
+ it('does not render resize handle when column canResize is false', () => {
+ render(
+
+ makeHeaderGroups([makeHeader('name', { canResize: false })]),
+ })}
+ />
+ );
+ const resizers = document.querySelectorAll('.resizer');
+ expect(resizers.length).toBe(0);
+ });
+
+ it('applies isResizing class when column is being resized', () => {
+ render(
+
+ makeHeaderGroups([
+ makeHeader('name', { canResize: true, isResizing: true }),
+ ]),
+ })}
+ />
+ );
+ expect(document.querySelector('.resizer.isResizing')).toBeTruthy();
+ });
+ });
+});
diff --git a/frontend/src/components/tables/CustomTable/__tests__/MultiSelectHeaderWrapper.test.jsx b/frontend/src/components/tables/CustomTable/__tests__/MultiSelectHeaderWrapper.test.jsx
new file mode 100644
index 00000000..74870c39
--- /dev/null
+++ b/frontend/src/components/tables/CustomTable/__tests__/MultiSelectHeaderWrapper.test.jsx
@@ -0,0 +1,360 @@
+import { render, screen, fireEvent } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import React from 'react';
+
+// ── Mantine core mock ──────────────────────────────────────────────────────────
+// We need MultiSelect to be identifiable by reference (element.type === MultiSelect),
+// so we export it from the mock so the component under test can compare against it.
+vi.mock('@mantine/core', async () => {
+ const MockMultiSelect = ({
+ value = [],
+ data = [],
+ onChange,
+ label
+ }) => (
+
+
+ );
+ expect(screen.getByTestId('plain-child')).toBeInTheDocument();
+ expect(screen.getByText('Hello')).toBeInTheDocument();
+ });
+
+ it('renders a plain text node unchanged', () => {
+ render(
+ {'just text'}
+ );
+ expect(screen.getByText('just text')).toBeInTheDocument();
+ });
+
+ it('recursively passes through nested non-MultiSelect elements', () => {
+ render(
+
+
+ );
+ expect(screen.getByTestId('nested')).toBeInTheDocument();
+ });
+ });
+
+ // ── MultiSelect with no selections ────────────────────────────────────────
+
+ describe('MultiSelect with no selections', () => {
+ it('renders the MultiSelect directly when value is empty', () => {
+ render(
+
+
+ );
+ expect(screen.getByTestId('multiselect')).toBeInTheDocument();
+ });
+
+ it('does not render pills when value is empty', () => {
+ render(
+
+
+ );
+ expect(screen.queryByTestId('pill')).not.toBeInTheDocument();
+ });
+
+ it('does not render a tooltip when value is empty', () => {
+ render(
+
+
+ );
+ expect(screen.queryByTestId('tooltip')).not.toBeInTheDocument();
+ });
+
+ it('handles undefined value as no selections', () => {
+ render(
+
+
+ );
+ expect(screen.queryByTestId('pill')).not.toBeInTheDocument();
+ });
+ });
+
+ // ── MultiSelect with one selection ────────────────────────────────────────
+
+ describe('MultiSelect with one selection', () => {
+ const data = makeData(3);
+ const value = ['val-0'];
+
+ it('renders a pill showing the first selected label', () => {
+ render(
+
+
+ );
+ const pill = screen.getByTestId('pill');
+ expect(pill).toBeInTheDocument();
+ expect(pill).toHaveTextContent('Label 0');
+ });
+
+ it('renders exactly one pill for a single selection', () => {
+ render(
+
+
+ );
+ expect(screen.getAllByTestId('pill')).toHaveLength(1);
+ });
+
+ it('renders a tooltip wrapping the pill area', () => {
+ render(
+
+
+ );
+ expect(screen.getByTestId('tooltip')).toBeInTheDocument();
+ });
+
+ it('still renders the underlying MultiSelect', () => {
+ render(
+
+
+ );
+ expect(screen.getByTestId('multiselect')).toBeInTheDocument();
+ });
+
+ it('falls back to the raw value when label is not found in data', () => {
+ render(
+
+
+ );
+ const pill = screen.getByTestId('pill');
+ expect(pill).toBeInTheDocument();
+ expect(pill).toHaveTextContent('unknown-val');
+ });
+
+ it('calls onChange with remaining values when the remove button is clicked', () => {
+ const onChange = vi.fn();
+ render(
+
+
+ );
+ fireEvent.click(screen.getByTestId('pill-remove'));
+ expect(onChange).toHaveBeenCalledWith([]);
+ });
+ });
+
+ // ── MultiSelect with multiple selections ──────────────────────────────────
+
+ describe('MultiSelect with multiple selections', () => {
+ const data = makeData(5);
+ const value = ['val-0', 'val-1', 'val-2'];
+
+ it('renders two pills: first label and overflow count', () => {
+ render(
+
+
+ );
+ expect(screen.getAllByTestId('pill')).toHaveLength(2);
+ });
+
+ it('shows the first label in the first pill', () => {
+ render(
+
+
+ );
+ const pills = screen.getAllByTestId('pill');
+ expect(pills[0]).toHaveTextContent('Label 0');
+ });
+
+ it('shows "+N" overflow count in the second pill', () => {
+ render(
+
+
+ );
+ // 3 selections → "+2"
+ expect(screen.getByText('+2')).toBeInTheDocument();
+ });
+
+ it('calls onChange with slice(1) when first pill remove is clicked', () => {
+ const onChange = vi.fn();
+ render(
+
+
+ );
+ const removeButtons = screen.getAllByTestId('pill-remove');
+ fireEvent.click(removeButtons[0]);
+ expect(onChange).toHaveBeenCalledWith(['val-1', 'val-2']);
+ });
+
+ it('calls onChange with [] when overflow pill remove is clicked', () => {
+ const onChange = vi.fn();
+ render(
+
+
+ );
+ const removeButtons = screen.getAllByTestId('pill-remove');
+ fireEvent.click(removeButtons[1]);
+ expect(onChange).toHaveBeenCalledWith([]);
+ });
+ });
+
+ // ── Tooltip with more than 10 selections ──────────────────────────────────
+
+ describe('tooltip overflow for > 10 selections', () => {
+ it('shows "+N more" text in tooltip area when more than 10 values are selected', () => {
+ const data = makeData(15);
+ const value = data.map((d) => d.value);
+
+ render(
+
+
+ );
+ expect(screen.getByText('+5 more')).toBeInTheDocument();
+ });
+
+ it('does not show "+N more" when selections are 10 or fewer', () => {
+ const data = makeData(10);
+ const value = data.map((d) => d.value);
+
+ render(
+
+
+ );
+ expect(screen.queryByText(/more$/)).not.toBeInTheDocument();
+ });
+ });
+
+ // ── Recursive enhancement ──────────────────────────────────────────────────
+
+ describe('recursive MultiSelect enhancement', () => {
+ it('enhances a MultiSelect nested inside a wrapper div', () => {
+ render(
+
+
+ );
+ expect(screen.getByTestId('pill')).toBeInTheDocument();
+ expect(screen.getByTestId('pill')).toHaveTextContent('Label 0');
+ });
+ });
+
+ // ── onChange absence ──────────────────────────────────────────────────────
+
+ describe('onChange not provided', () => {
+ it('does not throw when onChange is undefined and remove is clicked', () => {
+ render(
+
+
+ );
+ expect(() =>
+ fireEvent.click(screen.getByTestId('pill-remove'))
+ ).not.toThrow();
+ });
+
+ it('does not throw when clearAll is triggered without onChange', () => {
+ render(
+
+
+ );
+ const removeButtons = screen.getAllByTestId('pill-remove');
+ expect(() => fireEvent.click(removeButtons[1])).not.toThrow();
+ });
+ });
+});
diff --git a/frontend/src/components/tables/CustomTable/__tests__/index.test.jsx b/frontend/src/components/tables/CustomTable/__tests__/index.test.jsx
new file mode 100644
index 00000000..cfbe315e
--- /dev/null
+++ b/frontend/src/components/tables/CustomTable/__tests__/index.test.jsx
@@ -0,0 +1,846 @@
+import React from 'react';
+import {
+ renderHook,
+ act,
+ render,
+ fireEvent,
+} from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+// ── @tanstack/react-table ──────────────────────────────────────────────────────
+vi.mock('@tanstack/react-table', () => ({
+ getCoreRowModel: vi.fn(() => 'mock-core-row-model'),
+ useReactTable: vi.fn(),
+ flexRender: vi.fn(() => ),
+}));
+
+// ── Hook mocks ─────────────────────────────────────────────────────────────────
+vi.mock('../../../../hooks/useTablePreferences', () => ({
+ default: vi.fn(),
+}));
+
+// ── Child component mocks ──────────────────────────────────────────────────────
+vi.mock('../CustomTable', () => ({
+ default: () => ,
+}));
+
+vi.mock('../CustomTableHeader', () => ({
+ default: () => ,
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ Center: ({ children, style, onClick }) => (
+
@@ -225,7 +201,6 @@ const EPGsTable = () => {
const [epg, setEPG] = useState(null);
const [epgModalOpen, setEPGModalOpen] = useState(false);
const [dummyEpgModalOpen, setDummyEpgModalOpen] = useState(false);
- const [rowSelection, setRowSelection] = useState([]);
const [confirmDeleteOpen, setConfirmDeleteOpen] = useState(false);
const [deleteTarget, setDeleteTarget] = useState(null);
const [epgToDelete, setEpgToDelete] = useState(null);
@@ -251,11 +226,11 @@ const EPGsTable = () => {
}
// Send only the is_active field to trigger our special handling
- await API.updateEPG(
+ await updateEpg(
{
- id: epg.id,
is_active: !epg.is_active,
},
+ epg,
true
); // Add a new parameter to indicate this is just a toggle
} catch (error) {
@@ -395,7 +370,6 @@ const EPGsTable = () => {
[fullDateTimeFormat]
);
- const [isLoading, setIsLoading] = useState(true);
const [sorting, setSorting] = useState([]);
const editEPG = async (epg = null) => {
@@ -436,7 +410,7 @@ const EPGsTable = () => {
const executeDeleteEPG = async (id) => {
setDeleting(true);
try {
- await API.deleteEPG(id);
+ await deleteEpg(id);
} finally {
setDeleting(false);
setConfirmDeleteOpen(false);
@@ -444,8 +418,8 @@ const EPGsTable = () => {
};
const refreshEPG = async (id, force = false) => {
- await API.refreshEPG(id, force);
- notifications.show({
+ await refreshEpg(id, force);
+ showNotification({
title: 'EPG refresh initiated',
});
};
@@ -502,74 +476,11 @@ const EPGsTable = () => {
}
};
- const renderHeaderCell = (header) => {
- let sortingIcon = ArrowUpDown;
- if (sorting[0]?.id == header.id) {
- if (sorting[0].desc === false) {
- sortingIcon = ArrowUpNarrowWide;
- } else {
- sortingIcon = ArrowDownWideNarrow;
- }
- }
+ const onSortingChange = makeSortingChangeHandler(sorting, setSorting, (col, desc) =>
+ setData(getSortedEpgs(epgs, col, desc))
+ );
- switch (header.id) {
- default:
- return (
-
-
- {header.column.columnDef.header}
-
- {header.column.columnDef.sortable && (
-
- {React.createElement(sortingIcon, {
- onClick: () => onSortingChange(header.id),
- size: 14,
- })}
-
- )}
-
- );
- }
- };
-
- const onSortingChange = (column) => {
- console.log(column);
- const sortField = sorting[0]?.id;
- const sortDirection = sorting[0]?.desc;
-
- const newSorting = [];
- if (sortField == column) {
- if (sortDirection == false) {
- newSorting[0] = {
- id: column,
- desc: true,
- };
- }
- } else {
- newSorting[0] = {
- id: column,
- desc: false,
- };
- }
-
- setSorting(newSorting);
- if (newSorting.length > 0) {
- const compareColumn = newSorting[0].id;
- const compareDesc = newSorting[0].desc;
-
- setData(
- epgs.sort((a, b) => {
- console.log(a);
- console.log(newSorting[0].id);
- if (a[compareColumn] !== b[compareColumn]) {
- return compareDesc ? 1 : -1;
- }
-
- return 0;
- })
- );
- }
- };
+ const renderHeaderCell = makeHeaderCellRenderer(sorting, onSortingChange);
const table = useTable({
columns,
@@ -578,7 +489,6 @@ const EPGsTable = () => {
enablePagination: false,
enableRowSelection: false,
renderTopToolbar: false,
- onRowSelectionChange: setRowSelection,
manualSorting: true,
bodyCellRenderFns: {
actions: renderBodyCell,
@@ -632,7 +542,7 @@ const EPGsTable = () => {
EPGs
@@ -668,11 +576,8 @@ const EPGsTable = () => {
{
theme={theme}
row={row}
editLogo={editLogo}
- deleteLogo={deleteLogo}
+ handleDeleteLogo={handleDeleteLogo}
/>
),
},
@@ -536,7 +488,7 @@ const LogosTable = () => {
[
theme,
editLogo,
- deleteLogo,
+ handleDeleteLogo,
selectedRows,
handleSelectRow,
handleSelectAll,
diff --git a/frontend/src/components/tables/M3UsTable.jsx b/frontend/src/components/tables/M3UsTable.jsx
index 4a1d7e6f..fa21191e 100644
--- a/frontend/src/components/tables/M3UsTable.jsx
+++ b/frontend/src/components/tables/M3UsTable.jsx
@@ -1,11 +1,10 @@
-import React, {
+import {
useEffect,
useMemo,
useRef,
useState,
useCallback,
} from 'react';
-import API from '../../api';
import usePlaylistsStore from '../../store/playlists';
import M3UForm from '../forms/M3U';
import ServerGroupsManagerModal from '../ServerGroupsManagerModal';
@@ -20,16 +19,11 @@ import {
ActionIcon,
Tooltip,
Switch,
- Group,
- Center,
} from '@mantine/core';
import {
SquareMinus,
SquarePen,
RefreshCcw,
- ArrowUpDown,
- ArrowUpNarrowWide,
- ArrowDownWideNarrow,
SquarePlus,
} from 'lucide-react';
import useLocalStorage from '../../hooks/useLocalStorage';
@@ -42,55 +36,42 @@ import {
import ConfirmationDialog from '../../components/ConfirmationDialog';
import useWarningsStore from '../../store/warnings';
import { CustomTable, useTable } from './CustomTable';
+import {
+ deletePlaylist,
+ getExpirationInfo,
+ getExpirationTooltip,
+ getPlaylistAutoCreatedChannelsCount,
+ getSortedPlaylists,
+ getStatusColor,
+ getStatusContent,
+ formatStatusText,
+ refreshPlaylist,
+ updatePlaylist,
+} from '../../utils/tables/M3UsTableUtils.js';
+import {
+ makeHeaderCellRenderer,
+ makeSortingChangeHandler,
+} from './M3uTableUtils.jsx';
-// Helper function to format status text
-const formatStatusText = (status) => {
- switch (status) {
- case 'idle':
- return 'Idle';
- case 'fetching':
- return 'Fetching';
- case 'parsing':
- return 'Parsing';
- case 'error':
- return 'Error';
- case 'success':
- return 'Success';
- case 'pending_setup':
- return 'Pending Setup';
- default:
- return status
- ? status.charAt(0).toUpperCase() + status.slice(1)
- : 'Unknown';
- }
-};
+const StatusRow = ({ label, value }) => (
+
+ {label}{value ? ':' : ''}
+ {value && {value} }
+
+);
-// Helper function to get status text color
-const getStatusColor = (status) => {
- switch (status) {
- case 'idle':
- return 'gray.5';
- case 'fetching':
- return 'blue.5';
- case 'parsing':
- return 'indigo.5';
- case 'error':
- return 'red.5';
- case 'success':
- return 'green.5';
- case 'pending_setup':
- return 'orange.5'; // Orange to indicate action needed
- default:
- return 'gray.5';
- }
-};
+const StatusBox = ({ children }) => (
+
+ {children}
+
+);
const RowActions = ({
tableSize,
editPlaylist,
- deletePlaylist,
+ handleDeletePlaylist,
row,
- refreshPlaylist,
+ handleRefreshPlaylist,
}) => {
const iconSize =
tableSize == 'default' ? 'sm' : tableSize == 'compact' ? 'xs' : 'md';
@@ -111,7 +92,7 @@ const RowActions = ({
variant="transparent"
size={iconSize}
color="red.9"
- onClick={() => deletePlaylist(row.original.id)}
+ onClick={() => handleDeletePlaylist(row.original.id)}
>
+
+ );
+ case 'groups':
+ return (
+
+
+ );
case 'parsing':
- return buildParsingStats(data);
-
+ return (
+
+
+ );
+ case 'error':
+ return (
+
+ Error:
+
+ {content.error || 'Unknown error occurred'}
+
+
+ );
default:
- return data.status === 'error'
- ? buildErrorStats(data)
- : `${data.action || 'Processing'}...`;
+ return content.label;
}
};
- const buildDownloadingStats = (data) => {
- if (data.progress == 100) {
- return 'Download complete!';
- }
-
- if (data.progress == 0) {
- return 'Downloading...';
- }
-
- // Format time remaining in minutes:seconds
- const timeRemaining = data.time_remaining
- ? `${Math.floor(data.time_remaining / 60)}:${String(Math.floor(data.time_remaining % 60)).padStart(2, '0')}`
- : 'calculating...';
-
- // Format speed with appropriate unit (KB/s or MB/s)
- const speed =
- data.speed >= 1024
- ? `${(data.speed / 1024).toFixed(2)} MB/s`
- : `${Math.round(data.speed)} KB/s`;
-
- return (
-
-
-
-
- Downloading:
-
- {parseInt(data.progress)}%
-
-
-
- Speed:
-
- {speed}
-
-
-
- Time left:
-
- {timeRemaining}
-
-
-
- );
- };
-
- const buildGroupProcessingStats = (data) => {
- if (data.progress == 100) {
- return 'Groups processed!';
- }
-
- if (data.progress == 0) {
- return 'Processing groups...';
- }
-
- // Format time displays if available
- const elapsedTime = data.elapsed_time
- ? `${Math.floor(data.elapsed_time / 60)}:${String(Math.floor(data.elapsed_time % 60)).padStart(2, '0')}`
- : null;
-
- return (
-
-
-
-
- Processing groups:
-
- {parseInt(data.progress)}%
-
- {elapsedTime && (
-
-
- Elapsed:
-
- {elapsedTime}
-
- )}
- {data.groups_processed && (
-
-
- Groups:
-
- {data.groups_processed}
-
- )}
-
-
- );
- };
-
- const buildErrorStats = (data) => {
- return (
-
-
-
-
- Error:
-
-
-
- {data.error || 'Unknown error occurred'}
-
-
-
- );
- };
-
- const buildParsingStats = (data) => {
- if (data.progress == 100) {
- return 'Parsing complete!';
- }
-
- if (data.progress == 0) {
- return 'Parsing...';
- }
-
- // Format time displays
- const timeRemaining = data.time_remaining
- ? `${Math.floor(data.time_remaining / 60)}:${String(Math.floor(data.time_remaining % 60)).padStart(2, '0')}`
- : 'calculating...';
-
- const elapsedTime = data.elapsed_time
- ? `${Math.floor(data.elapsed_time / 60)}:${String(Math.floor(data.elapsed_time % 60)).padStart(2, '0')}`
- : '0:00';
-
- return (
-
-
-
-
- Parsing:
-
- {parseInt(data.progress)}%
-
- {data.elapsed_time && (
-
-
- Elapsed:
-
- {elapsedTime}
-
- )}
- {data.time_remaining && (
-
-
- Remaining:
-
- {timeRemaining}
-
- )}
- {data.streams_processed && (
-
-
- Streams:
-
- {data.streams_processed}
-
- )}
-
-
- );
- };
-
- const buildInitializingStats = () => {
- return (
-
-
-
-
- Initializing refresh...
-
-
-
-
- );
- };
-
const editPlaylist = async (playlist = null) => {
setPlaylist(playlist);
setPlaylistModalOpen(true);
};
- const refreshPlaylist = async (id) => {
+ const handleRefreshPlaylist = async (id) => {
// Provide immediate visual feedback before the API call
setRefreshProgress(id, {
action: 'initializing',
@@ -391,9 +221,9 @@ const M3UTable = () => {
});
try {
- await API.refreshPlaylist(id);
+ await refreshPlaylist(id);
// No need to set again since WebSocket will update us once the task starts
- } catch (error) {
+ } catch {
// If the API call fails, show an error state
setRefreshProgress(id, {
action: 'error',
@@ -406,7 +236,7 @@ const M3UTable = () => {
}
};
- const deletePlaylist = async (id) => {
+ const handleDeletePlaylist = async (id) => {
// Get playlist details for the confirmation dialog
const playlist = playlists.find((p) => p.id === id);
setPlaylistToDelete(playlist);
@@ -418,7 +248,7 @@ const M3UTable = () => {
// thinking there are zero auto-created channels.
let info;
try {
- const result = await API.getPlaylistAutoCreatedChannelsCount(id);
+ const result = await getPlaylistAutoCreatedChannelsCount(id);
info = result || { count: 0, sample_names: [] };
} catch {
info = {
@@ -448,7 +278,9 @@ const M3UTable = () => {
setIsLoading(true);
setDeleting(true);
try {
- await API.deletePlaylist(id);
+ await deletePlaylist(id);
+ } catch (error) {
+ console.error('Error deleting playlist:', error);
} finally {
setDeleting(false);
setIsLoading(false);
@@ -460,11 +292,11 @@ const M3UTable = () => {
const toggleActive = async (playlist) => {
try {
// Send only the is_active field to trigger our special handling
- await API.updatePlaylist(
+ await updatePlaylist(
{
- id: playlist.id,
is_active: !playlist.is_active,
},
+ playlist,
true
); // Add a new parameter to indicate this is just a toggle
} catch (error) {
@@ -685,34 +517,10 @@ const M3UTable = () => {
const now = getNow();
const daysLeft = diff(earliest, now, 'day');
- let color;
- let label;
- if (daysLeft < 0) {
- color = 'red.7';
- label = 'Expired';
- } else if (daysLeft === 0) {
- color = 'red.5';
- label = 'Expires today';
- } else if (daysLeft <= 7) {
- color = 'orange.5';
- label = `${daysLeft}d left`;
- } else if (daysLeft <= 30) {
- color = 'yellow.5';
- label = `${daysLeft}d left`;
- } else {
- label = format(earliest, fullDateFormat);
- }
+ const { color, label } = getExpirationInfo(daysLeft, earliest, fullDateFormat);
const allExpirations = data.all_expirations || [];
- const tooltipContent =
- allExpirations.length > 0
- ? allExpirations
- .map(
- (e) =>
- `${e.profile_name}: ${format(e.exp_date, fullDateTimeFormat)}${!e.is_active ? ' (inactive)' : ''}`
- )
- .join('\n')
- : label;
+ const tooltipContent = getExpirationTooltip(allExpirations, fullDateTimeFormat, label);
return (
{
},
],
[
- refreshPlaylist,
+ handleRefreshPlaylist,
editPlaylist,
- deletePlaylist,
+ handleDeletePlaylist,
toggleActive,
fullDateFormat,
fullDateTimeFormat,
@@ -776,7 +584,7 @@ const M3UTable = () => {
//optionally access the underlying virtualizer instance
const rowVirtualizerInstanceRef = useRef(null);
- const [isLoading, setIsLoading] = useState(true);
+ const [_isLoading, setIsLoading] = useState(true);
const closeModal = (newPlaylist = null) => {
if (newPlaylist) {
@@ -812,85 +620,11 @@ const M3UTable = () => {
}
}, [editPlaylistId, processedData, playlists, setEditPlaylistId]);
- const onSortingChange = (column) => {
- console.log(column);
- const sortField = sorting[0]?.id;
- const sortDirection = sorting[0]?.desc;
+ const onSortingChange = makeSortingChangeHandler(sorting, setSorting, (col, desc) =>
+ setData(getSortedPlaylists(playlists, col, desc))
+ );
- const newSorting = [];
- if (sortField == column) {
- if (sortDirection == false) {
- newSorting[0] = {
- id: column,
- desc: true,
- };
- }
- } else {
- newSorting[0] = {
- id: column,
- desc: false,
- };
- }
-
- setSorting(newSorting);
- if (newSorting.length > 0) {
- const compareColumn = newSorting[0].id;
- const compareDesc = newSorting[0].desc;
-
- setData(
- playlists
- .filter((playlist) => playlist.locked === false)
- .sort((a, b) => {
- const aVal = a[compareColumn];
- const bVal = b[compareColumn];
-
- // Always sort nulls/undefined to the end regardless of direction
- if (aVal == null && bVal == null) return 0;
- if (aVal == null) return 1;
- if (bVal == null) return -1;
-
- let comparison;
- if (typeof aVal === 'string') {
- comparison = aVal.localeCompare(bVal);
- } else {
- comparison = aVal < bVal ? -1 : aVal > bVal ? 1 : 0;
- }
-
- return compareDesc ? -comparison : comparison;
- })
- );
- }
- };
-
- const renderHeaderCell = (header) => {
- let sortingIcon = ArrowUpDown;
- if (sorting[0]?.id == header.id) {
- if (sorting[0].desc === false) {
- sortingIcon = ArrowUpNarrowWide;
- } else {
- sortingIcon = ArrowDownWideNarrow;
- }
- }
-
- switch (header.id) {
- default:
- return (
-
-
- {header.column.columnDef.header}
-
- {header.column.columnDef.sortable && (
-
- {React.createElement(sortingIcon, {
- onClick: () => onSortingChange(header.id),
- size: 14,
- })}
-
- )}
-
- );
- }
- };
+ const renderHeaderCell = makeHeaderCellRenderer(sorting, onSortingChange);
const renderBodyCell = useCallback(({ cell, row }) => {
switch (cell.column.id) {
@@ -899,9 +633,9 @@ const M3UTable = () => {
- {`${autoChannelsInfo.count} auto-synced channel${autoChannelsInfo.count === 1 ? '' : 's'} created by this provider will also be deleted.`}
+ {`${autoChannelsInfo.count} auto-synced ${autoChannelsInfo.count === 1 ? 'channel' : 'channels'} created by this provider will also be deleted.`}
) : null}
diff --git a/frontend/src/components/tables/M3uTableUtils.jsx b/frontend/src/components/tables/M3uTableUtils.jsx
new file mode 100644
index 00000000..226912a1
--- /dev/null
+++ b/frontend/src/components/tables/M3uTableUtils.jsx
@@ -0,0 +1,53 @@
+import React from 'react';
+import { Center, Group, Text } from '@mantine/core';
+import {
+ ArrowDownWideNarrow,
+ ArrowUpDown,
+ ArrowUpNarrowWide,
+} from 'lucide-react';
+
+export const makeHeaderCellRenderer = (sorting, onSortingChange) => (header) => {
+ let sortingIcon = ArrowUpDown;
+ if (sorting[0]?.id === header.id) {
+ sortingIcon =
+ sorting[0].desc === false ? ArrowUpNarrowWide : ArrowDownWideNarrow;
+ }
+
+ return (
+
+
+
+ ) : null,
+}));
+
+vi.mock('../../../forms/GroupManager', () => ({
+ default: ({ isOpen, onClose }) =>
+ isOpen ? (
+
+
+
+ ) : null,
+}));
+
+vi.mock('../../../modals/ProfileModal', () => ({
+ default: ({ opened, onClose }) =>
+ opened ? (
+
+
+
+ ) : null,
+ renderProfileOption: vi.fn(() => () => null),
+}));
+
+vi.mock('../../../modals/EPGMatchModal', () => ({
+ default: ({ opened, onClose }) =>
+ opened ? (
+
+
+
+ ) : null,
+}));
+
+vi.mock('../../../ConfirmationDialog', () => ({
+ default: ({ opened, onClose, onConfirm, title, loading }) =>
+ opened ? (
+
+ {title}
+
+
+
+ ) : null,
+}));
+
+// ── @mantine/core ──────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color, variant }) => (
+
+ ),
+ Box: ({ children, style }) => {children}
,
+ Button: ({ children, onClick, disabled, variant, color }) => (
+
+ ),
+ Flex: ({ children }) => {children}
,
+ Group: ({ children }) => {children}
,
+ Menu: Object.assign(
+ ({ children }) => {children}
,
+ {
+ Target: ({ children }) => {children}
,
+ Dropdown: ({ children }) => (
+ {children}
+ ),
+ Item: ({ children, onClick, disabled }) => (
+
+ ),
+ Divider: () => , + Label: ({ children }) =>
{children}
,
+ }
+ ),
+ MenuDivider: () => , + MenuDropdown: ({ children }) => ( +
{children}
+ ),
+ MenuItem: ({ children, onClick, disabled }) => (
+
+ ),
+ MenuLabel: ({ children }) => {children}
,
+ MenuTarget: ({ children }) => {children}
,
+ Popover: ({ children, opened }) => (
+
+ {children}
+
+ ),
+ PopoverDropdown: ({ children }) => (
+ {children}
+ ),
+ PopoverTarget: ({ children }) => {children}
,
+ Select: ({ value, onChange, data }) => (
+
+ ),
+ Text: ({ children, c }) => (
+
+ {children}
+
+ ),
+ TextInput: ({ value, onChange, placeholder }) => (
+
+ ),
+ Tooltip: ({ children, label }) => {children}
,
+ useMantineTheme: () => ({
+ tailwind: {
+ green: { 5: 'green.5' },
+ yellow: { 5: 'yellow.5' },
+ },
+ palette: { custom: {} },
+ }),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ ArrowDown01: () => ,
+ Binary: () => ,
+ CircleCheck: () => ,
+ EllipsisVertical: () => ,
+ Eye: () => ,
+ EyeOff: () => ,
+ Filter: () => ,
+ Lock: () => ,
+ LockOpen: () => ,
+ Pin: () => ,
+ PinOff: () => ,
+ Settings: () => ,
+ Square: () => ,
+ SquareCheck: () => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ SquarePlus: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useChannelsStore from '../../../../store/channels';
+import useChannelsTableStore from '../../../../store/channelsTable';
+import useAuthStore from '../../../../store/auth';
+import useWarningsStore from '../../../../store/warnings';
+import * as ChannelsTableUtils from '../../../../utils/tables/ChannelsTableUtils.js';
+import ChannelTableHeader from '../ChannelTableHeader';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const ADMIN = 10;
+const STANDARD = 1;
+
+const makeProfiles = () => ({
+ 0: { id: 0, name: 'All Channels' },
+ 1: { id: 1, name: 'Profile A' },
+ 2: { id: 2, name: 'Profile B' },
+});
+
+const makeTable = (overrides = {}) => ({
+ headerPinned: false,
+ setHeaderPinned: vi.fn(),
+ selectedTableIds: [],
+ setSelectedTableIds: vi.fn(),
+ ...overrides,
+});
+
+const makeDefaultProps = (overrides = {}) => ({
+ rows: [],
+ editChannel: vi.fn(),
+ deleteChannels: vi.fn(),
+ selectedTableIds: [],
+ table: makeTable(),
+ showDisabled: true,
+ setShowDisabled: vi.fn(),
+ showOnlyStreamlessChannels: false,
+ setShowOnlyStreamlessChannels: vi.fn(),
+ showOnlyStaleChannels: false,
+ setShowOnlyStaleChannels: vi.fn(),
+ showOnlyOverriddenChannels: false,
+ setShowOnlyOverriddenChannels: vi.fn(),
+ visibilityFilter: 'active',
+ setVisibilityFilter: vi.fn(),
+ ...overrides,
+});
+
+const setupMocks = ({
+ userLevel = ADMIN,
+ profiles = makeProfiles(),
+ selectedProfileId = '0',
+ isUnlocked = false,
+ isWarningSuppressed = vi.fn(() => false),
+ suppressWarning = vi.fn(),
+} = {}) => {
+ const mockSetSelectedProfileId = vi.fn();
+ const mockSetIsUnlocked = vi.fn();
+
+ vi.mocked(useChannelsStore).mockImplementation((sel) =>
+ sel({
+ profiles,
+ selectedProfileId,
+ setSelectedProfileId: mockSetSelectedProfileId,
+ })
+ );
+
+ vi.mocked(useChannelsTableStore).mockImplementation((sel) =>
+ sel({
+ isUnlocked,
+ setIsUnlocked: mockSetIsUnlocked,
+ })
+ );
+
+ vi.mocked(useAuthStore).mockImplementation((sel) =>
+ sel({ user: { user_level: userLevel } })
+ );
+
+ vi.mocked(useWarningsStore).mockImplementation((sel) =>
+ sel({ isWarningSuppressed, suppressWarning })
+ );
+
+ return { mockSetSelectedProfileId, mockSetIsUnlocked };
+};
+
+describe('ChannelTableHeader', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(ChannelsTableUtils.addChannelProfile).mockResolvedValue(undefined);
+ vi.mocked(ChannelsTableUtils.deleteChannelProfile).mockResolvedValue(undefined);
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the profile select', () => {
+ setupMocks();
+ render(
+ {children}
+
+ ),
+}));
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const makeHeader = (id, size, grow = false, minSize = 50) => ({
+ id,
+ getSize: () => size,
+ column: {
+ columnDef: { grow, minSize },
+ },
+});
+
+const makeTable = (overrides = {}) => {
+ const headers = [makeHeader('col1', 100), makeHeader('col2', 200)];
+
+ return {
+ tableSize: 'default',
+ filters: {},
+ allRowIds: [],
+ headerCellRenderFns: {},
+ selectedTableIds: [],
+ tableCellProps: vi.fn(),
+ headerPinned: false,
+ enableDragDrop: false,
+ expandedRowIds: [],
+ expandedRowRenderer: null,
+ bodyCellRenderFns: {},
+ getRowStyles: vi.fn(),
+ selectedTableIdsSet: new Set(),
+ handleRowClickRef: { current: vi.fn() },
+ onSelectAllChange: null,
+ renderBodyCell: null,
+ getState: () => ({ columnSizing: {} }),
+ getHeaderGroups: () => [{ headers }],
+ getFlatHeaders: () => headers,
+ getRowModel: () => ({ rows: [] }),
+ ...overrides,
+ };
+};
+
+describe('CustomTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders CustomTableHeader and CustomTableBody', () => {
+ render(
+ {children}
+
+ ),
+ Flex: ({ children, align, style }) => (
+
+ {children}
+
+ ),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ GripVertical: ({ size, opacity }) => (
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useChannelsTableStore from '../../../../store/channelsTable';
+import { useSortable } from '@dnd-kit/sortable';
+import CustomTableBody from '../CustomTableBody';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+const makeCell = (id, columnId, grow = false, maxSize = null) => ({
+ id: `${id}-${columnId}`,
+ column: {
+ id: columnId,
+ columnDef: {
+ grow,
+ ...(maxSize && { maxSize }),
+ },
+ },
+});
+
+const makeRow = (id, cells = [], originalId = null) => ({
+ id: `row-${id}`,
+ original: { id: originalId ?? id },
+ getVisibleCells: () => cells,
+});
+
+const defaultProps = (overrides = {}) => {
+ const row1 = makeRow(1, [makeCell(1, 'name'), makeCell(1, 'actions')]);
+ const row2 = makeRow(2, [makeCell(2, 'name'), makeCell(2, 'actions')]);
+
+ return {
+ getRowModel: vi.fn(() => ({ rows: [row1, row2] })),
+ expandedRowIds: [],
+ expandedRowRenderer: vi.fn(() => ),
+ renderBodyCell: vi.fn(({ cell }) => (
+ {cell.id}
+ )),
+ getRowStyles: null,
+ tableCellProps: null,
+ enableDragDrop: false,
+ selectedTableIdsSet: null,
+ handleRowClickRef: null,
+ ...overrides,
+ };
+};
+
+const setupMocks = ({ isUnlocked = false } = {}) => {
+ vi.mocked(useChannelsTableStore).mockImplementation((sel) =>
+ sel({ isUnlocked })
+ );
+};
+
+describe('CustomTableBody', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ setupMocks();
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders a tbody container', () => {
+ render(Expanded!
+ ));
+ const props = defaultProps({
+ getRowModel: vi.fn(() => ({ rows: [row] })),
+ expandedRowIds: [1],
+ expandedRowRenderer,
+ });
+ render(Expanded!
+ ));
+ const props = defaultProps({
+ getRowModel: vi.fn(() => ({ rows: [row] })),
+ expandedRowIds: [],
+ expandedRowRenderer,
+ });
+ render({children}
+ ),
+}));
+
+// ── @mantine/core ─────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ Box: ({ children, className, style, 'data-header-pinned': pinned }) => (
+
+ {children}
+
+ ),
+ Center: ({ children, style }) => {children}
,
+ Checkbox: ({ checked, indeterminate, onChange, size }) => (
+ {
+ if (el) el.indeterminate = !!indeterminate;
+ }}
+ onChange={onChange}
+ data-size={size}
+ />
+ ),
+ Flex: ({ children, align, style }) => (
+
+ {children}
+
+ ),
+}));
+
+// ── Imports after mocks ───────────────────────────────────────────────────────
+import useChannelsTableStore from '../../../../store/channelsTable';
+import CustomTableHeader from '../CustomTableHeader';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+/**
+ * Build a minimal header group structure that CustomTableHeader expects.
+ * Each header entry maps an id to a column definition.
+ */
+const makeHeader = (
+ id,
+ { grow = false, maxSize, canResize = false, isResizing = false, style } = {}
+) => ({
+ id,
+ column: {
+ id,
+ columnDef: { id, header: id.toUpperCase(), grow, maxSize, style },
+ getCanResize: () => canResize,
+ getIsResizing: () => isResizing,
+ },
+ getContext: () => ({}),
+ getResizeHandler: () => vi.fn(),
+ getSize: () => 100,
+});
+
+const makeHeaderGroups = (headers) => [{ id: 'hg-0', headers }];
+
+const defaultProps = (overrides = {}) => ({
+ getHeaderGroups: () =>
+ makeHeaderGroups([makeHeader('name'), makeHeader('status')]),
+ allRowIds: ['1', '2', '3'],
+ selectedTableIds: [],
+ headerCellRenderFns: {},
+ onSelectAllChange: vi.fn(),
+ tableCellProps: vi.fn(() => ({})),
+ headerPinned: true,
+ enableDragDrop: false,
+ ...overrides,
+});
+
+const setupStore = ({ isUnlocked = false } = {}) => {
+ vi.mocked(useChannelsTableStore).mockImplementation((sel) =>
+ sel({ isUnlocked })
+ );
+};
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('CustomTableHeader', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ setupStore();
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders a thead element', () => {
+ render(
+ {label && }
+ onChange?.(e.target.value ? [e.target.value] : [])}
+ />
+ {(data || []).map((opt) => (
+
+ ))}
+
+ );
+ MockMultiSelect.displayName = 'MultiSelect';
+
+ return {
+ MultiSelect: MockMultiSelect,
+ Box: ({ children, style, ...props }) => (
+
+ {children}
+
+ ),
+ Flex: ({ children, style }) => (
+
+ {children}
+
+ ),
+ Pill: ({
+ children,
+ onRemove,
+ onClick,
+ withRemoveButton,
+ removeButtonProps,
+ }) => (
+
+ {children}
+ {withRemoveButton && (
+
+ )}
+
+ ),
+ Tooltip: ({ children, label }) => (
+
+ {label}
+ {children}
+
+ ),
+ };
+});
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import { MultiSelect } from '@mantine/core';
+import MultiSelectHeaderWrapper from '../MultiSelectHeaderWrapper';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const makeData = (n = 3) =>
+ Array.from({ length: n }, (_, i) => ({
+ value: `val-${i}`,
+ label: `Label ${i}`,
+ }));
+
+describe('MultiSelectHeaderWrapper', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ // ── Non-MultiSelect passthrough ────────────────────────────────────────────
+
+ describe('non-MultiSelect children', () => {
+ it('renders a plain div child unchanged', () => {
+ render(
+ Hello
+
+ Nested
+
+
+
+
+ {children}
+
+ ),
+ Checkbox: ({ checked, onChange }) => (
+ {})}
+ />
+ ),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ ChevronDown: () => ,
+ ChevronRight: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import { useTable } from '../';
+import { useReactTable, flexRender } from '@tanstack/react-table';
+import useTablePreferences from '../../../../hooks/useTablePreferences';
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+const setupMocks = ({ headerPinned = false, tableSize = 'default' } = {}) => {
+ vi.mocked(useReactTable).mockReturnValue({
+ getRowModel: vi.fn(() => ({ rows: [] })),
+ getHeaderGroups: vi.fn(() => []),
+ });
+ vi.mocked(useTablePreferences).mockReturnValue({
+ headerPinned,
+ setHeaderPinned: vi.fn(),
+ tableSize,
+ setTableSize: vi.fn(),
+ });
+};
+
+const makeRow = (id) => ({ original: { id } });
+
+const makeCell = (columnId) => ({
+ column: { id: columnId, columnDef: {} },
+ getContext: () => ({}),
+});
+
+const makeClickEvent = (overrides = {}) => ({
+ shiftKey: false,
+ ctrlKey: false,
+ metaKey: false,
+ target: { closest: () => null },
+ ...overrides,
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('useTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ });
+
+ afterEach(() => {
+ // Clean up any body class/style mutations made by keyboard handlers
+ document.body.classList.remove('shift-key-active');
+ document.body.style.removeProperty('user-select');
+ document.body.style.removeProperty('-webkit-user-select');
+ document.body.style.removeProperty('-ms-user-select');
+ document.body.style.removeProperty('cursor');
+ });
+
+ // ── Initialization ─────────────────────────────────────────────────────────
+
+ describe('initialization', () => {
+ it('starts with an empty selectedTableIds array', () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2], columns: [], data: [] })
+ );
+ expect(result.current.selectedTableIds).toEqual([]);
+ });
+
+ it('starts with an empty expandedRowIds array', () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2], columns: [], data: [] })
+ );
+ expect(result.current.expandedRowIds).toEqual([]);
+ });
+
+ it('returns renderBodyCell as a function', () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [], columns: [], data: [] })
+ );
+ expect(typeof result.current.renderBodyCell).toBe('function');
+ });
+
+ it('exposes allRowIds in the returned object', () => {
+ setupMocks();
+ const allRowIds = [10, 20, 30];
+ const { result } = renderHook(() =>
+ useTable({ allRowIds, columns: [], data: [] })
+ );
+ expect(result.current.allRowIds).toEqual(allRowIds);
+ });
+
+ it('returns headerPinned and tableSize from useTablePreferences', () => {
+ setupMocks({ headerPinned: true, tableSize: 'compact' });
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [], columns: [], data: [] })
+ );
+ expect(result.current.headerPinned).toBe(true);
+ expect(result.current.tableSize).toBe('compact');
+ });
+
+ it('passes headerCellRenderFns through to the returned object', () => {
+ setupMocks();
+ const headerCellRenderFns = { name: vi.fn() };
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [], columns: [], data: [], headerCellRenderFns })
+ );
+ expect(result.current.headerCellRenderFns).toBe(headerCellRenderFns);
+ });
+
+ it('defaults to an empty bodyCellRenderFns when not provided', () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [], columns: [], data: [] })
+ );
+ expect(result.current.bodyCellRenderFns).toEqual({});
+ });
+ });
+
+ // ── Keyboard event handling ────────────────────────────────────────────────
+
+ describe('keyboard event handling', () => {
+ it('adds shift-key-active class and disables text selection on Shift keydown', () => {
+ setupMocks();
+ renderHook(() => useTable({ allRowIds: [], columns: [], data: [] }));
+
+ fireEvent.keyDown(window, { key: 'Shift' });
+
+ expect(document.body.classList.contains('shift-key-active')).toBe(true);
+ expect(document.body.style.userSelect).toBe('none');
+ });
+
+ it('removes shift-key-active class and restores text selection on Shift keyup', () => {
+ setupMocks();
+ renderHook(() => useTable({ allRowIds: [], columns: [], data: [] }));
+
+ fireEvent.keyDown(window, { key: 'Shift' });
+ fireEvent.keyUp(window, { key: 'Shift' });
+
+ expect(document.body.classList.contains('shift-key-active')).toBe(false);
+ expect(document.body.style.userSelect).toBe('');
+ });
+
+ it('removes shift-key-active class on window blur', () => {
+ setupMocks();
+ renderHook(() => useTable({ allRowIds: [], columns: [], data: [] }));
+
+ fireEvent.keyDown(window, { key: 'Shift' });
+ fireEvent.blur(window);
+
+ expect(document.body.classList.contains('shift-key-active')).toBe(false);
+ });
+
+ it('does not add shift-key-active class for non-Shift keydown', () => {
+ setupMocks();
+ renderHook(() => useTable({ allRowIds: [], columns: [], data: [] }));
+
+ fireEvent.keyDown(window, { key: 'a' });
+
+ expect(document.body.classList.contains('shift-key-active')).toBe(false);
+ });
+ });
+
+ // ── onSelectAllChange ──────────────────────────────────────────────────────
+
+ describe('onSelectAllChange', () => {
+ it('selects all allRowIds when checked', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2, 3], columns: [], data: [] })
+ );
+
+ await act(async () => {
+ result.current.onSelectAllChange({ target: { checked: true } });
+ });
+
+ expect(result.current.selectedTableIds).toEqual([1, 2, 3]);
+ });
+
+ it('clears selectedTableIds when unchecked', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2, 3], columns: [], data: [] })
+ );
+
+ await act(async () => {
+ result.current.onSelectAllChange({ target: { checked: true } });
+ });
+ await act(async () => {
+ result.current.onSelectAllChange({ target: { checked: false } });
+ });
+
+ expect(result.current.selectedTableIds).toEqual([]);
+ });
+
+ it('calls onRowSelectionChange callback with all ids when selecting all', async () => {
+ setupMocks();
+ const onRowSelectionChange = vi.fn();
+ const { result } = renderHook(() =>
+ useTable({
+ allRowIds: [1, 2],
+ columns: [],
+ data: [],
+ onRowSelectionChange,
+ })
+ );
+
+ await act(async () => {
+ result.current.onSelectAllChange({ target: { checked: true } });
+ });
+
+ expect(onRowSelectionChange).toHaveBeenCalledWith([1, 2]);
+ });
+
+ it('calls onRowSelectionChange with empty array when deselecting all', async () => {
+ setupMocks();
+ const onRowSelectionChange = vi.fn();
+ const { result } = renderHook(() =>
+ useTable({
+ allRowIds: [1, 2],
+ columns: [],
+ data: [],
+ onRowSelectionChange,
+ })
+ );
+
+ await act(async () => {
+ result.current.onSelectAllChange({ target: { checked: true } });
+ });
+ await act(async () => {
+ result.current.onSelectAllChange({ target: { checked: false } });
+ });
+
+ expect(onRowSelectionChange).toHaveBeenLastCalledWith([]);
+ });
+ });
+
+ // ── updateSelectedTableIds ─────────────────────────────────────────────────
+
+ describe('updateSelectedTableIds', () => {
+ it('updates selectedTableIds to the given array', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2, 3], columns: [], data: [] })
+ );
+
+ await act(async () => {
+ result.current.updateSelectedTableIds([2, 3]);
+ });
+
+ expect(result.current.selectedTableIds).toEqual([2, 3]);
+ });
+
+ it('calls onRowSelectionChange with the new ids', async () => {
+ setupMocks();
+ const onRowSelectionChange = vi.fn();
+ const { result } = renderHook(() =>
+ useTable({
+ allRowIds: [1, 2, 3],
+ columns: [],
+ data: [],
+ onRowSelectionChange,
+ })
+ );
+
+ await act(async () => {
+ result.current.updateSelectedTableIds([1]);
+ });
+
+ expect(onRowSelectionChange).toHaveBeenCalledWith([1]);
+ });
+
+ it('does not throw when onRowSelectionChange is not provided', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1], columns: [], data: [] })
+ );
+
+ await expect(
+ act(async () => result.current.updateSelectedTableIds([1]))
+ ).resolves.not.toThrow();
+ });
+ });
+
+ // ── handleRowClickRef ──────────────────────────────────────────────────────
+
+ describe('handleRowClickRef', () => {
+ it('does nothing when the click target is an interactive element', async () => {
+ setupMocks();
+ const onRowSelectionChange = vi.fn();
+ const { result } = renderHook(() =>
+ useTable({
+ allRowIds: [1],
+ columns: [],
+ data: [],
+ onRowSelectionChange,
+ })
+ );
+
+ const button = document.createElement('button');
+ await act(async () => {
+ result.current.handleRowClickRef.current(1, {
+ shiftKey: true,
+ ctrlKey: false,
+ metaKey: false,
+ target: {
+ closest: (sel) => (sel.includes('button') ? button : null),
+ },
+ });
+ });
+
+ expect(onRowSelectionChange).not.toHaveBeenCalled();
+ });
+
+ it('ctrl+click adds an unselected row to selectedTableIds', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2, 3], columns: [], data: [] })
+ );
+
+ await act(async () => {
+ result.current.handleRowClickRef.current(
+ 2,
+ makeClickEvent({ ctrlKey: true })
+ );
+ });
+
+ expect(result.current.selectedTableIds).toContain(2);
+ });
+
+ it('ctrl+click removes an already-selected row from selectedTableIds', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2, 3], columns: [], data: [] })
+ );
+
+ await act(async () => {
+ result.current.updateSelectedTableIds([2]);
+ });
+ await act(async () => {
+ result.current.handleRowClickRef.current(
+ 2,
+ makeClickEvent({ ctrlKey: true })
+ );
+ });
+
+ expect(result.current.selectedTableIds).not.toContain(2);
+ });
+
+ it('meta+click adds an unselected row to selectedTableIds', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2, 3], columns: [], data: [] })
+ );
+
+ await act(async () => {
+ result.current.handleRowClickRef.current(
+ 3,
+ makeClickEvent({ metaKey: true })
+ );
+ });
+
+ expect(result.current.selectedTableIds).toContain(3);
+ });
+
+ it('plain click (no modifier key) does not change selection', async () => {
+ setupMocks();
+ const onRowSelectionChange = vi.fn();
+ const { result } = renderHook(() =>
+ useTable({
+ allRowIds: [1, 2],
+ columns: [],
+ data: [],
+ onRowSelectionChange,
+ })
+ );
+
+ await act(async () => {
+ result.current.handleRowClickRef.current(1, makeClickEvent());
+ });
+
+ expect(onRowSelectionChange).not.toHaveBeenCalled();
+ });
+
+ it('shift+click selects the range between lastClickedId and the clicked row', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2, 3, 4, 5], columns: [], data: [] })
+ );
+
+ // Ctrl+click row 2 to establish lastClickedId
+ await act(async () => {
+ result.current.handleRowClickRef.current(
+ 2,
+ makeClickEvent({ ctrlKey: true })
+ );
+ });
+ // Shift+click row 4 to select range [2, 3, 4]
+ await act(async () => {
+ result.current.handleRowClickRef.current(
+ 4,
+ makeClickEvent({ shiftKey: true })
+ );
+ });
+
+ expect(result.current.selectedTableIds).toEqual(
+ expect.arrayContaining([2, 3, 4])
+ );
+ expect(result.current.selectedTableIds).toHaveLength(3);
+ });
+
+ it('shift+click preserves rows selected outside the shift-click range', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1, 2, 3, 4, 5], columns: [], data: [] })
+ );
+
+ // Pre-select row 1 (will be outside the upcoming range)
+ await act(async () => {
+ result.current.updateSelectedTableIds([1]);
+ });
+ // Ctrl+click row 5 to set lastClickedId=5 (also adds 5 to selection)
+ await act(async () => {
+ result.current.handleRowClickRef.current(
+ 5,
+ makeClickEvent({ ctrlKey: true })
+ );
+ });
+ // Shift+click row 3 → range is [3, 4, 5]; row 1 is preserved
+ await act(async () => {
+ result.current.handleRowClickRef.current(
+ 3,
+ makeClickEvent({ shiftKey: true })
+ );
+ });
+
+ expect(result.current.selectedTableIds).toEqual(
+ expect.arrayContaining([1, 3, 4, 5])
+ );
+ });
+ });
+
+ // ── renderBodyCell ─────────────────────────────────────────────────────────
+
+ describe('renderBodyCell', () => {
+ describe('bodyCellRenderFns override', () => {
+ it('calls the custom render fn and renders its output for the matching column id', () => {
+ setupMocks();
+ const customRenderFn = vi.fn(
+ () =>
+ );
+ const { result } = renderHook(() =>
+ useTable({
+ allRowIds: [],
+ columns: [],
+ data: [],
+ bodyCellRenderFns: { 'my-col': customRenderFn },
+ })
+ );
+
+ const row = makeRow(1);
+ const cell = makeCell('my-col');
+ const { getByTestId } = render(
+ result.current.renderBodyCell({ row, cell })
+ );
+
+ expect(customRenderFn).toHaveBeenCalledWith({ row, cell });
+ expect(getByTestId('custom-cell')).toBeInTheDocument();
+ });
+ });
+
+ describe('select column', () => {
+ it('renders a Checkbox for the select column', () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1], columns: [], data: [] })
+ );
+
+ const { getByTestId } = render(
+ result.current.renderBodyCell({
+ row: makeRow(1),
+ cell: makeCell('select'),
+ })
+ );
+
+ expect(getByTestId('checkbox')).toBeInTheDocument();
+ });
+
+ it('checkbox is unchecked for an unselected row', () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1], columns: [], data: [] })
+ );
+
+ const { getByTestId } = render(
+ result.current.renderBodyCell({
+ row: makeRow(1),
+ cell: makeCell('select'),
+ })
+ );
+
+ expect(getByTestId('checkbox')).not.toBeChecked();
+ });
+
+ it('checkbox is checked when the row is pre-selected', async () => {
+ setupMocks();
+ const { result } = renderHook(() =>
+ useTable({ allRowIds: [1], columns: [], data: [] })
+ );
+
+ await act(async () => {
+ result.current.updateSelectedTableIds([1]);
+ });
+
+ const { getByTestId } = render(
+ result.current.renderBodyCell({
+ row: makeRow(1),
+ cell: makeCell('select'),
+ })
+ );
+
+ expect(getByTestId('checkbox')).toBeChecked();
+ });
+
+ it('checking the checkbox adds the row to selectedTableIds', async () => {
+ setupMocks();
+ const tableRef = { current: null };
+
+ function TestWrapper() {
+ const table = useTable({ allRowIds: [1, 2], columns: [], data: [] });
+ tableRef.current = table;
+ return table.renderBodyCell({ row: makeRow(1), cell: makeCell('select') });
+ }
+
+ const user = userEvent.setup();
+ const { getByTestId } = render(
+ {children}
+
+ )),
+ KeyboardSensor: vi.fn(),
+ MouseSensor: vi.fn(),
+ TouchSensor: vi.fn(),
+ useDraggable: vi.fn(() => ({
+ attributes: {},
+ listeners: {},
+ setNodeRef: vi.fn(),
+ })),
+ useSensor: vi.fn((sensor) => sensor),
+ useSensors: vi.fn((...sensors) => sensors),
+}));
+
+vi.mock('@dnd-kit/modifiers', () => ({
+ restrictToVerticalAxis: vi.fn(),
+}));
+
+vi.mock('@dnd-kit/sortable', () => ({
+ arrayMove: vi.fn((arr, from, to) => {
+ const next = [...arr];
+ const [item] = next.splice(from, 1);
+ next.splice(to, 0, item);
+ return next;
+ }),
+ SortableContext: ({ children }) => (
+ {children}
+ ),
+ useSortable: vi.fn(() => ({
+ transform: null,
+ transition: null,
+ setNodeRef: vi.fn(),
+ isDragging: false,
+ })),
+ verticalListSortingStrategy: vi.fn(),
+}));
+
+vi.mock('@dnd-kit/utilities', () => ({
+ CSS: { Transform: { toString: vi.fn(() => '') } },
+}));
+
+// ── zustand/shallow ────────────────────────────────────────────────────────────
+vi.mock('zustand/shallow', () => ({
+ shallow: (a, b) => a === b,
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, ...rest }) => (
+
+ ),
+ Badge: ({ children, color, onClick, style }) => (
+
+ {children}
+
+ ),
+ Box: ({ children, style, className, ...rest }) => (
+
+ {children}
+
+ ),
+ Button: ({ children, onClick, leftSection }) => (
+
+ ),
+ Center: ({ children }) => {children}
,
+ Collapse: ({ children, in: open }) =>
+ open ? {children}
: null,
+ Flex: ({ children, style }) => (
+ {children}
+ ),
+ Group: ({ children }) => {children}
,
+ Text: ({ children, size }) => (
+
+ {children}
+
+ ),
+ Tooltip: ({ children, label }) => {children}
,
+ useMantineTheme: vi.fn(() => ({
+ tailwind: { red: { 6: '#fa5252' } },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ ChevronDown: () => ,
+ ChevronRight: () => ,
+ Eye: () => ,
+ GripHorizontal: () => ,
+ SquareMinus: ({ onClick, disabled, color }) => (
+
+ ),
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useChannelsTableStore from '../../../store/channelsTable';
+import usePlaylistsStore from '../../../store/playlists';
+import useVideoStore from '../../../store/useVideoStore';
+import useSettingsStore from '../../../store/settings';
+import useAuthStore from '../../../store/auth';
+import { buildLiveStreamUrl } from '../../../utils/components/FloatingVideoUtils.js';
+import * as ChannelTableStreamsUtils from '../../../utils/tables/ChannelTableStreamsUtils.js';
+import { copyToClipboard } from '../../../utils';
+import { DndContext } from '@dnd-kit/core';
+import { arrayMove } from '@dnd-kit/sortable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+
+const makeStream = (overrides = {}) => ({
+ id: 's-1',
+ name: 'Stream One',
+ m3u_account: 'acc-1',
+ url: 'http://example.com/stream',
+ stream_hash: 'hash-abc',
+ quality: '1080p',
+ stream_stats: null,
+ stream_stats_updated_at: null,
+ is_stale: false,
+ ...overrides,
+});
+
+const makeChannel = (streams = [makeStream()]) => ({
+ id: 'ch-1',
+ name: 'HBO',
+ streams,
+});
+
+const makePlaylists = () => [{ id: 'acc-1', name: 'My M3U' }];
+
+/** Wire all store mocks with sensible defaults */
+const setupMocks = ({
+ streams = [makeStream()],
+ playlists = makePlaylists(),
+ isAdmin = true,
+ isVideoVisible = false,
+ envMode = 'production',
+} = {}) => {
+ const mockPatchChannelStreamStats = vi.fn();
+
+ vi.mocked(useChannelsTableStore).mockImplementation((sel) => {
+ if (typeof sel === 'function') {
+ const storeState = {
+ getChannelStreams: () => streams,
+ patchChannelStreamStats: mockPatchChannelStreamStats,
+ };
+ return sel(storeState);
+ }
+ });
+
+ vi.mocked(usePlaylistsStore).mockImplementation((sel) => sel({ playlists }));
+
+ const mockShowVideo = vi.fn();
+ vi.mocked(useVideoStore).mockImplementation((sel) => {
+ const state = { showVideo: mockShowVideo, isVisible: isVideoVisible };
+ return sel(state);
+ });
+ // Also expose getState for the ref-based metadata read
+ useVideoStore.getState = vi.fn(() => ({ metadata: null }));
+
+ vi.mocked(useSettingsStore).mockImplementation((sel) =>
+ sel({ environment: { env_mode: envMode } })
+ );
+
+ vi.mocked(useAuthStore).mockImplementation((sel) =>
+ sel({ user: { user_level: isAdmin ? 10 : 1 } })
+ );
+
+ return { mockShowVideo, mockPatchChannelStreamStats };
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('ChannelStreams', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ vi.mocked(ChannelTableStreamsUtils.getChannelStreamStats).mockResolvedValue(
+ []
+ );
+ vi.mocked(ChannelTableStreamsUtils.reorderChannelStreams).mockResolvedValue(
+ undefined
+ );
+ vi.mocked(ChannelTableStreamsUtils.categorizeStreamStats).mockReturnValue({
+ basic: {},
+ video: {},
+ audio: {},
+ technical: {},
+ other: {},
+ });
+ });
+
+ // ── Rendering ────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders stream name', () => {
+ setupMocks();
+ render({children}
;
+ });
+
+ render({children}
;
+ });
+
+ render({children}
;
+ });
+
+ render({children}
,
+ PointerSensor: class PointerSensor {},
+ closestCenter: vi.fn(),
+ useSensor: vi.fn(),
+ useSensors: vi.fn(() => []),
+}));
+
+vi.mock('@dnd-kit/sortable', () => ({
+ SortableContext: ({ children }) => {children}
,
+ verticalListSortingStrategy: vi.fn(),
+}));
+
+// ── Store mocks ────────────────────────────────────────────────────────────────
+vi.mock('../../../store/channels', () => ({ default: vi.fn() }));
+vi.mock('../../../store/channelsTable', () => {
+ const mock = vi.fn();
+ mock.getState = vi.fn(() => ({ selectedChannelIds: [] }));
+ mock.setState = vi.fn();
+ return { default: mock };
+});
+vi.mock('../../../store/auth', () => ({ default: vi.fn() }));
+vi.mock('../../../store/epgs', () => ({ default: vi.fn() }));
+vi.mock('../../../store/settings', () => ({ default: vi.fn() }));
+vi.mock('../../../store/useVideoStore', () => ({ default: vi.fn() }));
+vi.mock('../../../store/outputProfiles', () => ({ default: vi.fn() }));
+vi.mock('../../../store/warnings', () => ({ default: vi.fn() }));
+
+// ── Hook mocks ─────────────────────────────────────────────────────────────────
+vi.mock('../../../hooks/useLocalStorage', () => ({
+ default: vi.fn(() => [{}, vi.fn()]),
+}));
+vi.mock('../../../hooks/useSmartLogos', () => ({
+ useChannelLogoSelection: vi.fn(() => ({ ensureLogosLoaded: vi.fn() })),
+}));
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../utils', () => ({
+ copyToClipboard: vi.fn().mockResolvedValue(undefined),
+ useDebounce: vi.fn((val) => val),
+}));
+vi.mock('../../../utils/forms/ChannelUtils.js', () => ({
+ listOverriddenFields: vi.fn(() => []),
+ requeryChannels: vi.fn().mockResolvedValue(undefined),
+}));
+vi.mock('../../../utils/components/FloatingVideoUtils.js', () => ({
+ buildLiveStreamUrl: vi.fn((path) => path),
+}));
+vi.mock('../../../utils/cards/RecordingCardUtils.js', () => ({
+ getShowVideoUrl: vi.fn(() => '/proxy/ts/stream/uuid-1'),
+}));
+vi.mock('../../../utils/tables/ChannelsTableUtils.js', () => ({
+ buildEPGUrl: vi.fn(() => 'http://localhost/output/epg'),
+ buildFetchParams: vi.fn(() => new URLSearchParams()),
+ buildHDHRUrl: vi.fn(() => 'http://localhost/hdhr'),
+ buildM3UUrl: vi.fn(() => 'http://localhost/output/m3u'),
+ deleteChannel: vi.fn().mockResolvedValue(undefined),
+ deleteChannels: vi.fn().mockResolvedValue(undefined),
+ epgUrlBase: 'http://localhost/output/epg',
+ getAllChannelIds: vi.fn().mockResolvedValue([1, 2]),
+ hdhrUrlBase: 'http://localhost/hdhr',
+ m3uUrlBase: 'http://localhost/output/m3u',
+ queryChannels: vi.fn().mockResolvedValue(undefined),
+ reorderChannel: vi.fn().mockResolvedValue(undefined),
+ updateProfileChannel: vi.fn().mockResolvedValue(undefined),
+ updateProfileChannels: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ── Child component mocks ──────────────────────────────────────────────────────
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+vi.mock('../ChannelsTable/ChannelsTableOnboarding', () => ({
+ default: ({ editChannel }) => (
+
+
+
+ ),
+}));
+vi.mock('../ChannelsTable/ChannelTableHeader', () => ({
+ default: ({
+ editChannel,
+ deleteChannels,
+ showDisabled,
+ setShowDisabled,
+ showOnlyStreamlessChannels,
+ setShowOnlyStreamlessChannels,
+ showOnlyStaleChannels,
+ setShowOnlyStaleChannels,
+ showOnlyOverriddenChannels,
+ setShowOnlyOverriddenChannels,
+ }) => (
+
+
+
+
+
+
+
+
+ ),
+}));
+vi.mock('../ChannelsTable/EditableCell', () => ({
+ EditableEPGCell: () => ,
+ EditableGroupCell: () => ,
+ EditableLogoCell: () => ,
+ EditableNumberCell: () => ,
+ EditableTextCell: () => ,
+}));
+vi.mock('../ChannelTableStreams', () => ({
+ default: () => ,
+}));
+vi.mock('../../forms/Channel', () => ({
+ default: ({ isOpen, onClose, channel }) =>
+ isOpen ? (
+
+ {channel?.name ?? 'new'}
+
+
+ ) : null,
+}));
+vi.mock('../../forms/ChannelBatch', () => ({
+ default: ({ isOpen, onClose }) =>
+ isOpen ? (
+
+
+
+ ) : null,
+}));
+vi.mock('../../forms/Recording', () => ({
+ default: ({ isOpen, onClose, channel }) =>
+ isOpen ? (
+
+ {channel?.name}
+
+
+ ) : null,
+}));
+vi.mock('../../ConfirmationDialog', () => ({
+ default: ({
+ opened,
+ onClose,
+ onConfirm,
+ title,
+ loading,
+ confirmLabel,
+ cancelLabel,
+ }) =>
+ opened ? (
+
+ {title}
+
+
+
+ ) : null,
+}));
+vi.mock('../../LazyLogo', () => ({
+ default: ({ alt }) =>
+ {children}
+
+ ),
+ Button: ({ children, onClick, leftSection, disabled, loading }) => (
+
+ ),
+ Center: ({ children, style }) => {children}
,
+ Flex: ({ children, style }) => {children}
,
+ Group: ({ children, style }) => {children}
,
+ Menu: Object.assign(
+ ({ children }) => {children}
,
+ {
+ Target: ({ children }) => {children}
,
+ Dropdown: ({ children }) => {children}
,
+ Label: ({ children }) => {children}
,
+ Item: ({ children, onClick, disabled, leftSection }) => (
+
+ ),
+ }
+ ),
+ MenuDropdown: ({ children }) => {children}
,
+ MenuItem: ({ children, onClick, disabled, leftSection }) => (
+
+ ),
+ MenuTarget: ({ children }) => {children}
,
+ MultiSelect: ({ value, data }) => (
+
+ ),
+ NativeSelect: ({ value, data, onChange }) => (
+
+ ),
+ NumberInput: ({ value, onChange }) => (
+ onChange(Number(e.target.value))}
+ />
+ ),
+ Pagination: ({ total, value, onChange }) => (
+
+
+ {value}
+
+
+ ),
+ Paper: ({ children, style }) => {children}
,
+ Popover: Object.assign(
+ ({ children }) => {children}
,
+ {
+ Target: ({ children }) => {children}
,
+ Dropdown: ({ children }) => (
+ {children}
+ ),
+ }
+ ),
+ PopoverDropdown: ({ children, onClick, onMouseDown }) => (
+
+ {children}
+
+ ),
+ PopoverTarget: ({ children }) => {children}
,
+ Select: ({ value, onChange, data, placeholder }) => (
+
+ ),
+ Stack: ({ children, style }) => {children}
,
+ Switch: ({ checked, onChange, label, disabled }) => (
+
+ ),
+ Text: ({ children, style }) => (
+
+ {children}
+
+ ),
+ TextInput: ({ value, placeholder, onChange, readOnly }) => (
+ {})}
+ readOnly={readOnly}
+ />
+ ),
+ Tooltip: ({ children, label }) => {children}
,
+ UnstyledButton: ({ children, onClick }) => (
+
+ ),
+ useMantineTheme: vi.fn(() => ({
+ tailwind: {
+ yellow: { 3: '#fde047' },
+ red: { 6: '#dc2626' },
+ green: { 5: '#22c55e' },
+ },
+ palette: {
+ custom: {
+ greenMain: '#22c55e',
+ indigoMain: '#6366f1',
+ greyBorder: '#71717a',
+ },
+ },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ ArrowDownWideNarrow: () => ,
+ ArrowUpDown: () => ,
+ ArrowUpNarrowWide: () => ,
+ CirclePlay: () => ,
+ Copy: () => ,
+ EllipsisVertical: () => ,
+ EyeOff: () => ,
+ Pencil: () => ,
+ ScanEye: () => ,
+ ScreenShare: () => ,
+ Scroll: () => ,
+ Search: () => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ Tv2: () => ,
+}));
+
+// ── CSS import ─────────────────────────────────────────────────────────────────
+vi.mock('../table.css', () => ({}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useChannelsStore from '../../../store/channels';
+import useChannelsTableStore from '../../../store/channelsTable';
+import useAuthStore from '../../../store/auth';
+import useEPGsStore from '../../../store/epgs';
+import useSettingsStore from '../../../store/settings';
+import useVideoStore from '../../../store/useVideoStore';
+import useOutputProfilesStore from '../../../store/outputProfiles';
+import useWarningsStore from '../../../store/warnings';
+import useLocalStorage from '../../../hooks/useLocalStorage';
+import { useTable } from '../CustomTable';
+import {
+ deleteChannel,
+ deleteChannels,
+ queryChannels,
+ getAllChannelIds,
+} from '../../../utils/tables/ChannelsTableUtils.js';
+import { requeryChannels } from '../../../utils/forms/ChannelUtils.js';
+import { copyToClipboard } from '../../../utils';
+import { buildLiveStreamUrl } from '../../../utils/components/FloatingVideoUtils.js';
+import { USER_LEVELS } from '../../../constants';
+import ChannelsTable from '../ChannelsTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeChannel = (overrides = {}) => ({
+ id: 1,
+ uuid: 'uuid-1',
+ name: 'Test Channel',
+ channel_number: 101,
+ effective_channel_number: 101,
+ effective_name: 'Test Channel',
+ streams: [{ id: 10, is_stale: false }],
+ hidden_from_output: false,
+ channel_group_id: null,
+ logo_id: null,
+ epg_data_id: null,
+ ...overrides,
+});
+
+const makeAdminUser = () => ({ id: 99, user_level: USER_LEVELS.ADMIN });
+const makeStandardUser = () => ({ id: 88, user_level: USER_LEVELS.STANDARD });
+
+let capturedTableOptions = null;
+
+const makeDefaultTableInstance = (overrides = {}) => ({
+ getRowModel: vi.fn(() => ({ rows: [] })),
+ getHeaderGroups: vi.fn(() => []),
+ setSelectedTableIds: vi.fn(),
+ selectedTableIds: [],
+ ...overrides,
+});
+
+const setupMocks = ({
+ channels = [makeChannel()],
+ authUser = makeAdminUser(),
+ isWarningSuppressed = vi.fn(() => false),
+ suppressWarning = vi.fn(),
+ selectedProfileId = '0',
+ profiles = { 0: { name: 'Default', channels: new Set() } },
+ pageCount = 1,
+ totalCount = 1,
+ allQueryIds = [1],
+ channelGroups = {},
+ epgs = {},
+ hasUnassignedEPGChannels = false,
+ tableOverrides = {},
+} = {}) => {
+ vi.mocked(useChannelsTableStore).mockImplementation((sel) =>
+ sel({
+ channels,
+ pageCount,
+ totalCount,
+ allQueryIds,
+ pagination: { pageIndex: 0, pageSize: 25 },
+ sorting: [],
+ hasUnassignedEPGChannels,
+ setSelectedChannelIds: vi.fn(),
+ setExpandedChannelId: vi.fn(),
+ setPagination: vi.fn(),
+ setSorting: vi.fn(),
+ setAllQueryIds: vi.fn(),
+ })
+ );
+ vi.mocked(useChannelsTableStore).getState.mockReturnValue({
+ selectedChannelIds: [],
+ });
+
+ vi.mocked(useChannelsStore).mockImplementation((sel) =>
+ sel({
+ channelIds: channels.map((c) => c.id),
+ profiles,
+ selectedProfileId,
+ channelGroups,
+ })
+ );
+
+ vi.mocked(useAuthStore).mockImplementation((sel) => sel({ user: authUser }));
+
+ vi.mocked(useEPGsStore).mockImplementation((sel) =>
+ sel({ epgs, tvgsById: {}, tvgsLoaded: true })
+ );
+
+ vi.mocked(useSettingsStore).mockImplementation((sel) =>
+ sel({ environment: { env_mode: 'production' } })
+ );
+
+ vi.mocked(useVideoStore).mockImplementation((sel) =>
+ sel({ showVideo: vi.fn() })
+ );
+
+ vi.mocked(useOutputProfilesStore).mockImplementation((sel) =>
+ sel({ profiles: [] })
+ );
+
+ vi.mocked(useWarningsStore).mockImplementation((sel) =>
+ sel({ isWarningSuppressed, suppressWarning })
+ );
+
+ vi.mocked(useLocalStorage).mockReturnValue([{}, vi.fn()]);
+
+ const tableInstance = makeDefaultTableInstance(tableOverrides);
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return tableInstance;
+ });
+
+ return { tableInstance };
+};
+
+const getActionsCol = () =>
+ capturedTableOptions.columns.find((c) => c.id === 'actions');
+
+const getCol = (id) => capturedTableOptions.columns.find((c) => c.id === id);
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('ChannelsTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ vi.mocked(deleteChannel).mockResolvedValue(undefined);
+ vi.mocked(deleteChannels).mockResolvedValue(undefined);
+ vi.mocked(queryChannels).mockResolvedValue(undefined);
+ vi.mocked(getAllChannelIds).mockResolvedValue([1]);
+ vi.mocked(requeryChannels).mockResolvedValue(undefined);
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders "Channels" heading', () => {
+ setupMocks();
+ render(
+ {epg?.name ?? 'new'}
+
+
+ ) : null,
+}));
+
+vi.mock('../../forms/DummyEPG', () => ({
+ default: ({ isOpen, onClose, epg }) =>
+ isOpen ? (
+
+ {epg?.name ?? 'new'}
+
+
+ ) : null,
+}));
+
+vi.mock('../../ConfirmationDialog', () => ({
+ default: ({
+ opened,
+ onClose,
+ onConfirm,
+ title,
+ message,
+ confirmLabel,
+ cancelLabel,
+ loading,
+ }) =>
+ opened ? (
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: ({ table }) => (
+ {title}
+
+ {typeof message === 'string' ? message : 'rich-message'}
+
+
+
+
+ {table?.getRowModel?.().rows.map((row) => (
+
+ ),
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color }) => (
+
+ ),
+ Box: ({ children, style }) =>
+ {row.getVisibleCells().map((cell) => (
+
+ ))}
+
+ {cell.column.id === 'actions'
+ ? table.bodyCellRenderFns?.actions?.({ cell, row })
+ : cell.column.columnDef.cell
+ ? cell.column.columnDef.cell(cell.getContext())
+ : cell.getValue?.()}
+
+ ))}
+ {children}
,
+ Button: ({
+ children,
+ onClick,
+ leftSection,
+ rightSection,
+ disabled,
+ loading,
+ }) => (
+
+ ),
+ Checkbox: ({ checked, onChange, label, disabled }) => (
+
+ ),
+ Flex: ({ children, style }) => {children}
,
+ Menu: Object.assign(
+ ({ children }) => {children}
,
+ {
+ Target: ({ children }) => {children}
,
+ Dropdown: ({ children }) => (
+ {children}
+ ),
+ Item: ({ children, onClick }) => (
+
+ ),
+ }
+ ),
+ MenuDropdown: ({ children }) => (
+ {children}
+ ),
+ MenuItem: ({ children, onClick }) => (
+
+ ),
+ MenuTarget: ({ children }) => {children}
,
+ Modal: ({ children, opened, onClose, title }) =>
+ opened ? (
+
+
+ ) : null,
+ Paper: ({ children, style }) => {title}
+
+ {children}
+ {children}
,
+ Progress: ({ value }) => ,
+ Stack: ({ children }) => {children}
,
+ Switch: ({ checked, onChange, disabled }) => (
+
+ ),
+ Text: ({ children, size, c, style }) => (
+
+ {children}
+
+ ),
+ Tooltip: ({ children, label }) => (
+ {children}
+ ),
+ useMantineTheme: vi.fn(() => ({
+ palette: { background: { paper: '#1a1a1a' } },
+ colors: { red: { 6: '#fa5252' }, green: { 6: '#40c057' } },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ ChevronDown: () => ,
+ RefreshCcw: () => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ SquarePlus: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useEPGsStore from '../../../store/epgs';
+import useWarningsStore from '../../../store/warnings';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import * as EPGsTableUtils from '../../../utils/tables/EPGsTableUtils.js';
+import { useTable, CustomTable } from '../CustomTable';
+import useLocalStorage from '../../../hooks/useLocalStorage';
+import { makeSortingChangeHandler } from '../M3uTableUtils.jsx';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeEpg = (overrides = {}) => ({
+ id: 'epg-1',
+ name: 'Test EPG',
+ source_type: 'xmltv',
+ url: 'http://example.com/epg.xml',
+ status: 'idle',
+ last_message: null,
+ is_active: true,
+ updated_at: '2024-01-01T12:00:00Z',
+ ...overrides,
+});
+
+const makeDummyEpg = (overrides = {}) =>
+ makeEpg({
+ id: 'epg-dummy',
+ name: 'Dummy EPG',
+ source_type: 'dummy',
+ ...overrides,
+ });
+
+// Captures the useTable options passed by EPGsTable so we can invoke
+// renderBodyCell and renderHeaderCell in tests.
+let capturedTableOptions = null;
+
+/** Wire stores and the useTable spy */
+const setupMocks = ({
+ epgs = { 'epg-1': makeEpg() },
+ refreshProgress = {},
+ isWarningSuppressed = vi.fn(() => false),
+ suppressWarning = vi.fn(),
+ tableSize = 'default',
+} = {}) => {
+ vi.mocked(useEPGsStore).mockImplementation((sel) =>
+ sel({ epgs, refreshProgress })
+ );
+
+ vi.mocked(useWarningsStore).mockImplementation((sel) =>
+ sel({ isWarningSuppressed, suppressWarning })
+ );
+
+ vi.mocked(useLocalStorage).mockReturnValue([tableSize, vi.fn()]);
+
+ // Capture the options EPGsTable passes to useTable so tests can call
+ // renderBodyCell / renderHeaderCell manually.
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return {
+ getRowModel: () => ({ rows: [] }),
+ bodyCellRenderFns: opts.bodyCellRenderFns ?? {},
+ getHeaderGroups: () => [],
+ };
+ });
+};
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+/** Build a minimal row/cell pair like TanStack Table would provide */
+const makeRowContext = (epgObj) => {
+ const row = {
+ id: epgObj.id,
+ original: epgObj,
+ getIsSelected: vi.fn(() => false),
+ getVisibleCells: vi.fn(() => []),
+ };
+ const cell = {
+ column: { id: 'actions', columnDef: {} },
+ getValue: vi.fn(() => epgObj.is_active),
+ row,
+ getContext: vi.fn(() => ({})),
+ };
+ return { row, cell };
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('EPGsTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ vi.mocked(EPGsTableUtils.deleteEpg).mockResolvedValue(undefined);
+ vi.mocked(EPGsTableUtils.refreshEpg).mockResolvedValue(undefined);
+ vi.mocked(EPGsTableUtils.updateEpg).mockResolvedValue(undefined);
+ vi.mocked(EPGsTableUtils.getSortedEpgs).mockImplementation((epgs) =>
+ Object.values(epgs)
+ );
+ });
+
+ // ── Header renders ─────────────────────────────────────────────────────────
+
+ describe('header / top toolbar', () => {
+ it('renders the "EPGs" heading', () => {
+ setupMocks();
+ render({msgCol.cell({ row })}
);
+ expect(container.firstChild).toBeEmptyDOMElement();
+ });
+
+ it('renders error message when status is error', () => {
+ const epg = makeEpg({ status: 'error', last_message: 'Something broke' });
+ setupMocks({ epgs: { 'epg-1': epg } });
+ render({getMsgCol().cell({ row })}
);
+ expect(container.firstChild).toBeEmptyDOMElement();
+ });
+
+ it('shows progress when progress.status is "in_progress" even at 100%', () => {
+ const epg = makeEpg();
+ vi.mocked(EPGsTableUtils.getProgressLabel).mockReturnValue('Processing');
+ setupMocks({
+ epgs: { 'epg-1': epg },
+ refreshProgress: {
+ 'epg-1': { action: 'processing', progress: 100, status: 'in_progress' },
+ },
+ });
+ render({getMsgCol().cell({ row })}
);
+ // condition fails (100 < 100=false, no in_progress, parsing_channels + idle=false)
+ // falls through to the idle-message branch; no last_message → returns null
+ expect(container.firstChild).toBeEmptyDOMElement();
+ });
+
+ it('renders nothing when there is no active progress and no status message', () => {
+ const epg = makeEpg({ status: 'idle', last_message: null });
+ setupMocks({ epgs: { 'epg-1': epg } });
+ render({getMsgCol().cell({ row })}
);
+ expect(container.firstChild).toBeEmptyDOMElement();
+ });
+ });
+
+ // ── Table structure ────────────────────────────────────────────────────────
+
+ describe('table structure', () => {
+ it('renders the CustomTable component', () => {
+ setupMocks();
+ render(
+ {logo?.name ?? 'new'}
+
+
+
+
+
+
+ ) : null,
+}));
+
+vi.mock('../../ConfirmationDialog', () => ({
+ default: ({
+ opened,
+ onClose,
+ onConfirm,
+ title,
+ message,
+ confirmLabel,
+ cancelLabel,
+ loading,
+ showDeleteFileOption,
+ }) =>
+ opened ? (
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color }) => (
+
+ ),
+ Badge: ({ children, color }) => (
+
+ {children}
+
+ ),
+ Box: ({ children, style }) => {title}
+
+ {typeof message === 'string' ? message : 'rich-message'}
+
+
+
+ {showDeleteFileOption && (
+
+ )}
+ {children}
,
+ Button: ({ children, onClick, leftSection, disabled, loading, color, variant }) => (
+
+ ),
+ Center: ({ children, style }) => {children}
,
+ Checkbox: ({ checked, onChange, label, disabled }) => (
+
+ ),
+ Group: ({ children, style }) => {children}
,
+ Image: ({ src, alt, fallbackSrc, style, onMouseEnter, onMouseLeave }) => (
+
+
+ {value}
+
+
+ ),
+ Paper: ({ children, style }) => {children}
,
+ Select: ({ value, onChange, data, style }) => (
+
+ ),
+ Stack: ({ children, style }) => {children}
,
+ Text: ({ children, size, c, style }) => (
+
+ {children}
+
+ ),
+ TextInput: ({ value, onChange, placeholder, style }) => (
+
+ ),
+ Tooltip: ({ children }) => {children}
,
+ useMantineTheme: vi.fn(() => ({
+ tailwind: {
+ yellow: { 3: '#fbbf24' },
+ red: { 6: '#dc2626' },
+ green: { 5: '#22c55e' },
+ },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ ExternalLink: () => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ SquarePlus: () => ,
+ Trash: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useLogosStore from '../../../store/logos';
+import useWarningsStore from '../../../store/warnings';
+import useLocalStorage from '../../../hooks/useLocalStorage';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import * as LogosTableUtils from '../../../utils/tables/LogosTableUtils.js';
+import { useTable } from '../CustomTable';
+import LogosTable from '../LogosTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeLogo = (overrides = {}) => ({
+ id: 1,
+ name: 'Test Logo',
+ url: 'http://example.com/logo.png',
+ cache_url: '/cached/logo.png',
+ channel_count: 0,
+ channel_names: [],
+ is_used: false,
+ ...overrides,
+});
+
+let capturedTableOptions = null;
+
+const setupMocks = ({
+ logos = { 1: makeLogo() },
+ storeLoading = false,
+ tableSize = 'default',
+} = {}) => {
+ const mockFetchAllLogos = vi.fn().mockResolvedValue(undefined);
+ const mockUpdateLogo = vi.fn();
+ const mockAddLogo = vi.fn();
+
+ vi.mocked(useLogosStore).mockImplementation((sel) => {
+ const state = {
+ logos,
+ fetchAllLogos: mockFetchAllLogos,
+ updateLogo: mockUpdateLogo,
+ addLogo: mockAddLogo,
+ isLoading: storeLoading,
+ };
+ return typeof sel === 'function' ? sel(state) : state;
+ });
+
+ vi.mocked(useWarningsStore).mockImplementation((sel) =>
+ sel({ suppressWarning: vi.fn(), isWarningSuppressed: vi.fn(() => false) })
+ );
+
+ vi.mocked(useLocalStorage).mockImplementation((key, defaultVal) => {
+ if (key === 'table-size') return [tableSize, vi.fn()];
+ if (key === 'logos-page-size') return [25, vi.fn()];
+ return [defaultVal, vi.fn()];
+ });
+
+ vi.mocked(LogosTableUtils.getFilteredLogos).mockReturnValue(Object.values(logos));
+
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return {
+ getRowModel: () => ({ rows: [] }),
+ getHeaderGroups: () => [],
+ setSelectedTableIds: vi.fn(),
+ };
+ });
+
+ return { mockFetchAllLogos, mockUpdateLogo, mockAddLogo };
+};
+
+// ── Column helpers ─────────────────────────────────────────────────────────────
+const getActionsCell = (logo) => {
+ const col = capturedTableOptions.columns.find((c) => c.id === 'actions');
+ return col.cell({ row: { id: logo.id, original: logo } });
+};
+
+const getSelectCell = (logo) => {
+ const col = capturedTableOptions.columns.find((c) => c.id === 'select');
+ return col.cell({ row: { id: logo.id, original: logo } });
+};
+
+const getSelectHeader = () => {
+ const col = capturedTableOptions.columns.find((c) => c.id === 'select');
+ return col.header({ table: {} });
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('LogosTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ vi.mocked(LogosTableUtils.deleteLogo).mockResolvedValue(undefined);
+ vi.mocked(LogosTableUtils.deleteLogos).mockResolvedValue(undefined);
+ vi.mocked(LogosTableUtils.cleanupUnusedLogos).mockResolvedValue({
+ deleted_count: 3,
+ local_files_deleted: 0,
+ });
+ window.open = vi.fn();
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the name filter input', () => {
+ setupMocks();
+ render(
+ {m3uAccount?.name ?? 'new'}
+
+
+
+ ) : null,
+}));
+
+vi.mock('../../ServerGroupsManagerModal', () => ({
+ default: ({ isOpen, onClose }) =>
+ isOpen ? (
+
+
+
+ ) : null,
+}));
+
+vi.mock('../../../components/ConfirmationDialog', () => ({
+ default: ({
+ opened,
+ onClose,
+ onConfirm,
+ title,
+ message,
+ confirmLabel,
+ cancelLabel,
+ loading,
+ }) =>
+ opened ? (
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color }) => (
+
+ ),
+ Box: ({ children, style }) => {title}
+
+ {typeof message === 'string' ? message : 'rich-message'}
+
+
+
+ {children}
,
+ Button: ({ children, onClick, leftSection, disabled, loading }) => (
+
+ ),
+ Flex: ({ children, style }) => {children}
,
+ Paper: ({ children, style }) => {children}
,
+ Switch: ({ checked, onChange }) => (
+
+ ),
+ Text: ({ children, size, c, fw, style }) => (
+
+ {children}
+
+ ),
+ Tooltip: ({ children, label }) => (
+ {children}
+ ),
+ useMantineTheme: vi.fn(() => ({
+ palette: { background: { paper: '#1a1a1a' } },
+ colors: { red: { 6: '#fa5252' }, green: { 6: '#40c057' } },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ // Icons used by M3UsTable
+ RefreshCcw: () => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ SquarePlus: () => ,
+ // Icons required by src/config/navigation.js (pulled in via store/auth)
+ Blocks: () => ,
+ ChartLine: () => ,
+ Database: () => ,
+ Download: () => ,
+ FileImage: () => ,
+ LayoutGrid: () => ,
+ ListOrdered: () => ,
+ Logs: () => ,
+ MonitorCog: () => ,
+ Package: () => ,
+ Play: () => ,
+ PlugZap: () => ,
+ Settings: () => ,
+ User: () => ,
+ Video: () => ,
+ Webhook: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import usePlaylistsStore from '../../../store/playlists';
+import useWarningsStore from '../../../store/warnings';
+import useLocalStorage from '../../../hooks/useLocalStorage';
+import * as M3UsTableUtils from '../../../utils/tables/M3UsTableUtils.js';
+import * as DateTimeUtils from '../../../utils/dateTimeUtils.js';
+import { useTable } from '../CustomTable';
+import M3UTable from '../M3UsTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makePlaylist = (overrides = {}) => ({
+ id: 1,
+ name: 'Test M3U',
+ account_type: 'M3U',
+ server_url: 'http://example.com/playlist.m3u',
+ file_path: null,
+ status: 'success',
+ last_message: 'Loaded 500 streams',
+ max_streams: 5,
+ profiles: [],
+ is_active: true,
+ locked: false,
+ updated_at: '2024-01-01T12:00:00Z',
+ earliest_expiration: '2024-12-01T00:00:00Z',
+ all_expirations: [],
+ ...overrides,
+});
+
+let capturedTableOptions = null;
+
+const setupMocks = ({
+ playlists = [makePlaylist()],
+ refreshProgress = {},
+ editPlaylistId = null,
+ isWarningSuppressed = vi.fn(() => false),
+ suppressWarning = vi.fn(),
+ tableSize = 'default',
+} = {}) => {
+ const mockSetRefreshProgress = vi.fn();
+ const mockSetEditPlaylistId = vi.fn();
+
+ vi.mocked(usePlaylistsStore).mockImplementation((sel) =>
+ sel({
+ playlists,
+ refreshProgress,
+ setRefreshProgress: mockSetRefreshProgress,
+ editPlaylistId,
+ setEditPlaylistId: mockSetEditPlaylistId,
+ })
+ );
+
+ vi.mocked(useWarningsStore).mockImplementation((sel) =>
+ sel({ isWarningSuppressed, suppressWarning })
+ );
+
+ vi.mocked(useLocalStorage).mockReturnValue([tableSize, vi.fn()]);
+
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return { getRowModel: () => ({ rows: [] }), getHeaderGroups: () => [] };
+ });
+
+ return { mockSetRefreshProgress, mockSetEditPlaylistId };
+};
+
+const getCol = (keyOrId) =>
+ capturedTableOptions.columns.find(
+ (c) => c.accessorKey === keyOrId || c.id === keyOrId
+ );
+
+const makeRowCtx = (playlist) => ({
+ row: { id: String(playlist.id), original: playlist },
+ cell: { column: { id: 'actions', columnDef: {} }, getValue: vi.fn() },
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('M3UTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ vi.mocked(M3UsTableUtils.deletePlaylist).mockResolvedValue(undefined);
+ vi.mocked(M3UsTableUtils.refreshPlaylist).mockResolvedValue(undefined);
+ vi.mocked(M3UsTableUtils.updatePlaylist).mockResolvedValue(undefined);
+ vi.mocked(M3UsTableUtils.getPlaylistAutoCreatedChannelsCount).mockResolvedValue({
+ count: 0,
+ sample_names: [],
+ });
+ vi.mocked(M3UsTableUtils.getStatusContent).mockReturnValue({ type: 'default', label: 'Idle' });
+ vi.mocked(DateTimeUtils.format).mockImplementation((val) => `formatted:${val}`);
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the "M3U Accounts" heading', () => {
+ setupMocks();
+ render({children}
,
+ Group: ({ children }) => {children}
,
+ Text: ({ children, size, name }) => (
+
+ {children}
+
+ ),
+}));
+
+vi.mock('lucide-react', () => ({
+ ArrowUpDown: (props) => (
+
+ ),
+ ArrowUpNarrowWide: (props) => (
+
+ ),
+ ArrowDownWideNarrow: (props) => (
+
+ ),
+}));
+
+// ── Helpers ────────────────────────────────────────────────────────────────────
+
+/** Build a minimal header object that matches what TanStack Table provides */
+const makeHeader = ({ id = 'name', label = 'Name', sortable = true } = {}) => ({
+ id,
+ column: {
+ columnDef: {
+ header: label,
+ sortable,
+ },
+ },
+});
+
+// ── makeHeaderCellRenderer ───────────────────────────────────────────────────
+
+describe('makeHeaderCellRenderer', () => {
+ describe('with no active sort', () => {
+ const sorting = [];
+ let onSortingChange;
+ let renderHeader;
+
+ beforeEach(() => {
+ onSortingChange = vi.fn();
+ renderHeader = makeHeaderCellRenderer(sorting, onSortingChange);
+ });
+
+ it('renders the column label text', () => {
+ render(renderHeader(makeHeader({ label: 'Channel' })));
+ expect(screen.getByTestId('text')).toHaveTextContent('Channel');
+ });
+
+ it('renders the neutral ArrowUpDown icon when no sort is active', () => {
+ render(renderHeader(makeHeader()));
+ expect(screen.getByTestId('icon-arrow-up-down')).toBeInTheDocument();
+ });
+
+ it('does not render a sort icon when column is not sortable', () => {
+ render(renderHeader(makeHeader({ sortable: false })));
+ expect(
+ screen.queryByTestId('icon-arrow-up-down')
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByTestId('icon-arrow-up-narrow-wide')
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByTestId('icon-arrow-down-wide-narrow')
+ ).not.toBeInTheDocument();
+ });
+
+ it('calls onSortingChange with the header id when icon is clicked', () => {
+ render(renderHeader(makeHeader({ id: 'title' })));
+ fireEvent.click(screen.getByTestId('icon-arrow-up-down'));
+ expect(onSortingChange).toHaveBeenCalledTimes(1);
+ expect(onSortingChange).toHaveBeenCalledWith('title');
+ });
+
+ it('sets the data-name attribute on the Text element to the header id', () => {
+ render(renderHeader(makeHeader({ id: 'status' })));
+ expect(screen.getByTestId('text')).toHaveAttribute('data-name', 'status');
+ });
+ });
+
+ describe('when sorting asc on the current column (desc: false)', () => {
+ it('renders ArrowUpNarrowWide icon', () => {
+ const sorting = [{ id: 'name', desc: false }];
+ const renderHeader = makeHeaderCellRenderer(sorting, vi.fn());
+ render(renderHeader(makeHeader({ id: 'name' })));
+ expect(
+ screen.getByTestId('icon-arrow-up-narrow-wide')
+ ).toBeInTheDocument();
+ });
+
+ it('does not render ArrowDownWideNarrow or ArrowUpDown', () => {
+ const sorting = [{ id: 'name', desc: false }];
+ const renderHeader = makeHeaderCellRenderer(sorting, vi.fn());
+ render(renderHeader(makeHeader({ id: 'name' })));
+ expect(
+ screen.queryByTestId('icon-arrow-down-wide-narrow')
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByTestId('icon-arrow-up-down')
+ ).not.toBeInTheDocument();
+ });
+ });
+
+ describe('when sorting desc on the current column (desc: true)', () => {
+ it('renders ArrowDownWideNarrow icon', () => {
+ const sorting = [{ id: 'name', desc: true }];
+ const renderHeader = makeHeaderCellRenderer(sorting, vi.fn());
+ render(renderHeader(makeHeader({ id: 'name' })));
+ expect(
+ screen.getByTestId('icon-arrow-down-wide-narrow')
+ ).toBeInTheDocument();
+ });
+
+ it('does not render ArrowUpNarrowWide or ArrowUpDown', () => {
+ const sorting = [{ id: 'name', desc: true }];
+ const renderHeader = makeHeaderCellRenderer(sorting, vi.fn());
+ render(renderHeader(makeHeader({ id: 'name' })));
+ expect(
+ screen.queryByTestId('icon-arrow-up-narrow-wide')
+ ).not.toBeInTheDocument();
+ expect(
+ screen.queryByTestId('icon-arrow-up-down')
+ ).not.toBeInTheDocument();
+ });
+ });
+
+ describe('when a different column is sorted', () => {
+ it('renders the neutral ArrowUpDown icon for the unsorted column', () => {
+ const sorting = [{ id: 'status', desc: false }];
+ const renderHeader = makeHeaderCellRenderer(sorting, vi.fn());
+ render(renderHeader(makeHeader({ id: 'name' })));
+ expect(screen.getByTestId('icon-arrow-up-down')).toBeInTheDocument();
+ });
+ });
+});
+
+// ── makeSortingChangeHandler ─────────────────────────────────────────────────
+
+describe('makeSortingChangeHandler', () => {
+ let setSorting;
+ let onDataSort;
+
+ beforeEach(() => {
+ setSorting = vi.fn();
+ onDataSort = vi.fn();
+ });
+
+ describe('first click on a new column', () => {
+ it('sets ascending sort (desc: false)', () => {
+ const handler = makeSortingChangeHandler([], setSorting, onDataSort);
+ handler('name');
+ expect(setSorting).toHaveBeenCalledWith([{ id: 'name', desc: false }]);
+ });
+
+ it('calls onDataSort with the column and desc: false', () => {
+ const handler = makeSortingChangeHandler([], setSorting, onDataSort);
+ handler('name');
+ expect(onDataSort).toHaveBeenCalledWith('name', false);
+ });
+ });
+
+ describe('second click on the same column (currently asc)', () => {
+ it('sets descending sort (desc: true)', () => {
+ const sorting = [{ id: 'name', desc: false }];
+ const handler = makeSortingChangeHandler(sorting, setSorting, onDataSort);
+ handler('name');
+ expect(setSorting).toHaveBeenCalledWith([{ id: 'name', desc: true }]);
+ });
+
+ it('calls onDataSort with the column and desc: true', () => {
+ const sorting = [{ id: 'name', desc: false }];
+ const handler = makeSortingChangeHandler(sorting, setSorting, onDataSort);
+ handler('name');
+ expect(onDataSort).toHaveBeenCalledWith('name', true);
+ });
+ });
+
+ describe('third click on the same column (currently desc) → clears sort', () => {
+ it('sets sorting to an empty array', () => {
+ const sorting = [{ id: 'name', desc: true }];
+ const handler = makeSortingChangeHandler(sorting, setSorting, onDataSort);
+ handler('name');
+ expect(setSorting).toHaveBeenCalledWith([]);
+ });
+
+ it('does NOT call onDataSort when sorting is cleared', () => {
+ const sorting = [{ id: 'name', desc: true }];
+ const handler = makeSortingChangeHandler(sorting, setSorting, onDataSort);
+ handler('name');
+ expect(onDataSort).not.toHaveBeenCalled();
+ });
+ });
+
+ describe('switching to a different column while another is sorted', () => {
+ it('resets to ascending sort on the new column', () => {
+ const sorting = [{ id: 'status', desc: true }];
+ const handler = makeSortingChangeHandler(sorting, setSorting, onDataSort);
+ handler('name');
+ expect(setSorting).toHaveBeenCalledWith([{ id: 'name', desc: false }]);
+ });
+
+ it('calls onDataSort with the new column and desc: false', () => {
+ const sorting = [{ id: 'status', desc: true }];
+ const handler = makeSortingChangeHandler(sorting, setSorting, onDataSort);
+ handler('name');
+ expect(onDataSort).toHaveBeenCalledWith('name', false);
+ });
+ });
+
+ describe('always calls setSorting', () => {
+ it('calls setSorting exactly once per handler invocation', () => {
+ const handler = makeSortingChangeHandler([], setSorting, onDataSort);
+ handler('title');
+ expect(setSorting).toHaveBeenCalledTimes(1);
+ });
+ });
+});
diff --git a/frontend/src/components/tables/__tests__/OutputProfilesTable.test.jsx b/frontend/src/components/tables/__tests__/OutputProfilesTable.test.jsx
new file mode 100644
index 00000000..47e66324
--- /dev/null
+++ b/frontend/src/components/tables/__tests__/OutputProfilesTable.test.jsx
@@ -0,0 +1,524 @@
+import React from 'react';
+import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// ── Store mocks ────────────────────────────────────────────────────────────────
+vi.mock('../../../store/outputProfiles', () => ({ default: vi.fn() }));
+
+// ── Hook mocks ─────────────────────────────────────────────────────────────────
+vi.mock('../../../hooks/useLocalStorage', () => ({
+ default: vi.fn(() => ['default', vi.fn()]),
+}));
+
+// ── Utility mocks ──────────────────────────────────────────────────────────────
+vi.mock('../../../utils/tables/OutputProfilesTableUtils.js', () => ({
+ deleteOutputProfile: vi.fn().mockResolvedValue(undefined),
+ updateOutputProfile: vi.fn().mockResolvedValue(undefined),
+}));
+
+// ── Child component mocks ──────────────────────────────────────────────────────
+vi.mock('../../forms/OutputProfile', () => ({
+ default: ({ isOpen, onClose, profile }) =>
+ isOpen ? (
+
+ {profile?.name ?? 'new'}
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color }) => (
+
+ ),
+ Box: ({ children, style }) => {children}
,
+ Button: ({ children, onClick, leftSection, disabled, loading }) => (
+
+ ),
+ Center: ({ children }) => {children}
,
+ Flex: ({ children }) => {children}
,
+ Paper: ({ children, style }) => {children}
,
+ Stack: ({ children, style }) => {children}
,
+ Switch: ({ checked, onChange, disabled }) => (
+
+ ),
+ Text: ({ children, size, style }) => (
+
+ {children}
+
+ ),
+ Tooltip: ({ children, label }) => (
+ {children}
+ ),
+ useMantineTheme: vi.fn(() => ({
+ palette: { background: { paper: '#1a1a1a' } },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ Eye: () => ,
+ EyeOff: () => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ SquarePlus: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useOutputProfilesStore from '../../../store/outputProfiles';
+import useLocalStorage from '../../../hooks/useLocalStorage';
+import * as OutputProfilesTableUtils from '../../../utils/tables/OutputProfilesTableUtils.js';
+import { useTable } from '../CustomTable';
+import OutputProfiles from '../OutputProfilesTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeProfile = (overrides = {}) => ({
+ id: 1,
+ name: 'Test Profile',
+ command: 'ffmpeg',
+ parameters: '-c:v copy',
+ is_active: true,
+ locked: false,
+ ...overrides,
+});
+
+let capturedTableOptions = null;
+
+const setupMocks = ({
+ profiles = [makeProfile()],
+ tableSize = 'default',
+} = {}) => {
+ vi.mocked(useOutputProfilesStore).mockImplementation((sel) =>
+ sel({ profiles })
+ );
+
+ vi.mocked(useLocalStorage).mockReturnValue([tableSize, vi.fn()]);
+
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return {
+ getRowModel: () => ({ rows: [] }),
+ getHeaderGroups: () => [],
+ };
+ });
+};
+
+const getCol = (keyOrId) =>
+ capturedTableOptions.columns.find(
+ (c) => c.accessorKey === keyOrId || c.id === keyOrId
+ );
+
+const makeRowCtx = (profile) => ({
+ row: { id: String(profile.id), original: profile },
+ cell: { column: { id: 'actions', columnDef: {} }, getValue: vi.fn(() => undefined) },
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('OutputProfiles', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ vi.mocked(OutputProfilesTableUtils.deleteOutputProfile).mockResolvedValue(undefined);
+ vi.mocked(OutputProfilesTableUtils.updateOutputProfile).mockResolvedValue(undefined);
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the "Add Output Profile" button', () => {
+ setupMocks();
+ render(
+ {profile?.name ?? 'new'}
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color }) => (
+
+ ),
+ Box: ({ children, style }) => {children}
,
+ Button: ({ children, onClick, leftSection, disabled, loading }) => (
+
+ ),
+ Center: ({ children }) => {children}
,
+ Flex: ({ children }) => {children}
,
+ Paper: ({ children, style }) => {children}
,
+ Stack: ({ children, style }) => {children}
,
+ Switch: ({ checked, onChange, disabled }) => (
+
+ ),
+ Text: ({ children, name }) => (
+
+ {children}
+
+ ),
+ Tooltip: ({ children, label }) => (
+ {children}
+ ),
+ useMantineTheme: vi.fn(() => ({
+ palette: { background: { paper: '#1a1a1a' } },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ Eye: () => ,
+ EyeOff: () => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ SquarePlus: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useStreamProfilesStore from '../../../store/streamProfiles';
+import useSettingsStore from '../../../store/settings';
+import { useTable } from '../CustomTable';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import { updateStreamProfile } from '../../../utils/forms/StreamProfileUtils.js';
+import API from '../../../api';
+import StreamProfiles from '../StreamProfilesTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeProfile = (overrides = {}) => ({
+ id: 1,
+ name: 'Test Profile',
+ command: 'ffmpeg',
+ parameters: '-c copy',
+ is_active: true,
+ locked: false,
+ ...overrides,
+});
+
+let capturedTableOptions = null;
+
+const setupMocks = ({
+ profiles = [makeProfile()],
+ defaultProfileId = 99,
+} = {}) => {
+ vi.mocked(useStreamProfilesStore).mockImplementation((sel) =>
+ sel({ profiles })
+ );
+
+ vi.mocked(useSettingsStore).mockImplementation((sel) =>
+ sel({ settings: { default_stream_profile: defaultProfileId } })
+ );
+
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return {
+ getRowModel: () => ({ rows: [] }),
+ getHeaderGroups: () => [],
+ };
+ });
+};
+
+const getCol = (keyOrId) =>
+ capturedTableOptions.columns.find(
+ (c) => c.accessorKey === keyOrId || c.id === keyOrId
+ );
+
+const makeRowCtx = (profile) => ({
+ row: { id: String(profile.id), original: profile },
+ cell: {
+ column: { id: 'actions', columnDef: {} },
+ getValue: vi.fn(() => undefined),
+ },
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('StreamProfiles', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ vi.mocked(API.deleteStreamProfile).mockResolvedValue(undefined);
+ vi.mocked(updateStreamProfile).mockResolvedValue(undefined);
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the "Add Stream Profile" button', () => {
+ setupMocks();
+ render(
+ {stream?.name ?? 'new'}
+
+
+ ) : null,
+}));
+
+vi.mock('../../ConfirmationDialog', () => ({
+ default: ({ opened, onClose, onConfirm, title, message, confirmLabel, cancelLabel, loading }) =>
+ opened ? (
+
+ {title}
+ {typeof message === 'string' ? message : 'message'}
+
+
+
+ ) : null,
+}));
+
+vi.mock('../../modals/CreateChannelModal', () => ({
+ default: ({ opened, onClose, onConfirm }) =>
+ opened ? (
+
+
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled }) => (
+
+ ),
+ Box: ({ children, style }) => {children}
,
+ Button: ({ children, onClick, leftSection, disabled, loading }) => (
+
+ ),
+ Card: ({ children, style }) => (
+ {children}
+ ),
+ Center: ({ children, style }) => {children}
,
+ Divider: ({ label }) => , + Flex: ({ children, style }) => ( +
{children}
+ ),
+ Group: ({ children, style }) => {children}
,
+ LoadingOverlay: ({ visible }) => visible ? : null,
+ Menu: Object.assign(
+ ({ children }) => {children}
,
+ {
+ Target: ({ children }) => {children}
,
+ Dropdown: ({ children }) => {children}
,
+ Label: ({ children }) => {children}
,
+ Item: ({ children, onClick, leftSection }) => (
+
+ ),
+ Divider: () => , + } + ), + MenuDivider: () =>
, + MenuDropdown: ({ children }) =>
{children}
,
+ MenuItem: ({ children, onClick, leftSection }) => (
+
+ ),
+ MenuLabel: ({ children }) => {children}
,
+ MenuTarget: ({ children }) => {children}
,
+ MultiSelect: ({ onChange, value, data }) => (
+
+ ),
+ NativeSelect: ({ onChange, value, data }) => (
+
+ ),
+ Pagination: ({ total, value, onChange }) => (
+
+
+ {value}
+
+
+ ),
+ Paper: ({ children, style }) => {children}
,
+ Stack: ({ children, style }) => {children}
,
+ Text: ({ children, style }) => (
+ {children}
+ ),
+ TextInput: ({ onChange, value, placeholder }) => (
+
+ ),
+ Title: ({ children, style }) => {children}
, + Tooltip: ({ children, label }) => ( +{children}
+ ),
+ UnstyledButton: ({ children, onClick }) => (
+
+ ),
+ useMantineTheme: vi.fn(() => ({
+ tailwind: { blue: { 6: '#3b82f6' }, green: { 5: '#22c55e' }, yellow: { 3: '#fde047' } },
+ palette: { background: { paper: '#1a1a1a' } },
+ colors: {},
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ ArrowDownWideNarrow: () => ,
+ ArrowUpDown: () => ,
+ ArrowUpNarrowWide: () => ,
+ Copy: () => ,
+ EllipsisVertical: () => ,
+ Eye: () => ,
+ EyeOff: () => ,
+ Filter: () => ,
+ ListPlus: () => ,
+ RotateCcw: () => ,
+ Search: () => ,
+ Square: () => ,
+ SquareCheck: () => ,
+ SquareMinus: () => ,
+ SquarePlus: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import usePlaylistsStore from '../../../store/playlists';
+import useChannelsStore from '../../../store/channels';
+import useSettingsStore from '../../../store/settings';
+import useVideoStore from '../../../store/useVideoStore';
+import useChannelsTableStore from '../../../store/channelsTable';
+import useWarningsStore from '../../../store/warnings';
+import useStreamsTableStore from '../../../store/streamsTable';
+import useLocalStorage from '../../../hooks/useLocalStorage';
+import { useNavigate } from 'react-router-dom';
+import { useTable } from '../CustomTable';
+import * as StreamsTableUtils from '../../../utils/tables/StreamsTableUtils.js';
+import StreamsTable from '../StreamsTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeStream = (overrides = {}) => ({
+ id: 1,
+ name: 'Test Stream',
+ url: 'http://example.com/stream',
+ stream_hash: 'abc123',
+ channel_group: 'group-1',
+ m3u_account: 10,
+ tvg_id: 'tvg-1',
+ stream_stats: null,
+ is_custom: true,
+ is_stale: false,
+ ...overrides,
+});
+
+let capturedTableOptions = null;
+
+const DEFAULT_PAGINATION = { pageIndex: 0, pageSize: 50 };
+const DEFAULT_SORTING = [{ id: 'name', desc: false }];
+
+const setupMocks = ({
+ streams = [makeStream()],
+ pageCount = 1,
+ totalCount = 1,
+ allQueryIds = [1],
+ pagination = DEFAULT_PAGINATION,
+ sorting = DEFAULT_SORTING,
+ selectedStreamIds = [],
+ playlists = [{ id: 10, name: 'My M3U' }],
+ channelGroups = { 'group-1': { name: 'Sports' } },
+ expandedChannelId = null,
+ selectedChannelIds = [],
+ channelProfiles = {},
+ isWarningSuppressed = vi.fn(() => false),
+ suppressWarning = vi.fn(),
+ envMode = 'production',
+ showVideo = vi.fn(),
+ isVisible = false,
+ tableSize = null,
+} = {}) => {
+ vi.mocked(useStreamsTableStore).mockImplementation((sel) =>
+ sel({
+ streams,
+ pageCount,
+ totalCount,
+ allQueryIds,
+ pagination,
+ sorting,
+ selectedStreamIds,
+ setAllQueryIds: vi.fn(),
+ setPagination: vi.fn(),
+ setSorting: vi.fn(),
+ setSelectedStreamIds: vi.fn(),
+ })
+ );
+
+ vi.mocked(usePlaylistsStore).mockImplementation((sel) =>
+ sel({ playlists, fetchPlaylists: vi.fn(), isLoading: false })
+ );
+
+ vi.mocked(useChannelsStore).mockImplementation((sel) =>
+ sel({
+ channelGroups,
+ fetchChannelGroups: vi.fn(),
+ profiles: channelProfiles,
+ selectedProfileId: '0',
+ })
+ );
+
+ vi.mocked(useSettingsStore).mockImplementation((sel) =>
+ sel({ environment: { env_mode: envMode } })
+ );
+
+ vi.mocked(useVideoStore).mockImplementation((sel) =>
+ sel({ showVideo, isVisible })
+ );
+
+ vi.mocked(useChannelsTableStore).mockImplementation((sel) =>
+ sel({
+ expandedChannelId,
+ selectedChannelIds,
+ channels: [],
+ })
+ );
+
+ vi.mocked(useWarningsStore).mockImplementation((sel) =>
+ sel({ suppressWarning, isWarningSuppressed })
+ );
+
+ // useLocalStorage: first call is column-sizing, second is column-visibility
+ vi.mocked(useLocalStorage)
+ .mockReturnValueOnce([{}, vi.fn()]) // streams-table-column-sizing
+ .mockReturnValueOnce([tableSize, vi.fn()]); // streams-table-column-visibility
+
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return {
+ getRowModel: () => ({ rows: [] }),
+ getHeaderGroups: () => [],
+ setSelectedTableIds: vi.fn(),
+ tableSize: tableSize ?? 'default',
+ };
+ });
+};
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('StreamsTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+
+ vi.mocked(StreamsTableUtils.queryStreamsTable).mockResolvedValue({ count: 5, results: [] });
+ vi.mocked(StreamsTableUtils.getAllStreamIds).mockResolvedValue([]);
+ vi.mocked(StreamsTableUtils.getStreamFilterOptions).mockResolvedValue({
+ groups: [],
+ m3u_accounts: [],
+ });
+ vi.mocked(StreamsTableUtils.deleteStream).mockResolvedValue(undefined);
+ vi.mocked(StreamsTableUtils.deleteStreams).mockResolvedValue(undefined);
+ vi.mocked(StreamsTableUtils.addStreamsToChannel).mockResolvedValue(undefined);
+ vi.mocked(StreamsTableUtils.requeryStreams).mockResolvedValue(undefined);
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the "Streams" heading', () => {
+ setupMocks();
+ render(
+ {userAgent?.name ?? 'new'}
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color }) => (
+
+ ),
+ Box: ({ children, style }) => {children}
,
+ Button: ({ children, onClick, leftSection, disabled, loading }) => (
+
+ ),
+ Center: ({ children }) => {children}
,
+ Flex: ({ children }) => {children}
,
+ Paper: ({ children, style }) => {children}
,
+ Stack: ({ children, style }) => {children}
,
+ Text: ({ children, name }) => (
+
+ {children}
+
+ ),
+ Tooltip: ({ children, label }) => (
+ {children}
+ ),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ Check: ({ color }) => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ SquarePlus: () => ,
+ X: ({ color }) => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useUserAgentsStore from '../../../store/userAgents';
+import useSettingsStore from '../../../store/settings';
+import { useTable } from '../CustomTable';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import API from '../../../api';
+import UserAgentsTable from '../UserAgentsTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeUA = (overrides = {}) => ({
+ id: 1,
+ name: 'Chrome Default',
+ user_agent: 'Mozilla/5.0 Chrome/120',
+ description: 'Standard Chrome UA',
+ is_active: true,
+ ...overrides,
+});
+
+let capturedTableOptions = null;
+
+const setupMocks = ({
+ userAgents = [makeUA()],
+ defaultUserAgentId = 99,
+} = {}) => {
+ vi.mocked(useUserAgentsStore).mockImplementation((sel) =>
+ sel({ userAgents })
+ );
+
+ vi.mocked(useSettingsStore).mockImplementation((sel) =>
+ sel({ settings: { default_user_agent: defaultUserAgentId } })
+ );
+
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return {
+ getRowModel: () => ({ rows: [] }),
+ getHeaderGroups: () => [],
+ };
+ });
+};
+
+const makeRowCtx = (ua) => ({
+ row: { id: String(ua.id), original: ua },
+ cell: {
+ column: { id: 'actions', columnDef: {} },
+ getValue: vi.fn(() => undefined),
+ },
+});
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('UserAgentsTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ vi.mocked(API.deleteUserAgent).mockResolvedValue(undefined);
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the "Add User-Agent" button', () => {
+ setupMocks();
+ render(
+ {user?.username ?? 'new'}
+
+
+ ) : null,
+}));
+
+vi.mock('../../ConfirmationDialog', () => ({
+ default: ({ opened, onClose, onConfirm, title, loading, confirmLabel, cancelLabel }) =>
+ opened ? (
+
+ {title}
+
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color }) => (
+
+ ),
+ Badge: ({ children, color }) => (
+
+ {children}
+
+ ),
+ Box: ({ children, style }) => {children}
,
+ Button: ({ children, onClick, leftSection, disabled, loading }) => (
+
+ ),
+ Flex: ({ children, style }) => {children}
,
+ Group: ({ children, style }) => (
+ {children}
+ ),
+ LoadingOverlay: ({ visible }) => visible ? : null,
+ Paper: ({ children, style }) => {children}
,
+ Stack: ({ children, style }) => {children}
,
+ Text: ({ children, style, name }) => (
+
+ {children}
+
+ ),
+ Tooltip: ({ children, label }) => (
+ {children}
+ ),
+ useMantineTheme: vi.fn(() => ({
+ tailwind: {
+ yellow: { 3: '#fde047' },
+ red: { 6: '#dc2626' },
+ green: { 5: '#22c55e' },
+ },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ Eye: () => ,
+ EyeOff: () => ,
+ SquareMinus: () => ,
+ SquarePen: () => ,
+ SquarePlus: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useUsersStore from '../../../store/users';
+import useChannelsStore from '../../../store/channels';
+import useAuthStore from '../../../store/auth';
+import useWarningsStore from '../../../store/warnings';
+import { useDateTimeFormat, format } from '../../../utils/dateTimeUtils.js';
+import { useTable } from '../CustomTable';
+import API from '../../../api';
+import { USER_LEVELS, USER_LEVEL_LABELS } from '../../../constants';
+import UsersTable from '../UsersTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeUser = (overrides = {}) => ({
+ id: 1,
+ username: 'testuser',
+ first_name: 'Test',
+ last_name: 'User',
+ email: 'test@example.com',
+ user_level: USER_LEVELS.STANDARD,
+ date_joined: '2024-01-15T10:00:00Z',
+ last_login: '2024-06-01T12:00:00Z',
+ custom_properties: { xc_password: 'secret123' },
+ channel_profiles: [],
+ ...overrides,
+});
+
+const makeAdminUser = (overrides = {}) =>
+ makeUser({ id: 99, username: 'admin', user_level: USER_LEVELS.ADMIN, ...overrides });
+
+let capturedTableOptions = null;
+
+const setupMocks = ({
+ users = [makeUser()],
+ authUser = makeAdminUser(),
+ profiles = { 10: { id: 10, name: 'HD Profile' } },
+ isWarningSuppressed = vi.fn(() => false),
+ suppressWarning = vi.fn(),
+} = {}) => {
+ vi.mocked(useUsersStore).mockImplementation((sel) =>
+ sel({ users })
+ );
+
+ vi.mocked(useChannelsStore).mockImplementation((sel) =>
+ sel({ profiles })
+ );
+
+ vi.mocked(useAuthStore).mockImplementation((sel) =>
+ sel({ user: authUser })
+ );
+
+ vi.mocked(useWarningsStore).mockImplementation((sel) =>
+ sel({ isWarningSuppressed, suppressWarning })
+ );
+
+ vi.mocked(useDateTimeFormat).mockReturnValue({
+ fullDateFormat: 'MM/DD/YYYY',
+ fullDateTimeFormat: 'MM/DD/YYYY HH:mm',
+ });
+
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return {
+ getRowModel: () => ({ rows: [] }),
+ getHeaderGroups: () => [],
+ };
+ });
+};
+
+const getActionsCell = () =>
+ capturedTableOptions.columns.find((c) => c.id === 'actions');
+
+const getCol = (key) =>
+ capturedTableOptions.columns.find(
+ (c) => c.accessorKey === key || c.id === key
+ );
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('UsersTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ vi.mocked(API.deleteUser).mockResolvedValue(undefined);
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the "Users" heading', () => {
+ setupMocks();
+ render(
+ {title}
+
+
+
+ ) : null,
+}));
+
+vi.mock('../CustomTable', () => ({
+ CustomTable: () => ,
+ useTable: vi.fn(),
+}));
+
+// ── Mantine core ───────────────────────────────────────────────────────────────
+vi.mock('@mantine/core', () => ({
+ ActionIcon: ({ children, onClick, disabled, color }) => (
+
+ ),
+ Badge: ({ children, color }) => (
+
+ {children}
+
+ ),
+ Box: ({ children, style }) => {children}
,
+ Button: ({ children, onClick, leftSection, disabled, loading }) => (
+
+ ),
+ Center: ({ children, style }) => {children}
,
+ Checkbox: ({ checked, indeterminate, onChange }) => (
+
+ ),
+ Group: ({ children, style }) => (
+ {children}
+ ),
+ Image: ({ src, alt, fallbackSrc }) => (
+
+
+ {value}
+
+
+ ),
+ Paper: ({ children, style }) => {children}
,
+ Select: ({ value, onChange, data }) => (
+
+ ),
+ Stack: ({ children, style }) => {children}
,
+ Text: ({ children, style, name }) => (
+
+ {children}
+
+ ),
+ TextInput: ({ value, onChange, placeholder }) => (
+
+ ),
+ Tooltip: ({ children, label }) => (
+ {children}
+ ),
+ useMantineTheme: vi.fn(() => ({
+ tailwind: {
+ red: { 6: '#dc2626' },
+ },
+ })),
+}));
+
+// ── lucide-react ───────────────────────────────────────────────────────────────
+vi.mock('lucide-react', () => ({
+ ExternalLink: () => ,
+ SquareMinus: () => ,
+ Trash: () => ,
+}));
+
+// ── Imports after mocks ────────────────────────────────────────────────────────
+import useVODLogosStore from '../../../store/vodLogos';
+import { useTable } from '../CustomTable';
+import { showNotification } from '../../../utils/notificationUtils.js';
+import VODLogosTable from '../VODLogosTable';
+
+// ── Factories ──────────────────────────────────────────────────────────────────
+const makeLogo = (overrides = {}) => ({
+ id: 1,
+ name: 'Test Logo',
+ url: 'http://example.com/logo.png',
+ cache_url: '/cache/logo.png',
+ movie_count: 0,
+ series_count: 0,
+ item_names: [],
+ ...overrides,
+});
+
+let capturedTableOptions = null;
+
+const setupMocks = ({
+ logos = [makeLogo()],
+ totalCount = 1,
+ isLoading = false,
+ unusedCount = 0,
+} = {}) => {
+ const fetchVODLogos = vi.fn().mockResolvedValue(undefined);
+ const deleteVODLogo = vi.fn().mockResolvedValue(undefined);
+ const deleteVODLogos = vi.fn().mockResolvedValue(undefined);
+ const cleanupUnusedVODLogos = vi.fn().mockResolvedValue({ deleted_count: 3 });
+ const getUnusedLogosCount = vi.fn().mockResolvedValue(unusedCount);
+
+ vi.mocked(useVODLogosStore).mockReturnValue({
+ logos,
+ totalCount,
+ isLoading,
+ fetchVODLogos,
+ deleteVODLogo,
+ deleteVODLogos,
+ cleanupUnusedVODLogos,
+ getUnusedLogosCount,
+ });
+
+ vi.mocked(useTable).mockImplementation((opts) => {
+ capturedTableOptions = opts;
+ return {
+ getRowModel: () => ({ rows: [] }),
+ getHeaderGroups: () => [],
+ setSelectedTableIds: vi.fn(),
+ };
+ });
+
+ return {
+ fetchVODLogos,
+ deleteVODLogo,
+ deleteVODLogos,
+ cleanupUnusedVODLogos,
+ getUnusedLogosCount,
+ };
+};
+
+const getCol = (key) =>
+ capturedTableOptions.columns.find(
+ (c) => c.accessorKey === key || c.id === key
+ );
+
+// ══════════════════════════════════════════════════════════════════════════════
+// Tests
+// ══════════════════════════════════════════════════════════════════════════════
+
+describe('VODLogosTable', () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ capturedTableOptions = null;
+ });
+
+ // ── Rendering ──────────────────────────────────────────────────────────────
+
+ describe('rendering', () => {
+ it('renders the name filter input', () => {
+ setupMocks();
+ render(