' +
- tuning + checkbox + accuracyBadge(key) + fmtBadge(song) + overlay +
+ tuning + checkbox + accuracyBadge(key) + fmtBadge(song) + personalBadges(song) + overlay +
'
' +
inlineBtns +
'
' +
@@ -890,11 +905,13 @@
bar.innerHTML =
'
' + state.selected.size + ' selected' +
'
' +
+ '
' +
'
' +
'
';
bar.querySelector('[data-batch="clear"]').addEventListener('click', () => { state.selected.clear(); reload(); renderBatchBar(); });
bar.querySelector('[data-batch="saved"]').addEventListener('click', batchSave);
bar.querySelector('[data-batch="playlist"]').addEventListener('click', batchAddToPlaylist);
+ bar.querySelector('[data-batch="details"]').addEventListener('click', openBulkEdit);
}
async function batchSave() {
@@ -1044,6 +1061,94 @@
reload(); renderBatchBar();
}
+ // Bulk personal-meta editor (P2) — apply-to-all over the current selection via
+ // the batch endpoint (one request). Additive + mixed-state safe: difficulty
+ // defaults to "Leave" (each song keeps its own value); tags ADD/REMOVE rather
+ // than replace, so a bulk action never silently wipes per-song data. Notes are
+ // inherently per-song, so they're deliberately not bulk-editable.
+ function openBulkEdit() {
+ const fns = [...state.selected];
+ if (!fns.length) return;
+ // Tags present across the selection (from the embedded row payload) → one-tap
+ // removable chips, no extra fetch.
+ const present = new Set();
+ fns.forEach((fn) => ((state.songsById[fn] && state.songsById[fn].tags) || []).forEach((t) => present.add(t)));
+ const bulk = { diff: 'keep', add: [], remove: new Set() };
+ const norm = (raw) => String(raw || '').trim().toLowerCase().replace(/\s+/g, ' ').slice(0, 60);
+
+ const overlay = document.createElement('div');
+ overlay.className = 'fixed inset-0 z-[200] bg-black/60 backdrop-blur-sm flex items-center justify-center p-4';
+ const onKey = (e) => { if (e.key === 'Escape') { e.preventDefault(); done(); } };
+ function done() { overlay.remove(); document.removeEventListener('keydown', onKey); }
+ document.addEventListener('keydown', onKey);
+ overlay.addEventListener('click', (e) => { if (e.target === overlay) done(); });
+ document.body.appendChild(overlay);
+
+ function render() {
+ const diffBtn = (val, label) =>
+ '
';
+ const addChips = bulk.add.map((t) => '
' + esc(t) +
+ '').join('');
+ const rmChips = [...present].sort((a, b) => a.localeCompare(b)).map((t) =>
+ '
').join('');
+ const nothing = bulk.diff === 'keep' && !bulk.add.length && !bulk.remove.size;
+ overlay.innerHTML =
+ '
';
+
+ overlay.querySelectorAll('[data-bulk-x]').forEach((b) => b.addEventListener('click', done));
+ overlay.querySelectorAll('[data-bd]').forEach((b) => b.addEventListener('click', () => { bulk.diff = b.getAttribute('data-bd'); render(); }));
+ overlay.querySelectorAll('[data-badd-rm]').forEach((b) => b.addEventListener('click', () => { const t = b.getAttribute('data-badd-rm'); const i = bulk.add.indexOf(t); if (i >= 0) bulk.add.splice(i, 1); render(); }));
+ overlay.querySelectorAll('[data-brm]').forEach((b) => b.addEventListener('click', () => { const t = b.getAttribute('data-brm'); if (bulk.remove.has(t)) bulk.remove.delete(t); else bulk.remove.add(t); render(); }));
+ const addInput = overlay.querySelector('[data-badd-input]');
+ const addTag = () => { const t = norm(addInput && addInput.value); if (t && !bulk.add.includes(t)) { bulk.add.push(t); render(); overlay.querySelector('[data-badd-input]')?.focus(); } };
+ overlay.querySelector('[data-badd-btn]')?.addEventListener('click', addTag);
+ addInput?.addEventListener('keydown', (e) => { if (e.key === 'Enter') { e.preventDefault(); addTag(); } });
+ overlay.querySelector('[data-bulk-apply]')?.addEventListener('click', applyBulk);
+ }
+
+ async function applyBulk() {
+ const body = { filenames: fns };
+ if (bulk.diff === 'clear') body.set_difficulty = null;
+ else if (bulk.diff !== 'keep') body.set_difficulty = Number(bulk.diff);
+ if (bulk.add.length) body.add_tags = bulk.add;
+ if (bulk.remove.size) body.remove_tags = [...bulk.remove];
+ if (!('set_difficulty' in body) && !body.add_tags && !body.remove_tags) { done(); return; }
+ // jsend returns null on HTTP error / network failure — don't tear down the
+ // selection or reload as if it worked. Surface the failure and let the user retry.
+ const res = await jsend('POST', '/api/songs/user-meta/batch', body);
+ if (!res) {
+ if (window.fbNotify) { try { window.fbNotify.show({ title: 'Bulk edit failed', message: 'Could not save your changes. Please try again.', icon: '⚠️', accent: '#EF4444' }); } catch (e) { /* */ } }
+ return;
+ }
+ done();
+ finishBatch();
+ }
+
+ render();
+ overlay.querySelector('[data-badd-input]')?.focus();
+ }
+
async function jsend(method, url, body) {
try { const r = await fetch(url, { method, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }); return r.ok ? r.json() : null; } catch (e) { return null; }
}
@@ -1654,6 +1759,234 @@
function closeDrawer() { document.getElementById('v3-songs-drawer')?.classList.add('translate-x-full'); document.getElementById('v3-songs-overlay')?.classList.add('hidden'); updateFilterBadge(); }
function updateFilterBadge() { const b = document.getElementById('v3-songs-filter-count'); if (b) { const n = activeFilterCount(); b.textContent = n; b.classList.toggle('hidden', n === 0); } }
+ // ── Song Details drawer (P2) ───────────────────────────────────────────--
+ // Evolves the legacy edit-metadata modal into a v3 slide-in drawer that
+ // unifies catalog identity (writes back into the feedpak FILE), the personal
+ // practice layer (difficulty / tags / notes — local, never shared), the like
+ // heart, and remove-from-library. Reuses the filter-drawer slide idiom
+ // (fixed-right panel + overlay + translate-x-full) but is built on demand and
+ // body-appended, so it opens from any card context. The Charts drawer (P5d)
+ // reuses this pattern.
+ const DIFF_LABELS = ['', 'Very easy', 'Easy', 'Medium', 'Hard', 'Very hard'];
+ let _detailsEls = null; // {overlay, drawer, opener, onKey} while open
+
+ function closeDetails() {
+ if (!_detailsEls) return;
+ const { overlay, drawer, opener, onKey } = _detailsEls;
+ _detailsEls = null;
+ document.removeEventListener('keydown', onKey);
+ drawer.classList.add('translate-x-full');
+ overlay.classList.add('opacity-0');
+ setTimeout(() => { drawer.remove(); overlay.remove(); }, 200);
+ if (opener && document.body.contains(opener)) { try { opener.focus({ preventScroll: true }); } catch (_) { /* */ } }
+ }
+
+ async function openDetails(song) {
+ if (!song || !song.filename) return;
+ closeDetails();
+ const fn = song.filename;
+ const opener = document.activeElement;
+ // Notes aren't in the grid row payload; difficulty/tags are, but re-read
+ // for authority (another tab / a bulk edit may have changed them).
+ let meta = { user_difficulty: (song.user_difficulty != null ? song.user_difficulty : null), notes: '', tags: song.tags || [] };
+ try { const r = await fetch('/api/song/' + enc(fn) + '/user-meta'); if (r.ok) meta = await r.json(); } catch (_) { /* offline → row data */ }
+ let vocab = [];
+ try { const r = await fetch('/api/tags'); if (r.ok) vocab = (await r.json()).tags || []; } catch (_) { /* */ }
+ if (_detailsEls) closeDetails(); // a concurrent open resolved first
+
+ const st = {
+ t: song.title || '', a: song.artist || '', al: song.album || '', y: song.year != null ? String(song.year) : '',
+ diff: (meta.user_difficulty != null ? meta.user_difficulty : null),
+ notes: meta.notes || '', tags: (meta.tags || []).slice(),
+ fav: !!song.favorite, artDataUrl: null,
+ };
+
+ const overlay = document.createElement('div');
+ overlay.className = 'fixed inset-0 bg-black/50 z-[60] opacity-0 transition-opacity duration-200';
+ const drawer = document.createElement('aside');
+ drawer.id = 'v3-song-details-drawer';
+ drawer.className = 'fixed top-0 right-0 h-full w-full sm:w-[26rem] bg-fb-sidebar border-l border-fb-border/50 z-[61] transform translate-x-full transition-transform duration-200 overflow-y-auto v3-scroll';
+ drawer.setAttribute('role', 'dialog');
+ drawer.setAttribute('aria-modal', 'true');
+ drawer.setAttribute('aria-label', 'Song details');
+ document.body.appendChild(overlay);
+ document.body.appendChild(drawer);
+
+ const onKey = (e) => { if (e.key === 'Escape') { e.preventDefault(); closeDetails(); } };
+ document.addEventListener('keydown', onKey);
+ overlay.addEventListener('click', closeDetails);
+ _detailsEls = { overlay, drawer, opener, onKey };
+
+ const render = () => { drawer.innerHTML = detailsHtml(song, st, vocab); wireDetails(drawer, song, st, vocab, render); };
+ render();
+ requestAnimationFrame(() => { drawer.classList.remove('translate-x-full'); overlay.classList.remove('opacity-0'); });
+ if (window._trapFocusInModal) { try { window._trapFocusInModal(drawer); } catch (_) { /* */ } }
+ const first = drawer.querySelector('#det-title');
+ if (first) { try { first.focus({ preventScroll: true }); const n = first.value.length; first.setSelectionRange(n, n); } catch (_) { /* */ } }
+ }
+
+ function detailsHtml(song, st, vocab) {
+ const art = st.artDataUrl || artUrl(song);
+ const diffBtns = [1, 2, 3, 4, 5].map((n) =>
+ '
').join('');
+ const applied = new Set(st.tags);
+ const tagChips = st.tags.length
+ ? st.tags.map((t) => '
' + esc(t) +
+ '').join('')
+ : '
No tags yet';
+ const suggest = (vocab || []).filter((v) => !applied.has(v.tag)).slice(0, 8).map((v) =>
+ '
').join('');
+ const field = (id, label, val) =>
+ '
' +
+ '
';
+ return '
' +
+ '
Song details
' +
+ '' +
+
+ '
' +
+ '
' +
+ '
 + ')
' +
+ '
Change
' +
+ '
' +
+ '
' + esc(song.title || song.filename) + '
' +
+ '
' +
+ 'a like, not a rating
' +
+
+ // Identity — writes back into the feedpak FILE
+ '
' +
+
+ // Personal practice layer — local, never shared
+ '
Your practice · stays on this device
' +
+ '
' +
+ '
' +
+ '
' + diffBtns + '' + esc(st.diff ? DIFF_LABELS[st.diff] : 'Not set') + '
' +
+ '
' +
+ '
' + tagChips + '
' +
+ '
' +
+ '
' +
+ (suggest ? '
' + suggest + '
' : '') + '
' +
+ '
' +
+ '
' +
+
+ '
' +
+ '
' +
+ '
' +
+ '
';
+ }
+
+ function wireDetails(drawer, song, st, vocab, render) {
+ const $ = (s) => drawer.querySelector(s);
+ drawer.querySelectorAll('[data-det-close]').forEach((b) => b.addEventListener('click', closeDetails));
+ // Catalog inputs update state without a re-render (keep caret / focus).
+ const bindInput = (id, key) => { const el = $('#' + id); if (el) el.addEventListener('input', () => { st[key] = el.value; }); };
+ bindInput('det-title', 't'); bindInput('det-artist', 'a'); bindInput('det-album', 'al'); bindInput('det-year', 'y');
+ const notes = $('#det-notes'); if (notes) notes.addEventListener('input', () => { st.notes = notes.value; });
+
+ drawer.querySelectorAll('[data-diff]').forEach((b) => b.addEventListener('click', () => {
+ const n = Number(b.getAttribute('data-diff'));
+ st.diff = (st.diff === n ? null : n); // click the active one to unset
+ render();
+ }));
+ $('[data-diff-clear]')?.addEventListener('click', () => { st.diff = null; render(); });
+
+ drawer.querySelectorAll('[data-tag-rm]').forEach((b) => b.addEventListener('click', () => {
+ const t = b.getAttribute('data-tag-rm'); const i = st.tags.indexOf(t); if (i >= 0) st.tags.splice(i, 1); render();
+ }));
+ drawer.querySelectorAll('[data-tag-add]').forEach((b) => b.addEventListener('click', () => { if (addDetailTag(st, b.getAttribute('data-tag-add'))) render(); }));
+ const addFromInput = () => { const el = $('#det-tag-input'); if (!el) return; if (addDetailTag(st, el.value)) { render(); drawer.querySelector('#det-tag-input')?.focus(); } };
+ $('[data-tag-addbtn]')?.addEventListener('click', addFromInput);
+ $('#det-tag-input')?.addEventListener('keydown', (e) => { if (e.key === 'Enter') { e.preventDefault(); addFromInput(); } });
+
+ const artWrap = $('[data-det-art]'); const artFile = $('#det-art-file');
+ if (artWrap && artFile) {
+ artWrap.addEventListener('click', () => artFile.click());
+ artFile.addEventListener('change', () => {
+ const f = artFile.files && artFile.files[0]; if (!f) return;
+ const rd = new FileReader();
+ rd.onload = (e) => { st.artDataUrl = e.target.result; const img = $('#det-art-preview'); if (img) { img.src = st.artDataUrl; img.style.visibility = 'visible'; } };
+ rd.readAsDataURL(f);
+ });
+ }
+
+ $('[data-det-fav]')?.addEventListener('click', async (e) => {
+ try {
+ const r = await fetch('/api/favorites/toggle', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ filename: song.filename }) });
+ const d = await r.json(); st.fav = !!d.favorite;
+ const btn = e.currentTarget; btn.textContent = st.fav ? '♥ Liked' : '♡ Like';
+ btn.classList.toggle('text-fb-accent', st.fav); btn.classList.toggle('text-fb-textDim', !st.fav);
+ _patchCardFav(song.filename, st.fav);
+ } catch (_) { /* */ }
+ });
+
+ $('[data-det-save]')?.addEventListener('click', () => saveDetails(song, st));
+ $('[data-det-remove]')?.addEventListener('click', () => removeFromLibrary(song));
+ }
+
+ // Normalize + append a tag to the drawer's working set (mirrors the server's
+ // _normalize_tag). Returns whether it was actually added (new + non-blank).
+ function addDetailTag(st, raw) {
+ const t = String(raw || '').trim().toLowerCase().replace(/\s+/g, ' ').slice(0, 60);
+ if (!t || st.tags.includes(t)) return false;
+ st.tags.push(t); st.tags.sort((a, b) => a.localeCompare(b)); return true;
+ }
+
+ // Keep a rendered card's heart in sync when the drawer toggles the like (the
+ // heart is instant, not part of Save — matches the on-card heart).
+ function _patchCardFav(fn, fav) {
+ const sel = (window.CSS && CSS.escape) ? CSS.escape(fn) : fn;
+ document.querySelectorAll('[data-fn="' + sel + '"] [data-fav]').forEach((btn) => {
+ btn.textContent = fav ? '♥' : '♡';
+ btn.setAttribute('aria-pressed', fav ? 'true' : 'false');
+ btn.classList.toggle('text-fb-accent', fav); btn.classList.toggle('text-white', !fav);
+ });
+ }
+
+ async function saveDetails(song, st) {
+ const fn = song.filename;
+ const catChanged = st.t.trim() !== (song.title || '') || st.a.trim() !== (song.artist || '')
+ || st.al.trim() !== (song.album || '') || String(st.y).trim() !== (song.year != null ? String(song.year) : '');
+ const ops = [];
+ if (catChanged) ops.push(fetch('/api/song/' + enc(fn) + '/meta', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ title: st.t.trim(), artist: st.a.trim(), album: st.al.trim(), year: String(st.y).trim() }) }));
+ ops.push(fetch('/api/song/' + enc(fn) + '/user-meta', { method: 'PUT', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ user_difficulty: st.diff, notes: st.notes, tags: st.tags }) }));
+ if (st.artDataUrl) ops.push(fetch('/api/song/' + enc(fn) + '/art/upload', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ image: st.artDataUrl }) }));
+ // Fire the writes concurrently but know each outcome — a failed write must not
+ // look like a save. allSettled keeps partial results; treat a rejection OR a
+ // non-ok HTTP response as failure and keep the drawer open so the user can retry.
+ const results = await Promise.allSettled(ops);
+ const failed = results.some((r) => r.status === 'rejected' || (r.value && r.value.ok === false));
+ if (failed) {
+ if (window.fbNotify) { try { window.fbNotify.show({ title: 'Save failed', message: 'Could not save your changes. Please try again.', icon: '⚠️', accent: '#EF4444' }); } catch (e) { /* */ } }
+ return;
+ }
+ closeDetails();
+ try { reload(); } catch (_) { /* not on the songs grid */ }
+ }
+
+ async function removeFromLibrary(song) {
+ const title = song.title || song.filename;
+ let ok;
+ if (window._confirmDialog) {
+ ok = await window._confirmDialog({
+ title: 'Remove from library?',
+ body: '
Remove ' + esc(title) + ' from your library?
' +
+ '
This permanently deletes the file from disk. This cannot be undone.
',
+ confirmText: 'Remove', cancelText: 'Cancel', danger: true,
+ });
+ } else { ok = window.confirm('Remove "' + title + '" from your library? This deletes the file from disk.'); }
+ if (!ok) return;
+ try { const r = await fetch('/api/song/' + enc(song.filename), { method: 'DELETE' }); if (!r.ok) return; } catch (_) { return; }
+ closeDetails();
+ try { reload(); } catch (_) { /* */ }
+ }
+
+ // Expose the opener so the core `edit-metadata` card action opens this drawer
+ // (it falls back to the legacy modal where this isn't defined).
+ window.__fbOpenSongDetails = openDetails;
+
// The host loads the Folder Library plugin's screen.js at startup (defining
// window.folderLibrary). If it isn't present yet, inject it once; the
// plugin's IIFEs are idempotent so a redundant evaluation is a no-op. The
diff --git a/tests/test_batch_user_meta.py b/tests/test_batch_user_meta.py
new file mode 100644
index 0000000..f67f70b
--- /dev/null
+++ b/tests/test_batch_user_meta.py
@@ -0,0 +1,152 @@
+"""Tests for the bulk personal-meta endpoint (P2):
+POST /api/songs/user-meta/batch — the apply-to-all behind the Songs batch bar.
+DB-only, never touches files. Additive by design: bulk tag edits ADD/REMOVE
+(never full-replace) and an omitted `set_difficulty` leaves each song's own
+value alone (mixed-state "leave unchanged")."""
+
+import importlib
+import sys
+
+import pytest
+from fastapi.testclient import TestClient
+
+
+@pytest.fixture()
+def server(tmp_path, monkeypatch, isolate_logging):
+ monkeypatch.setenv("CONFIG_DIR", str(tmp_path))
+ monkeypatch.setenv("FEEDBACK_SKIP_STARTUP_TASKS", "1")
+ sys.modules.pop("server", None)
+ srv = importlib.import_module("server")
+ try:
+ yield srv
+ finally:
+ conn = getattr(getattr(srv, "meta_db", None), "conn", None)
+ if conn is not None:
+ conn.close()
+ sys.modules.pop("server", None)
+
+
+@pytest.fixture()
+def client(server):
+ return TestClient(server.app)
+
+
+def _seed(server, *filenames):
+ for fn in filenames:
+ server.meta_db.put(fn, 0, 0, {"title": fn.split(".")[0], "artist": "A"})
+
+
+def _um(client, fn):
+ return client.get(f"/api/song/{fn}/user-meta").json()
+
+
+BATCH = "/api/songs/user-meta/batch"
+
+
+# ── Difficulty across a selection ────────────────────────────────────────────
+
+def test_batch_set_difficulty_on_all(client, server):
+ _seed(server, "a.archive", "b.archive", "c.archive")
+ r = client.post(BATCH, json={"filenames": ["a.archive", "b.archive"],
+ "set_difficulty": 4})
+ assert r.status_code == 200
+ assert r.json()["updated"] == 2
+ assert _um(client, "a.archive")["user_difficulty"] == 4
+ assert _um(client, "b.archive")["user_difficulty"] == 4
+ # untouched song stays unset
+ assert _um(client, "c.archive")["user_difficulty"] is None
+
+
+def test_batch_clear_difficulty_preserves_notes(client, server):
+ _seed(server, "a.archive", "b.archive")
+ client.put("/api/song/a.archive/user-meta", json={"user_difficulty": 3, "notes": "keep me"})
+ client.put("/api/song/b.archive/user-meta", json={"user_difficulty": 2})
+ r = client.post(BATCH, json={"filenames": ["a.archive", "b.archive"],
+ "set_difficulty": None})
+ assert r.status_code == 200
+ # a still has its notes; b (no notes) is fully cleared
+ a = _um(client, "a.archive")
+ assert a["user_difficulty"] is None and a["notes"] == "keep me"
+ assert _um(client, "b.archive") == {"user_difficulty": None, "notes": "", "tags": []}
+
+
+def test_omitting_set_difficulty_leaves_each_value(client, server):
+ """Mixed-state: no set_difficulty key → every song keeps its own difficulty
+ while tags still apply."""
+ _seed(server, "a.archive", "b.archive")
+ client.put("/api/song/a.archive/user-meta", json={"user_difficulty": 1})
+ client.put("/api/song/b.archive/user-meta", json={"user_difficulty": 5})
+ client.post(BATCH, json={"filenames": ["a.archive", "b.archive"],
+ "add_tags": ["gig"]})
+ assert _um(client, "a.archive")["user_difficulty"] == 1
+ assert _um(client, "b.archive")["user_difficulty"] == 5
+ assert _um(client, "a.archive")["tags"] == ["gig"]
+
+
+# ── Tags: additive, never full-replace ───────────────────────────────────────
+
+def test_batch_add_tags_does_not_clobber_existing(client, server):
+ _seed(server, "a.archive", "b.archive")
+ client.put("/api/song/a.archive/user-meta", json={"tags": ["existing"]})
+ client.post(BATCH, json={"filenames": ["a.archive", "b.archive"],
+ "add_tags": ["Warm-ups", "warm-ups"]}) # dupe-folds
+ assert _um(client, "a.archive")["tags"] == ["existing", "warm-ups"]
+ assert _um(client, "b.archive")["tags"] == ["warm-ups"]
+
+
+def test_batch_remove_tags(client, server):
+ _seed(server, "a.archive", "b.archive")
+ client.put("/api/song/a.archive/user-meta", json={"tags": ["gig", "riffs"]})
+ client.put("/api/song/b.archive/user-meta", json={"tags": ["gig"]})
+ client.post(BATCH, json={"filenames": ["a.archive", "b.archive"],
+ "remove_tags": ["gig"]})
+ assert _um(client, "a.archive")["tags"] == ["riffs"]
+ assert _um(client, "b.archive")["tags"] == []
+
+
+def test_add_wins_over_remove_conflict(client, server):
+ _seed(server, "a.archive")
+ client.post(BATCH, json={"filenames": ["a.archive"],
+ "add_tags": ["keep"], "remove_tags": ["keep"]})
+ assert _um(client, "a.archive")["tags"] == ["keep"]
+
+
+def test_returned_tag_vocabulary_refreshes(client, server):
+ _seed(server, "a.archive", "b.archive")
+ body = client.post(BATCH, json={"filenames": ["a.archive", "b.archive"],
+ "add_tags": ["warmups"]}).json()
+ assert {"tag": "warmups", "count": 2} in body["tags"]
+
+
+# ── Validation ───────────────────────────────────────────────────────────────
+
+def test_empty_filenames_is_400(client, server):
+ assert client.post(BATCH, json={"filenames": [], "set_difficulty": 3}).status_code == 400
+ assert client.post(BATCH, json={"set_difficulty": 3}).status_code == 400
+
+
+def test_nothing_to_apply_is_400(client, server):
+ _seed(server, "a.archive")
+ assert client.post(BATCH, json={"filenames": ["a.archive"]}).status_code == 400
+
+
+@pytest.mark.parametrize("bad", [0, 6, 2.5, "x", True])
+def test_bad_set_difficulty_is_400(client, server, bad):
+ _seed(server, "a.archive")
+ assert client.post(BATCH, json={"filenames": ["a.archive"],
+ "set_difficulty": bad}).status_code == 400
+
+
+def test_tags_must_be_arrays(client, server):
+ _seed(server, "a.archive")
+ assert client.post(BATCH, json={"filenames": ["a.archive"],
+ "add_tags": "gig"}).status_code == 400
+
+
+def test_batch_survives_rescan(client, server):
+ _seed(server, "a.archive")
+ client.post(BATCH, json={"filenames": ["a.archive"],
+ "set_difficulty": 3, "add_tags": ["t"]})
+ server.meta_db.put("a.archive", 1, 1, {"title": "a", "artist": "A"})
+ m = _um(client, "a.archive")
+ assert m["user_difficulty"] == 3 and m["tags"] == ["t"]