mirror of
https://github.com/got-feedBack/feedBack-desktop.git
synced 2026-07-23 05:11:43 +00:00
393 lines
18 KiB
JavaScript
393 lines
18 KiB
JavaScript
const test = require('node:test');
|
|
const assert = require('node:assert/strict');
|
|
const fs = require('node:fs');
|
|
const os = require('node:os');
|
|
const path = require('node:path');
|
|
const Module = require('node:module');
|
|
const ts = require('typescript');
|
|
|
|
const ROOT = path.join(__dirname, '..');
|
|
const EXECUTOR_TS = path.join(ROOT, 'src', 'main', 'audio-effects-executor.ts');
|
|
|
|
function loadExecutorModule() {
|
|
const source = fs.readFileSync(EXECUTOR_TS, 'utf8');
|
|
const compiled = ts.transpileModule(source, {
|
|
compilerOptions: {
|
|
module: ts.ModuleKind.CommonJS,
|
|
target: ts.ScriptTarget.ES2022,
|
|
esModuleInterop: true,
|
|
},
|
|
fileName: EXECUTOR_TS,
|
|
}).outputText;
|
|
const mod = new Module(EXECUTOR_TS, module);
|
|
mod.filename = EXECUTOR_TS;
|
|
mod.paths = Module._nodeModulePaths(path.dirname(EXECUTOR_TS));
|
|
mod._compile(compiled, EXECUTOR_TS);
|
|
return mod.exports;
|
|
}
|
|
|
|
function tempAsset(ext) {
|
|
const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'slopsmith-audio-effects-'));
|
|
const file = path.join(dir, `asset${ext}`);
|
|
fs.writeFileSync(file, 'test');
|
|
return file;
|
|
}
|
|
|
|
function plan(overrides = {}) {
|
|
return {
|
|
schema: 'slopsmith.audio_effects.chain_plan.v1',
|
|
planId: 'plan-1',
|
|
routeKey: 'desktop-main',
|
|
providerId: 'rig-builder',
|
|
stages: [
|
|
{ stageId: 'pre', kind: 'nam', role: 'pre-pedal', assetRef: 'asset:pre' },
|
|
{ stageId: 'cab', kind: 'ir', role: 'cab', assetRef: 'asset:cab', bypassed: true },
|
|
],
|
|
segments: [{ segmentId: 'lead', stageIds: ['pre'], stageBypass: { pre: true } }],
|
|
...overrides,
|
|
};
|
|
}
|
|
|
|
test('audio-effects executor validates and loads a trusted chain plan without leaking asset paths', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
const calls = [];
|
|
const native = {
|
|
loadPreset: async presetJson => {
|
|
const parsed = JSON.parse(presetJson);
|
|
calls.push(parsed.chain);
|
|
return { success: true, slotsLoaded: parsed.chain.length };
|
|
},
|
|
getChainState: () => [{ id: 10 }, { id: 11 }],
|
|
setMultiBypass: changes => { calls.push(['multi', changes]); return true; },
|
|
setBypass: (slotId, bypassed) => { calls.push(['bypass', slotId, bypassed]); return true; },
|
|
setParameter: (slotId, paramIndex, value) => { calls.push(['param', slotId, paramIndex, value]); return true; },
|
|
};
|
|
const executor = createAudioEffectsExecutor(() => native);
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
|
|
const loaded = await executor.loadChainPlan({
|
|
authorization: 'playback-session',
|
|
plan: plan(),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
});
|
|
const inspected = executor.inspectRoute('desktop-main');
|
|
const segment = await executor.activateSegment({ routeKey: 'desktop-main', segmentId: 'lead' });
|
|
const bypass = await executor.setStageBypass({ routeKey: 'desktop-main', stageId: 'pre', bypassed: true });
|
|
const param = await executor.setStageParameter({ routeKey: 'desktop-main', stageId: 'pre', paramIndex: 2, value: 0.75 });
|
|
const encoded = JSON.stringify({ loaded, inspected, segment, bypass, param });
|
|
|
|
assert.equal(loaded.outcome, 'handled');
|
|
assert.equal(inspected.payload.route.nativeStageCount, 2);
|
|
assert.equal(segment.outcome, 'handled');
|
|
assert.equal(bypass.outcome, 'handled');
|
|
assert.equal(param.outcome, 'handled');
|
|
assert.deepEqual(calls[0].map(stage => stage.type), [1, 2]);
|
|
assert.deepEqual(calls[1], ['multi', [{ slotId: 10, bypassed: true }, { slotId: 11, bypassed: true }]]);
|
|
assert.equal(encoded.includes(namPath), false);
|
|
assert.equal(encoded.includes(irPath), false);
|
|
assert.equal(encoded.includes('asset:pre'), false);
|
|
});
|
|
|
|
test('audio-effects executor rejects a plan with duplicate segmentIds', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
const native = {
|
|
loadPreset: async () => ({ success: true, slotsLoaded: 2 }),
|
|
getChainState: () => [{ id: 10 }, { id: 11 }],
|
|
};
|
|
const executor = createAudioEffectsExecutor(() => native);
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
const loaded = await executor.loadChainPlan({
|
|
authorization: 'playback-session',
|
|
plan: plan({ segments: [
|
|
{ segmentId: 'lead', stageIds: ['pre'] },
|
|
{ segmentId: 'lead', stageIds: ['cab'] },
|
|
] }),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
});
|
|
assert.equal(loaded.outcome, 'failed');
|
|
assert.equal(JSON.stringify(loaded.payload.errors).includes('duplicate segmentId'), true);
|
|
});
|
|
|
|
test('audio-effects executor returns failed (with rollback) when native chain-state lookup throws', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
const native = {
|
|
savePreset: () => 'previous',
|
|
loadPreset: async () => ({ success: true, slotsLoaded: 2 }),
|
|
getChainState: () => { throw new Error('native chain-state boom'); },
|
|
};
|
|
const executor = createAudioEffectsExecutor(() => native);
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
const loaded = await executor.loadChainPlan({
|
|
authorization: 'playback-session',
|
|
plan: plan(),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
});
|
|
assert.equal(loaded.outcome, 'failed');
|
|
assert.equal(loaded.payload.rollbackApplied, true);
|
|
// The route must not be registered when the lookup failed.
|
|
assert.equal(executor.inspectRoute('desktop-main').outcome, 'no-target');
|
|
});
|
|
|
|
test('audio-effects executor rolls back to degraded when native slot mapping is incomplete', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
const native = {
|
|
savePreset: () => 'previous',
|
|
loadPreset: async () => ({ success: true, slotsLoaded: 2 }),
|
|
// loadPreset reports both stages loaded, but the chain state only maps one valid slot.
|
|
getChainState: () => [{ id: 10 }, { id: -1 }],
|
|
};
|
|
const executor = createAudioEffectsExecutor(() => native);
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
const loaded = await executor.loadChainPlan({
|
|
authorization: 'playback-session',
|
|
plan: plan(),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
});
|
|
assert.equal(loaded.outcome, 'degraded');
|
|
assert.equal(loaded.payload.slotsMapped, 1);
|
|
assert.equal(executor.inspectRoute('desktop-main').outcome, 'no-target');
|
|
});
|
|
|
|
test('audio-effects executor owns load mute, route gain, start, and release', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
const calls = [];
|
|
const native = {
|
|
savePreset: () => 'previous',
|
|
loadPreset: presetJson => { calls.push(['load', JSON.parse(presetJson).chain.length]); return { success: true, slotsLoaded: 2 }; },
|
|
clearChain: () => { calls.push(['clear']); return true; },
|
|
getChainState: () => [{ id: 10 }, { id: 11 }],
|
|
isMonitorMuted: () => { calls.push(['is-muted']); return true; },
|
|
setMonitorMute: muted => { calls.push(['monitor', muted]); return true; },
|
|
setMonitorMuteSuppressed: suppressed => { calls.push(['suppress', suppressed]); return true; },
|
|
setGain: (which, value) => { calls.push(['gain', which, value]); return true; },
|
|
startAudio: () => { calls.push(['start']); return true; },
|
|
};
|
|
const executor = createAudioEffectsExecutor(() => native);
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
|
|
const loaded = await executor.loadChainPlan({
|
|
authorization: 'playback-session',
|
|
plan: plan(),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
options: { preloadMute: { targetGain: 4, holdMs: 0 }, gains: { input: 8, chain: 4 }, startAudio: true },
|
|
});
|
|
const gained = await executor.setRouteGain({ routeKey: 'desktop-main', gains: { chain: 2 } });
|
|
const released = await executor.releaseRoute({ routeKey: 'desktop-main' });
|
|
const inspected = executor.inspectRoute('desktop-main');
|
|
await new Promise(resolve => setTimeout(resolve, 40));
|
|
|
|
assert.equal(loaded.outcome, 'handled');
|
|
assert.equal(gained.outcome, 'handled');
|
|
assert.equal(released.outcome, 'handled');
|
|
assert.equal(inspected.outcome, 'no-target');
|
|
assert.deepEqual(calls.slice(0, 7), [
|
|
['is-muted'],
|
|
['gain', 'chain', 0],
|
|
['monitor', false],
|
|
['load', 2],
|
|
['gain', 'input', 8],
|
|
['start'],
|
|
['gain', 'chain', 2],
|
|
]);
|
|
assert.equal(calls.some(call => call[0] === 'clear'), true);
|
|
assert.equal(calls.some(call => call[0] === 'monitor' && call[1] === true), true);
|
|
assert.equal(calls.some(call => call[0] === 'suppress' && call[1] === false), true);
|
|
assert.equal(calls.some(call => call[0] === 'gain' && call[1] === 'chain' && call[2] === 4), false);
|
|
assert.equal(calls.some(call => call[0] === 'gain' && call[1] === 'chain' && call[2] === 0), true);
|
|
});
|
|
|
|
test('audio-effects executor rejects unauthorised, missing, and raw-path-like plans before native load', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
let loadCount = 0;
|
|
const executor = createAudioEffectsExecutor(() => ({
|
|
loadPreset: () => { loadCount += 1; return { success: true, slotsLoaded: 1 }; },
|
|
getChainState: () => [{ id: 1 }],
|
|
}));
|
|
|
|
const noAuth = await executor.loadChainPlan({ plan: plan(), assets: {} });
|
|
const missingAsset = await executor.loadChainPlan({ authorization: 'user-action', plan: plan(), assets: {} });
|
|
const rawPath = await executor.loadChainPlan({
|
|
authorization: 'user-action',
|
|
plan: plan({ stages: [{ stageId: 'amp', kind: 'nam', role: 'amp', assetRef: '/Users/example/private/model.nam' }] }),
|
|
assets: {},
|
|
});
|
|
const encoded = JSON.stringify({ noAuth, missingAsset, rawPath });
|
|
|
|
assert.equal(noAuth.outcome, 'failed');
|
|
assert.equal(missingAsset.outcome, 'failed');
|
|
assert.equal(rawPath.outcome, 'failed');
|
|
assert.equal(loadCount, 0);
|
|
assert.equal(encoded.includes('/Users/example'), false);
|
|
assert.equal(encoded.includes('model.nam'), false);
|
|
});
|
|
|
|
test('audio-effects executor rejects duplicate stage ids before native load', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
let loadCount = 0;
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
const executor = createAudioEffectsExecutor(() => ({
|
|
loadPreset: () => { loadCount += 1; return { success: true, slotsLoaded: 2 }; },
|
|
getChainState: () => [{ id: 1 }, { id: 2 }],
|
|
}));
|
|
|
|
const result = await executor.loadChainPlan({
|
|
authorization: 'user-action',
|
|
plan: plan({
|
|
stages: [
|
|
{ stageId: 'dup', kind: 'nam', role: 'amp', assetRef: 'asset:pre' },
|
|
{ stageId: 'dup', kind: 'ir', role: 'cab', assetRef: 'asset:cab' },
|
|
],
|
|
}),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
});
|
|
|
|
assert.equal(result.outcome, 'failed');
|
|
assert.equal(loadCount, 0);
|
|
assert.equal(JSON.stringify(result).includes('Duplicate stageId dup'), true);
|
|
});
|
|
|
|
test('audio-effects executor rolls back and avoids route state on partial native loads', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
const calls = [];
|
|
const executor = createAudioEffectsExecutor(() => ({
|
|
savePreset: () => 'previous-preset',
|
|
loadPreset: presetJson => {
|
|
calls.push(presetJson);
|
|
return { success: true, slotsLoaded: 1 };
|
|
},
|
|
getChainState: () => [{ id: 10 }],
|
|
}));
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
|
|
const loaded = await executor.loadChainPlan({
|
|
authorization: 'playback-session',
|
|
plan: plan(),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
});
|
|
const inspected = executor.inspectRoute('desktop-main');
|
|
const encoded = JSON.stringify(loaded);
|
|
|
|
assert.equal(loaded.outcome, 'degraded');
|
|
assert.equal(loaded.payload.rollbackApplied, true);
|
|
assert.equal(inspected.outcome, 'no-target');
|
|
assert.equal(calls.length, 2);
|
|
assert.equal(calls[1], 'previous-preset');
|
|
assert.equal(encoded.includes(namPath), false);
|
|
assert.equal(encoded.includes(irPath), false);
|
|
});
|
|
|
|
test('audio-effects executor reports native control failures without throwing IPC errors', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
const executor = createAudioEffectsExecutor(() => ({
|
|
loadPreset: () => ({ success: true, slotsLoaded: 2 }),
|
|
getChainState: () => [{ id: 10 }, { id: 11 }],
|
|
setBypass: async () => { throw new Error('plugin crash /Users/example/private.nam'); },
|
|
setParameter: async () => ({ success: false }),
|
|
setMultiBypass: async () => false,
|
|
}));
|
|
|
|
const loaded = await executor.loadChainPlan({
|
|
authorization: 'playback-session',
|
|
plan: plan(),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
});
|
|
const bypass = await executor.setStageBypass({ routeKey: 'desktop-main', stageId: 'pre', bypassed: true });
|
|
const param = await executor.setStageParameter({ routeKey: 'desktop-main', stageId: 'pre', paramIndex: 2, value: 0.75 });
|
|
const segment = await executor.activateSegment({ routeKey: 'desktop-main', segmentId: 'lead' });
|
|
const encoded = JSON.stringify({ bypass, param, segment });
|
|
|
|
assert.equal(loaded.outcome, 'handled');
|
|
assert.equal(bypass.outcome, 'failed');
|
|
assert.equal(bypass.reason, 'Native stage bypass threw');
|
|
assert.equal(param.outcome, 'failed');
|
|
assert.equal(param.reason, 'Native stage parameter returned failure');
|
|
assert.equal(segment.outcome, 'failed');
|
|
assert.equal(segment.reason, 'Native multi-bypass returned failure');
|
|
assert.equal(encoded.includes('/Users/example'), false);
|
|
assert.equal(encoded.includes('private.nam'), false);
|
|
});
|
|
|
|
test('audio-effects executor rejects coerced parameter indices', async () => {
|
|
const { createAudioEffectsExecutor } = loadExecutorModule();
|
|
const namPath = tempAsset('.nam');
|
|
const irPath = tempAsset('.wav');
|
|
const calls = [];
|
|
const executor = createAudioEffectsExecutor(() => ({
|
|
loadPreset: () => ({ success: true, slotsLoaded: 2 }),
|
|
getChainState: () => [{ id: 10 }, { id: 11 }],
|
|
setParameter: (...args) => { calls.push(args); return true; },
|
|
}));
|
|
|
|
await executor.loadChainPlan({
|
|
authorization: 'playback-session',
|
|
plan: plan(),
|
|
assets: {
|
|
'asset:pre': { kind: 'nam', path: namPath, safeName: 'pre' },
|
|
'asset:cab': { kind: 'ir', path: irPath, safeName: 'cab' },
|
|
},
|
|
});
|
|
|
|
assert.equal((await executor.setStageParameter({ routeKey: 'desktop-main', stageId: 'pre', paramIndex: false, value: 0.75 })).outcome, 'failed');
|
|
assert.equal((await executor.setStageParameter({ routeKey: 'desktop-main', stageId: 'pre', paramIndex: '', value: 0.75 })).outcome, 'failed');
|
|
assert.equal((await executor.setStageParameter({ routeKey: 'desktop-main', stageId: 'pre', paramIndex: 4096, value: 0.75 })).outcome, 'failed');
|
|
assert.equal((await executor.setStageParameter({ routeKey: 'desktop-main', stageId: 'pre', paramIndex: '2', value: '0.75' })).outcome, 'handled');
|
|
assert.deepEqual(calls, [[10, 2, 0.75]]);
|
|
});
|
|
|
|
test('preload exposes the trusted audio-effects executor surface', () => {
|
|
const preload = fs.readFileSync(path.join(ROOT, 'src', 'main', 'preload.ts'), 'utf8');
|
|
const bridge = fs.readFileSync(path.join(ROOT, 'src', 'main', 'audio-bridge.ts'), 'utf8');
|
|
|
|
assert.equal(preload.includes('audioEffects: {'), true);
|
|
for (const method of ['loadChainPlan', 'releaseRoute', 'inspectRoute', 'activateSegment', 'setStageBypass', 'setStageParameter', 'setRouteGain']) {
|
|
assert.equal(preload.includes(`${method}:`), true);
|
|
}
|
|
for (const channel of [
|
|
'audio-effects:loadChainPlan',
|
|
'audio-effects:releaseRoute',
|
|
'audio-effects:inspectRoute',
|
|
'audio-effects:activateSegment',
|
|
'audio-effects:setStageBypass',
|
|
'audio-effects:setStageParameter',
|
|
'audio-effects:setRouteGain',
|
|
]) {
|
|
assert.equal(bridge.includes(channel), true);
|
|
}
|
|
assert.equal(bridge.includes("ipcMain.handle('audio-effects:loadChainPlan', async"), true);
|
|
assert.equal(bridge.includes('vstSlotPaths.clear();\n return await audioEffects.loadChainPlan(request);'), true);
|
|
assert.equal(bridge.includes('if (normalizedPayload.inputType !== normalizedPayload.outputType)'), true);
|
|
});
|