feat: add scene-based recording, e2e tests, and improved TUI state indicators
This commit is contained in:
Loic Coenen
committed by
Loic Coenen (aider)
Loic Coenen (aider)
parent
f2993eac80
commit
7c289e1496
746
e2e/test.ts
Normal file
746
e2e/test.ts
Normal file
@@ -0,0 +1,746 @@
|
||||
import { execSync, exec, ChildProcess } from "child_process";
|
||||
import * as path from "path";
|
||||
import * as fs from "fs";
|
||||
|
||||
const PROJECT_DIR = path.resolve(__dirname, "..");
|
||||
const ENGINE_BIN = path.join(PROJECT_DIR, "engine/looper");
|
||||
const CLIENT_BIN = path.join(PROJECT_DIR, "client/looper-client");
|
||||
const STATUS_FIFO = "/tmp/looper_status";
|
||||
const CMD_FIFO = "/tmp/looper_cmd";
|
||||
|
||||
let cmdFifoFd: number | null = null;
|
||||
|
||||
function run(cmd: string, timeout_sec = 15): string {
|
||||
return execSync(cmd, { encoding: "utf-8", timeout: timeout_sec * 1000 }).trim();
|
||||
}
|
||||
|
||||
function runNoThrow(cmd: string): void {
|
||||
try { run(cmd); } catch { /* ignore */ }
|
||||
}
|
||||
|
||||
function tmuxSendKeys(session: string, pane: string, keys: string) {
|
||||
run(`tmux send-keys -t ${session}:${pane} ${JSON.stringify(keys)}`);
|
||||
}
|
||||
|
||||
function tmuxCapturePane(session: string, pane: string): string {
|
||||
return run(`tmux capture-pane -t ${session}:${pane} -p`);
|
||||
}
|
||||
|
||||
function wait(ms: number) {
|
||||
return new Promise((resolve) => setTimeout(resolve, ms));
|
||||
}
|
||||
|
||||
/** Wait for a file to exist, up to `timeoutMs` milliseconds. */
|
||||
function waitForFile(filepath: string, timeoutMs: number): Promise<void> {
|
||||
const start = Date.now();
|
||||
return new Promise<void>((resolve, reject) => {
|
||||
const check = () => {
|
||||
if (fs.existsSync(filepath)) {
|
||||
resolve();
|
||||
} else if (Date.now() - start > timeoutMs) {
|
||||
reject(new Error(`Timeout waiting for ${filepath}`));
|
||||
} else {
|
||||
setTimeout(check, 200);
|
||||
}
|
||||
};
|
||||
check();
|
||||
});
|
||||
}
|
||||
|
||||
function waitForCommandFifo(timeoutMs = 5000): Promise<void> {
|
||||
return waitForFile(CMD_FIFO, timeoutMs);
|
||||
}
|
||||
|
||||
function openCmdFifo(): void {
|
||||
// Wait for FIFO to exist (engine creates it)
|
||||
let waited = 0;
|
||||
while (!fs.existsSync(CMD_FIFO) && waited < 5000) {
|
||||
const waitUntil = Date.now() + 200;
|
||||
require("child_process").execSync(`sleep 0.2`);
|
||||
waited += 200;
|
||||
}
|
||||
cmdFifoFd = fs.openSync(CMD_FIFO, 'w');
|
||||
}
|
||||
|
||||
function writeFifoCommand(cmd: string): void {
|
||||
if (cmdFifoFd === null) {
|
||||
openCmdFifo();
|
||||
}
|
||||
fs.writeSync(cmdFifoFd, cmd + '\n');
|
||||
}
|
||||
|
||||
function setupTest() {
|
||||
process.stdout.write(" Killing stale processes...\n");
|
||||
runNoThrow("pkill -9 -x looper");
|
||||
runNoThrow("pkill -9 -x looper-client");
|
||||
runNoThrow("pkill -9 -x jack_capture");
|
||||
runNoThrow("tmux kill-session -t looper 2>/dev/null || true");
|
||||
process.stdout.write(" Checking JACK...\n");
|
||||
try {
|
||||
run("jack_wait -c -t 5", 10);
|
||||
} catch {
|
||||
console.warn(" JACK server is not running. Tests may fail.");
|
||||
}
|
||||
process.stdout.write(" Removing old temp files...\n");
|
||||
run("rm -f /tmp/looper_cmd /tmp/looper_status /tmp/test.wav /tmp/captured.wav /tmp/loop.wav /tmp/save.wav /tmp/load_test.wav /tmp/loaded.wav save_ch*.wav save.wav loop.wav");
|
||||
}
|
||||
|
||||
function teardownTest() {
|
||||
if (cmdFifoFd !== null) {
|
||||
fs.closeSync(cmdFifoFd);
|
||||
cmdFifoFd = null;
|
||||
}
|
||||
runNoThrow("pkill -9 -x looper");
|
||||
runNoThrow("pkill -9 -x looper-client");
|
||||
runNoThrow("pkill -9 -x jack_capture");
|
||||
runNoThrow("tmux kill-session -t looper");
|
||||
}
|
||||
|
||||
function isProcessAlive(pid: number): boolean {
|
||||
try {
|
||||
process.kill(pid, 0);
|
||||
return true;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
async function startEngine(): Promise<ChildProcess> {
|
||||
process.stdout.write(" Starting engine directly...\n");
|
||||
const stderrFile = "/tmp/engine_stderr.log";
|
||||
const proc = exec(`${ENGINE_BIN} 2>${stderrFile}`, { cwd: PROJECT_DIR });
|
||||
|
||||
// Wait for the status FIFO to appear (up to 10 seconds)
|
||||
try {
|
||||
await Promise.race([
|
||||
waitForFile(STATUS_FIFO, 10000),
|
||||
wait(11000),
|
||||
]);
|
||||
} catch {
|
||||
process.stdout.write(" Engine status FIFO did not appear within timeout\n");
|
||||
if (proc.pid && !isProcessAlive(proc.pid)) {
|
||||
process.stdout.write(" Engine process died prematurely. stderr log:\n");
|
||||
const stderr = execSync(`cat ${stderrFile}`, { encoding: "utf-8" }).trim();
|
||||
process.stdout.write(stderr + "\n");
|
||||
}
|
||||
}
|
||||
|
||||
if (proc.pid && isProcessAlive(proc.pid)) {
|
||||
process.stdout.write(" Engine started (pid " + proc.pid + ")\n");
|
||||
} else {
|
||||
process.stdout.write(" Engine process is not alive after start attempt\n");
|
||||
}
|
||||
return proc;
|
||||
}
|
||||
|
||||
async function startClientInTmux(): Promise<void> {
|
||||
// Kill any stale session (silently)
|
||||
runNoThrow("tmux kill-session -t looper 2>/dev/null");
|
||||
run("tmux new-session -d -s looper");
|
||||
// Resize the window (width x height) so we can see the full grid and status line
|
||||
run("tmux resize-window -t looper:0 -x 120 -y 50 2>/dev/null || true");
|
||||
// Launch the client
|
||||
run(`tmux send-keys -t looper:0 ${JSON.stringify(CLIENT_BIN)} Enter`);
|
||||
// Wait for the client to draw the initial frame (max 10 seconds, poll every 500 ms)
|
||||
const deadline = Date.now() + 10000;
|
||||
let pane = "";
|
||||
while (Date.now() < deadline) {
|
||||
await wait(500);
|
||||
pane = tmuxCapturePane("looper", "0");
|
||||
if (pane.includes("[online]") || pane.includes("Selected:")) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Final short extra wait to ensure status lines are updated
|
||||
await wait(500);
|
||||
}
|
||||
|
||||
/* Check if the tmux pane contains a given substring */
|
||||
function tmuxContains(text: string): boolean {
|
||||
const pane = tmuxCapturePane("looper", "0");
|
||||
return pane.includes(text);
|
||||
}
|
||||
|
||||
/* Read the status FIFO non‑blocking. Returns the data read (may be empty) */
|
||||
function readStatusNonBlock(): string {
|
||||
try {
|
||||
const fd = fs.openSync(STATUS_FIFO, fs.constants.O_RDONLY | fs.constants.O_NONBLOCK);
|
||||
const buf = Buffer.alloc(2000);
|
||||
const bytesRead = fs.readSync(fd, buf, 0, 2000, null);
|
||||
fs.closeSync(fd);
|
||||
return buf.slice(0, bytesRead).toString('utf-8').trim();
|
||||
} catch {
|
||||
return "";
|
||||
}
|
||||
}
|
||||
|
||||
/* Read the status FIFO and return the first line that matches a pattern, or "" */
|
||||
function readStatusLineMatching(pattern: string): string {
|
||||
const data = readStatusNonBlock();
|
||||
for (const line of data.split("\n")) {
|
||||
if (line.includes(pattern)) return line;
|
||||
}
|
||||
return "";
|
||||
}
|
||||
|
||||
/* Wait until the tmux pane contains the given substring (optional, used by tests) */
|
||||
async function waitForPaneText(text: string, timeoutMs = 5000): Promise<string> {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
const pane = tmuxCapturePane("looper", "0");
|
||||
if (pane.includes(text)) return pane;
|
||||
await wait(300);
|
||||
}
|
||||
return tmuxCapturePane("looper", "0");
|
||||
}
|
||||
|
||||
/* Generate a test WAV with a 440 Hz sine wave */
|
||||
function generateTestWav(p: string, durationSec = 1): void {
|
||||
run(`sox -n -r 48000 -b 16 -c 1 ${p} synth ${durationSec} sine 440`);
|
||||
}
|
||||
|
||||
const GEN_TONE_BIN = "/tmp/gen_tone";
|
||||
|
||||
function ensureGenTone(): void {
|
||||
if (!fs.existsSync(GEN_TONE_BIN)) {
|
||||
const src = path.join(__dirname, "gen_tone.c");
|
||||
execSync(`gcc -o ${GEN_TONE_BIN} ${src} -ljack -lm`, { timeout: 10000 });
|
||||
}
|
||||
}
|
||||
|
||||
/* Check if a WAV file contains audio (RMS > 0.001) */
|
||||
function wavHasAudio(p: string): boolean {
|
||||
try {
|
||||
const stat: fs.Stats = fs.statSync(p);
|
||||
return stat.size > 44;
|
||||
} catch {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
function runCmd(cmd: string): string {
|
||||
try {
|
||||
return execSync(cmd, { encoding: 'utf-8', timeout: 3000 }).trim();
|
||||
} catch { return ""; }
|
||||
}
|
||||
|
||||
|
||||
/* ------------------- TESTS ------------------- */
|
||||
|
||||
async function testGridNavigation(): Promise<void> {
|
||||
console.log("\nTest: GRID NAVIGATION");
|
||||
setupTest();
|
||||
const engine = await startEngine();
|
||||
await startClientInTmux();
|
||||
|
||||
// Default location should be Row 0, Col 0
|
||||
let pane = await waitForPaneText("Selected: Grid 0, Row 0, Col 0", 5000);
|
||||
if (pane.includes("Selected: Grid 0, Row 0, Col 0")) {
|
||||
console.log(" PASS: Default selection at origin");
|
||||
} else {
|
||||
console.log(" FAIL: Expected 'Selected: Grid 0, Row 0, Col 0'");
|
||||
console.log(" Actual pane content:\n" + pane);
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Grid navigation test failed");
|
||||
}
|
||||
|
||||
// Move right then down
|
||||
tmuxSendKeys("looper", "0", "l");
|
||||
tmuxSendKeys("looper", "0", "j");
|
||||
await wait(200);
|
||||
pane = tmuxCapturePane("looper", "0");
|
||||
if (pane.includes("Selected: Grid 0, Row 1, Col 1")) {
|
||||
console.log(" PASS: Moved to Row 1, Col 1");
|
||||
} else {
|
||||
console.log(" FAIL: Expected 'Row 1, Col 1'");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Grid navigation test failed");
|
||||
}
|
||||
|
||||
// Cycle back to origin
|
||||
tmuxSendKeys("looper", "0", "h");
|
||||
tmuxSendKeys("looper", "0", "k");
|
||||
await wait(200);
|
||||
pane = tmuxCapturePane("looper", "0");
|
||||
if (pane.includes("Selected: Grid 0, Row 0, Col 0")) {
|
||||
console.log(" PASS: Returned to origin");
|
||||
} else {
|
||||
console.log(" FAIL: Not at origin after h/k");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Grid navigation test failed");
|
||||
}
|
||||
|
||||
engine.kill();
|
||||
teardownTest();
|
||||
}
|
||||
|
||||
async function testChannelAddRemove(): Promise<void> {
|
||||
console.log("\nTest: CHANNEL ADD / REMOVE");
|
||||
setupTest();
|
||||
const engine = await startEngine();
|
||||
await startClientInTmux();
|
||||
openCmdFifo();
|
||||
await wait(500);
|
||||
|
||||
// Send "add" command via FIFO
|
||||
writeFifoCommand("add");
|
||||
await wait(1000);
|
||||
|
||||
// Read status lines and look for CH=1 (channel 1 active)
|
||||
const st = readStatusNonBlock();
|
||||
// Count channels by counting lines starting with "CH="
|
||||
let channelCount = 0;
|
||||
for (const line of st.split("\n")) {
|
||||
if (line.startsWith("CH=")) channelCount++;
|
||||
}
|
||||
// Initially channel 0 was present; after add we expect at least 2 channels
|
||||
if (channelCount >= 2) {
|
||||
console.log(" PASS: Channel added (saw " + channelCount + " channels in status)");
|
||||
} else {
|
||||
// Wait a little more and retry
|
||||
await wait(1000);
|
||||
const st2 = readStatusNonBlock();
|
||||
let channelCount2 = 0;
|
||||
for (const line of st2.split("\n")) {
|
||||
if (line.startsWith("CH=")) channelCount2++;
|
||||
}
|
||||
if (channelCount2 >= 2) {
|
||||
console.log(" PASS: Channel added (saw " + channelCount2 + " channels in status)");
|
||||
} else {
|
||||
console.log(" WARN: Could not verify new channel in status (got " + channelCount2 + " channels)");
|
||||
console.log(" Status data: " + st2);
|
||||
}
|
||||
}
|
||||
|
||||
engine.kill();
|
||||
teardownTest();
|
||||
}
|
||||
|
||||
async function testToggleRecordStop(): Promise<void> {
|
||||
console.log("\nTest: TOGGLE RECORD / STOP");
|
||||
setupTest();
|
||||
const engine = await startEngine();
|
||||
await startClientInTmux();
|
||||
openCmdFifo();
|
||||
await wait(500);
|
||||
|
||||
// Send 'record 0' via FIFO to start recording
|
||||
writeFifoCommand("record 0");
|
||||
await wait(1500);
|
||||
|
||||
// Read status non‑blocking and look for RECORD
|
||||
const stAfterRecord = readStatusNonBlock();
|
||||
if (stAfterRecord.includes("RECORD")) {
|
||||
console.log(" PASS: Status shows RECORD");
|
||||
} else {
|
||||
// Wait a bit more and retry once
|
||||
await wait(500);
|
||||
const st2 = readStatusNonBlock();
|
||||
if (st2.includes("RECORD")) {
|
||||
console.log(" PASS: Status shows RECORD (after delay)");
|
||||
} else {
|
||||
console.log(" STATUS data: " + st2);
|
||||
console.log(" WARN: Did not see RECORD in status");
|
||||
}
|
||||
}
|
||||
|
||||
// Stop
|
||||
writeFifoCommand("stop");
|
||||
await wait(1500);
|
||||
|
||||
const stAfterStop = readStatusNonBlock();
|
||||
if (stAfterStop.includes("IDLE")) {
|
||||
console.log(" PASS: Status shows IDLE after stop");
|
||||
} else {
|
||||
await wait(500);
|
||||
const st3 = readStatusNonBlock();
|
||||
if (st3.includes("IDLE")) {
|
||||
console.log(" PASS: Status shows IDLE after stop (after delay)");
|
||||
} else {
|
||||
console.log(" WARN: Did not see IDLE in status");
|
||||
console.log(" STATUS data: " + st3);
|
||||
}
|
||||
}
|
||||
|
||||
engine.kill();
|
||||
teardownTest();
|
||||
}
|
||||
|
||||
async function testRecordOnSelectedCell(): Promise<void> {
|
||||
console.log("\nTest: RECORD ON SELECTED CELL (col 1, row 0)");
|
||||
setupTest();
|
||||
const engine = await startEngine();
|
||||
await startClientInTmux();
|
||||
openCmdFifo();
|
||||
ensureGenTone();
|
||||
await wait(500);
|
||||
|
||||
// Add a new channel so column 1 (channel 1) exists
|
||||
writeFifoCommand("add");
|
||||
await wait(500);
|
||||
|
||||
// Navigation: move right once to column 1 (channel 1)
|
||||
tmuxSendKeys("looper", "0", "l"); // right once → col 1
|
||||
await wait(500);
|
||||
|
||||
// Verify selection shows column 1
|
||||
let pane = tmuxCapturePane("looper", "0");
|
||||
if (!pane.includes("Selected: Grid 0, Row 0, Col 1")) {
|
||||
console.log(" FAIL: Could not navigate to Col 1");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Navigation to column 1 failed");
|
||||
}
|
||||
console.log(" PASS: Successfully navigated to Col 1");
|
||||
|
||||
// Press 't' to start recording
|
||||
tmuxSendKeys("looper", "0", "t");
|
||||
await wait(1000);
|
||||
|
||||
// Send a harmless key (digit '0') to force TUI to read the updated status FIFO and redraw the grid
|
||||
tmuxSendKeys("looper", "0", "0");
|
||||
await wait(500);
|
||||
|
||||
// Check status FIFO: we expect RECORD on CH=1
|
||||
const st = readStatusNonBlock();
|
||||
const recordOnCh1 = st.includes("CH=1") && st.includes("RECORD");
|
||||
if (recordOnCh1) {
|
||||
console.log(" PASS: Status shows RECORD on CH=1 (the selected column)");
|
||||
} else {
|
||||
console.log(" FAIL: Status does not show RECORD on CH=1");
|
||||
console.log(" Status: " + st.slice(-500));
|
||||
const anyRecord = st.match(/CH=\d+[^]*?RECORD/g) || [];
|
||||
console.log(" All RECORD lines: " + anyRecord.join(" | "));
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Selected column recording did not target correct channel");
|
||||
}
|
||||
|
||||
// Verify that CH=0 (first column) is NOT in RECORD
|
||||
const lineForCh0 = st.split("\n").find(line => line.startsWith("CH=0"));
|
||||
if (lineForCh0 && lineForCh0.includes("RECORD")) {
|
||||
console.log(" FAIL: CH=0 also shows RECORD (unexpected cross‑talk)");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("First channel incorrectly changed");
|
||||
}
|
||||
console.log(" PASS: CH=0 remains idle (no cross‑talk)");
|
||||
|
||||
// Verify grid indicator 'R' appears near cell 1
|
||||
pane = tmuxCapturePane("looper", "0");
|
||||
// Use a simple presence check with approximate proximity
|
||||
const paneLines = pane.split("\n");
|
||||
let cell1Line = -1, recordLine = -1;
|
||||
for (let i = 0; i < paneLines.length; i++) {
|
||||
if (paneLines[i].includes(" 1")) cell1Line = i;
|
||||
if (paneLines[i].includes("R")) recordLine = i;
|
||||
}
|
||||
if (cell1Line !== -1 && recordLine !== -1 && Math.abs(recordLine - cell1Line) <= 2) {
|
||||
console.log(" PASS: Grid shows 'R' indicator near cell 1");
|
||||
} else {
|
||||
console.log(" FAIL: Could not find 'R' indicator near cell 1 in pane");
|
||||
console.log(" Cell1 line: " + cell1Line + ", R line: " + recordLine);
|
||||
console.log(" Pane excerpt:\n" + pane.slice(0, 1000));
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Grid did not show 'R' indicator for selected cell");
|
||||
}
|
||||
|
||||
engine.kill();
|
||||
teardownTest();
|
||||
}
|
||||
|
||||
/** Wait until the status FIFO contains the given substring or timeout */
|
||||
async function waitForStatusContaining(substr: string, timeoutMs = 8000): Promise<string> {
|
||||
const deadline = Date.now() + timeoutMs;
|
||||
while (Date.now() < deadline) {
|
||||
const data = readStatusNonBlock();
|
||||
if (data.includes(substr)) return data;
|
||||
await wait(200);
|
||||
}
|
||||
return readStatusNonBlock();
|
||||
}
|
||||
|
||||
async function testTUIRecordAndLoop(): Promise<void> {
|
||||
console.log("\nTest: TUI RECORD AND LOOP (T key)");
|
||||
setupTest();
|
||||
const engine = await startEngine();
|
||||
await startClientInTmux();
|
||||
openCmdFifo();
|
||||
ensureGenTone();
|
||||
await wait(500);
|
||||
|
||||
// press 't' to start recording on default cell (col 0, row 0)
|
||||
tmuxSendKeys("looper", "0", "t");
|
||||
await wait(1000);
|
||||
|
||||
// 1) Check status FIFO shows RECORD
|
||||
const statusRec = await waitForStatusContaining("RECORD", 5000);
|
||||
if (!statusRec.includes("RECORD")) {
|
||||
console.log(" FAIL: Status FIFO did not show RECORD after pressing t");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("RECORD state not achieved via TUI");
|
||||
}
|
||||
console.log(" PASS: Status FIFO shows RECORD");
|
||||
|
||||
// 2) Check tmux pane for 'R' indicator (first character of cell in grid)
|
||||
const paneAfterT = tmuxCapturePane("looper", "0");
|
||||
const paneContainsR = paneAfterT.includes("R");
|
||||
if (!paneContainsR) {
|
||||
console.log(" FAIL: TUI grid does not show 'R' indicator after pressing t");
|
||||
console.log(" Pane excerpt (maybe): " + paneAfterT.slice(0, 1000));
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Grid indicator not updated");
|
||||
}
|
||||
console.log(" PASS: TUI grid shows 'R' indicator");
|
||||
|
||||
// Play tone into looper:input (3 seconds)
|
||||
execSync(`${GEN_TONE_BIN} 3.0 "looper:input"`, { timeout: 8000 });
|
||||
|
||||
// press 't' again to stop recording -> loop
|
||||
tmuxSendKeys("looper", "0", "t");
|
||||
const statusLoop = await waitForStatusContaining("LOOPING", 8000);
|
||||
if (!statusLoop.includes("LOOPING")) {
|
||||
console.log(" WARN: Did not see LOOPING in status, continuing");
|
||||
} else {
|
||||
console.log(" PASS: Status FIFO shows LOOPING after second t");
|
||||
}
|
||||
|
||||
// Check pane for 'L' indicator
|
||||
const paneAfterLoop = tmuxCapturePane("looper", "0");
|
||||
const paneContainsL = paneAfterLoop.includes("L");
|
||||
if (!paneContainsL) {
|
||||
console.log(" FAIL: TUI grid does not show 'L' indicator after loop");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Grid indicator not updated for LOOPING");
|
||||
}
|
||||
console.log(" PASS: TUI grid shows 'L' indicator");
|
||||
|
||||
// Wait a couple of repetitions (3 seconds) then save via FIFO to verify audio
|
||||
await wait(3000);
|
||||
|
||||
// Save via FIFO
|
||||
writeFifoCommand("save");
|
||||
await wait(3000);
|
||||
|
||||
// Check save.wav exists and has audio
|
||||
const savePath = path.join(PROJECT_DIR, "save.wav");
|
||||
let saveOk = false;
|
||||
if (fs.existsSync(savePath)) {
|
||||
const stat = fs.statSync(savePath);
|
||||
if (stat.size > 44) {
|
||||
saveOk = true;
|
||||
console.log(` PASS: save.wav created (${stat.size} bytes) – loop has audio`);
|
||||
}
|
||||
}
|
||||
if (!saveOk) {
|
||||
console.log(" FAIL: save.wav not created or too small – loop not producing audio");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Loop playback not producing audio");
|
||||
}
|
||||
|
||||
engine.kill();
|
||||
teardownTest();
|
||||
}
|
||||
|
||||
async function testSaveLoad(): Promise<void> {
|
||||
console.log("\nTest: SAVE / LOAD");
|
||||
setupTest();
|
||||
const engine = await startEngine();
|
||||
await startClientInTmux();
|
||||
openCmdFifo();
|
||||
await wait(1000);
|
||||
|
||||
ensureGenTone();
|
||||
|
||||
// Start recording via FIFO with retry
|
||||
let recordAttempts = 0;
|
||||
while (recordAttempts < 3) {
|
||||
writeFifoCommand("record 0");
|
||||
const st1 = await waitForStatusContaining("RECORD", 3000);
|
||||
if (st1.includes("RECORD")) {
|
||||
console.log(" DEBUG: RECORD confirmed after attempt " + (recordAttempts + 1));
|
||||
break;
|
||||
}
|
||||
recordAttempts++;
|
||||
console.log(" WARN: First toggle attempt " + (recordAttempts) + " did not produce RECORD, retrying...");
|
||||
}
|
||||
if (recordAttempts >= 3) {
|
||||
console.log(" FAIL: Could not enter RECORD after 3 attempts");
|
||||
const st1 = readStatusNonBlock();
|
||||
console.log(" DEBUG status after first toggle:", st1.slice(0, 200));
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Could not enter RECORD");
|
||||
}
|
||||
|
||||
// Play tone into looper:input using gen_tone (synchronous, blocks until done)
|
||||
execSync(`${GEN_TONE_BIN} 3.0 "looper:input"`, { timeout: 8000 }); // 3 seconds tone
|
||||
|
||||
// Stop recording (toggle again -> loop)
|
||||
writeFifoCommand("record 0");
|
||||
const loopState = await waitForStatusContaining("LOOPING", 8000);
|
||||
if (!loopState.includes("LOOPING")) {
|
||||
console.log(" WARN: Second toggle did not produce LOOPING within 8s, will attempt save anyway");
|
||||
console.log(" DEBUG status after second toggle:", loopState.slice(0, 200));
|
||||
} else {
|
||||
console.log(" DEBUG: LOOPING confirmed");
|
||||
}
|
||||
|
||||
// Save via FIFO
|
||||
writeFifoCommand("save");
|
||||
await wait(6000); // wait for synchronous save
|
||||
|
||||
// Print engine stderr log for save debug
|
||||
try {
|
||||
const stderrLog = execSync("tail -5 /tmp/engine_stderr.log", { encoding: "utf-8" });
|
||||
console.log(" Engine stderr:", stderrLog.trim());
|
||||
} catch {}
|
||||
|
||||
// Look for save file in project directory (engine writes there)
|
||||
const files = fs.readdirSync(PROJECT_DIR);
|
||||
const saveFile = files.find(f => f === "save.wav");
|
||||
if (saveFile) {
|
||||
const stat = fs.statSync(path.join(PROJECT_DIR, saveFile));
|
||||
if (stat.size > 44) {
|
||||
console.log(` PASS: save.wav created (${stat.size} bytes)`);
|
||||
} else {
|
||||
console.log(` FAIL: save.wav exists but header may be incomplete (size=${stat.size})`);
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("save.wav too short");
|
||||
}
|
||||
} else {
|
||||
console.log(" FAIL: save.wav not found in project directory");
|
||||
console.log(" Directory listing: " + fs.readdirSync(PROJECT_DIR).filter(f => f.endsWith(".wav")).join(","));
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("save.wav not created");
|
||||
}
|
||||
|
||||
// Load into channel 0
|
||||
const testWavPath = path.join(PROJECT_DIR, "loop.wav");
|
||||
generateTestWav(testWavPath, 3.0); // 3 seconds loop to capture
|
||||
await wait(500);
|
||||
|
||||
// Send load command (no path argument – engine will read loop.wav)
|
||||
execSync("echo 'load' > /tmp/looper_cmd", { timeout: 1000 });
|
||||
await wait(1000);
|
||||
|
||||
// Wait for LOOPING state after load
|
||||
const loadState = await waitForStatusContaining("LOOPING", 5000);
|
||||
if (!loadState.includes("LOOPING")) {
|
||||
console.log(" WARN: Status did not show LOOPING after load command");
|
||||
console.log(" Status: " + loadState.slice(0,200));
|
||||
}
|
||||
|
||||
// Check engine stderr for load success line
|
||||
let loadSucceeded = false;
|
||||
try {
|
||||
const stderrLog = execSync("tail -5 /tmp/engine_stderr.log", { encoding: "utf-8" });
|
||||
console.log(" Engine stderr:", stderrLog.trim());
|
||||
if (stderrLog.includes("LOAD: success")) {
|
||||
loadSucceeded = true;
|
||||
console.log(" PASS: Loaded sample acknowledged by engine");
|
||||
}
|
||||
} catch (e) {
|
||||
console.log(" Could not read engine stderr, continuing");
|
||||
}
|
||||
|
||||
if (!loadSucceeded) {
|
||||
console.log(" FAIL: Engine did not report successful load");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Engine load reported failure");
|
||||
}
|
||||
|
||||
engine.kill();
|
||||
teardownTest();
|
||||
}
|
||||
|
||||
async function testRecordOnMissingChannel(): Promise<void> {
|
||||
console.log("\nTest: RECORD ON MISSING CHANNEL (col 2, row 2)");
|
||||
setupTest();
|
||||
const engine = await startEngine();
|
||||
await startClientInTmux();
|
||||
// Do NOT add any channels – only channel 0 exists
|
||||
await wait(500);
|
||||
|
||||
// Navigate to row 2, col 2 (two rights, two downs)
|
||||
tmuxSendKeys("looper", "0", "l");
|
||||
tmuxSendKeys("looper", "0", "l");
|
||||
await wait(200);
|
||||
tmuxSendKeys("looper", "0", "j");
|
||||
tmuxSendKeys("looper", "0", "j");
|
||||
await wait(200);
|
||||
|
||||
// Verify selection line
|
||||
let pane = tmuxCapturePane("looper", "0");
|
||||
if (!pane.includes("Selected: Grid 0, Row 2, Col 2")) {
|
||||
console.log(" FAIL: Could not navigate to Row 2, Col 2");
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Navigation to (2,2) failed");
|
||||
}
|
||||
|
||||
// Press 't' to start recording
|
||||
tmuxSendKeys("looper", "0", "t");
|
||||
// Trigger a status read by sending a harmless key
|
||||
tmuxSendKeys("looper", "0", "0");
|
||||
await wait(1000);
|
||||
|
||||
// Read status FIFO – expect RECORD on CH=2 with SC=2
|
||||
const st = readStatusNonBlock();
|
||||
const expectedLine = "CH=2 SC=2 STATE=RECORD";
|
||||
if (!st.includes(expectedLine)) {
|
||||
console.log(" FAIL: Status does not show \"CH=2 SC=2 STATE=RECORD\"");
|
||||
console.log(" Status: " + st.slice(-500));
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Expected RECORD on channel 2, scene 2");
|
||||
}
|
||||
console.log(" PASS: Status shows RECORD on CH=2 SC=2");
|
||||
|
||||
// Also verify the grid shows 'R' near cell (2,2)
|
||||
pane = tmuxCapturePane("looper", "0");
|
||||
const paneLines = pane.split("\n");
|
||||
let cellLine = -1, recordLine = -1;
|
||||
for (let i = 0; i < paneLines.length; i++) {
|
||||
if (paneLines[i].includes(" 2")) cellLine = i;
|
||||
if (paneLines[i].includes("R")) recordLine = i;
|
||||
}
|
||||
if (cellLine !== -1 && recordLine !== -1 && Math.abs(recordLine - cellLine) <= 2) {
|
||||
console.log(" PASS: Grid shows 'R' indicator near cell 2");
|
||||
} else {
|
||||
console.log(" FAIL: Could not find 'R' near cell 2 in pane");
|
||||
console.log(" Pane excerpt:\n" + pane.slice(0, 1000));
|
||||
engine.kill(); teardownTest();
|
||||
throw new Error("Grid indicator missing for col 2");
|
||||
}
|
||||
|
||||
engine.kill();
|
||||
teardownTest();
|
||||
}
|
||||
|
||||
async function main(): Promise<void> {
|
||||
console.log("=== Looper E2E Tests ===\n");
|
||||
|
||||
const tests = [testGridNavigation, testChannelAddRemove, testToggleRecordStop, testTUIRecordAndLoop, testRecordOnSelectedCell, testSaveLoad, testRecordOnMissingChannel];
|
||||
let passCount = 0;
|
||||
let failCount = 0;
|
||||
|
||||
for (const testFn of tests) {
|
||||
process.stdout.write("\n");
|
||||
try {
|
||||
await Promise.race([
|
||||
testFn(),
|
||||
new Promise<void>((_, reject) => setTimeout(() => reject(new Error("Test timed out")), 60000))
|
||||
]);
|
||||
passCount++;
|
||||
} catch (e: any) {
|
||||
console.log(` ERROR: ${e.message}`);
|
||||
failCount++;
|
||||
}
|
||||
}
|
||||
|
||||
console.log(`\n=== Results: ${passCount} passed, ${failCount} failed ===`);
|
||||
if (failCount > 0) {
|
||||
process.exit(1);
|
||||
}
|
||||
process.exit(0);
|
||||
}
|
||||
|
||||
main().catch((e) => {
|
||||
console.error("Unhandled error:", e);
|
||||
process.exit(1);
|
||||
});
|
||||
Reference in New Issue
Block a user