fix: improve maestro test output

Author: thymikee

src/__tests__/cli-network.test.ts

@@ -8,6 +8,7 @@ import { runCliCapture } from './cli-capture.ts';
 function makeFailedReplayResult() {
   return {
     file: '/tmp/02-fail.ad',
+    title: 'Checkout failure',
     session: 'default:test:suite:2',
     status: 'failed',
     durationMs: 5,
@@ -106,11 +107,14 @@ test('test command prints suite summary and exits non-zero on failures', async (
   assert.equal(result.calls[0]?.meta?.requestProgress, 'replay-test');
   assert.match(result.stderr, /Running replay suite\.\.\./);
   assert.doesNotMatch(result.stdout, /PASS \/tmp\/01-pass\.ad/);
-  assert.match(result.stdout, /FAIL \/tmp\/02-fail\.ad after 2 attempts \(5ms\)/);
+  assert.match(
+    result.stdout,
+    /FAIL "Checkout failure" in 02-fail\.ad after 2 attempts \(total 0\.005s\)/,
+  );
   assert.match(result.stdout, /Replay failed at step 1 \(open Demo\): boom/);
   assert.match(result.stdout, /artifacts: \/tmp\/test-artifacts\/02-fail/);
   assert.doesNotMatch(result.stdout, /SKIP \/tmp\/03-skip\.ad/);
-  assert.match(result.stdout, /Test summary: 1 passed, 1 failed in 25ms/);
+  assert.match(result.stdout, /Test summary: 1 passed, 1 failed in 0\.025s/);
 });
 
 test('test command --verbose prints all test statuses', async () => {
@@ -120,8 +124,8 @@ test('test command --verbose prints all test statuses', async () => {
 
   assert.equal(result.code, 1);
   assert.match(result.stderr, /Running replay suite\.\.\./);
-  assert.match(result.stdout, /PASS \/tmp\/01-pass\.ad \(10ms\)/);
-  assert.match(result.stdout, /SKIP \/tmp\/03-skip\.ad/);
+  assert.match(result.stdout, /PASS 01-pass\.ad \(0\.01s\)/);
+  assert.match(result.stdout, /SKIP 03-skip\.ad/);
 });
 
 test('test command reports flaky passed-on-retry cases in the default summary', async () => {
@@ -138,20 +142,38 @@ test('test command reports flaky passed-on-retry cases in the default summary',
       failures: [],
       tests: [
         {
-          file: '/tmp/01-flaky.ad',
+          file: '/tmp/auth-flow.yml',
+          title: 'Authentication flow',
           session: 'default:test:suite:1',
           status: 'passed',
-          durationMs: 10,
+          durationMs: 112151,
+          finalAttemptDurationMs: 17492,
           attempts: 2,
+          attemptFailures: [
+            {
+              attempt: 1,
+              message: 'Replay failed at step 3 (tapOn "Log in"): selector not found',
+              durationMs: 94659,
+            },
+          ],
         },
       ],
     },
   }));
 
   assert.equal(result.code, null);
   assert.match(result.stderr, /Running replay suite\.\.\./);
-  assert.match(result.stdout, /FLAKY \/tmp\/01-flaky\.ad after 2 attempts \(10ms\)/);
-  assert.match(result.stdout, /Test summary: 1 passed, 0 failed, 1 flaky in 25ms/);
+  assert.doesNotMatch(result.stdout, /FLAKY/);
+  assert.match(result.stdout, /Test summary: 1 passed, 0 failed, 1 flaky in 0\.025s/);
+  assert.match(result.stdout, /Flaky tests:/);
+  assert.match(
+    result.stdout,
+    /PASS "Authentication flow" after 2 attempts \(passed attempt 17\.5s, total 112\.2s\)/,
+  );
+  assert.match(
+    result.stdout,
+    /attempt 1 failed \(94\.7s\): Replay failed at step 3 \(tapOn "Log in"\): selector not found/,
+  );
 });
 
 test('test --maestro forwards Maestro backend and platform for directory suites', async () => {

src/cli-test.ts

@@ -40,16 +40,15 @@ function renderReplayTestSummary(
     for (const entry of data.failures) {
       renderFailedTestResult(entry);
     }
-    for (const entry of flaky) {
-      renderFlakyTestResult(entry);
-    }
   }
 
   const durationMs = typeof data.durationMs === 'number' ? data.durationMs : undefined;
   const flakySuffix = flaky.length > 0 ? `, ${flaky.length} flaky` : '';
+  const durationSuffix = durationMs !== undefined ? ` in ${formatDurationSeconds(durationMs)}` : '';
   process.stdout.write(
-    `Test summary: ${data.passed} passed, ${data.failed} failed${flakySuffix}${durationMs !== undefined ? ` in ${durationMs}ms` : ''}\n`,
+    `Test summary: ${data.passed} passed, ${data.failed} failed${flakySuffix}${durationSuffix}\n`,
   );
+  renderFlakyTestSummary(flaky);
   return getReplayTestExitCode(data);
 }
 
@@ -59,11 +58,10 @@ function renderVerboseTestResult(result: ReplaySuiteTestResult): void {
     return;
   }
 
-  const prefix = replayResultPrefix(result);
-  const attemptSuffix =
-    'attempts' in result && result.attempts > 1 ? ` after ${result.attempts} attempts` : '';
-  const durationSuffix = result.durationMs > 0 ? ` (${result.durationMs}ms)` : '';
-  process.stdout.write(`${prefix} ${result.file}${attemptSuffix}${durationSuffix}\n`);
+  const durationSuffix = formatReplayTestDurationSuffix(result);
+  process.stdout.write(
+    `${replayResultPrefix(result)} ${replayTestDisplayName(result)}${durationSuffix}\n`,
+  );
   if (result.status === 'skipped') {
     process.stdout.write(`  ${result.message ?? 'skipped'}\n`);
   }
@@ -73,16 +71,18 @@ function renderFailedTestResult(
   result: Extract<ReplaySuiteTestResult, { status: 'failed' }>,
 ): void {
   const attemptSuffix = result.attempts > 1 ? ` after ${result.attempts} attempts` : '';
-  const durationSuffix = result.durationMs > 0 ? ` (${result.durationMs}ms)` : '';
-  process.stdout.write(`FAIL ${result.file}${attemptSuffix}${durationSuffix}\n`);
+  const durationSuffix = formatReplayTestDurationSuffix(result);
+  process.stdout.write(
+    `FAIL ${replayFailedTestDisplayName(result)}${attemptSuffix}${durationSuffix}\n`,
+  );
   process.stdout.write(`  ${result.error?.message ?? 'Unknown test failure'}\n`);
   for (const line of replayFailureConsoleLines(result)) {
     process.stdout.write(`  ${line}\n`);
   }
 }
 
 function replayResultPrefix(result: ReplaySuiteTestResult): string {
-  if (result.status === 'passed') return result.attempts > 1 ? 'FLAKY' : 'PASS';
+  if (result.status === 'passed') return 'PASS';
   if (result.status === 'skipped') return 'SKIP';
   return 'INFO';
 }
@@ -98,17 +98,83 @@ function replayFailureConsoleLines(
   ].filter(Boolean);
 }
 
-function renderFlakyTestResult(result: Extract<ReplaySuiteTestResult, { status: 'passed' }>): void {
-  const durationSuffix = result.durationMs > 0 ? ` (${result.durationMs}ms)` : '';
-  process.stdout.write(`FLAKY ${result.file} after ${result.attempts} attempts${durationSuffix}\n`);
-}
-
 function isFlakyReplayTestResult(
   result: ReplaySuiteTestResult,
 ): result is Extract<ReplaySuiteTestResult, { status: 'passed' }> {
   return result.status === 'passed' && result.attempts > 1;
 }
 
+function renderFlakyTestSummary(
+  results: Array<Extract<ReplaySuiteTestResult, { status: 'passed' }>>,
+): void {
+  if (results.length === 0) return;
+  process.stdout.write('Flaky tests:\n');
+  for (const result of results) {
+    process.stdout.write(
+      `  PASS ${replayTestDisplayName(result)} after ${result.attempts} attempts${formatFlakyReplayDurationSuffix(result)}\n`,
+    );
+    for (const failure of result.attemptFailures ?? []) {
+      const attemptDuration =
+        typeof failure.durationMs === 'number'
+          ? ` (${formatDurationSeconds(failure.durationMs)})`
+          : '';
+      process.stdout.write(
+        `    attempt ${failure.attempt} failed${attemptDuration}: ${failure.message}\n`,
+      );
+    }
+  }
+}
+
+function replayTestDisplayName(result: ReplaySuiteTestResult): string {
+  const title = replayTestTitle(result);
+  if (title && title.length > 0) return JSON.stringify(title);
+  return path.basename(result.file);
+}
+
+function replayFailedTestDisplayName(
+  result: Extract<ReplaySuiteTestResult, { status: 'failed' }>,
+): string {
+  const title = replayTestTitle(result);
+  const filename = path.basename(result.file);
+  return title && title.length > 0 ? `${JSON.stringify(title)} in ${filename}` : filename;
+}
+
+function replayTestCaseName(result: ReplaySuiteTestResult): string {
+  return replayTestTitle(result) ?? path.basename(result.file);
+}
+
+function replayTestTitle(result: ReplaySuiteTestResult): string | undefined {
+  const title = result.title?.trim();
+  return title && title.length > 0 ? title : undefined;
+}
+
+function formatReplayTestDurationSuffix(result: ReplaySuiteTestResult): string {
+  if (result.status === 'passed' && result.attempts > 1) {
+    return formatFlakyReplayDurationSuffix(result);
+  }
+  if (result.status === 'failed' && result.attempts > 1 && result.durationMs > 0) {
+    return ` (total ${formatDurationSeconds(result.durationMs)})`;
+  }
+
+  const durationMs =
+    result.status === 'passed' && typeof result.finalAttemptDurationMs === 'number'
+      ? result.finalAttemptDurationMs
+      : result.durationMs;
+  return durationMs > 0 ? ` (${formatDurationSeconds(durationMs)})` : '';
+}
+
+function formatFlakyReplayDurationSuffix(
+  result: Extract<ReplaySuiteTestResult, { status: 'passed' }>,
+): string {
+  const timings = [
+    typeof result.finalAttemptDurationMs === 'number'
+      ? `passed attempt ${formatDurationSeconds(result.finalAttemptDurationMs)}`
+      : '',
+    result.durationMs > 0 ? `total ${formatDurationSeconds(result.durationMs)}` : '',
+  ].filter(Boolean);
+  return timings.length > 0 ? ` (${timings.join(', ')})` : '';
+}
+
 function getReplayTestExitCode(data: ReplaySuiteResult): number {
   return data.failed > 0 ? 1 : 0;
 }
@@ -144,7 +210,7 @@ function buildReplayJunitXml(suite: ReplaySuiteResult): string {
 }
 
 function renderJUnitTestCase(test: ReplaySuiteTestResult): string[] {
-  const name = xmlEscape(path.basename(test.file));
+  const name = xmlEscape(replayTestCaseName(test));
   const className = xmlEscape(
     path.dirname(test.file) === '.' ? test.file : path.dirname(test.file),
   );
@@ -239,6 +305,13 @@ function formatJUnitSeconds(durationMs: number): string {
   return (Math.max(0, durationMs) / 1000).toFixed(3);
 }
 
+function formatDurationSeconds(durationMs: number): string {
+  const seconds = Math.max(0, durationMs) / 1000;
+  if (seconds >= 10) return `${seconds.toFixed(1)}s`;
+  if (seconds >= 1) return `${seconds.toFixed(2)}s`;
+  return `${seconds.toFixed(3).replace(/0+$/, '').replace(/\.$/, '')}s`;
+}
+
 function xmlEscape(value: string): string {
   return value
     .replaceAll('&', '&amp;')

src/compat/maestro/replay-flow.ts

@@ -21,6 +21,12 @@ export function parseMaestroReplayFlow(
   return parseMaestroReplayFlowInternal(script, createParseContext(options));
 }
 
+export function readMaestroFlowName(script: string): string | undefined {
+  const values = parseYamlDocuments(script);
+  const { config } = splitMaestroDocuments(values);
+  return config.name;
+}
+
 function parseMaestroReplayFlowInternal(
   script: string,
   context: MaestroParseContext,
@@ -259,6 +265,7 @@ function normalizeConfig(value: unknown): MaestroFlowConfig {
     throw new AppError('INVALID_ARGS', 'Maestro flow config must be a YAML map.');
   }
   return {
+    ...(typeof value.name === 'string' && value.name.length > 0 ? { name: value.name } : {}),
     ...(typeof value.appId === 'string' && value.appId.length > 0 ? { appId: value.appId } : {}),
     ...(isPlainRecord(value.env) ? { env: readEnvMap(value.env, 'env') } : {}),
     ...(Array.isArray(value.onFlowStart)

src/compat/maestro/types.ts

@@ -1,6 +1,7 @@
 import type { ParsedReplayScript, ReplayScriptMetadata } from '../../replay/script.ts';
 
 export type MaestroFlowConfig = {
+  name?: string;
   appId?: string;
   env?: Record<string, string>;
   onFlowStart?: MaestroCommand[];

src/daemon/handlers/__tests__/session-test-discovery.test.ts

@@ -57,7 +57,10 @@ test('discoverReplayTestEntries rejects empty post-filter suites', () => {
 
 test('discoverReplayTestEntries includes Maestro yaml flows for Maestro test suites', () => {
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-test-discovery-maestro-'));
-  fs.writeFileSync(path.join(root, '01-flow.yaml'), 'appId: demo\n---\n- launchApp\n');
+  fs.writeFileSync(
+    path.join(root, '01-flow.yaml'),
+    'appId: demo\nname: Bottom Tabs - Dynamic\n---\n- launchApp\n',
+  );
   fs.writeFileSync(path.join(root, '02-flow.yml'), 'appId: demo\n---\n- launchApp\n');
   fs.writeFileSync(path.join(root, '03-flow.ad'), 'open "Demo"\n');
 
@@ -76,4 +79,8 @@ test('discoverReplayTestEntries includes Maestro yaml flows for Maestro test sui
     entries.map((entry) => entry.kind),
     ['run', 'run', 'run'],
   );
+  assert.equal(entries[0]?.kind, 'run');
+  if (entries[0]?.kind === 'run') {
+    assert.equal(entries[0].title, 'Bottom Tabs - Dynamic');
+  }
 });

src/daemon/handlers/__tests__/session-test-suite.test.ts

@@ -65,7 +65,7 @@ test('test discovers Maestro YAML suites when replay backend is set', async () =
   const root = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-device-test-suite-maestro-'));
   fs.writeFileSync(
     path.join(root, 'auth-flow.yml'),
-    ['appId: demo.app', '---', '- launchApp', ''].join('\n'),
+    ['appId: demo.app', 'name: Authentication flow', '---', '- launchApp', ''].join('\n'),
   );
 
   const invoked: DaemonRequest[] = [];
@@ -91,6 +91,7 @@ test('test discovers Maestro YAML suites when replay backend is set', async () =
   expect(invoked.map((req) => [req.command, req.positionals])).toEqual([['open', ['demo.app']]]);
   expect(data.passed).toBe(1);
   expect(data.failed).toBe(0);
+  expect((data.tests as Array<Record<string, unknown>>)[0]?.title).toBe('Authentication flow');
 });
 
 test('test emits progress when attempts retry and pass', async () => {
@@ -130,6 +131,13 @@ test('test emits progress when attempts retry and pass', async () => {
 
   const data = expectOkData(response);
   expect(data.passed).toBe(1);
+  expect((data.tests as Array<Record<string, unknown>>)[0]?.attemptFailures).toEqual([
+    {
+      attempt: 1,
+      message: 'Replay failed at step 1 (open "Demo"): first attempt failed',
+      durationMs: expect.any(Number),
+    },
+  ]);
   expect(events.map((event) => event.status)).toEqual(['fail', 'pass']);
   expect(events[0]).toMatchObject({
     type: 'replay-test',

src/daemon/handlers/session-test-discovery.ts

@@ -5,6 +5,7 @@ import type { PlatformSelector } from '../../utils/device.ts';
 import { resolveRequestTrackingId } from '../request-cancel.ts';
 import { SessionStore } from '../session-store.ts';
 import { readReplayScriptMetadata, type ReplayScriptMetadata } from '../../replay/script.ts';
+import { readMaestroFlowName } from '../../compat/maestro/replay-flow.ts';
 
 const GLOB_PATTERN_CHARS = /[*?[\]{}]/;
 
@@ -14,6 +15,7 @@ export type ReplayTestDiscoveryEntry =
   | {
       kind: 'run';
       path: string;
+      title?: string;
       metadata: ReplayScriptMetadata;
     }
   | {
@@ -42,13 +44,14 @@ export function discoverReplayTestEntries(params: {
   for (const filePath of filePaths) {
     const script = fs.readFileSync(filePath, 'utf8');
     const metadata = readReplayScriptMetadata(script);
+    const title = readReplayTestTitle(script, filePath, replayBackend);
     if (!platformFilter) {
-      entries.push({ kind: 'run', path: filePath, metadata });
+      entries.push({ kind: 'run', path: filePath, title, metadata });
       continue;
     }
     if (!metadata.platform) {
       if (isMaestroReplayBackend(replayBackend)) {
-        entries.push({ kind: 'run', path: filePath, metadata });
+        entries.push({ kind: 'run', path: filePath, title, metadata });
       } else {
         entries.push({
           kind: 'skip',
@@ -62,7 +65,7 @@ export function discoverReplayTestEntries(params: {
     if (!matchesPlatformFilter(platformFilter, metadata.platform)) {
       continue;
     }
-    entries.push({ kind: 'run', path: filePath, metadata });
+    entries.push({ kind: 'run', path: filePath, title, metadata });
   }
 
   const runnableCount = entries.filter((entry) => entry.kind === 'run').length;
@@ -177,6 +180,16 @@ function isMaestroReplayBackend(replayBackend: string | undefined): boolean {
   return replayBackend === 'maestro';
 }
 
+function readReplayTestTitle(
+  script: string,
+  filePath: string,
+  replayBackend: string | undefined,
+): string | undefined {
+  return isMaestroReplayBackend(replayBackend) && path.extname(filePath) !== '.ad'
+    ? readMaestroFlowName(script)
+    : undefined;
+}
+
 function looksLikeGlob(value: string): boolean {
   return GLOB_PATTERN_CHARS.test(value);
 }