@react-native-harness/jest 1.1.0 → 1.2.0

package/src/__tests__/index.test.ts

@@ -1,61 +1,141 @@
-import { describe, expect, it, vi } from 'vitest';
-import type { Harness } from '../harness.js';
-import type { Config as HarnessConfig } from '@react-native-harness/config';
-import type { Config, Test, TestWatcher } from 'jest-runner';
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import type { Config, Test, TestRunnerOptions, TestWatcher } from 'jest-runner';
+import type { TestSuiteResult } from '@react-native-harness/bridge';
+import type { HarnessSession } from '../harness-session.js';
+import { HarnessError } from '@react-native-harness/tools';
 import JestHarness from '../index.js';
-import { StartupStallError } from '../errors.js';
+
+const resolveUndefined = async () => undefined;
+
+// ---------------------------------------------------------------------------
+// Module mocks
+// ---------------------------------------------------------------------------
+
+const mockSession: HarnessSession = {
+  config: { metroPort: 8081 } as HarnessSession['config'],
+  context: {} as HarnessSession['context'],
+  ensureAppReady: vi.fn(resolveUndefined),
+  runTestFile: vi.fn(async (): Promise<TestSuiteResult> => ({
+    name: '',
+    tests: [],
+    suites: [],
+    status: 'passed',
+    duration: 0,
+  })),
+  restartApp: vi.fn(resolveUndefined),
+  resetCrashState: vi.fn(),
+  flushClientLogs: vi.fn(() => []),
+  callHook: vi.fn(resolveUndefined),
+  setRunState: vi.fn(),
+  dispose: vi.fn(resolveUndefined),
+};
+
+const mockCreateHarnessSession = vi.hoisted(() => vi.fn(async () => mockSession));
+const mockExecuteRun = vi.hoisted(() => vi.fn(async () => undefined));
+
+vi.mock('../harness-session.js', () => ({
+  createHarnessSession: mockCreateHarnessSession,
+}));
+
+vi.mock('../execute-run.js', () => ({
+  executeRun: mockExecuteRun,
+}));
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+const makeOptions = (): TestRunnerOptions => ({ serial: true });
+const makeWatcher = (): TestWatcher => ({ isInterrupted: () => false } as TestWatcher);
+const makeTest = (): Test => ({
+  path: '/test/example.ts',
+  context: { config: {} as Config.ProjectConfig },
+} as Test);
+
+const makeGlobalConfig = (overrides: Partial<Config.GlobalConfig> = {}): Config.GlobalConfig =>
+  ({ rootDir: '/project', watch: false, watchAll: false, collectCoverage: false, ...overrides } as Config.GlobalConfig);
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+beforeEach(() => {
+  vi.clearAllMocks();
+  (mockSession.dispose as ReturnType<typeof vi.fn>).mockResolvedValue(undefined);
+  mockExecuteRun.mockResolvedValue(undefined);
+  mockCreateHarnessSession.mockResolvedValue(mockSession);
+});
 
 describe('JestHarness', () => {
-  it('reports StartupStallError without a stack trace', async () => {
-    const runner = new JestHarness({} as Config.GlobalConfig);
-    const onFailure = vi.fn();
-
-    const harness = {
-      ensureAppReady: vi
-        .fn()
-        .mockRejectedValue(new StartupStallError(1500, 3)),
-      callHook: vi.fn(async () => undefined),
-      setRunState: vi.fn(),
-      getRunState: vi.fn(() => null),
-      crashSupervisor: {
-        beginTestRun: vi.fn(),
-        waitForCrash: vi.fn(),
-        cancelCrashWaiters: vi.fn(),
-        reset: vi.fn(),
-      },
-    } as unknown as Harness;
-
-    await runner._createInBandTestRun(
-      [
-        {
-          path: '/tmp/example.harness.ts',
-          context: {
-            config: {},
-          },
-        } as Test,
-      ],
-      {
-        isInterrupted: () => false,
-      } as TestWatcher,
-      harness,
-      {
-        detectNativeCrashes: true,
-        resetEnvironmentBetweenTestFiles: false,
-      } as HarnessConfig,
-      () => Promise.resolve(),
-      () => Promise.resolve(),
-      onFailure
-    );
-
-    expect(onFailure).toHaveBeenCalledWith(
-      expect.objectContaining({
-        path: '/tmp/example.harness.ts',
-      }),
-      {
-        message:
-          'The app did not request its Metro bundle after 3 launch attempts within 1500ms. Last Metro status: unknown.',
-        stack: '',
+  describe('session lifecycle', () => {
+    it('creates a session on the first run', async () => {
+      const runner = new JestHarness(makeGlobalConfig());
+
+      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+
+      expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
+    });
+
+    it('reuses the session across runs in watch mode', async () => {
+      const runner = new JestHarness(makeGlobalConfig({ watch: true }));
+
+      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+
+      expect(mockCreateHarnessSession).toHaveBeenCalledOnce();
+      expect(mockSession.dispose).not.toHaveBeenCalled();
+    });
+
+    it('disposes the session after each run in normal mode', async () => {
+      const runner = new JestHarness(makeGlobalConfig());
+
+      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+
+      expect(mockSession.dispose).toHaveBeenCalledOnce();
+    });
+
+    it('creates a fresh session for each run in normal mode', async () => {
+      const runner = new JestHarness(makeGlobalConfig());
+
+      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+      await runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions());
+
+      expect(mockCreateHarnessSession).toHaveBeenCalledTimes(2);
+    });
+  });
+
+  describe('error handling', () => {
+    it('converts HarnessError into a formatted string before throwing', async () => {
+      class TestHarnessError extends HarnessError {
+        constructor() { super('something went wrong'); this.name = 'TestHarnessError'; }
       }
-    );
+
+      mockCreateHarnessSession.mockRejectedValue(new TestHarnessError());
+
+      const runner = new JestHarness(makeGlobalConfig());
+
+      await expect(
+        runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions()),
+      ).rejects.toBeTypeOf('string');
+    });
+
+    it('propagates non-HarnessError exceptions as-is', async () => {
+      const cause = new TypeError('unexpected');
+      mockCreateHarnessSession.mockRejectedValue(cause);
+
+      const runner = new JestHarness(makeGlobalConfig());
+
+      await expect(
+        runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), makeOptions()),
+      ).rejects.toBe(cause);
+    });
+
+    it('throws when called without serial flag', async () => {
+      const runner = new JestHarness(makeGlobalConfig());
+
+      await expect(
+        runner.runTests([makeTest()], makeWatcher(), vi.fn(), vi.fn(), vi.fn(), { serial: false }),
+      ).rejects.toThrow('Parallel test running is not supported');
+    });
   });
 });

package/src/__tests__/resource-lock.test.ts

@@ -2,10 +2,7 @@ import fs from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-  createResourceLockManager,
-  hashResourceLockKey,
-} from '../resource-lock.js';
+import { createResourceLockManager } from '../resource-lock.js';
 
 describe('resource lock manager', () => {
   let rootDir: string;
@@ -74,11 +71,11 @@ describe('resource lock manager', () => {
       name: 'AbortError',
     });
 
-    const queueDir = path.join(rootDir, hashResourceLockKey(key), 'queue');
-    const queuedEntries = await fs.readdir(queueDir);
-    expect(queuedEntries).toHaveLength(0);
-
+    // The aborted waiter must have cleaned up its ticket. Verify by releasing
+    // the first lock and confirming a fresh acquire completes immediately.
     await firstLease.release();
+    const cleanupLease = await manager.acquire(key);
+    await cleanupLease.release();
   });
 
   it('keeps queued tickets alive while the waiting process is still active', async () => {
@@ -102,38 +99,31 @@ describe('resource lock manager', () => {
   });
 
   it('reclaims a stale owner before granting the lock', async () => {
-    const manager = createResourceLockManager({
+    const key = 'web:browser:chromium';
+
+    // Simulate a live process holding the lock.
+    const manager1 = createResourceLockManager({
+      rootDir,
+      pollIntervalMs: 5,
+      heartbeatIntervalMs: 20,
+    });
+    const staleLease = await manager1.acquire(key);
+
+    // A second manager whose isProcessActive always returns false will consider
+    // any owner — including the live one above — immediately stale and reclaim it.
+    const manager2 = createResourceLockManager({
       rootDir,
       pollIntervalMs: 5,
       heartbeatIntervalMs: 20,
       staleLockTimeoutMs: 50,
       isProcessActive: () => false,
     });
-    const key = 'web:browser:chromium';
-    const keyDir = path.join(rootDir, hashResourceLockKey(key));
-    const queueDir = path.join(keyDir, 'queue');
-    const ownerFilePath = path.join(keyDir, 'owner.json');
-
-    await fs.mkdir(queueDir, { recursive: true });
-    await fs.writeFile(
-      ownerFilePath,
-      JSON.stringify({
-        ticketId: 'stale-owner',
-        key,
-        pid: 999999,
-        createdAt: Date.now() - 1000,
-        heartbeatAt: Date.now() - 1000,
-      }),
-      'utf8',
-    );
-
-    const lease = await manager.acquire(key);
-    const owner = JSON.parse(await fs.readFile(ownerFilePath, 'utf8')) as {
-      ticketId: string;
-    };
-    expect(owner.ticketId).not.toBe('stale-owner');
 
+    const lease = await manager2.acquire(key);
     await lease.release();
+
+    // manager1 was evicted; its release is best-effort.
+    await staleLease.release();
   });
 
   it('keeps owner metadata valid when heartbeat writes overlap', async () => {
@@ -144,20 +134,12 @@ describe('resource lock manager', () => {
       staleLockTimeoutMs: 200,
     });
     const key = 'ios:simulator:iPhone 17 Pro:26.2';
-    const ownerFilePath = path.join(
-      rootDir,
-      hashResourceLockKey(key),
-      'owner.json',
-    );
     const actualWriteFile = fs.writeFile.bind(fs);
     const writeFileSpy = vi
       .spyOn(fs, 'writeFile')
       .mockImplementation(async (file, data, options) => {
-        if (
-          typeof file === 'string' &&
-          file.startsWith(ownerFilePath) &&
-          file !== ownerFilePath
-        ) {
+        // Delay atomic temp-file writes to simulate overlapping heartbeat flushes.
+        if (typeof file === 'string' && file.startsWith(rootDir) && file.endsWith('.tmp')) {
           await new Promise((resolve) => setTimeout(resolve, 25));
         }
 
@@ -166,6 +148,11 @@ describe('resource lock manager', () => {
 
     try {
       const lease = await manager.acquire(key);
+
+      // Discover the owner file after acquire creates the key directory.
+      const [keyDirName] = await fs.readdir(rootDir);
+      const ownerFilePath = path.join(rootDir, keyDirName, 'owner.json');
+
       const initialOwner = JSON.parse(
         await fs.readFile(ownerFilePath, 'utf8'),
       ) as ResourceLockOwner;

package/src/client-log-handler.ts

@@ -1,50 +1,33 @@
 import type { ReportableEvent } from '@react-native-harness/bundler-metro';
-import chalk from 'chalk';
+import type { TestResult as JestTestResult } from '@jest/test-result';
 import util from 'node:util';
-import { log } from './logs.js';
 
 export type ClientLogEvent = Extract<ReportableEvent, { type: 'client_log' }>;
+export type ClientLogBuffer = NonNullable<JestTestResult['console']>;
+export type ClientLogEntry = ClientLogBuffer[number];
+export type ClientLogCollector = {
+  handleEvent: (event: ReportableEvent) => void;
+  flush: () => ClientLogBuffer;
+};
 
 type LogLevel = ClientLogEvent['level'];
+type JestLogLevel = ClientLogEntry['type'];
 
 /**
- * Gets the display level for a log level.
+ * Gets the Jest console level for a client log level.
  * Note: Metro treats 'trace' as 'log' because Hermes doesn't include stack traces.
  */
-const getDisplayLevel = (level: LogLevel): string => {
-  // Metro converts trace to log for display (Hermes doesn't provide stack traces)
-  if (level === 'trace') {
-    return 'LOG';
-  }
-  return level.toUpperCase();
-};
-
-/**
- * Creates a styled tag for a log level with colored box appearance.
- */
-const createLevelTag = (level: LogLevel): string => {
-  const displayLevel = getDisplayLevel(level);
-  const label = ` ${displayLevel} `;
-
-  if (!chalk.supportsColor) {
-    return `[${displayLevel}]`;
-  }
-
+const getJestLogLevel = (level: LogLevel): JestLogLevel | null => {
   switch (level) {
-    case 'error':
-      return chalk.reset.inverse.bold.red(label);
-    case 'warn':
-      return chalk.reset.inverse.bold.yellow(label);
-    case 'info':
-      return chalk.reset.inverse.bold.cyan(label);
-    case 'debug':
-      return chalk.reset.inverse.bold.blue(label);
+    case 'group':
+    case 'groupCollapsed':
+    case 'groupEnd':
+      return null;
     case 'trace':
-      // Trace displays as LOG but with a distinct color
-      return chalk.reset.inverse.bold.magenta(label);
+      return 'log';
     case 'log':
     default:
-      return chalk.reset.inverse.bold.white(label);
+      return level;
   }
 };
 
@@ -56,46 +39,47 @@ export const formatClientLogMessage = (data: unknown[]): string => {
   if (data.length === 0) {
     return '';
   }
+
   return util.format(...data);
 };
 
 /**
- * Formats a client log event into a log line with styled level prefix.
+ * Formats a client log event into Jest's buffered console entry format.
  */
-export const formatClientLogLine = (event: ClientLogEvent): string => {
-  const tag = createLevelTag(event.level);
+export const formatClientLogEntry = (
+  event: ClientLogEvent
+): ClientLogEntry | null => {
+  const logLevel = getJestLogLevel(event.level);
+  if (!logLevel) {
+    return null;
+  }
+
   const message = formatClientLogMessage(event.data);
-  return `${tag} ${message}`;
+  return {
+    message,
+    origin: '',
+    type: logLevel,
+  };
 };
 
-/**
- * Handles a client_log event by formatting and logging it.
- * Returns true if the event was handled, false otherwise.
- */
-export const handleClientLogEvent = (event: ReportableEvent): boolean => {
-  if (event.type !== 'client_log') {
-    return false;
-  }
-
-  // Skip group events - they don't produce output
-  if (
-    event.level === 'group' ||
-    event.level === 'groupCollapsed' ||
-    event.level === 'groupEnd'
-  ) {
-    return true;
-  }
+export const createClientLogCollector = (): ClientLogCollector => {
+  let buffer: ClientLogBuffer = [];
 
-  const logLine = formatClientLogLine(event);
-  log(logLine);
-  return true;
-};
+  return {
+    handleEvent: (event) => {
+      if (event.type !== 'client_log') {
+        return;
+      }
 
-/**
- * Creates a client log event listener that can be added to the Metro reporter.
- */
-export const createClientLogListener = (): ((event: ReportableEvent) => void) => {
-  return (event: ReportableEvent) => {
-    handleClientLogEvent(event);
+      const entry = formatClientLogEntry(event);
+      if (entry) {
+        buffer.push(entry);
+      }
+    },
+    flush: () => {
+      const flushed = buffer;
+      buffer = [];
+      return flushed;
+    },
   };
 };