badb5dd7de
`DownloadEngine` grows async query methods that wrap plugin iteration: `get_all_downloads` (concatenates every plugin's active downloads), `get_download_status` (first plugin to recognize the id wins), `cancel_download` (with source-hint routing — streaming sources go direct, unknown hints route to Soulseek as peer username), and `clear_all_completed_downloads` (skips unconfigured plugins). Code moved from the orchestrator's hand-iterated loops into the engine. Orchestrator delegation comes in B3 — for B2 the engine methods exist but nothing calls them yet. Per-plugin behavior preserved verbatim (defensive `try ... except` swallows per-iteration, unconfigured-skip on clear, source-hint routing semantics). Phase A pinning tests + 8 new engine query tests catch any drift. Pure additive — zero behavior change for users.
389 lines
14 KiB
Python
389 lines
14 KiB
Python
"""Tests for the DownloadEngine skeleton (Phase B).
|
|
|
|
Pinning the engine's state-storage contract: add/update/remove,
|
|
per-source iteration, find-by-id, plugin registration, lock-held
|
|
mutations vs lock-released reads. Future phases (C/D/E/F) bolt
|
|
behavior on top of this surface — these tests stay green and act
|
|
as the regression net while behavior moves in.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import threading
|
|
|
|
import pytest
|
|
|
|
from core.download_engine import DownloadEngine
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Plugin registration
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_register_plugin_stores_under_source_name():
|
|
engine = DownloadEngine()
|
|
plugin = object()
|
|
engine.register_plugin('soulseek', plugin)
|
|
assert engine.get_plugin('soulseek') is plugin
|
|
assert 'soulseek' in engine.registered_sources()
|
|
|
|
|
|
def test_get_plugin_returns_none_for_unknown_source():
|
|
engine = DownloadEngine()
|
|
assert engine.get_plugin('made_up') is None
|
|
|
|
|
|
def test_register_plugin_overwrites_on_duplicate(caplog):
|
|
"""Re-registering under the same name overwrites and warns. Not a
|
|
common path but useful so test fixtures that build a fresh engine
|
|
can swap a mock plugin in without setup gymnastics."""
|
|
engine = DownloadEngine()
|
|
first = object()
|
|
second = object()
|
|
engine.register_plugin('soulseek', first)
|
|
engine.register_plugin('soulseek', second)
|
|
assert engine.get_plugin('soulseek') is second
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Active-download state — add / get / update / remove
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_add_record_inserts_under_composite_key():
|
|
engine = DownloadEngine()
|
|
engine.add_record('youtube', 'dl-1', {'state': 'Initializing', 'progress': 0.0})
|
|
|
|
rec = engine.get_record('youtube', 'dl-1')
|
|
assert rec is not None
|
|
assert rec['state'] == 'Initializing'
|
|
assert rec['progress'] == 0.0
|
|
|
|
|
|
def test_get_record_returns_shallow_copy():
|
|
"""Mutating the returned dict must NOT affect engine state.
|
|
Engine reads should be safe to hold / iterate without locks."""
|
|
engine = DownloadEngine()
|
|
engine.add_record('youtube', 'dl-1', {'state': 'Initializing'})
|
|
|
|
rec = engine.get_record('youtube', 'dl-1')
|
|
rec['state'] = 'TamperedByCaller'
|
|
|
|
# Engine state still has the original.
|
|
fresh = engine.get_record('youtube', 'dl-1')
|
|
assert fresh['state'] == 'Initializing'
|
|
|
|
|
|
def test_update_record_applies_partial_patch():
|
|
engine = DownloadEngine()
|
|
engine.add_record('tidal', 'dl-2', {'state': 'Initializing', 'progress': 0.0,
|
|
'file_path': None})
|
|
|
|
engine.update_record('tidal', 'dl-2', {'state': 'Completed, Succeeded',
|
|
'progress': 100.0,
|
|
'file_path': '/tmp/song.flac'})
|
|
|
|
rec = engine.get_record('tidal', 'dl-2')
|
|
assert rec['state'] == 'Completed, Succeeded'
|
|
assert rec['progress'] == 100.0
|
|
assert rec['file_path'] == '/tmp/song.flac'
|
|
|
|
|
|
def test_update_record_is_noop_when_record_removed():
|
|
"""If a record was removed (e.g. user cancelled mid-download),
|
|
the worker thread's late update is silently dropped — never
|
|
raises. Mirrors the per-client `if download_id in active_downloads`
|
|
guard pattern that's all over the existing clients."""
|
|
engine = DownloadEngine()
|
|
engine.add_record('tidal', 'dl-2', {'state': 'Initializing'})
|
|
engine.remove_record('tidal', 'dl-2')
|
|
|
|
# Should not raise.
|
|
engine.update_record('tidal', 'dl-2', {'state': 'Completed, Succeeded'})
|
|
|
|
assert engine.get_record('tidal', 'dl-2') is None
|
|
|
|
|
|
def test_remove_record_returns_removed_record():
|
|
engine = DownloadEngine()
|
|
engine.add_record('qobuz', 'dl-3', {'state': 'InProgress'})
|
|
|
|
removed = engine.remove_record('qobuz', 'dl-3')
|
|
assert removed is not None
|
|
assert removed['state'] == 'InProgress'
|
|
assert engine.get_record('qobuz', 'dl-3') is None
|
|
|
|
|
|
def test_remove_record_returns_none_when_missing():
|
|
engine = DownloadEngine()
|
|
assert engine.remove_record('qobuz', 'never-existed') is None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Iteration
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_iter_records_for_source_filters_correctly():
|
|
engine = DownloadEngine()
|
|
engine.add_record('youtube', 'yt-1', {'title': 'A'})
|
|
engine.add_record('youtube', 'yt-2', {'title': 'B'})
|
|
engine.add_record('tidal', 'td-1', {'title': 'C'})
|
|
|
|
yt_records = list(engine.iter_records_for_source('youtube'))
|
|
assert len(yt_records) == 2
|
|
assert {r['title'] for r in yt_records} == {'A', 'B'}
|
|
|
|
td_records = list(engine.iter_records_for_source('tidal'))
|
|
assert len(td_records) == 1
|
|
assert td_records[0]['title'] == 'C'
|
|
|
|
|
|
def test_iter_all_records_yields_source_paired_with_record():
|
|
engine = DownloadEngine()
|
|
engine.add_record('youtube', 'yt-1', {'title': 'A'})
|
|
engine.add_record('tidal', 'td-1', {'title': 'B'})
|
|
|
|
pairs = list(engine.iter_all_records())
|
|
assert len(pairs) == 2
|
|
sources = {source for source, _ in pairs}
|
|
titles = {record['title'] for _, record in pairs}
|
|
assert sources == {'youtube', 'tidal'}
|
|
assert titles == {'A', 'B'}
|
|
|
|
|
|
def test_iter_yields_shallow_copies():
|
|
"""Iteration returns COPIES — caller can hold the list and mutate
|
|
each record without affecting engine state. Important: future
|
|
Phase B3's `get_all_downloads` will iterate then build
|
|
DownloadStatus objects from the snapshots."""
|
|
engine = DownloadEngine()
|
|
engine.add_record('youtube', 'yt-1', {'title': 'A'})
|
|
|
|
snapshot = list(engine.iter_records_for_source('youtube'))
|
|
snapshot[0]['title'] = 'TAMPERED'
|
|
|
|
fresh = engine.get_record('youtube', 'yt-1')
|
|
assert fresh['title'] == 'A'
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# find_record — id-only lookup
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_find_record_returns_source_and_copy():
|
|
engine = DownloadEngine()
|
|
engine.add_record('youtube', 'shared-id-shape', {'title': 'A'})
|
|
|
|
result = engine.find_record('shared-id-shape')
|
|
assert result is not None
|
|
source, record = result
|
|
assert source == 'youtube'
|
|
assert record['title'] == 'A'
|
|
|
|
|
|
def test_find_record_returns_none_for_unknown_id():
|
|
engine = DownloadEngine()
|
|
engine.add_record('youtube', 'yt-1', {})
|
|
assert engine.find_record('nonexistent') is None
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Thread safety — basic concurrent-mutation smoke
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_concurrent_adds_dont_lose_records():
|
|
"""Hammer the engine with concurrent add_record from multiple
|
|
threads. With proper locking, every record lands in state.
|
|
Future Phase C BackgroundDownloadWorker spawns N threads doing
|
|
exactly this kind of mutation."""
|
|
engine = DownloadEngine()
|
|
|
|
def add_records(source, base):
|
|
for i in range(50):
|
|
engine.add_record(source, f'{base}-{i}', {'i': i})
|
|
|
|
threads = [
|
|
threading.Thread(target=add_records, args=(f'src-{n}', f'dl-{n}'))
|
|
for n in range(4)
|
|
]
|
|
for t in threads:
|
|
t.start()
|
|
for t in threads:
|
|
t.join()
|
|
|
|
total = sum(1 for _ in engine.iter_all_records())
|
|
assert total == 4 * 50 # 200 records, none lost
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Cross-source query dispatch (Phase B2)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _run_async(coro):
|
|
import asyncio
|
|
loop = asyncio.new_event_loop()
|
|
try:
|
|
return loop.run_until_complete(coro)
|
|
finally:
|
|
loop.close()
|
|
|
|
|
|
class _FakePlugin:
|
|
"""Minimal plugin double for engine query tests. Exposes the
|
|
methods engine.get_all_downloads / get_download_status /
|
|
cancel_download / clear_all_completed_downloads call."""
|
|
|
|
def __init__(self, name, configured=True, downloads=None,
|
|
cancel_result=True, clear_result=True):
|
|
self.name = name
|
|
self._configured = configured
|
|
self._downloads = downloads or []
|
|
self._cancel_result = cancel_result
|
|
self._clear_result = clear_result
|
|
self.cancel_calls = []
|
|
self.clear_calls = 0
|
|
|
|
def is_configured(self):
|
|
return self._configured
|
|
|
|
async def get_all_downloads(self):
|
|
return list(self._downloads)
|
|
|
|
async def get_download_status(self, download_id):
|
|
for d in self._downloads:
|
|
if getattr(d, 'id', None) == download_id:
|
|
return d
|
|
return None
|
|
|
|
async def cancel_download(self, download_id, source_hint, remove):
|
|
self.cancel_calls.append((download_id, source_hint, remove))
|
|
return self._cancel_result
|
|
|
|
async def clear_all_completed_downloads(self):
|
|
self.clear_calls += 1
|
|
return self._clear_result
|
|
|
|
|
|
class _FakeStatus:
|
|
def __init__(self, id, source):
|
|
self.id = id
|
|
self.source = source
|
|
|
|
|
|
def test_engine_get_all_downloads_aggregates_across_plugins():
|
|
"""Engine concatenates every plugin's get_all_downloads output —
|
|
same behavior as the legacy orchestrator."""
|
|
engine = DownloadEngine()
|
|
yt_plugin = _FakePlugin('youtube', downloads=[_FakeStatus('yt-1', 'youtube')])
|
|
td_plugin = _FakePlugin('tidal', downloads=[_FakeStatus('td-1', 'tidal'),
|
|
_FakeStatus('td-2', 'tidal')])
|
|
engine.register_plugin('youtube', yt_plugin)
|
|
engine.register_plugin('tidal', td_plugin)
|
|
|
|
result = _run_async(engine.get_all_downloads())
|
|
assert len(result) == 3
|
|
assert {r.id for r in result} == {'yt-1', 'td-1', 'td-2'}
|
|
|
|
|
|
def test_engine_get_all_downloads_swallows_per_plugin_exceptions():
|
|
"""One plugin throwing must NOT take down the whole list — same
|
|
defensive behavior as the legacy orchestrator (matched by
|
|
`try ... except: pass` on every iteration)."""
|
|
engine = DownloadEngine()
|
|
|
|
class _BrokenPlugin:
|
|
async def get_all_downloads(self):
|
|
raise RuntimeError("boom")
|
|
|
|
yt_plugin = _FakePlugin('youtube', downloads=[_FakeStatus('yt-1', 'youtube')])
|
|
engine.register_plugin('broken', _BrokenPlugin())
|
|
engine.register_plugin('youtube', yt_plugin)
|
|
|
|
result = _run_async(engine.get_all_downloads())
|
|
assert [r.id for r in result] == ['yt-1']
|
|
|
|
|
|
def test_engine_get_download_status_returns_first_match():
|
|
engine = DownloadEngine()
|
|
yt_plugin = _FakePlugin('youtube', downloads=[_FakeStatus('shared', 'youtube')])
|
|
td_plugin = _FakePlugin('tidal', downloads=[])
|
|
engine.register_plugin('youtube', yt_plugin)
|
|
engine.register_plugin('tidal', td_plugin)
|
|
|
|
result = _run_async(engine.get_download_status('shared'))
|
|
assert result is not None
|
|
assert result.id == 'shared'
|
|
|
|
|
|
def test_engine_cancel_routes_streaming_source_directly():
|
|
"""When source_hint is a known streaming-source name (not
|
|
'soulseek'), engine routes the cancel to that specific plugin
|
|
only — doesn't ask every other plugin first."""
|
|
engine = DownloadEngine()
|
|
yt_plugin = _FakePlugin('youtube')
|
|
td_plugin = _FakePlugin('tidal')
|
|
engine.register_plugin('youtube', yt_plugin)
|
|
engine.register_plugin('tidal', td_plugin)
|
|
|
|
_run_async(engine.cancel_download('dl-1', 'tidal', remove=False))
|
|
assert yt_plugin.cancel_calls == []
|
|
assert td_plugin.cancel_calls == [('dl-1', 'tidal', False)]
|
|
|
|
|
|
def test_engine_cancel_routes_unknown_source_hint_to_soulseek():
|
|
"""A username that's NOT in the plugin registry is a real
|
|
Soulseek peer name — route to the soulseek plugin."""
|
|
engine = DownloadEngine()
|
|
sl_plugin = _FakePlugin('soulseek')
|
|
yt_plugin = _FakePlugin('youtube')
|
|
engine.register_plugin('soulseek', sl_plugin)
|
|
engine.register_plugin('youtube', yt_plugin)
|
|
|
|
_run_async(engine.cancel_download('dl-1', 'random_peer_username', remove=False))
|
|
assert sl_plugin.cancel_calls == [('dl-1', 'random_peer_username', False)]
|
|
assert yt_plugin.cancel_calls == []
|
|
|
|
|
|
def test_engine_cancel_falls_back_to_iterating_all_plugins_without_hint():
|
|
"""No source hint → ask every plugin until one accepts the
|
|
cancel (returns True). Mirrors legacy orchestrator behavior."""
|
|
engine = DownloadEngine()
|
|
yt_plugin = _FakePlugin('youtube', cancel_result=False)
|
|
td_plugin = _FakePlugin('tidal', cancel_result=True)
|
|
engine.register_plugin('youtube', yt_plugin)
|
|
engine.register_plugin('tidal', td_plugin)
|
|
|
|
result = _run_async(engine.cancel_download('dl-1', None, remove=False))
|
|
assert result is True
|
|
# Both plugins were asked; tidal accepted.
|
|
assert len(yt_plugin.cancel_calls) == 1
|
|
assert len(td_plugin.cancel_calls) == 1
|
|
|
|
|
|
def test_engine_clear_all_skips_unconfigured_plugins():
|
|
"""Unconfigured plugins are silently skipped (no API call, no
|
|
error) — matches legacy orchestrator's defensive handling."""
|
|
engine = DownloadEngine()
|
|
configured = _FakePlugin('youtube', configured=True, clear_result=True)
|
|
unconfigured = _FakePlugin('tidal', configured=False)
|
|
engine.register_plugin('youtube', configured)
|
|
engine.register_plugin('tidal', unconfigured)
|
|
|
|
result = _run_async(engine.clear_all_completed_downloads())
|
|
assert result is True
|
|
assert configured.clear_calls == 1
|
|
assert unconfigured.clear_calls == 0
|
|
|
|
|
|
def test_engine_clear_all_returns_false_when_any_configured_plugin_fails():
|
|
engine = DownloadEngine()
|
|
failing = _FakePlugin('youtube', configured=True, clear_result=False)
|
|
engine.register_plugin('youtube', failing)
|
|
|
|
result = _run_async(engine.clear_all_completed_downloads())
|
|
assert result is False
|