';
info.items.forEach(function (item) {
var miss = item.missing || [];
+ _gapRows[item.folder] = item;
var seriesChecked = !!_ignSel.series[item.folder];
var picked = _ignSel.slots[item.folder] || [];
var chips = miss.map(function (sl) {
- var on = picked.indexOf(sl) !== -1 ? " checked" : "";
+ var on = seriesChecked || picked.indexOf(sl) !== -1 ? " checked" : "";
return '' +
'' +
- escHtml(t("Ganze Serie ignorieren", "Ignore whole series")) + " ' +
+ escHtml(t("Serie auswählen", "Select series")) + " " +
'' + escHtml(item.title) + " " +
- '' + miss.length + " " + escHtml(t("fehlend", "missing")) + " ' + miss.length + " " + escHtml(t("fehlend", "missing")) + " " +
+ '' +
+ escHtml(t("Lücken füllen", "Fill gaps")) + " " +
'' + escHtml(item.location) + " " +
'' + chips + "
";
@@ -828,7 +865,9 @@ function _incompleteTableHtml(info) {
'' +
escHtml(t("Auswahl leeren", "Clear selection")) + " " +
'' +
- escHtml(t("Auswahl ignorieren", "Ignore selected")) + " ";
+ escHtml(t("Auswahl ignorieren", "Ignore selected")) + "" +
+ '' +
+ escHtml(t("Auswahl herunterladen", "Download selected")) + " ";
return mh;
}
@@ -1148,17 +1187,40 @@ function _renderDuplicatesTable(info) {
// Ignore / restore actions
// ---------------------------------------------------------------
+function statsOpenGapFill(button) {
+ var row = _ignRowOf(button);
+ var item = row && _gapRows[row.dataset.folder];
+ if (item) window.openGapFill(item);
+}
+
+function statsDownloadSelectedGaps() {
+ var folders = new Set(Object.keys(_ignSel.series).concat(Object.keys(_ignSel.slots)));
+ var items = [];
+ folders.forEach(function (folder) {
+ var row = _gapRows[folder];
+ var slots = _ignSel.series[folder] || _ignSel.slots[folder];
+ if (row && slots && slots.length) items.push(Object.assign({}, row, { missing_slots: slots.slice() }));
+ });
+ window.openGapFillBatch(items, function (item) {
+ delete _ignSel.series[item.folder];
+ delete _ignSel.slots[item.folder];
+ delete _ignSel.titles[item.folder];
+ _updateIgnActions();
+ });
+}
+
function mediaIgnoreSelected() {
// Read from _ignSel, not the DOM: with pagination the checkboxes of every
// other page do not exist, so a DOM scan would drop those selections.
var items = {};
Object.keys(_ignSel.series).forEach(function (folder) {
- items[folder] = { folder: folder, title: _ignSel.titles[folder] || folder, all: true };
+ var slots = _ignSel.series[folder];
+ if (slots.length) items[folder] = { folder: folder, title: _ignSel.titles[folder] || folder, slots: slots.slice() };
});
Object.keys(_ignSel.slots).forEach(function (folder) {
var slots = _ignSel.slots[folder] || [];
if (!slots.length) return;
- if (items[folder] && items[folder].all) return; // whole series covers it
+ if (items[folder]) return;
items[folder] = { folder: folder, title: _ignSel.titles[folder] || folder, slots: slots.slice() };
});
@@ -1631,3 +1693,14 @@ function renderStats(data, container) {
// (mfLazyPanel, monitoring.html); the standalone page loads at once.
if (window.mfLazyPanel) window.mfLazyPanel("stats", function () { loadStats(); });
else loadStats();
+
+function openLinkedIncompleteModal() {
+ if (window.location.hash !== "#incomplete") return;
+ // The gap list has its own endpoint and also works with media stats disabled.
+ _modalView.incomplete.q = "";
+ switchIncompleteView("incomplete");
+ openIncompleteModal();
+}
+
+window.addEventListener("hashchange", openLinkedIncompleteModal);
+openLinkedIncompleteModal();
diff --git a/src/mediaforge/web/templates/_gap_fill_modal.html b/src/mediaforge/web/templates/_gap_fill_modal.html
new file mode 100644
index 0000000..9e4997f
--- /dev/null
+++ b/src/mediaforge/web/templates/_gap_fill_modal.html
@@ -0,0 +1,42 @@
+
+
+
×
+
+
+
+
+ {{ _('Source') }}
+ {{ _('Language') }}
+ {{ _('Provider') }}
+
+
+
+
+
+
+
+
+
×
+
+
+
+ {{ _('Language') }}
+ {{ _('Provider') }}
+
+
+
+
+
+
{{ _('Leave kids mode') }}
{% endif %}
{% include "shared_modals.html" %}
+{% include "_gap_fill_modal.html" %}
{# Same "Could be for you" Details button as above -- markup only needed
in the new_home layout. #}
{% if new_home %}{% include "mf_detail_modal.html" %}{% endif %}
{% endblock %} {% block scripts %}
+
+
+
{% if new_home %}
@@ -1309,4 +1314,4 @@ {{ _('Leave kids mode') }}
})();
{% endif %}
-{% endblock %}
\ No newline at end of file
+{% endblock %}
diff --git a/src/mediaforge/web/templates/monitoring.html b/src/mediaforge/web/templates/monitoring.html
index 17bd38c..c94b7f2 100644
--- a/src/mediaforge/web/templates/monitoring.html
+++ b/src/mediaforge/web/templates/monitoring.html
@@ -5,6 +5,8 @@
{{ t.label }}
{% endblock %}
{% block scripts %}
+{% include "_gap_fill_modal.html" %}
+
+
+
{# MFCharts must load before stats.js, which draws the Statistics panel. #}
+
+
+
{% endblock %}
diff --git a/tests/test_gap_downloads_node.cjs b/tests/test_gap_downloads_node.cjs
new file mode 100644
index 0000000..e4892c7
--- /dev/null
+++ b/tests/test_gap_downloads_node.cjs
@@ -0,0 +1,61 @@
+const test = require('node:test');
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const vm = require('node:vm');
+const code = fs.readFileSync('src/mediaforge/web/static/gap_downloads.js', 'utf8');
+function setup(fetch) {
+ const window = {t: (_, en) => en};
+ const context = {window, fetch, AbortController, DOMException, setTimeout, clearTimeout};
+ vm.runInNewContext(code, context);
+ return window.MFGapDownloads;
+}
+function ctx() { return {cancel: new AbortController()}; }
+function response(data, status = 200, type = 'application/json') {
+ return {ok: status < 400, status, headers: {get: () => type}, json: async () => data};
+}
+test('proxy errors report HTTP status without parsing HTML', async () => {
+ const api = setup(async () => ({ok: false, status: 502, headers: {get: () => 'text/html'}, json: () => { throw Error('invalid JSON'); }}));
+ await assert.rejects(api.request('/api/series?url=x', ctx()), /HTTP 502/);
+});
+test('successful searches are cached and failures are not', async () => {
+ let calls = 0;
+ const api = setup(async () => { calls++; return response({}, calls === 1 ? 503 : 200); });
+ await assert.rejects(api.request('/api/search', ctx(), {keyword:'Example'}));
+ await api.request('/api/search', ctx(), {keyword:'Example'});
+ await api.request('/api/search', ctx(), {keyword:'Example'});
+ assert.equal(calls, 2);
+});
+test('missing IMDb information falls back to an exact title', async () => {
+ const api = setup(async (url) => response(url === '/api/search' ? {results:[{title:'Example',url:'https://x'}]} : {imdb_id:''}));
+ const found = await api.find({title:'Example [imdbid-tt123]'}, ctx(), [{id:'x',label:'X'}]);
+ assert.equal(found.match, 0);
+});
+test('requests are limited and waiting requests can be cancelled', async () => {
+ let active = 0, max = 0;
+ const api = setup(async () => { active++; max = Math.max(active, max); await new Promise(r => setTimeout(r, 10)); active--; return response({}); });
+ await Promise.all(Array.from({length: 12}, (_, i) => api.request('/api/series?url=' + i, ctx())));
+ assert.equal(max, 3);
+ const cancelled = ctx(); cancelled.cancel.abort();
+ await assert.rejects(api.request('/api/series?url=x', cancelled), {name: 'AbortError'});
+});
+test('series selection sends missing slots instead of a permanent ignore', () => {
+ const stats = fs.readFileSync('src/mediaforge/web/static/stats.js', 'utf8');
+ const start = stats.indexOf('function mediaIgnoreSelected()');
+ const end = stats.indexOf('/** Restore one slot', start);
+ let payload;
+ const context = {_ignSel:{series:{folder:['S1E2','S2']},slots:{},titles:{folder:'Example'}}, _gapRows:{folder:{missing:['S1E2','S2']}}, fetch: (_, options) => { payload = JSON.parse(options.body); return {then: () => ({then: () => ({catch: () => {}})})}; }, Object};
+ vm.runInNewContext(stats.slice(start, end) + '\nmediaIgnoreSelected();', context);
+ assert.deepEqual(JSON.parse(JSON.stringify(payload.items)), [{folder:'folder',title:'Example',slots:['S1E2','S2']}]);
+});
+test('batch stops searching after a source matches', async () => {
+ const calls = [];
+ const api = setup(async (url, options) => {
+ calls.push([url, options && options.body]);
+ if (url === '/api/search') return response({results:[{title:'Example',url:'https://x'}]});
+ if (url.startsWith('/api/seasons')) return response({seasons:[{season_number:1,url:'https://x/s1'}]});
+ if (url.startsWith('/api/episodes')) return response({episodes:[{episode_number:2,url:'https://x/e2'}]});
+ return response({});
+ });
+ await api.prepare({title:'Example',missing:['S1E2']}, ctx(), [{id:'one',label:'One'},{id:'two',label:'Two'}]);
+ assert.equal(calls.filter(call => call[0] === '/api/search').length, 1);
+});
diff --git a/tests/test_home_gaps.py b/tests/test_home_gaps.py
new file mode 100644
index 0000000..b8ed542
--- /dev/null
+++ b/tests/test_home_gaps.py
@@ -0,0 +1,45 @@
+"""Gap payloads used by the home page's download dialog."""
+
+from mediaforge.web.routes.browse import _feed_gap_rows
+
+
+def test_gap_dialog_receives_more_than_twelve_slots(monkeypatch):
+ monkeypatch.setattr("mediaforge.web.db.get_media_ignores", lambda: {})
+ rows = _feed_gap_rows([{
+ "folder": "Example", "seasons": {"1": [{"episode": 20}]},
+ }])
+ assert len(rows[0]["missing"]) == 12
+ assert rows[0]["missing_slots"] == [f"S1E{n}" for n in range(1, 20)]
+ assert rows[0]["missing_count"] == 19
+
+
+def test_ignored_episode_in_missing_season_is_sent_to_dialog(monkeypatch):
+ monkeypatch.setattr("mediaforge.web.db.get_media_ignores", lambda: {
+ "example": {"slots": ["S1E2"]},
+ })
+ rows = _feed_gap_rows([{
+ "folder": "Example", "seasons": {"2": [{"episode": 1}]},
+ }])
+ assert rows[0]["missing_slots"] == ["S1"]
+ assert rows[0]["ignored_slots"] == ["S1E2"]
+
+
+def test_ignored_series_is_not_offered_for_gap_filling(monkeypatch):
+ monkeypatch.setattr("mediaforge.web.db.get_media_ignores", lambda: {
+ "example": {"slots": ["__all__"]},
+ })
+ assert not _feed_gap_rows([{
+ "folder": "Example", "seasons": {"1": [{"episode": 3}]},
+ }])
+
+
+def test_statistics_preserve_ignored_slots_for_missing_season_download(monkeypatch):
+ from mediaforge.web.routes import stats
+
+ monkeypatch.setattr(stats, "_active_library_cache", lambda cache: cache)
+ monkeypatch.setattr(stats, "get_media_ignores", lambda: {"example": {"slots": ["S1E2"]}})
+ result = stats._compute_media_stats({"test": {"data": {"titles": [{
+ "folder": "Example", "seasons": {"2": [{"episode": 1, "path": "test.mkv"}]},
+ }]}}})
+ assert result["incomplete"][0]["missing"] == ["S1"]
+ assert result["incomplete"][0]["ignored_slots"] == ["S1E2"]
diff --git a/tests/test_home_gaps_browser.py b/tests/test_home_gaps_browser.py
new file mode 100644
index 0000000..adb3dea
--- /dev/null
+++ b/tests/test_home_gaps_browser.py
@@ -0,0 +1,381 @@
+"""Opt-in browser checks: MEDIAFORGE_BROWSER_TESTS=1 pytest tests/test_home_gaps_browser.py.
+
+Uses Patchright's Chromium, or MEDIAFORGE_TEST_BROWSER for a local executable.
+All provider and queue requests are intercepted; no downloads are started.
+"""
+
+import json
+import os
+import re
+from pathlib import Path
+
+import pytest
+from jinja2 import Environment
+
+WEB = Path(__file__).resolve().parents[1] / "src/mediaforge/web"
+pytestmark = pytest.mark.skipif(
+ os.environ.get("MEDIAFORGE_BROWSER_TESTS") != "1",
+ reason="opt-in browser tests",
+)
+
+
+@pytest.fixture()
+def gap_page():
+ from patchright.sync_api import sync_playwright
+
+ downloads = []
+ responses = {
+ "/api/search/sources": {"sources": [{"id": "test", "label": "Test", "enabled": True}]},
+ "/api/settings/client": {},
+ "/api/search": {"results": [{"title": "Example", "url": "https://source.test/example"}]},
+ "/api/series": {"title": "Example", "imdb_id": "tt41298100"},
+ "/api/seasons": {"seasons": [
+ {"season_number": 1, "url": "https://source.test/s1"},
+ {"season_number": 2, "url": "https://source.test/s2"},
+ ]},
+ "/api/episodes": {"episodes": [
+ {"episode_number": 1, "url": "https://source.test/e1", "downloaded": True,
+ "languages": ["German Dub"]},
+ {"episode_number": 2, "url": "https://source.test/e2",
+ "languages": ["German Dub", "English Sub"]},
+ {"episode_number": 3, "url": "https://source.test/e3",
+ "languages": ["English Sub"]},
+ {"episode_number": 4, "url": "https://source.test/e4",
+ "languages": ["German Dub"]},
+ ]},
+ "/api/providers": {"providers": {"German Dub": ["VOE"], "English Sub": ["VOE"]}},
+ "/api/download": {"queue_id": 42},
+ }
+ template = (WEB / "templates/_gap_fill_modal.html").read_text(encoding="utf-8")
+ html = Environment().from_string(template).render(_=lambda s: s)
+ css = "\n".join((WEB / "static" / name).read_text(encoding="utf-8") for name in (
+ "variables.css", "base.css", "forms.css", "buttons.css",
+ "modals.css", "shared_modals.css", "home_gaps.css",
+ ))
+ with sync_playwright() as p:
+ executable = os.environ.get("MEDIAFORGE_TEST_BROWSER")
+ browser = p.chromium.launch(headless=True, executable_path=executable, timeout=15000)
+ page = browser.new_page(viewport={"width": 390, "height": 844})
+
+ def respond(route):
+ path = route.request.url.split("mediaforge.test", 1)[-1].split("?", 1)[0]
+ if path == "/":
+ route.fulfill(content_type="text/html", body=
+ 'Open ' + html)
+ return
+ if path not in responses:
+ route.fulfill(status=404, body="")
+ return
+ if path == "/api/download":
+ downloads.append(route.request.post_data_json)
+ body = responses[path]
+ if callable(body):
+ body = body(route.request)
+ route.fulfill(status=403 if body.get("error") else 200,
+ content_type="application/json", body=json.dumps(body))
+
+ page.route("**/*", respond)
+ page.goto("http://mediaforge.test/")
+ page.add_script_tag(content="""
+ window.t = (de, en) => de;
+ window.loadSearchSources = async () => [{id: 'test', label: 'Test', enabled: true}];
+ window.loadGeneralSettings = async () => ({});
+ window._sourceIsOn = s => s.enabled;
+ """)
+ for name in ("gap_downloads.js", "home_gaps.js", "gap_batch.js"):
+ page.add_script_tag(content=(WEB / "static" / name).read_text(encoding="utf-8"))
+ yield page, responses, downloads
+ browser.close()
+
+
+def open_gap(page, **overrides):
+ item = {"title": "Example", "missing_slots": ["S1E1", "S1E2", "S1E3"]}
+ item.update(overrides)
+ page.evaluate("item => window.openGapFill(item)", item, isolated_context=False)
+
+
+def test_click_queues_only_missing_episodes_in_selected_language(gap_page):
+ page, _, downloads = gap_page
+ open_gap(page)
+ assert page.locator("#gapFillEpisodes li").all_text_contents() == ["S1E2"]
+ page.locator("#gapFillSubmit").click()
+ page.wait_for_function("document.querySelector('#gapFillSubmit').textContent === 'Hinzugefügt'")
+ assert downloads == [{
+ "series_url": "https://source.test/example", "title": "Example",
+ "episodes": ["https://source.test/e2"], "language": "German Dub", "provider": "VOE",
+ }]
+ assert page.locator("#gapFillSubmit").is_disabled()
+
+
+def test_whole_season_respects_ignored_and_existing_episodes(gap_page):
+ page, _, _ = gap_page
+ open_gap(page, missing_slots=["S1"], ignored_slots=["S1E2"])
+ assert page.locator("#gapFillEpisodes li").all_text_contents() == ["S1E4"]
+
+
+def test_language_change_updates_episodes_before_queuing(gap_page):
+ page, _, downloads = gap_page
+ open_gap(page)
+ page.locator("#gapFillLanguage").select_option("English Sub")
+ page.wait_for_function("!document.querySelector('#gapFillSubmit').disabled")
+ assert page.locator("#gapFillEpisodes li").all_text_contents() == ["S1E2", "S1E3"]
+ page.locator("#gapFillSubmit").click()
+ page.wait_for_function("document.querySelector('#gapFillSubmit').textContent === 'Hinzugefügt'")
+ assert downloads[0]["episodes"] == ["https://source.test/e2", "https://source.test/e3"]
+
+
+def test_unrelated_search_result_requires_explicit_choice(gap_page):
+ page, responses, _ = gap_page
+ responses["/api/search"]["results"][0]["title"] = "Example sequel"
+ open_gap(page)
+ assert page.locator("#gapFillSource").input_value() == ""
+ assert page.locator("#gapFillSubmit").is_disabled()
+ page.locator("#gapFillSource").select_option("0")
+ page.wait_for_function("!document.querySelector('#gapFillSubmit').disabled")
+
+
+def test_different_release_year_is_not_automatically_selected(gap_page):
+ page, responses, _ = gap_page
+ responses["/api/search"]["results"][0]["title"] = "Example (1990)"
+ open_gap(page, title="Example (2020)")
+ assert page.locator("#gapFillSource").input_value() == ""
+ assert page.locator("#gapFillSubmit").is_disabled()
+
+
+@pytest.mark.parametrize("folder, expected", [
+ ("Reborn as a Space Mercenary I Woke Up Piloting the Strongest Starship! "
+ "(2026-2026) [imdbid-tt41298100]",
+ "Reborn as a Space Mercenary I Woke Up Piloting the Strongest Starship!"),
+ ("Example (2026) [imdbid-tt41298100]", "Example"),
+ ("Example (2020-2026) [tmdbid-1234] [tvdbid-5678]", "Example"),
+ ("Example (2020–2026) {imdb-tt41298100}", "Example"),
+ ("Example (2020-) [tmdb-1234]", "Example"),
+ ("Example [imdbid-tt41298100] (2026)", "Example"),
+ ("[Oshi no Ko] (2023-2026) [imdbid-tt21030032]", "[Oshi no Ko]"),
+ ("Example (The Animation) [imdbid-tt41298100]", "Example (The Animation)"),
+])
+def test_search_strips_library_metadata_and_preserves_display_title(gap_page, folder, expected):
+ page, responses, _ = gap_page
+ searches = []
+ page.on("request", lambda req: searches.append(req.post_data_json)
+ if req.url.endswith("/api/search") else None)
+ responses["/api/search"]["results"][0]["title"] = expected
+ match = re.search(r"tt\d+", folder)
+ if match:
+ responses["/api/series"]["imdb_id"] = match[0]
+ open_gap(page, title=folder)
+ assert searches == [{"keyword": expected, "site": "test"}]
+ assert page.locator("#gapFillTitle").inner_text() == "Lücken füllen: " + folder
+ assert page.locator("#gapFillSubmit").is_enabled()
+
+
+def test_alternative_provider_title_opens_matching_series_directly(gap_page):
+ page, responses, _ = gap_page
+ responses["/api/search"]["results"][0]["title"] = "Mezametara Saikyou"
+ open_gap(page, title="Reborn as a Space Mercenary (2026-2026) [imdbid-tt41298100]")
+ assert page.locator("#gapFillSource").input_value() == "0"
+ assert page.locator("#gapFillEpisodes li").all_text_contents() == ["S1E2"]
+ assert page.locator("#gapFillSubmit").is_enabled()
+
+
+def test_imdb_mismatch_is_not_overridden_by_equal_title(gap_page):
+ page, responses, _ = gap_page
+ responses["/api/series"]["imdb_id"] = "tt99999999"
+ open_gap(page, title="Example (2026) [imdbid-tt41298100]")
+ assert page.locator("#gapFillSource").input_value() == ""
+ assert page.locator("#gapFillSubmit").is_disabled()
+
+
+def test_verified_series_is_selected_instead_of_first_search_result(gap_page):
+ page, responses, _ = gap_page
+ responses["/api/search"]["results"] = [
+ {"title": "Example", "url": "https://source.test/wrong"},
+ {"title": "Alternative title", "url": "https://source.test/correct"},
+ ]
+ responses["/api/series"] = lambda req: {
+ "imdb_id": "tt41298100" if "correct" in req.url else "tt99999999",
+ }
+ open_gap(page, title="Example (2026) [imdbid-tt41298100]")
+ assert page.locator("#gapFillSource").input_value() == "1"
+ assert page.locator("#gapFillSubmit").is_enabled()
+
+
+def test_failed_episode_lookup_cannot_queue_partial_data(gap_page):
+ page, responses, downloads = gap_page
+ responses["/api/episodes"] = {"error": "Source unavailable"}
+ open_gap(page)
+ assert "Source unavailable" in page.locator("#gapFillStatus").inner_text()
+ assert page.locator("#gapFillSubmit").is_disabled()
+ assert not downloads
+
+
+def test_queue_refusal_stays_visible_and_does_not_claim_success(gap_page):
+ page, responses, downloads = gap_page
+ responses["/api/download"] = {"error": "not permitted"}
+ open_gap(page)
+ page.locator("#gapFillSubmit").click()
+ page.wait_for_function("document.querySelector('#gapFillStatus').textContent.includes('not permitted')")
+ assert len(downloads) == 1
+ assert page.locator("#gapFillSubmit").is_disabled()
+ assert page.locator("#gapFillClose").is_enabled()
+
+
+def test_escape_restores_focus_and_scroll(gap_page):
+ page, _, _ = gap_page
+ page.locator("#opener").focus()
+ open_gap(page)
+ assert page.evaluate("document.body.style.overflow") == "hidden"
+ page.keyboard.press("Escape")
+ assert page.locator("#gapFillOverlay").is_hidden()
+ assert page.evaluate("document.activeElement.id") == "opener"
+ assert page.evaluate("document.body.style.overflow") == ""
+
+
+def test_individual_episode_selection_queues_only_checked_episode(gap_page):
+ page, _, downloads = gap_page
+ open_gap(page)
+ page.locator("#gapFillLanguage").select_option("English Sub")
+ page.locator("#gapFillSubmit:enabled").wait_for()
+ page.locator("#gapFillEpisodes input").nth(1).uncheck()
+ assert page.locator("#gapFillSelectAll").evaluate("el => el.indeterminate")
+ page.locator("#gapFillSubmit").click()
+ page.wait_for_function("document.querySelectorAll('#gapFillEpisodes li').length === 1")
+ assert downloads[0]["episodes"] == ["https://source.test/e2"]
+ page.locator("#gapFillEpisodes input").check()
+ page.locator("#gapFillSubmit").click()
+ page.wait_for_function("document.querySelector('#gapFillSubmit').textContent === 'Hinzugefügt'")
+ assert downloads[1]["episodes"] == ["https://source.test/e3"]
+
+
+def test_all_missing_button_works_with_empty_individual_selection(gap_page):
+ page, _, downloads = gap_page
+ open_gap(page)
+ page.locator("#gapFillLanguage").select_option("English Sub")
+ page.locator("#gapFillSubmit:enabled").wait_for()
+ page.locator("#gapFillSelectAll").uncheck()
+ assert page.locator("#gapFillSubmit").is_disabled()
+ assert page.locator("#gapFillAllSubmit").is_enabled()
+ page.locator("#gapFillAllSubmit").click()
+ page.wait_for_function("document.querySelector('#gapFillSubmit').textContent === 'Hinzugefügt'")
+ assert downloads[0]["episodes"] == ["https://source.test/e2", "https://source.test/e3"]
+
+
+def batch_searches(responses):
+ responses["/api/search"] = lambda req: {"results": [{
+ "title": req.post_data_json["keyword"],
+ "url": "https://source.test/" + req.post_data_json["keyword"],
+ }]}
+
+
+def test_batch_queues_selected_slots_for_multiple_series(gap_page):
+ page, responses, downloads = gap_page
+ batch_searches(responses)
+ page.evaluate("""() => window.openGapFillBatch([
+ {title:'First', folder:'first', missing_slots:['S1E2']},
+ {title:'Second', folder:'second', missing_slots:['S1E4']}
+ ])""", isolated_context=False)
+ page.locator("#gapBatchSubmit:enabled").wait_for()
+ page.locator("#gapBatchSubmit").click()
+ page.wait_for_function("document.querySelector('#gapBatchSubmit').textContent === 'Abgeschlossen'")
+ assert [(d["title"], d["episodes"]) for d in downloads] == [
+ ("First", ["https://source.test/e2"]), ("Second", ["https://source.test/e4"]),
+ ]
+ assert all(d["language"] == "German Dub" and d["provider"] == "VOE" for d in downloads)
+
+
+def test_batch_language_must_cover_all_selected_episodes(gap_page):
+ page, responses, downloads = gap_page
+ batch_searches(responses)
+ page.evaluate("""() => window.openGapFillBatch([
+ {title:'First', folder:'first', missing_slots:['S1E2','S1E3']}
+ ])""", isolated_context=False)
+ assert page.locator("#gapBatchSubmit").is_disabled()
+ page.locator("#gapBatchLanguage").select_option("English Sub")
+ page.locator("#gapBatchSubmit:enabled").wait_for()
+ page.locator("#gapBatchSubmit").click()
+ page.wait_for_function("document.querySelector('#gapBatchSubmit').textContent === 'Abgeschlossen'")
+ assert downloads[0]["episodes"] == ["https://source.test/e2", "https://source.test/e3"]
+
+
+def test_batch_reports_partial_failure_and_only_clears_successful_series(gap_page):
+ page, responses, downloads = gap_page
+ batch_searches(responses)
+ responses["/api/download"] = lambda req: {"error": "not permitted"} if req.post_data_json["title"] == "Second" else {"queue_id": 42}
+ page.evaluate("""() => {
+ window.queuedFolders = [];
+ return window.openGapFillBatch([
+ {title:'First', folder:'first', missing_slots:['S1E2']},
+ {title:'Second', folder:'second', missing_slots:['S1E4']}
+ ], item => window.queuedFolders.push(item.folder));
+ }""", isolated_context=False)
+ page.locator("#gapBatchSubmit:enabled").wait_for()
+ page.locator("#gapBatchSubmit").click()
+ page.wait_for_function("document.querySelector('#gapBatchSubmit').textContent === 'Abgeschlossen'")
+ assert page.evaluate("window.queuedFolders", isolated_context=False) == ["first"]
+ assert "not permitted" in page.locator("#gapBatchEntries").inner_text()
+ assert "1 / 2" in page.locator("#gapBatchStatus").inner_text()
+ assert len(downloads) == 2
+
+
+def test_batch_does_not_silently_skip_an_unavailable_selected_slot(gap_page):
+ page, responses, downloads = gap_page
+ batch_searches(responses)
+ page.evaluate("""() => window.openGapFillBatch([
+ {title:'First', folder:'first', missing_slots:['S1E2','S1E9']}
+ ])""", isolated_context=False)
+ assert page.locator("#gapBatchSubmit").is_disabled()
+ assert "S1E9" in page.locator("#gapBatchEntries").inner_text()
+ assert not downloads
+
+
+def test_batch_requires_a_shared_provider(gap_page):
+ page, responses, downloads = gap_page
+ batch_searches(responses)
+ responses["/api/providers"] = lambda req: {"providers": {
+ "German Dub": ["VOE"] if "e2" in req.url else ["Filemoon"],
+ }}
+ page.evaluate("""() => window.openGapFillBatch([
+ {title:'First', folder:'first', missing_slots:['S1E2']},
+ {title:'Second', folder:'second', missing_slots:['S1E4']}
+ ])""", isolated_context=False)
+ assert page.locator("#gapBatchSubmit").is_disabled()
+ assert "Kein gemeinsamer Anbieter" in page.locator("#gapBatchStatus").inner_text()
+ assert not downloads
+
+
+def test_unmatched_series_can_be_removed_from_batch_without_guessing(gap_page):
+ page, responses, downloads = gap_page
+ responses["/api/search"] = lambda req: {"results": [{
+ "title": "First" if req.post_data_json["keyword"] == "First" else "Unrelated",
+ "url": "https://source.test/example",
+ }]}
+ page.evaluate("""() => window.openGapFillBatch([
+ {title:'First', folder:'first', missing_slots:['S1E2']},
+ {title:'Second', folder:'second', missing_slots:['S1E4']}
+ ])""", isolated_context=False)
+ assert page.locator("#gapBatchSubmit").is_disabled()
+ page.locator("#gapBatchEntries input").nth(1).uncheck()
+ page.locator("#gapBatchSubmit:enabled").wait_for()
+ page.locator("#gapBatchSubmit").click()
+ page.wait_for_function("document.querySelector('#gapBatchSubmit').textContent === 'Abgeschlossen'")
+ assert len(downloads) == 1
+ assert downloads[0]["title"] == "First"
+
+
+@pytest.mark.parametrize("width", [390, 1280])
+def test_dialog_fits_viewport_and_keeps_keyboard_focus(gap_page, width):
+ page, _, _ = gap_page
+ page.set_viewport_size({"width": width, "height": 844})
+ open_gap(page)
+ box = page.locator("#gapFillOverlay .gap-fill-modal").bounding_box()
+ assert box["x"] >= 0
+ assert box["x"] + box["width"] <= width
+ assert box["y"] >= 0
+ assert box["y"] + box["height"] <= 844
+ page.locator("#gapFillSubmit").focus()
+ page.keyboard.press("Tab")
+ assert page.evaluate("document.activeElement.id") == "gapFillClose"
+ output = os.environ.get("MEDIAFORGE_SCREENSHOT_DIR")
+ if output:
+ page.screenshot(path=str(Path(output) / f"gap-fill-{width}.png"))
diff --git a/tests/test_stats_gap_link_browser.py b/tests/test_stats_gap_link_browser.py
new file mode 100644
index 0000000..ff4e373
--- /dev/null
+++ b/tests/test_stats_gap_link_browser.py
@@ -0,0 +1,218 @@
+"""Opt-in browser tests for the dashboard's complete gap list."""
+
+import json
+import os
+from pathlib import Path
+from urllib.parse import parse_qs, urlparse
+
+import pytest
+from jinja2 import Environment
+
+WEB = Path(__file__).resolve().parents[1] / "src/mediaforge/web"
+pytestmark = pytest.mark.skipif(
+ os.environ.get("MEDIAFORGE_BROWSER_TESTS") != "1", reason="opt-in browser tests",
+)
+
+
+@pytest.fixture()
+def stats_page():
+ from patchright.sync_api import sync_playwright
+
+ body = Environment().from_string(
+ (WEB / "templates/_stats_body.html").read_text(encoding="utf-8") +
+ (WEB / "templates/_gap_fill_modal.html").read_text(encoding="utf-8"),
+ ).render(_=lambda s: s)
+ css = "\n".join((WEB / "static" / name).read_text(encoding="utf-8") for name in (
+ "variables.css", "base.css", "forms.css", "buttons.css", "cards.css",
+ "modals.css", "stats.css", "shared_modals.css", "home_gaps.css",
+ ))
+ # Omit media statistics deliberately: the direct link must not require them.
+ payload = {"general": {}, "queue": {}, "sync": {}}
+ items = [{"folder": f"series-{i}", "title": f"Series {i:02}", "location": "Test",
+ "missing": [f"S1E{n}" for n in range(1, 28)]} for i in range(25)]
+ requests = []
+ state = {"downloads": [], "ignored": [], "failures": set()}
+ with sync_playwright() as p:
+ browser = p.chromium.launch(
+ headless=True, executable_path=os.environ.get("MEDIAFORGE_TEST_BROWSER"),
+ timeout=15000,
+ )
+ page = browser.new_page()
+
+ def respond(route):
+ url = urlparse(route.request.url)
+ if url.path == "/stats":
+ route.fulfill(content_type="text/html", body=
+ '