Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

test: identify stalled animatic capture phases (#13284)

[._.]/ Adam Eivy17a1eb53ccb8
diff --git a/server/services/musicVideo/animaticCapture.browser.test.js b/server/services/musicVideo/animaticCapture.browser.test.js
index f33f202d2e..e1afce5e3a 100644
--- a/server/services/musicVideo/animaticCapture.browser.test.js
+++ b/server/services/musicVideo/animaticCapture.browser.test.js
@@ -1,4 +1,4 @@
-import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from 'vitest';
import { mkdtemp, rm, symlink, writeFile } from 'node:fs/promises';
import { tmpdir } from 'node:os';
import { join, resolve } from 'node:path';
@@ -7,6 +7,7 @@ import express from 'express';
import sharp from 'sharp';
import { chromium } from 'playwright-core';
import { startOwnedBrowserFixture } from '../../test/browserFixture.js';
+import { createTestPhaseDiagnostics } from '../../test/testPhaseDiagnostics.js';
import { browserSuiteCanRun, resolveTestChrome, resolveClientBundler } from '../../lib/browserSuiteGate.js';
import { findFfmpeg } from '../../lib/ffmpeg.js';
import { filmLookPreset } from '../../lib/filmLook.js';
@@ -97,24 +98,27 @@ function App(){const[state,setState]=useState(null);window.show=(project,t)=>{wi
await page.waitForFunction(() => typeof window.show === 'function');
}, 30000);
+ let phase;
+ beforeEach(({ onTestFailed }) => { phase = createTestPhaseDiagnostics(onTestFailed); });
+
const show = async (value, t) => {
- await page.evaluate(({ value, t }) => { window.uploads = []; window.show(value, t); }, { value, t });
+ await phase('show-render', () => page.evaluate(({ value, t }) => { window.uploads = []; window.show(value, t); }, { value, t }));
// Assigning currentTime is synchronous; its seeked handler can still leave Ending later.
- await page.waitForFunction((t) => Math.abs(document.querySelector('audio')?.currentTime - t) < 0.00001 && !document.querySelector('audio').seeking, t);
- await page.waitForFunction(() => [...document.querySelectorAll('figure img')].every((image) => image.complete && image.naturalWidth > 0));
+ await phase('show-song-seek', () => page.waitForFunction((t) => Math.abs(document.querySelector('audio')?.currentTime - t) < 0.00001 && !document.querySelector('audio').seeking, t));
+ await phase('show-images-ready', () => page.waitForFunction(() => [...document.querySelectorAll('figure img')].every((image) => image.complete && image.naturalWidth > 0)));
};
const capture = async (label = '') => {
- await page.evaluate(() => { window.uploads = []; window.captureErrors = []; });
- await page.waitForFunction(() => [...document.querySelectorAll('video[data-preview-video]')].every(video => Number(getComputedStyle(video.parentElement).opacity) === 0 || (!video.seeking && video.dataset.pausedFrame === String(video.currentTime))));
- await page.getByRole('button', { name: 'Save frame', exact: true }).click();
- await page.waitForFunction(() => window.uploads.length > 0 || window.captureErrors.length > 0);
- expect(await page.evaluate(() => window.captureErrors), label).toEqual([]);
- const saved = Buffer.from(await page.evaluate(() => window.uploads.at(-1)));
+ await phase('capture-reset', () => page.evaluate(() => { window.uploads = []; window.captureErrors = []; }));
+ await phase('capture-video-ready', () => page.waitForFunction(() => [...document.querySelectorAll('video[data-preview-video]')].every(video => Number(getComputedStyle(video.parentElement).opacity) === 0 || (!video.seeking && video.dataset.pausedFrame === String(video.currentTime)))));
+ await phase('capture-click', () => page.getByRole('button', { name: 'Save frame', exact: true }).click());
+ await phase('capture-upload-or-error', () => page.waitForFunction(() => window.uploads.length > 0 || window.captureErrors.length > 0));
+ expect(await phase('capture-read-errors', () => page.evaluate(() => window.captureErrors)), label).toEqual([]);
+ const saved = Buffer.from(await phase('capture-read-upload', () => page.evaluate(() => window.uploads.at(-1))));
const picture = page.getByLabel('Storyboard animatic', { exact: true }).locator(':scope > div').first();
// Global notification chrome is outside the video frame being saved.
- const displayed = await picture.screenshot({ style: '[data-toast-id]{visibility:hidden}' });
- const a = await sharp(saved).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
- const b = await sharp(displayed).ensureAlpha().raw().toBuffer({ resolveWithObject: true });
+ const displayed = await phase('capture-screenshot', () => picture.screenshot({ style: '[data-toast-id]{visibility:hidden}' }));
+ const a = await phase('capture-decode-saved', () => sharp(saved).ensureAlpha().raw().toBuffer({ resolveWithObject: true }));
+ const b = await phase('capture-decode-displayed', () => sharp(displayed).ensureAlpha().raw().toBuffer({ resolveWithObject: true }));
expect([a.info.width, a.info.height]).toEqual([b.info.width, b.info.height]);
let difference = 0, opaque = 0;
for (let i = 0; i < a.data.length; i += 1) {
@@ -303,23 +307,23 @@ function App(){const[state,setState]=useState(null);window.show=(project,t)=>{wi
it('freezes the displayed outro canvas and exact look before capture', async () => {
await show(project([still], { statsOutro: { enabled: true, durationSec: 8 }, filmLook: filmLookPreset('polaroid') }), 1);
const look = page.getByRole('button', { name: 'Film look', exact: true });
- if (await look.getAttribute('aria-pressed') === 'false') await look.click();
+ await phase('outro-enable-look', async () => {
+ if (await look.getAttribute('aria-pressed') === 'false') await look.click();
+ });
// The canvas mounts with provisional counts, so its presence/fonts do not
// establish a capture basis. Wait for the tally, then let React paint it.
const statsReady = page.waitForResponse('**/api/music-video/*/stats-outro');
- await page.getByRole('button', { name: 'Ending', exact: true }).click();
- await page.getByTestId('animatic-stats-outro').waitFor();
- const statsResponse = await statsReady;
+ await phase('outro-activate', () => page.getByRole('button', { name: 'Ending', exact: true }).click());
+ await phase('outro-canvas-ready', () => page.getByTestId('animatic-stats-outro').waitFor());
+ const statsResponse = await phase('outro-stats-response', () => statsReady);
expect(statsResponse.ok()).toBe(true);
- expect(await statsResponse.finished()).toBeNull();
- await page.evaluate(async () => {
- await document.fonts.ready;
- await new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)));
- });
+ expect(await phase('outro-stats-finished', () => statsResponse.finished())).toBeNull();
+ await phase('outro-fonts-ready', () => page.evaluate(() => document.fonts.ready));
+ await phase('outro-paint-settled', () => page.evaluate(() => new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)))));
const saved = await capture();
- expect(await page.locator('[data-film-look="exact"]').count()).toBe(1);
- await page.evaluate(() => new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done))));
- await page.evaluate(() => { window.uploads = []; });
+ expect(await phase('outro-exact-look', () => page.locator('[data-film-look="exact"]').count())).toBe(1);
+ await phase('outro-repeat-paint', () => page.evaluate(() => new Promise((done) => requestAnimationFrame(() => requestAnimationFrame(done)))));
+ await phase('outro-repeat-reset', () => page.evaluate(() => { window.uploads = []; }));
expect(Buffer.compare(saved, await capture())).toBe(0);
});
diff --git a/server/test/testPhaseDiagnostics.js b/server/test/testPhaseDiagnostics.js
new file mode 100644
index 0000000000..3202d624cf
--- /dev/null
+++ b/server/test/testPhaseDiagnostics.js
@@ -0,0 +1,36 @@
+// Observe awaited test operations without racing them or changing their deadlines.
+// Failure hooks run before suite-owned teardown and survive quiet CI reporters.
+export function createTestPhaseDiagnostics(onTestFailed) {
+ const started = performance.now();
+ const events = [];
+ let active = 'not-started';
+ let ended = false;
+ const record = (name, state) => {
+ if (ended) return;
+ if (events.length === 24) events.shift();
+ events.push(`${name}:${state}@${Math.round(performance.now() - started)}ms`);
+ };
+ onTestFailed(({ task }) => {
+ ended = true;
+ const evidence = `Test phases: active=${active}; elapsed=${Math.round(performance.now() - started)}ms; recent=${events.join(',')}`;
+ for (const error of task.result.errors) {
+ error.message += `\n${evidence}`;
+ if (error.stack) error.stack += `\n${evidence}`;
+ }
+ });
+ return async (name, operation) => {
+ // Only developer-authored labels, never browser content, URLs or errors.
+ if (!/^[a-z][a-z0-9-]{0,63}$/.test(name)) throw new Error('Invalid test phase label');
+ active = name;
+ record(name, 'start');
+ try {
+ const value = await operation();
+ record(name, 'done');
+ active = 'between-phases';
+ return value;
+ } catch (error) {
+ record(name, 'failed');
+ throw error;
+ }
+ };
+}
diff --git a/server/test/testPhaseDiagnostics.test.js b/server/test/testPhaseDiagnostics.test.js
new file mode 100644
index 0000000000..3e5839066f
--- /dev/null
+++ b/server/test/testPhaseDiagnostics.test.js
@@ -0,0 +1,58 @@
+import { expect, it } from 'vitest';
+import { spawnSync } from 'node:child_process';
+import { mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+// Uniquely catches diagnostics lost by a runner timeout or quiet CI reporting,
+// and proves observation neither replaces the original error nor waits on Chrome.
+it('retains bounded phase evidence with the original failure before suite teardown', () => {
+ const root = mkdtempSync(join(tmpdir(), 'test-phase-contract-'));
+ const vitest = fileURLToPath(new URL('../node_modules/vitest/vitest.mjs', import.meta.url));
+ const api = fileURLToPath(new URL('../node_modules/vitest/dist/index.js', import.meta.url));
+ const diagnostics = fileURLToPath(new URL('./testPhaseDiagnostics.js', import.meta.url));
+ const report = join(root, 'report.json');
+ const cleanup = join(root, 'cleanup.json');
+ try {
+ writeFileSync(join(root, 'vitest.config.mjs'), 'export default { test: { maxWorkers: 1, fileParallelism: false } };');
+ writeFileSync(join(root, 'phases.test.mjs'), `
+ import { it, afterAll } from ${JSON.stringify(api)};
+ import { writeFileSync } from 'node:fs';
+ import { createTestPhaseDiagnostics } from ${JSON.stringify(diagnostics)};
+ const observed = [];
+ const observe = context => createTestPhaseDiagnostics(callback => context.onTestFailed(result => {
+ callback(result);
+ observed.push(result.task.result.errors.map(error => error.message));
+ }));
+ it('stalled screenshot', async context => {
+ const phase = observe(context);
+ for (let i = 0; i < 30; i++) await phase('capture-ready', () => undefined);
+ await phase('capture-screenshot', () => new Promise(() => {}));
+ }, 40);
+ it('rejected upload', async context => {
+ const phase = observe(context);
+ await phase('capture-upload-or-error', () => { throw new Error('original synthetic failure'); });
+ });
+ afterAll(() => writeFileSync(${JSON.stringify(cleanup)}, JSON.stringify(observed)));
+ `);
+ const env = { ...process.env, NODE_ENV: 'test', NODE_DISABLE_COMPILE_CACHE: '1' };
+ delete env.VITEST_POOL_ID;
+ delete env.VITEST_WORKER_ID;
+ const result = spawnSync(process.execPath, [vitest, 'run', '--configLoader', 'native', '--root', root,
+ '--config', join(root, 'vitest.config.mjs'), '--silent', '--reporter=json', '--outputFile', report],
+ { env, encoding: 'utf8', timeout: 20000 });
+ expect(result.status, result.stdout + result.stderr).toBe(1);
+ const failures = JSON.parse(readFileSync(report, 'utf8')).testResults[0].assertionResults;
+ expect(failures.map(test => test.status)).toEqual(['failed', 'failed']);
+ expect(failures[0].failureMessages.join('\n')).toContain('Test timed out in 40ms');
+ expect(failures[0].failureMessages.join('\n')).toContain('active=capture-screenshot');
+ expect(failures[1].failureMessages.join('\n')).toContain('original synthetic failure');
+ expect(failures[1].failureMessages.join('\n')).toContain('active=capture-upload-or-error');
+ const observed = JSON.parse(readFileSync(cleanup, 'utf8'));
+ expect(observed).toHaveLength(2);
+ expect(observed[0][0]).toContain('capture-screenshot:start@');
+ expect(observed[0][0].split('recent=')[1].split(',')).toHaveLength(24);
+ expect(observed[1][0]).toContain('capture-upload-or-error:failed@');
+ } finally { rmSync(root, { recursive: true, force: true }); }
+});