mirror of
https://github.com/got-feedBack/feedBack.git
synced 2026-07-29 16:11:42 +00:00
4148b0e72e
Reword comments/docstrings/strings and rename identifiers that referenced the external game and its file formats: - format-id "psarc" -> "archive"; local vars psarc_path -> song_path, psarc_base -> tone_base - lyrics provenance value "sng" -> "notechart" (legacy "sng" still accepted) - highway_3d fret-ghost scope value "rocksmith" -> "chords" (invalid/legacy values fall back to the default, preserving behaviour) - neutralise references in prose, test names/data, .gitattributes and docs No functional change beyond the renamed identifiers; all Python compiles.
238 lines
14 KiB
JavaScript
238 lines
14 KiB
JavaScript
const { test } = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const { loadPlayback, captureEvents, dispatch, makeTarget, makeAdapter, diagnosticsSnapshot } = require('./playback_test_harness');
|
|
const { loadCapabilities } = require('./capabilities_test_harness');
|
|
|
|
test('playback reports no-owner no-handler and unsupported command outcomes explicitly', async () => {
|
|
const noOwnerWindow = loadCapabilities();
|
|
const noOwner = await noOwnerWindow.slopsmith.capabilities.dispatch({ capability: 'playback', command: 'inspect', requester: 'test' });
|
|
assert.equal(noOwner.status, 'no-owner');
|
|
|
|
const noHandlerWindow = loadCapabilities();
|
|
noHandlerWindow.slopsmith.capabilities.registerOwner('playback', { pluginId: 'test-owner', commands: ['inspect'], events: [] });
|
|
const noHandler = await noHandlerWindow.slopsmith.capabilities.dispatch({ capability: 'playback', command: 'inspect', requester: 'test' });
|
|
assert.equal(noHandler.status, 'no-handler');
|
|
|
|
const unsupportedWindow = loadPlayback();
|
|
const unsupported = await dispatch(unsupportedWindow, 'teleport', { requesterId: 'test' });
|
|
assert.equal(unsupported.status, 'unsupported-command');
|
|
});
|
|
|
|
test('playback registers as an active core owner', async () => {
|
|
const window = loadPlayback();
|
|
const snapshot = window.slopsmith.capabilities.snapshotDiagnostics();
|
|
const playback = snapshot.pipelines.find(pipeline => pipeline.name === 'playback');
|
|
|
|
assert.ok(playback, 'playback pipeline exists');
|
|
assert.equal(playback.review.lifecycle, 'active');
|
|
assert.ok(playback.participants.some(participant => participant.pluginId === 'core.playback' && participant.roles.includes('owner')));
|
|
assert.ok(playback.participants[0].commands.includes('start'));
|
|
assert.ok(playback.participants[0].events.includes('seeked'));
|
|
});
|
|
|
|
test('start requires a target and explicit user authorization for fresh audible playback', async () => {
|
|
const window = loadPlayback();
|
|
|
|
const missing = await dispatch(window, 'start', { requesterId: 'plugin.practice', authorization: 'user-action' });
|
|
assert.equal(missing.status, 'no-target');
|
|
|
|
const noGesture = await dispatch(window, 'start', { requesterId: 'plugin.practice', target: makeTarget() });
|
|
assert.equal(noGesture.status, 'user-action-required');
|
|
|
|
const adapter = makeAdapter();
|
|
window.slopsmith.playback.registerTransportAdapter(adapter);
|
|
const events = captureEvents(window, 'playback:ready');
|
|
const result = await dispatch(window, 'start', { requesterId: 'core.player.controls', authorization: 'user-action', target: makeTarget() });
|
|
|
|
assert.equal(result.status, 'ready');
|
|
assert.ok(adapter.calls.some(call => call[0] === 'start'));
|
|
assert.equal(events.length, 1);
|
|
const state = diagnosticsSnapshot(window).state;
|
|
assert.equal(state.state, 'ready');
|
|
assert.equal(state.target.targetId.startsWith('target-'), true);
|
|
assert.match(state.target.settingsKey, /^settings-v1-[a-z0-9]{7}$/);
|
|
assert.equal(events[0].payload.target.settingsKey, state.target.settingsKey);
|
|
});
|
|
|
|
test('settings key is stable across arrangements while target id remains arrangement scoped', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter());
|
|
const base = makeTarget({ filename: '/Users/example/DLC/Artist - Song_p.archive', arrangement: 'Lead', arrangementIndex: 0 });
|
|
|
|
await dispatch(window, 'start', { requesterId: 'core.player.controls', authorization: 'user-action', target: base });
|
|
const leadTarget = diagnosticsSnapshot(window).state.target;
|
|
await dispatch(window, 'start', { requesterId: 'core.player.controls', authorization: 'user-action', target: { ...base, arrangement: 'Bass', arrangementIndex: 1 } });
|
|
const bassTarget = diagnosticsSnapshot(window).state.target;
|
|
|
|
assert.match(leadTarget.settingsKey, /^settings-v1-[a-z0-9]{7}$/);
|
|
assert.equal(bassTarget.settingsKey, leadTarget.settingsKey);
|
|
assert.notEqual(bassTarget.targetId, leadTarget.targetId);
|
|
});
|
|
|
|
test('unsafe caller-supplied settings keys are hashed before exposure', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter());
|
|
|
|
await dispatch(window, 'start', {
|
|
requesterId: 'core.player.controls',
|
|
authorization: 'user-action',
|
|
target: makeTarget({ settingsKey: 'settings-private-song-name' }),
|
|
});
|
|
const encoded = JSON.stringify(diagnosticsSnapshot(window));
|
|
|
|
assert.match(diagnosticsSnapshot(window).state.target.settingsKey, /^settings-v1-[a-z0-9]{7}$/);
|
|
assert.doesNotMatch(encoded, /private-song-name/);
|
|
});
|
|
|
|
test('unsafe caller-supplied target ids are hashed before exposure', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter());
|
|
|
|
await dispatch(window, 'start', {
|
|
requesterId: 'core.player.controls',
|
|
authorization: 'user-action',
|
|
target: makeTarget({ targetId: 'target-private-song-name' }),
|
|
});
|
|
const encoded = JSON.stringify(diagnosticsSnapshot(window));
|
|
|
|
assert.match(diagnosticsSnapshot(window).state.target.targetId, /^target-[a-z0-9]+$/);
|
|
assert.doesNotMatch(encoded, /private-song-name/);
|
|
});
|
|
|
|
test('dispatch requester owns playback command attribution', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter());
|
|
|
|
const started = await dispatch(window, 'start', { requesterId: 'core.player.controls', authorization: 'user-action', target: makeTarget() }, 'plugin.remote');
|
|
const paused = await dispatch(window, 'pause', { requesterId: 'core.player.controls' }, 'plugin.remote');
|
|
const snapshot = diagnosticsSnapshot(window);
|
|
const outcomeIds = snapshot.history.current.recentOutcomes.map(item => item.requesterId).join(',');
|
|
|
|
assert.equal(started.status, 'ready');
|
|
assert.equal(paused.status, 'paused');
|
|
assert.equal(snapshot.state.transport.requesterId, 'plugin.remote');
|
|
assert.equal(outcomeIds.includes('core.player.controls'), false);
|
|
assert.equal(outcomeIds.includes('plugin.remote'), true);
|
|
});
|
|
|
|
test('transport commands emit ordered lifecycle events and normalize outcomes', async () => {
|
|
const window = loadPlayback();
|
|
const adapter = makeAdapter({ duration: 10 });
|
|
window.slopsmith.playback.registerTransportAdapter(adapter);
|
|
const events = [];
|
|
for (const eventName of ['playback:requested', 'playback:loading', 'playback:ready', 'playback:paused', 'playback:resumed', 'playback:seeking', 'playback:seeked', 'playback:loop-set', 'playback:loop-cleared']) {
|
|
window.slopsmith.on(eventName, event => events.push(event.type.replace('playback:', '')));
|
|
}
|
|
|
|
await dispatch(window, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
await dispatch(window, 'pause', { requesterId: 'core.player.controls', priority: 'user' });
|
|
await dispatch(window, 'resume', { requesterId: 'core.player.controls', priority: 'user' });
|
|
const seek = await dispatch(window, 'seek', { requesterId: 'core.player.controls', time: 999 });
|
|
const loop = await dispatch(window, 'set-loop', { requesterId: 'core.player.controls', startTime: 2, endTime: 4 });
|
|
const cleared = await dispatch(window, 'clear-loop', { requesterId: 'core.player.controls' });
|
|
|
|
assert.deepEqual(events.slice(0, 3), ['requested', 'loading', 'ready']);
|
|
assert.ok(events.indexOf('seeking') < events.indexOf('seeked'));
|
|
assert.equal(seek.status, 'clamped');
|
|
assert.equal(seek.payload.landedTime, 10);
|
|
assert.equal(loop.status, 'active');
|
|
assert.equal(cleared.status, 'cleared');
|
|
});
|
|
|
|
test('seek preserves pre-seek playback state and external seek events update state', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter({ startPlaying: true, seekResult: { completed: true, from: 1, to: 5 } }));
|
|
await dispatch(window, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
|
|
const seek = await dispatch(window, 'seek', { requesterId: 'core.player.controls', time: 5 });
|
|
assert.equal(seek.status, 'completed');
|
|
assert.equal(diagnosticsSnapshot(window).state.state, 'playing');
|
|
|
|
window.slopsmith.playback.transportEvent('seeking', { requesterId: 'core.player.controls', media: { currentTime: 5 }, isPlaying: true });
|
|
assert.equal(diagnosticsSnapshot(window).state.state, 'seeking');
|
|
window.slopsmith.playback.transportEvent('seeked', { requesterId: 'core.player.controls', media: { currentTime: 9 }, isPlaying: true });
|
|
assert.equal(diagnosticsSnapshot(window).state.state, 'playing');
|
|
});
|
|
|
|
test('clear-loop requires an active playback session', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter());
|
|
|
|
const cleared = await dispatch(window, 'clear-loop', { requesterId: 'core.player.controls' });
|
|
assert.equal(cleared.status, 'no-target');
|
|
});
|
|
|
|
test('ended transport events and seek failure/rollback outcomes are distinguishable', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter({ seekResult: { completed: true, from: 5, to: 4.5 } }));
|
|
await dispatch(window, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
const rolledBack = await dispatch(window, 'seek', { requesterId: 'core.player.controls', time: 8 });
|
|
assert.equal(rolledBack.status, 'rolled-back');
|
|
|
|
const failedWindow = loadPlayback();
|
|
failedWindow.slopsmith.playback.registerTransportAdapter(makeAdapter({ seekError: 'seek failed' }));
|
|
await dispatch(failedWindow, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
const failed = await dispatch(failedWindow, 'seek', { requesterId: 'core.player.controls', time: 3 });
|
|
assert.equal(failed.status, 'failed');
|
|
assert.equal(failed.outcome, 'failed');
|
|
assert.equal(diagnosticsSnapshot(failedWindow).state.state, 'paused');
|
|
|
|
const unsupportedWindow = loadPlayback();
|
|
unsupportedWindow.slopsmith.playback.registerTransportAdapter({ inspect: () => ({ currentTime: 0, duration: 120, isPlaying: true }), start: () => ({ currentTime: 0, duration: 120, isPlaying: true }) });
|
|
await dispatch(unsupportedWindow, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
const unsupported = await dispatch(unsupportedWindow, 'seek', { requesterId: 'core.player.controls', time: 3 });
|
|
assert.equal(unsupported.status, 'unsupported-command');
|
|
assert.equal(diagnosticsSnapshot(unsupportedWindow).state.state, 'playing');
|
|
|
|
const malformedWindow = loadPlayback();
|
|
malformedWindow.slopsmith.playback.registerTransportAdapter(makeAdapter({ seekResult: { completed: true, from: 2, to: NaN } }));
|
|
await dispatch(malformedWindow, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
const malformed = await dispatch(malformedWindow, 'seek', { requesterId: 'core.player.controls', time: 6 });
|
|
assert.equal(malformed.status, 'failed');
|
|
assert.match(malformed.reason, /malformed seek result/i);
|
|
|
|
window.slopsmith.playback.transportEvent('ended', { requesterId: 'core.player.controls', currentTime: 120 });
|
|
assert.equal(diagnosticsSnapshot(window).state.state, 'ended');
|
|
});
|
|
|
|
test('invalid loop boundaries do not mutate an active loop', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter());
|
|
await dispatch(window, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
await dispatch(window, 'set-loop', { requesterId: 'core.player.controls', startTime: 2, endTime: 4 });
|
|
|
|
const rejected = await dispatch(window, 'set-loop', { requesterId: 'core.player.controls', startTime: 8, endTime: 4 });
|
|
const loop = diagnosticsSnapshot(window).state.loop;
|
|
|
|
assert.equal(rejected.status, 'rejected');
|
|
assert.equal(loop.state, 'active');
|
|
assert.equal(loop.startTime, 2);
|
|
assert.equal(loop.endTime, 4);
|
|
});
|
|
|
|
test('normal resume is denied after a user-priority pause until a user action resumes', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter());
|
|
await dispatch(window, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
await dispatch(window, 'pause', { requesterId: 'core.player.controls', priority: 'user' });
|
|
|
|
const blocked = await dispatch(window, 'resume', { requesterId: 'plugin.remote', priority: 'normal' });
|
|
assert.equal(blocked.status, 'denied');
|
|
|
|
const accepted = await dispatch(window, 'resume', { requesterId: 'core.player.controls', priority: 'user' });
|
|
assert.equal(accepted.status, 'playing');
|
|
});
|
|
|
|
test('stale and cancelled operations are reported distinctly', async () => {
|
|
const window = loadPlayback();
|
|
window.slopsmith.playback.registerTransportAdapter(makeAdapter({ seekResult: { completed: false, from: 2, to: NaN } }));
|
|
await dispatch(window, 'start', { authorization: 'user-action', requesterId: 'core.player.controls', target: makeTarget() });
|
|
const sessionId = diagnosticsSnapshot(window).state.sessionId;
|
|
|
|
const stale = await dispatch(window, 'pause', { requesterId: 'plugin.remote', sessionId: `${sessionId}-old` });
|
|
const cancelled = await dispatch(window, 'seek', { requesterId: 'core.player.controls', time: 8 });
|
|
|
|
assert.equal(stale.status, 'stale');
|
|
assert.equal(cancelled.status, 'cancelled');
|
|
});
|