@react-native-harness/jest 1.4.0-rc.1 → 1.4.0

package/src/__tests__/execute-run.test.ts

@@ -11,6 +11,7 @@ import {
   AppBridgeDisconnectedError,
   DeviceNotRespondingError,
 } from '@react-native-harness/bridge/server';
+import { createDiagnostics } from '@react-native-harness/tools';
 import type { HarnessSession } from '../harness-session.js';
 import { executeRun } from '../execute-run.js';
 
@@ -29,6 +30,16 @@ vi.mock('../run.js', () => ({
   runHarnessTestFile: mockRunHarnessTestFile,
 }));
 
+// Mock the reporting module so diagnostics tests can inspect the entries that
+// would have been reported without touching the real filesystem, and so
+// asserting on them doesn't race with executeRun's own diagnostics.flush().
+const mockPrintSummary = vi.hoisted(() => vi.fn());
+const mockWriteTraceFile = vi.hoisted(() => vi.fn(async () => '/fake/trace.json'));
+vi.mock('../diagnostics/index.js', () => ({
+  printSummary: mockPrintSummary,
+  writeTraceFile: mockWriteTraceFile,
+}));
+
 // ---------------------------------------------------------------------------
 // Helpers
 // ---------------------------------------------------------------------------
@@ -112,9 +123,11 @@ const makeSession = (overrides: Partial<HarnessSession> = {}): HarnessSession =>
       config: {},
     },
   } as HarnessSession['context'],
+  diagnostics: createDiagnostics({ enabled: false }),
   ensureAppReady: vi.fn(resolveUndefined),
   runTestFile: vi.fn(async () => makeHarnessResult()),
   restartApp: vi.fn(resolveUndefined),
+  resetEnvironment: vi.fn(resolveUndefined),
   resetCrashState: vi.fn(),
   flushClientLogs: vi.fn(() => []),
   callHook: vi.fn(resolveUndefined),
@@ -186,13 +199,68 @@ describe('executeRun', () => {
     });
   });
 
+  describe('diagnostics', () => {
+    beforeEach(() => {
+      mockPrintSummary.mockClear();
+      mockWriteTraceFile.mockClear();
+    });
+
+    it('records run.total and run.file spans when diagnostics is enabled', async () => {
+      const diagnostics = createDiagnostics({ enabled: true });
+      const session = makeSession({ diagnostics });
+
+      await executeRun(session, [makeTest('/a.ts')], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+
+      // executeRun flushes and hands entries to the (mocked) reporter in its
+      // finally block, so we inspect what was reported rather than flushing
+      // the diagnostics instance ourselves.
+      expect(mockPrintSummary).toHaveBeenCalledTimes(1);
+      const entries = mockPrintSummary.mock.calls[0]?.[0] as Array<{ label: string; status: string; attrs?: Record<string, unknown> }>;
+      const runEntry = entries.find((e) => e.label === 'run.total');
+      const fileEntry = entries.find((e) => e.label === 'run.file');
+
+      expect(runEntry).toMatchObject({ status: 'ok', attrs: { status: 'passed' } });
+      expect(runEntry?.attrs?.runId).toBeTypeOf('string');
+      expect(fileEntry).toMatchObject({ status: 'ok', attrs: { file: '../a.ts', status: 'passed' } });
+      expect(fileEntry?.attrs?.runId).toBeTypeOf('string');
+      expect(mockWriteTraceFile).toHaveBeenCalledWith(entries, expect.objectContaining({ runId: expect.any(String) }));
+    });
+
+    it('still records run.total when a test throws', async () => {
+      const diagnostics = createDiagnostics({ enabled: true });
+      const session = makeSession({
+        diagnostics,
+        ensureAppReady: vi.fn(async () => { throw new Error('unexpected'); }),
+      });
+
+      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+
+      const entries = mockPrintSummary.mock.calls[0]?.[0] as Array<{ label: string; attrs?: Record<string, unknown> }>;
+      expect(entries.find((e) => e.label === 'run.total')).toBeDefined();
+      expect(entries.find((e) => e.label === 'run.file')).toMatchObject({
+        attrs: { status: 'failed' },
+      });
+    });
+
+    it('is a no-op and does not generate a report when diagnostics is disabled', async () => {
+      const diagnostics = createDiagnostics({ enabled: false });
+      const session = makeSession({ diagnostics });
+
+      await executeRun(session, [makeTest()], makeWatcher(), makeEmitEvent().emitEvent, makeGlobalConfig());
+
+      expect(diagnostics.flush()).toEqual([]);
+      expect(mockPrintSummary).not.toHaveBeenCalled();
+      expect(mockWriteTraceFile).not.toHaveBeenCalled();
+    });
+  });
+
   describe('happy path', () => {
     it('emits file start, ensureAppReady, runTestFile, file success in order', async () => {
       const order: string[] = [];
       const session = makeSession({
         ensureAppReady: vi.fn(async () => { order.push('ensureAppReady'); }),
       });
-      const emitEvent: EmitEvent = (async (eventName, ..._eventData) => {
+      const emitEvent: EmitEvent = (async (eventName) => {
         if (eventName === 'test-file-start') {
           order.push('test-file-start');
         }
@@ -236,6 +304,25 @@ describe('executeRun', () => {
       expect(payload.status).toBe('passed');
     });
 
+    it('marks the final run state as completed', async () => {
+      const session = makeSession();
+
+      await executeRun(
+        session,
+        [makeTest()],
+        makeWatcher(),
+        makeEmitEvent().emitEvent,
+        makeGlobalConfig(),
+      );
+
+      expect(session.setRunState).toHaveBeenLastCalledWith(
+        expect.objectContaining({
+          completed: true,
+          status: 'passed',
+        }),
+      );
+    });
+
     it('attaches buffered client logs to the Jest result', async () => {
       const clientLogs = [{ message: 'Loaded screen', origin: '', type: 'warn' }] satisfies NonNullable<JestTestResult['console']>;
       const session = makeSession({
@@ -330,6 +417,65 @@ describe('executeRun', () => {
         ['test-file-success', expect.anything(), expect.anything()],
       ]);
     });
+
+    it('includes pending promise diagnostics in live test-case failures', async () => {
+      let testRunnerListener:
+        | ((event: TestRunnerTestStartedEvent | TestRunnerTestFinishedEvent) => void)
+        | undefined;
+      const { emitEvent, calls: emittedEvents } = makeEmitEvent();
+      const session = makeSession({
+        onTestRunnerEvent: vi.fn((listener) => {
+          testRunnerListener = listener as typeof testRunnerListener;
+          return () => undefined;
+        }),
+      });
+
+      mockRunHarnessTestFile.mockImplementation(async () => {
+        testRunnerListener?.({
+          type: 'test-finished',
+          file: 'example.ts',
+          suite: 'suite',
+          name: 'hangs',
+          ancestorTitles: ['suite'],
+          fullName: 'suite hangs',
+          startedAt: 100,
+          duration: 50,
+          status: 'failed',
+          error: {
+            name: 'TestCaseTimeoutError',
+            message: 'Test timed out after 50ms: suite hangs',
+            diagnostics: {
+              pendingPromises: {
+                total: 1,
+                items: [
+                  {
+                    id: 7,
+                    createdAt: 110,
+                    stack: 'Error: Promise created\n    at hangs (example.ts:10:5)',
+                  },
+                ],
+              },
+            },
+          },
+        });
+
+        return makeFileRunResult();
+      });
+
+      await executeRun(session, [makeTest()], makeWatcher(), emitEvent, makeGlobalConfig());
+
+      expect(emittedEvents).toContainEqual([
+        'test-case-result',
+        'example.ts',
+        expect.objectContaining({
+          failureMessages: [
+            expect.stringContaining(
+              'Pending promises at timeout: 1\n\nPromise #7, created 10ms after test start:',
+            ),
+          ],
+        }),
+      ]);
+    });
   });
 
   describe('runtime failures', () => {
@@ -437,7 +583,7 @@ describe('executeRun', () => {
   });
 
   describe('resetEnvironmentBetweenTestFiles', () => {
-    it('calls restartApp before the second test but not the first', async () => {
+    it('calls resetEnvironment before the second test but not the first', async () => {
       const session = makeSession({
         config: {
           metroPort: 8081,
@@ -458,8 +604,184 @@ describe('executeRun', () => {
         makeGlobalConfig(),
       );
 
-      // restartApp should be called for tests 2 and 3, not test 1.
-      expect(session.restartApp).toHaveBeenCalledTimes(2);
+      // resetEnvironment should be called for tests 2 and 3, not test 1.
+      expect(session.resetEnvironment).toHaveBeenCalledTimes(2);
+      expect(session.restartApp).not.toHaveBeenCalled();
+    });
+
+    it('calls resetEnvironment with the "runtime" strategy configured', async () => {
+      const session = makeSession({
+        config: {
+          metroPort: 8081,
+          resetEnvironmentBetweenTestFiles: 'runtime',
+          detectNativeCrashes: false,
+          runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+          ],
+        } as HarnessSession['config'],
+      });
+
+      await executeRun(
+        session,
+        [makeTest('/a.ts'), makeTest('/b.ts')],
+        makeWatcher(),
+        makeEmitEvent().emitEvent,
+        makeGlobalConfig(),
+      );
+
+      expect(session.resetEnvironment).toHaveBeenCalledTimes(1);
+      expect(session.resetEnvironment).toHaveBeenCalledWith('/b.ts');
+    });
+
+    it('does not call resetEnvironment when resetEnvironmentBetweenTestFiles is false', async () => {
+      const session = makeSession({
+        config: {
+          metroPort: 8081,
+          resetEnvironmentBetweenTestFiles: false,
+          detectNativeCrashes: false,
+          runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+          ],
+        } as HarnessSession['config'],
+      });
+
+      await executeRun(
+        session,
+        [makeTest('/a.ts'), makeTest('/b.ts')],
+        makeWatcher(),
+        makeEmitEvent().emitEvent,
+        makeGlobalConfig(),
+      );
+
+      expect(session.resetEnvironment).not.toHaveBeenCalled();
+    });
+
+    it('restarts after a test case timeout before the next runnable file', async () => {
+      const timedOutResult = makeHarnessResult('failed');
+      timedOutResult.tests = [
+        {
+          name: 'hangs',
+          status: 'failed',
+          duration: 10,
+          error: {
+            name: 'TestCaseTimeoutError',
+            message: 'Test timed out after 10ms: hangs',
+          },
+        },
+      ];
+      mockRunHarnessTestFile
+        .mockResolvedValueOnce(makeFileRunResult({
+          harnessResult: timedOutResult,
+          jestResult: makeJestResult({
+            numFailingTests: 1,
+            numPassingTests: 0,
+          }),
+        }))
+        .mockResolvedValueOnce(makeFileRunResult());
+      const session = makeSession({
+        config: {
+          metroPort: 8081,
+          resetEnvironmentBetweenTestFiles: false,
+          detectNativeCrashes: false,
+          runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+          ],
+        } as HarnessSession['config'],
+      });
+
+      await executeRun(
+        session,
+        [makeTest('/a.ts'), makeTest('/b.ts')],
+        makeWatcher(),
+        makeEmitEvent().emitEvent,
+        makeGlobalConfig(),
+      );
+
+      expect(session.restartApp).toHaveBeenCalledTimes(1);
+      expect(session.restartApp).toHaveBeenCalledWith('/a.ts');
+    });
+
+    it('restarts after a timeout in the last runnable file', async () => {
+      const timedOutResult = makeHarnessResult('failed');
+      timedOutResult.tests = [
+        {
+          name: 'hangs',
+          status: 'failed',
+          duration: 10,
+          error: {
+            name: 'TestCaseTimeoutError',
+            message: 'Test timed out after 10ms: hangs',
+          },
+        },
+      ];
+      mockRunHarnessTestFile.mockResolvedValueOnce(makeFileRunResult({
+        harnessResult: timedOutResult,
+        jestResult: makeJestResult({
+          numFailingTests: 1,
+          numPassingTests: 0,
+        }),
+      }));
+      const session = makeSession({
+        config: {
+          metroPort: 8081,
+          resetEnvironmentBetweenTestFiles: false,
+          detectNativeCrashes: false,
+          runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+          ],
+        } as HarnessSession['config'],
+      });
+
+      await executeRun(
+        session,
+        [makeTest('/a.ts')],
+        makeWatcher(),
+        makeEmitEvent().emitEvent,
+        makeGlobalConfig({ watch: true }),
+      );
+
+      expect(session.restartApp).toHaveBeenCalledTimes(1);
+      expect(session.restartApp).toHaveBeenCalledWith('/a.ts');
+    });
+
+    it('restarts after a suite hook timeout', async () => {
+      const timedOutResult = makeHarnessResult('failed');
+      timedOutResult.suites = [
+        {
+          name: 'suite',
+          tests: [],
+          suites: [],
+          status: 'failed',
+          duration: 10,
+          error: {
+            name: 'SuiteHookTimeoutError',
+            message: 'beforeAll hook timed out after 10ms in suite: suite',
+          },
+        },
+      ];
+      mockRunHarnessTestFile.mockResolvedValueOnce(makeFileRunResult({
+        harnessResult: timedOutResult,
+        jestResult: makeJestResult({
+          numFailingTests: 1,
+          numPassingTests: 0,
+        }),
+      }));
+      const session = makeSession();
+
+      await executeRun(
+        session,
+        [makeTest('/a.ts')],
+        makeWatcher(),
+        makeEmitEvent().emitEvent,
+        makeGlobalConfig(),
+      );
+
+      expect(session.restartApp).toHaveBeenCalledTimes(1);
+      expect(session.restartApp).toHaveBeenCalledWith('/a.ts');
     });
   });
 
@@ -520,6 +842,7 @@ describe('executeRun', () => {
       );
 
       expect(session.restartApp).not.toHaveBeenCalled();
+      expect(session.resetEnvironment).not.toHaveBeenCalled();
       expect(mockRunHarnessTestFile).toHaveBeenCalledTimes(1);
     });
   });

package/src/__tests__/format-harness-error.test.ts

@@ -0,0 +1,32 @@
+import { describe, expect, it } from 'vitest';
+import { formatHarnessErrorMessage } from '../format-harness-error.js';
+
+describe('formatHarnessErrorMessage', () => {
+  it('formats pending promise diagnostics for timeout errors', () => {
+    const message = formatHarnessErrorMessage(
+      {
+        name: 'TestCaseTimeoutError',
+        message: 'Test timed out after 50ms: suite hangs',
+        diagnostics: {
+          pendingPromises: {
+            total: 2,
+            items: [
+              {
+                id: 7,
+                createdAt: 110,
+                stack: 'Error: Promise created\n    at hangs (example.ts:10:5)',
+              },
+            ],
+          },
+        },
+      },
+      { testStartedAt: 100 },
+    );
+
+    expect(message).toContain('Test timed out after 50ms: suite hangs');
+    expect(message).toContain('Pending promises at timeout: 2');
+    expect(message).toContain('Showing 1 of 2 pending promises.');
+    expect(message).toContain('Promise #7, created 10ms after test start:');
+    expect(message).toContain('  Error: Promise created');
+  });
+});

package/src/__tests__/harness-cache.test.ts

@@ -0,0 +1,91 @@
+import type { HarnessPlatform } from '@react-native-harness/platforms';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { maybeLogMetroCacheReused } from '../harness-session.js';
+
+const { createHarnessCache, isWarm, logMetroCacheReused } = vi.hoisted(() => {
+  const isWarm = vi.fn();
+
+  return {
+    isWarm,
+    createHarnessCache: vi.fn((options: { projectRoot: string }) => ({
+      paths: {
+        root: `${options.projectRoot}/.harness/cache`,
+        metroTransform: `${options.projectRoot}/.harness/cache/metro`,
+        metroFileMap: `${options.projectRoot}/.harness/cache/metro-file-map`,
+      },
+      isWarm,
+      ensureDomainDirectories: vi.fn(),
+    })),
+    logMetroCacheReused: vi.fn(),
+  };
+});
+
+vi.mock('@react-native-harness/cache', () => ({
+  createHarnessCache,
+}));
+
+vi.mock('../logs.js', async (importOriginal) => ({
+  ...(await importOriginal<typeof import('../logs.js')>()),
+  logMetroCacheReused,
+}));
+
+const platform = { name: 'test-runner' } as HarnessPlatform;
+
+describe('maybeLogMetroCacheReused', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('logs the reuse message when caching is enabled and the cache is warm', () => {
+    isWarm.mockReturnValue(true);
+
+    maybeLogMetroCacheReused({
+      config: { cache: { metro: true } },
+      projectRoot: '/tmp/app',
+      platform,
+    });
+
+    expect(createHarnessCache).toHaveBeenCalledWith({
+      projectRoot: '/tmp/app',
+    });
+    expect(isWarm).toHaveBeenCalledWith('metro');
+    expect(logMetroCacheReused).toHaveBeenCalledWith(platform);
+  });
+
+  it('logs the reuse message with a warm cache when caching is on by default', () => {
+    isWarm.mockReturnValue(true);
+
+    maybeLogMetroCacheReused({
+      config: {},
+      projectRoot: '/tmp/app',
+      platform,
+    });
+
+    expect(logMetroCacheReused).toHaveBeenCalledWith(platform);
+  });
+
+  it('does not log when caching is enabled but the cache is cold', () => {
+    isWarm.mockReturnValue(false);
+
+    maybeLogMetroCacheReused({
+      config: { cache: { metro: true } },
+      projectRoot: '/tmp/app',
+      platform,
+    });
+
+    expect(logMetroCacheReused).not.toHaveBeenCalled();
+  });
+
+  it('does not log when caching is disabled, regardless of cache state', () => {
+    isWarm.mockReturnValue(true);
+
+    maybeLogMetroCacheReused({
+      config: { cache: { metro: false } },
+      projectRoot: '/tmp/app',
+      platform,
+    });
+
+    expect(createHarnessCache).not.toHaveBeenCalled();
+    expect(logMetroCacheReused).not.toHaveBeenCalled();
+  });
+});