mirror of
https://github.com/got-feedBack/feedBack.git
synced 2026-10-02 19:21:50 +00:00
df4e17bc99
* feat(v3): flag library songs by working-tuning match (working-tuning PR 6) Each song's tuning chip in the v3 library grid is now coloured by whether your CURRENT working tuning covers it: green = play it now, amber = needs a retune (with a matching tooltip). Uses the tuner plugin's coverageReport (async), so it runs as a post-paint decoration pass — chips render instantly, then colour a tick later; a token cancels a superseded pass so scrolling stays snappy. Re-flags on working-tuning-changed (retune / instrument swap / reset), no re-fetch. Fully feature-detected: without the tuner coverage API + the host workingTuning state, the chips render exactly as before. v3-only, single file (static/v3/songs.js). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01QbexxfTt8q2tAn436MqGWF * fix(tuner/library): correct bass matching + memoize player tuning (PR #668 review) Review fixes for working-tuning PR 6 (library tuning-match chips): - Bass songs were scored against the guitar tuning. The chip passed no arrangement to coverageReport, so isBassArrangement fell back to guitar — a 4-string bass drop-D read as guitar could FALSE-MATCH a drop-D guitar player (green). songCard now flags a bass-only song (every arrangement name matches /\bbass\b/) with data-tuning-bass, and decorateTuningChips passes arrangement 'Bass'/'Lead' so coverage uses the right base pitches. Mixed guitar+bass songs → guitar (the song-level tuning is the guitar one); least-wrong given one tuning per song. - Per-chip /api/settings fetch storm. coverageReport()→_playerTuning() fetched /api/settings once per visible chip per grid paint (~60). _playerTuning is now memoized (the player's tuning is song-independent) so all callers share one read; invalidated on instrument:changed / working-tuning-changed, with a 3s TTL so a settings write that doesn't emit an event still heals. A transient fetch failure is NOT cached (next read retries) — else one hiccup would freeze coverage. Tests: player tuning shared across songs (one fetch); transient-failure retry (fails without the fix). The prior #680 dedup test updated for the memoized behavior. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com> Co-authored-by: byrongamatos <xasiklas@gmail.com>
634 lines
29 KiB
JavaScript
634 lines
29 KiB
JavaScript
'use strict';
|
||
|
||
const { test } = require('node:test');
|
||
const assert = require('node:assert/strict');
|
||
const fs = require('node:fs');
|
||
const path = require('node:path');
|
||
const vm = require('node:vm');
|
||
|
||
const APP_JS = path.join(__dirname, '..', '..', 'static', 'app.js');
|
||
const TUNER_SCREEN_JS = path.join(__dirname, '..', '..', 'plugins', 'tuner', 'screen.js');
|
||
const TUNING_UTILS_JS = path.join(__dirname, '..', '..', 'plugins', 'tuner', 'utils', 'tuning-utils.js');
|
||
|
||
function loadTuningHelpers() {
|
||
const src = fs.readFileSync(APP_JS, 'utf8');
|
||
const start = src.indexOf('function isBassArrangement(');
|
||
const endMarker = 'window.feedBack.parseRawTuningOffsets = parseRawTuningOffsets;';
|
||
const end = src.indexOf(endMarker);
|
||
if (start === -1 || end === -1) throw new Error('tuning helper block not found in app.js');
|
||
const sandbox = { window: { feedBack: {} }, exports: {} };
|
||
vm.createContext(sandbox);
|
||
vm.runInContext(
|
||
src.slice(start, end + endMarker.length),
|
||
sandbox
|
||
);
|
||
return sandbox.window.feedBack;
|
||
}
|
||
|
||
const feedBackHelpers = loadTuningHelpers();
|
||
|
||
function createTunerSandbox(opts) {
|
||
// Auto-open is opt-in (default off in prod). The sandbox defaults it ON so the
|
||
// behaviour tests exercise the feature; pass { autoOpen: false } to gate it off.
|
||
const autoOpen = !opts || opts.autoOpen !== false;
|
||
// The player's physical instrument for the §4 coverage check (core /api/settings).
|
||
// Absent → the endpoint reports not-ok → coverage stays conservative (can't
|
||
// decide → don't suppress the prompt), preserving the pre-coverage behaviour.
|
||
const playerSettings = (opts && opts.player) || null;
|
||
const enableCalls = [];
|
||
let playerActive = true;
|
||
let songInfo = null;
|
||
|
||
const sandbox = {
|
||
console,
|
||
Promise,
|
||
queueMicrotask,
|
||
setTimeout(fn) { fn(); return 0; },
|
||
clearTimeout() {},
|
||
fetch(url) {
|
||
const _u = String(url);
|
||
if (_u.includes('/api/settings')) {
|
||
return Promise.resolve(playerSettings
|
||
? { ok: true, json: () => Promise.resolve(playerSettings) }
|
||
: { ok: false, json: () => Promise.resolve({}) });
|
||
}
|
||
if (_u.includes('/config')) {
|
||
return Promise.resolve({
|
||
json: () => Promise.resolve({
|
||
showFloatingButton: true,
|
||
visualizationMode: 'default',
|
||
audioInputMode: 'auto',
|
||
autoOpenOnTuningChange: autoOpen,
|
||
lastInstrument: 'guitar-6',
|
||
lastTuning: 'Standard',
|
||
freeTune: false,
|
||
disabledTunings: [],
|
||
customTunings: {},
|
||
}),
|
||
});
|
||
}
|
||
return Promise.resolve({
|
||
json: () => Promise.resolve({
|
||
tunings: { 'guitar-6': { Standard: [82.41, 110, 146.83, 196, 246.94, 329.63] } },
|
||
referencePitch: 440,
|
||
}),
|
||
});
|
||
},
|
||
localStorage: {
|
||
getItem: () => null,
|
||
setItem() {},
|
||
},
|
||
document: {
|
||
getElementById(id) {
|
||
if (id === 'player') {
|
||
return { classList: { contains: () => playerActive } };
|
||
}
|
||
if (id === 'v3-tuner-wrap') return null;
|
||
return null;
|
||
},
|
||
querySelector() { return null; },
|
||
createElement(tag) {
|
||
const el = {
|
||
tagName: tag.toUpperCase(),
|
||
src: '',
|
||
classList: { add() {}, remove() {}, contains: () => false },
|
||
className: '',
|
||
style: {},
|
||
appendChild() {},
|
||
remove() {},
|
||
addEventListener() {},
|
||
removeEventListener() {},
|
||
querySelector: () => null,
|
||
setAttribute() {},
|
||
onload: null,
|
||
onerror: null,
|
||
};
|
||
if (tag === 'script') {
|
||
queueMicrotask(() => { if (el.onload) el.onload(); });
|
||
}
|
||
return el;
|
||
},
|
||
head: { appendChild() {} },
|
||
body: { appendChild() {} },
|
||
addEventListener() {},
|
||
removeEventListener() {},
|
||
},
|
||
__setPlayerActive(v) { playerActive = v; },
|
||
__setSongInfo(info) {
|
||
songInfo = info;
|
||
sandbox.window.feedBack.currentSong = info ? {
|
||
filename: info.filename || 'song.sloppak',
|
||
arrangementIndex: info.arrangement_index,
|
||
tuning: info.tuning,
|
||
} : null;
|
||
},
|
||
__enableCalls: enableCalls,
|
||
};
|
||
|
||
sandbox.window = sandbox;
|
||
sandbox.window.feedBack = {
|
||
...feedBackHelpers,
|
||
on() {},
|
||
off() {},
|
||
currentSong: null,
|
||
};
|
||
sandbox.window.highway = {
|
||
getSongInfo: () => songInfo,
|
||
};
|
||
// _tunerUtils comes from the REAL tuning-utils.js (loaded into the sandbox
|
||
// below) so the §4 coverage check runs real pitch math, not stubbed values.
|
||
sandbox.window._tunerUI = () => ({
|
||
addButton() {},
|
||
initUI() {},
|
||
renderInstrumentOptions() {},
|
||
renderTuningOptions() {},
|
||
renderStringNotes() {},
|
||
updateSaveAsCustomVisibility() {},
|
||
updateFreeTuneUI() {},
|
||
updateFloatingButton() {},
|
||
updatePlayerButton() {},
|
||
updateFloatingButtonVisibility() {},
|
||
updateInstrumentDisplay() {},
|
||
positionPanel() {},
|
||
updateUI() {},
|
||
});
|
||
sandbox.window._tunerAudio = {
|
||
start: async () => {},
|
||
stop() {},
|
||
restart: async () => {},
|
||
};
|
||
sandbox.window._tunerViz_default = () => ({
|
||
update() {},
|
||
destroy() {},
|
||
});
|
||
|
||
vm.createContext(sandbox);
|
||
vm.runInContext(fs.readFileSync(TUNING_UTILS_JS, 'utf8'), sandbox);
|
||
vm.runInContext(fs.readFileSync(TUNER_SCREEN_JS, 'utf8'), sandbox);
|
||
|
||
const realEnable = sandbox.window.tuner.enable.bind(sandbox.window.tuner);
|
||
sandbox.window.tuner.enable = async (enableOpts) => {
|
||
enableCalls.push(enableOpts || {});
|
||
return realEnable(enableOpts);
|
||
};
|
||
|
||
return sandbox;
|
||
}
|
||
|
||
const CUSTOM_GUITAR = {
|
||
filename: 'amnesia.sloppak',
|
||
arrangement: 'Lead',
|
||
arrangement_index: 0,
|
||
stringCount: 6,
|
||
tuning: [-2, 0, 0, 0, -2, -2],
|
||
};
|
||
|
||
const E_STANDARD = {
|
||
filename: 'standard.sloppak',
|
||
arrangement: 'Lead',
|
||
arrangement_index: 0,
|
||
stringCount: 6,
|
||
tuning: [0, 0, 0, 0, 0, 0],
|
||
};
|
||
|
||
const DROP_D = {
|
||
filename: 'dropd.sloppak',
|
||
arrangement: 'Lead',
|
||
arrangement_index: 0,
|
||
stringCount: 6,
|
||
tuning: [-2, 0, 0, 0, 0, 0],
|
||
};
|
||
|
||
const BASS_EADG = {
|
||
filename: 'bass.sloppak',
|
||
arrangement: 'Bass',
|
||
arrangement_index: 0,
|
||
stringCount: 4,
|
||
tuning: [0, 0, 0, 0],
|
||
};
|
||
|
||
async function ready(sandbox, song) {
|
||
sandbox.__setSongInfo(song);
|
||
await sandbox.window._tunerAutoOpen.maybeAutoOpenOnTuningChange();
|
||
}
|
||
|
||
test('tuning identity: same effective tuning returns same key', () => {
|
||
const sandbox = createTunerSandbox();
|
||
const key = sandbox.window._tunerAutoOpen.tuningIdentityKey(CUSTOM_GUITAR);
|
||
assert.equal(key, sandbox.window._tunerAutoOpen.tuningIdentityKey({ ...CUSTOM_GUITAR }));
|
||
assert.match(key, /^g:6:-2,0,0,0,-2,-2$/);
|
||
});
|
||
|
||
test('tuning identity: DADGAD custom vs E Standard differ', () => {
|
||
const sandbox = createTunerSandbox();
|
||
const custom = sandbox.window._tunerAutoOpen.tuningIdentityKey(CUSTOM_GUITAR);
|
||
const standard = sandbox.window._tunerAutoOpen.tuningIdentityKey(E_STANDARD);
|
||
assert.notEqual(custom, standard);
|
||
});
|
||
|
||
test('tuning identity: E Standard vs Drop D differ', () => {
|
||
const sandbox = createTunerSandbox();
|
||
const standard = sandbox.window._tunerAutoOpen.tuningIdentityKey(E_STANDARD);
|
||
const dropD = sandbox.window._tunerAutoOpen.tuningIdentityKey(DROP_D);
|
||
assert.notEqual(standard, dropD);
|
||
});
|
||
|
||
test('tuning identity: bass 4-string vs guitar 6-string differ', () => {
|
||
const sandbox = createTunerSandbox();
|
||
const bass = sandbox.window._tunerAutoOpen.tuningIdentityKey(BASS_EADG);
|
||
const guitar = sandbox.window._tunerAutoOpen.tuningIdentityKey({
|
||
...BASS_EADG,
|
||
arrangement: 'Lead',
|
||
stringCount: 6,
|
||
tuning: [0, 0, 0, 0, 0, 0],
|
||
});
|
||
assert.notEqual(bass, guitar);
|
||
assert.match(bass, /^b:4:/);
|
||
assert.match(guitar, /^g:6:/);
|
||
});
|
||
|
||
test('tuning identity: missing tuning returns null', () => {
|
||
const sandbox = createTunerSandbox();
|
||
assert.equal(sandbox.window._tunerAutoOpen.tuningIdentityKey(null), null);
|
||
assert.equal(sandbox.window._tunerAutoOpen.tuningIdentityKey({ tuning: [] }), null);
|
||
});
|
||
|
||
test('first song load sets lastTuningKey but does not auto-open', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, E_STANDARD);
|
||
assert.equal(sandbox.__enableCalls.length, 0);
|
||
assert.equal(sandbox.window._tunerAutoOpen.getState().lastTuningKey, 'g:6:0,0,0,0,0,0');
|
||
});
|
||
|
||
test('custom tuning then E Standard triggers one auto-open', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, CUSTOM_GUITAR);
|
||
await ready(sandbox, E_STANDARD);
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
});
|
||
|
||
test('E Standard then Drop D triggers one auto-open', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, E_STANDARD);
|
||
await ready(sandbox, DROP_D);
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
});
|
||
|
||
test('same tuning twice does not auto-open', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, E_STANDARD);
|
||
await ready(sandbox, { ...E_STANDARD, filename: 'other.sloppak' });
|
||
assert.equal(sandbox.__enableCalls.length, 0);
|
||
});
|
||
|
||
test('duplicate song:ready for same tuning does not auto-open repeatedly', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, CUSTOM_GUITAR);
|
||
await ready(sandbox, E_STANDARD);
|
||
await ready(sandbox, E_STANDARD);
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
});
|
||
|
||
test('if tuner already enabled, no duplicate enable call', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, CUSTOM_GUITAR);
|
||
sandbox.window._tunerAutoOpen.setEnabledForTests(true);
|
||
const before = sandbox.__enableCalls.length;
|
||
await ready(sandbox, E_STANDARD);
|
||
assert.equal(sandbox.__enableCalls.length, before);
|
||
});
|
||
|
||
test('user dismiss prevents reopen for same session', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, CUSTOM_GUITAR);
|
||
await ready(sandbox, { ...E_STANDARD, filename: 'amnesia.sloppak', arrangement_index: 0 });
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
sandbox.window._tunerAutoOpen.setEnabledForTests(true);
|
||
sandbox.window.tuner.disable();
|
||
await ready(sandbox, { ...DROP_D, filename: 'amnesia.sloppak', arrangement_index: 0 });
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
});
|
||
|
||
test('song:loading clears dismiss state for next load', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, CUSTOM_GUITAR);
|
||
await ready(sandbox, E_STANDARD);
|
||
sandbox.window.tuner.disable();
|
||
sandbox.window._tunerAutoOpen.onSongLoading();
|
||
await ready(sandbox, DROP_D);
|
||
assert.equal(sandbox.__enableCalls.length, 2);
|
||
});
|
||
|
||
test('auto-open is gated off when the setting is disabled (opt-in)', async () => {
|
||
const sandbox = createTunerSandbox({ autoOpen: false });
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, CUSTOM_GUITAR);
|
||
await ready(sandbox, E_STANDARD); // a real tuning change, but the setting is off
|
||
assert.equal(sandbox.__enableCalls.length, 0);
|
||
});
|
||
|
||
test('auto-open enables in persist mode (passes { auto: true })', async () => {
|
||
const sandbox = createTunerSandbox();
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, CUSTOM_GUITAR);
|
||
await ready(sandbox, E_STANDARD);
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
assert.equal(sandbox.__enableCalls[0].auto, true);
|
||
});
|
||
|
||
test('persist: an auto-opened tuner is not torn down by autoplay / stray clicks', () => {
|
||
const screenSrc = fs.readFileSync(TUNER_SCREEN_JS, 'utf8');
|
||
const uiSrc = fs.readFileSync(
|
||
path.join(__dirname, '..', '..', 'plugins', 'tuner', 'utils', 'ui.js'), 'utf8');
|
||
// The gate is opt-in on the server config flag.
|
||
assert.match(screenSrc, /autoOpenOnTuningChange/);
|
||
// enable() records whether this was an auto-open …
|
||
assert.match(screenSrc, /_state\.autoOpened\s*=\s*auto/);
|
||
// … the outside-click dismiss is armed only for a manual open …
|
||
assert.match(screenSrc, /if \(!auto\)[\s\S]*?addEventListener\('click'/);
|
||
// … and the autoplay song:play closer ignores an auto-opened tuner (the flash fix).
|
||
assert.match(uiSrc, /state\.enabled && !state\.autoOpened/);
|
||
});
|
||
|
||
test('screen.js registers song:loading and song:ready auto-open listeners at boot', () => {
|
||
const src = fs.readFileSync(TUNER_SCREEN_JS, 'utf8');
|
||
assert.match(src, /function _installAutoOpenListeners/);
|
||
assert.match(src, /window\.feedBack\.on\('song:loading', _onAutoOpenSongLoading\)/);
|
||
assert.match(src, /window\.feedBack\.on\('song:ready', _onAutoOpenSongReady\)/);
|
||
assert.match(src, /function _tuningIdentityKey/);
|
||
assert.doesNotMatch(src, /restartCurrentSong/);
|
||
});
|
||
|
||
// ── §4 instrument-coverage (E1.5) ──────────────────────────────────────────
|
||
// Player physical instruments (core /api/settings shape: instrument/string_count/
|
||
// tuning offsets/reference_pitch).
|
||
const PLAYER_GUITAR_8_FS = { instrument: 'guitar', string_count: 8, tuning: [0, 0, 0, 0, 0, 0, 0, 0], reference_pitch: 440 }; // F# standard
|
||
const PLAYER_GUITAR_6 = { instrument: 'guitar', string_count: 6, tuning: [0, 0, 0, 0, 0, 0], reference_pitch: 440 }; // E standard
|
||
const SONG_7B = { filename: '7b.sloppak', arrangement: 'Lead', arrangement_index: 0, stringCount: 7, tuning: [0, 0, 0, 0, 0, 0, 0] }; // B standard 7
|
||
const SONG_DROP_A7 = { filename: 'dropa7.sloppak', arrangement: 'Lead', arrangement_index: 0, stringCount: 7, tuning: [-2, 0, 0, 0, 0, 0, 0] }; // Drop A 7
|
||
|
||
test('coverage: an 8-string F# player is NOT prompted for a covered 6-/7-string standard song', async () => {
|
||
const sandbox = createTunerSandbox({ player: PLAYER_GUITAR_8_FS });
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, DROP_D); // first song → sets lastTuningKey, no open
|
||
await ready(sandbox, E_STANDARD); // 6-E lives on the 8-string's top 6 → suppressed
|
||
assert.equal(sandbox.__enableCalls.length, 0);
|
||
await ready(sandbox, SONG_7B); // 7-B lives on the 8-string's top 7 → suppressed
|
||
assert.equal(sandbox.__enableCalls.length, 0);
|
||
});
|
||
|
||
test('coverage: a Drop-A 7-string song STILL prompts the 8-string F# player (dropped string absent)', async () => {
|
||
const sandbox = createTunerSandbox({ player: PLAYER_GUITAR_8_FS });
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, E_STANDARD); // first → no open
|
||
await ready(sandbox, SONG_DROP_A7); // needs an open A1; the 8-string has F#1/B1, not A1 → prompt
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
});
|
||
|
||
test('coverage: a 6-string-standard player IS prompted for Drop D', async () => {
|
||
const sandbox = createTunerSandbox({ player: PLAYER_GUITAR_6 });
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, E_STANDARD); // first → no open
|
||
await ready(sandbox, DROP_D); // low E must drop to D → not covered → prompt
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
});
|
||
|
||
test('coverage: a reference-pitch mismatch (A432 player vs A440 song) prompts even when the shape matches', async () => {
|
||
const sandbox = createTunerSandbox({ player: { ...PLAYER_GUITAR_6, reference_pitch: 432 } });
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, DROP_D); // first → no open
|
||
await ready(sandbox, E_STANDARD); // shape matches, but the whole instrument is ~32¢ flat → prompt
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
});
|
||
|
||
test('coverage: covered/uncovered is decided by contiguous pitch alignment (direct)', async () => {
|
||
const sandbox = createTunerSandbox({ player: PLAYER_GUITAR_8_FS });
|
||
const cover = (song) => sandbox.window._tunerAutoOpen.coveredByPlayerInstrument(song);
|
||
assert.equal(await cover(E_STANDARD), true); // 6-E is a run inside 8-string F#
|
||
assert.equal(await cover(SONG_7B), true); // 7-B is a run inside 8-string F#
|
||
assert.equal(await cover(SONG_DROP_A7), false); // Drop-A's low A1 isn't an open string on it
|
||
});
|
||
|
||
test('coverage: with no declared instrument it stays conservative (prompts as before)', async () => {
|
||
const sandbox = createTunerSandbox(); // no /api/settings instrument
|
||
sandbox.window._tunerAutoOpen.resetState();
|
||
await ready(sandbox, CUSTOM_GUITAR);
|
||
await ready(sandbox, E_STANDARD);
|
||
assert.equal(sandbox.__enableCalls.length, 1);
|
||
});
|
||
|
||
// ── §4 coverage report + badge cue (E1.6) ──────────────────────────────────
|
||
test('coverage report names the string(s) to retune', async () => {
|
||
// Note: report objects come from the vm sandbox realm, so compare fields, not
|
||
// deepStrictEqual (which checks prototype identity across realms).
|
||
const sandbox = createTunerSandbox({ player: PLAYER_GUITAR_8_FS });
|
||
const rep = (s) => sandbox.window._tunerAutoOpen.coverageReport(s);
|
||
const covered = await rep(E_STANDARD);
|
||
assert.equal(covered.covered, true);
|
||
assert.equal(covered.retune.length, 0);
|
||
assert.equal(covered.reference, false);
|
||
const dropA = await rep(SONG_DROP_A7);
|
||
assert.equal(dropA.covered, false);
|
||
assert.equal(dropA.retune.length, 1);
|
||
assert.equal(dropA.retune[0].from, 'B'); // the user's exact case → "retune B → A"
|
||
assert.equal(dropA.retune[0].to, 'A');
|
||
});
|
||
|
||
test('coverage report flags a whole-instrument reference mismatch', async () => {
|
||
const sandbox = createTunerSandbox({ player: { ...PLAYER_GUITAR_6, reference_pitch: 432 } });
|
||
const rep = await sandbox.window._tunerAutoOpen.coverageReport(E_STANDARD);
|
||
assert.equal(rep.covered, false);
|
||
assert.equal(rep.reference, true);
|
||
});
|
||
|
||
test('the tuner badge surfaces a passive coverage cue (badges.js)', () => {
|
||
const badgesSrc = fs.readFileSync(
|
||
path.join(__dirname, '..', '..', 'static', 'v3', 'badges.js'), 'utf8');
|
||
// Recomputes via the tuner plugin's coverageReport on song:ready …
|
||
assert.match(badgesSrc, /api\.coverageReport/);
|
||
assert.match(badgesSrc, /sm\.on\('song:ready'/);
|
||
// … and shows an advisory ring + tooltip naming the retune (it never auto-opens).
|
||
assert.match(badgesSrc, /function _applyCoverageCue/);
|
||
assert.match(badgesSrc, /report\.retune/);
|
||
assert.match(badgesSrc, /boxShadow/);
|
||
});
|
||
|
||
test('auto-open does not require app.js changes', () => {
|
||
const appSrc = fs.readFileSync(APP_JS, 'utf8');
|
||
assert.doesNotMatch(appSrc, /_tunerAutoOpen|maybeAutoOpenOnTuningChange/);
|
||
});
|
||
|
||
// ── PR 3: per-instrument live working tuning (the both-directions fix) ──────
|
||
test('coverage reads the live per-instrument working tuning, so it prompts BOTH directions', async () => {
|
||
// GUITAR-6 selected; the player's LIVE working tuning is Drop-D (they retuned).
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'guitar', string_count: 6, tuning: 'Standard' } });
|
||
sandbox.window.feedBack.workingTuning = {
|
||
get: () => ({ offsets: [-2, 0, 0, 0, 0, 0], stringCount: 6, instrument: 'guitar', referencePitch: 440 }),
|
||
set() {},
|
||
};
|
||
const rep = (s) => sandbox.window._tunerAutoOpen.coverageReport(s);
|
||
// The Drop-D song now MATCHES the live tuning → covered (no prompt).
|
||
assert.equal((await rep(DROP_D)).covered, true);
|
||
// An E-standard song NO LONGER matches (the player is in Drop-D) → not covered →
|
||
// prompts to tune the low string back UP to E. The old static-profile logic missed
|
||
// this "coming back" direction entirely.
|
||
const estd = await rep(E_STANDARD);
|
||
assert.equal(estd.covered, false);
|
||
assert.equal(estd.retune.length, 1);
|
||
assert.equal(estd.retune[0].from, 'D'); // player low string is D…
|
||
assert.equal(estd.retune[0].to, 'E'); // …song wants E → "tune D → E" (up)
|
||
});
|
||
|
||
// Wire a set-capturing workingTuning stub, then run a coverage read so the tuner caches
|
||
// the selected-instrument identity (publish is synchronous and writes to that cached
|
||
// slot — an auto-open always runs coverage first, so this mirrors real ordering).
|
||
async function _primeSets(sandbox, get = () => ({ offsets: null })) {
|
||
const sets = [];
|
||
sandbox.window.feedBack.workingTuning = { get, set: (state, opts) => sets.push({ state, opts }) };
|
||
await sandbox.window._tunerAutoOpen.playerTuning();
|
||
return sets;
|
||
}
|
||
|
||
test('clearing the auto-opened tuner publishes the song tuning to the right instrument slot', async () => {
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'guitar', string_count: 6, tuning: 'Standard' } });
|
||
const sets = await _primeSets(sandbox);
|
||
sandbox.window._tunerAutoOpen.publishWorkingTuning(DROP_D);
|
||
assert.equal(sets.length, 1);
|
||
assert.deepEqual(sets[0].state.offsets, [-2, 0, 0, 0, 0, 0]); // the song's tuning
|
||
assert.equal(sets[0].state.instrument, 'guitar');
|
||
assert.equal(sets[0].opts.instrument, 'guitar-6'); // targets the guitar slot
|
||
assert.equal(sets[0].opts.provenance, 'assumed'); // a guess, not mic-verified
|
||
});
|
||
|
||
test('publish targets the SELECTED instrument slot, not a song-derived one (string-count mismatch)', async () => {
|
||
// A 5-string bass is selected; the cleared song is a 4-string bass chart. The publish
|
||
// must land in bass-5 (what coverage reads), NOT bass-4 (where it would be stranded).
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'bass', string_count: 5, tuning: 'Standard' } });
|
||
const sets = await _primeSets(sandbox);
|
||
sandbox.window._tunerAutoOpen.publishWorkingTuning(BASS_EADG);
|
||
assert.equal(sets.length, 1);
|
||
assert.equal(sets[0].opts.instrument, 'bass-5'); // the selected instrument's slot
|
||
assert.equal(sets[0].state.instrument, 'bass');
|
||
});
|
||
|
||
test('publish skips a cross-instrument chart (bass arrangement while guitar is selected)', async () => {
|
||
// Guitar selected, but the player manually opened the Bass arrangement and cleared.
|
||
// That is not evidence the guitar was retuned — do not pollute either slot.
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'guitar', string_count: 6, tuning: 'Standard' } });
|
||
const sets = await _primeSets(sandbox);
|
||
sandbox.window._tunerAutoOpen.publishWorkingTuning(BASS_EADG);
|
||
assert.equal(sets.length, 0);
|
||
});
|
||
|
||
test('publish carries the player reference pitch so the slot is self-consistent', async () => {
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'guitar', string_count: 6, tuning: 'Standard', reference_pitch: 432 } });
|
||
const sets = await _primeSets(sandbox);
|
||
sandbox.window._tunerAutoOpen.publishWorkingTuning(DROP_D);
|
||
assert.equal(sets.length, 1);
|
||
assert.equal(sets[0].state.referencePitch, 432);
|
||
});
|
||
|
||
test('publish skips when the instrument could not be confidently resolved (settings unreadable)', async () => {
|
||
// No player settings → /api/settings reports not-ok → we never cached a confident
|
||
// selection, so publish must NOT write to a guessed default slot.
|
||
const sandbox = createTunerSandbox(); // no player
|
||
const sets = await _primeSets(sandbox);
|
||
sandbox.window._tunerAutoOpen.publishWorkingTuning(DROP_D);
|
||
assert.equal(sets.length, 0);
|
||
});
|
||
|
||
// ── #655 fix: transactional open — a dismiss during the audio-start await must not
|
||
// re-enable the tuner afterward (no zombie enabled-but-hidden state). See issue #675.
|
||
test('dismiss during the audio-start await does not leave a zombie enabled tuner', async () => {
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'guitar', string_count: 6, tuning: 'Standard' } });
|
||
// Minimal UI so real enable() gets past the panel-show line to the audio-start await
|
||
// (the default sandbox _tunerUI is a no-op that never creates uiContainer).
|
||
const el = () => ({
|
||
classList: { add() {}, remove() {}, toggle() {}, contains: () => false },
|
||
querySelector: () => null, appendChild() {}, remove() {}, style: {},
|
||
});
|
||
const origTunerUI = sandbox.window._tunerUI; // the sandbox's full no-op method set
|
||
sandbox.window._tunerUI = (state, actions) => {
|
||
const api = origTunerUI(state, actions);
|
||
state.uiContainer = el();
|
||
state.vizContainer = el();
|
||
state.skipBtn = el();
|
||
api.showMicError = api.showMicError || (() => {});
|
||
return api;
|
||
};
|
||
// The OPEN's audio start resolves only AFTER a ×/Skip dismiss has landed — i.e. the
|
||
// user dismissed while audio was starting. (disable()'s own background-audio resume
|
||
// is a later call and resolves at once.)
|
||
let firstStart = true;
|
||
sandbox.window._tunerAudio.start = () => {
|
||
if (!firstStart) return Promise.resolve();
|
||
firstStart = false;
|
||
return Promise.resolve().then(() => { sandbox.window.tuner.disable(); });
|
||
};
|
||
await sandbox.window.tuner.enable({ auto: true });
|
||
assert.equal(sandbox.window._tunerAutoOpen.getState().enabled, false,
|
||
'a mid-open dismiss must win — the tuner stays disabled, not enabled-but-hidden');
|
||
});
|
||
// ── #656 fix: coverage stays conservative when the instrument identity is unknown.
|
||
// A fresh profile (/api/settings omits instrument/string_count/tuning) must NOT be
|
||
// assumed to be standard guitar and silently suppress the prompt. See issue #677.
|
||
test('coverage is conservative when settings carry no instrument identity', async () => {
|
||
const sandbox = createTunerSandbox({ player: {} }); // settings object, but no instrument fields
|
||
const covered = await sandbox.window._tunerAutoOpen.coveredByPlayerInstrument(E_STANDARD);
|
||
assert.equal(covered, false, 'unknown instrument → not covered → still prompt');
|
||
});
|
||
|
||
test('a configured standard-guitar player still covers a standard song', async () => {
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'guitar', string_count: 6, tuning: 'Standard' } });
|
||
const covered = await sandbox.window._tunerAutoOpen.coveredByPlayerInstrument(E_STANDARD);
|
||
assert.equal(covered, true, 'a known standard guitar covers a standard song (no regression)');
|
||
});
|
||
// ── #657 fix (#680) + #668 fix: coverage is deduped, and the player tuning is memoized
|
||
// across songs (it depends on the selected instrument, not the song). Many coverage
|
||
// calls — the auto-open gate, the badge cue, AND the library's per-song tuning-match
|
||
// chips — share ONE /api/settings fetch until the instrument / working tuning changes.
|
||
test('coverage reports share one /api/settings fetch across songs (player tuning memoized)', async () => {
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'guitar', string_count: 6, tuning: 'Standard' } });
|
||
let settingsFetches = 0;
|
||
const origFetch = sandbox.window.fetch;
|
||
sandbox.window.fetch = (url) => {
|
||
if (String(url).includes('/api/settings')) settingsFetches += 1;
|
||
return origFetch(url);
|
||
};
|
||
const api = sandbox.window._tunerAutoOpen;
|
||
const [a, b] = await Promise.all([api.coverageReport(DROP_D), api.coverageReport(DROP_D)]);
|
||
assert.equal(settingsFetches, 1, 'concurrent reports for the same song share one fetch');
|
||
assert.deepEqual(a, b);
|
||
// A different song re-evaluates coverage but reuses the memoized player tuning — the
|
||
// player didn't retune or switch instruments, so no second /api/settings read.
|
||
api.onSongLoading();
|
||
await api.coverageReport(E_STANDARD);
|
||
assert.equal(settingsFetches, 1, 'a different song reuses the memoized player tuning — no refetch');
|
||
});
|
||
|
||
// ── #668 fix: a transient /api/settings failure must NOT be pinned by the player-tuning
|
||
// memo — the next read retries (else one hiccup freezes coverage as "unknown" for good).
|
||
test('a transient /api/settings failure is not cached — the next coverage read retries', async () => {
|
||
const sandbox = createTunerSandbox({ player: { instrument: 'guitar', string_count: 6, tuning: 'Standard' } });
|
||
let failNext = true;
|
||
const origFetch = sandbox.window.fetch;
|
||
sandbox.window.fetch = (url) => {
|
||
if (String(url).includes('/api/settings') && failNext) { failNext = false; return Promise.reject(new Error('boom')); }
|
||
return origFetch(url);
|
||
};
|
||
const api = sandbox.window._tunerAutoOpen;
|
||
const r1 = await api.coverageReport(DROP_D); // settings read failed → conservative "none" report
|
||
assert.equal(r1.retune.length, 0, 'a fetch failure yields the empty/unknown report');
|
||
api.onSongLoading(); // clear the coverage cache to force a recompute
|
||
const r2 = await api.coverageReport(DROP_D); // retry: settings now readable → a real report
|
||
assert.equal(r2.retune.length, 1, 'the retry actually computes coverage (Drop-D low string vs standard)');
|
||
});
|