feat: platform filters

.nx/version-plans/version-plan-platform-filters.md

@@ -0,0 +1,5 @@
+---
+__default__: minor
+---
+
+Harness test files can now opt into platform-specific execution by suffixing the file name with a known platform, while shared harness tests continue to run everywhere. When you run Harness for a specific runner, files for other known platforms are filtered out before Jest schedules them, so `*.ios.harness.*` and `*.android.harness.*` tests can live side by side without failing on the wrong platform.

apps/playground/src/__tests__/only-android.android.harness.ts

@@ -0,0 +1,8 @@
+import { Platform } from 'react-native';
+import { describe, expect, test } from 'react-native-harness';
+
+describe('Android-only harness test', () => {
+  test('reports android platform', () => {
+    expect(Platform.OS).toBe('android');
+  });
+});

apps/playground/src/__tests__/only-ios.ios.harness.ts

@@ -0,0 +1,8 @@
+import { Platform } from 'react-native';
+import { describe, expect, test } from 'react-native-harness';
+
+describe('iOS-only harness test', () => {
+  test('reports ios platform', () => {
+    expect(Platform.OS).toBe('ios');
+  });
+});

packages/cli/src/__tests__/jest-platform-ignore-pattern.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, it } from 'vitest';
+import type { Config } from '@react-native-harness/config';
+import {
+  addJestPlatformIgnorePatternArg,
+  createPlatformTestPathIgnorePattern,
+} from '../jest-platform-ignore-pattern.js';
+
+const makeConfig = (): Config => ({
+  entryPoint: 'index.js',
+  appRegistryComponentName: 'App',
+  defaultRunner: 'ios',
+  runners: [
+    {
+      name: 'ios',
+      platformId: 'ios',
+      runner: '/virtual/ios-runner.js',
+      config: {},
+    },
+    {
+      name: 'android',
+      platformId: 'android',
+      runner: '/virtual/android-runner.js',
+      config: {},
+    },
+    {
+      name: 'web',
+      platformId: 'web',
+      runner: '/virtual/web-runner.js',
+      config: {},
+    },
+  ],
+  plugins: [],
+  metroPort: 8081,
+  webSocketPort: undefined,
+  bridgeTimeout: 60000,
+  platformReadyTimeout: 300000,
+  bundleStartTimeout: 60000,
+  maxAppRestarts: 2,
+  resetEnvironmentBetweenTestFiles: true,
+  unstable__skipAlreadyIncludedModules: false,
+  unstable__enableMetroCache: false,
+  permissions: false,
+  detectNativeCrashes: true,
+  crashDetectionInterval: 500,
+  disableViewFlattening: false,
+  forwardClientLogs: false,
+});
+
+describe('createPlatformTestPathIgnorePattern', () => {
+  it('matches harness test files for other known platforms only', () => {
+    const pattern = createPlatformTestPathIgnorePattern({
+      knownPlatformIds: ['android', 'ios', 'web'],
+      platformId: 'ios',
+    });
+
+    expect(pattern).toBe('\\.(android|web)\\.harness\\.(?:[mc]?[jt]sx?)$');
+    if (pattern == null) {
+      throw new Error('Expected platform ignore pattern to be generated');
+    }
+
+    const regex = new RegExp(pattern);
+    expect(regex.test('/tests/only-android.android.harness.ts')).toBe(true);
+    expect(regex.test('/tests/browser.web.harness.tsx')).toBe(true);
+    expect(regex.test('/tests/only-ios.ios.harness.ts')).toBe(false);
+    expect(regex.test('/tests/shared.harness.ts')).toBe(false);
+    expect(regex.test('/tests/custom.foo.harness.ts')).toBe(false);
+  });
+});
+
+describe('addJestPlatformIgnorePatternArg', () => {
+  it('adds a Jest testPathIgnorePatterns arg for the selected runner platform', async () => {
+    const argv = ['node', 'harness', '--harnessRunner', 'android'];
+
+    await expect(
+      addJestPlatformIgnorePatternArg({
+        argv,
+        cwd: '/tmp/project',
+        loadConfig: async () => ({
+          projectRoot: '/tmp/project',
+          config: makeConfig(),
+        }),
+      }),
+    ).resolves.toBe(true);
+
+    expect(argv).toEqual([
+      'node',
+      'harness',
+      '--harnessRunner',
+      'android',
+      '--testPathIgnorePatterns',
+      '\\.(ios|web)\\.harness\\.(?:[mc]?[jt]sx?)$',
+    ]);
+  });
+
+  it('uses the default runner when no runner CLI arg is provided', async () => {
+    const argv = ['node', 'harness'];
+
+    await expect(
+      addJestPlatformIgnorePatternArg({
+        argv,
+        cwd: '/tmp/project',
+        loadConfig: async () => ({
+          projectRoot: '/tmp/project',
+          config: makeConfig(),
+        }),
+      }),
+    ).resolves.toBe(true);
+
+    expect(argv.at(-2)).toBe('--testPathIgnorePatterns');
+    expect(argv.at(-1)).toBe('\\.(android|web)\\.harness\\.(?:[mc]?[jt]sx?)$');
+  });
+});

packages/cli/src/index.ts

@@ -2,6 +2,7 @@ import { run, yargsOptions } from 'jest-cli';
 import { getConfig } from '@react-native-harness/config';
 import { runInitWizard } from './wizard/index.js';
 import { runPlatformCommand } from './platform-commands.js';
+import { addJestPlatformIgnorePatternArg } from './jest-platform-ignore-pattern.js';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
@@ -237,6 +238,11 @@ const main = async () => {
     }
   }
 
+  await addJestPlatformIgnorePatternArg({
+    argv: process.argv,
+    cwd: process.cwd(),
+  });
+
   await checkForOldConfig();
   run();
 };

packages/cli/src/jest-platform-ignore-pattern.ts

@@ -0,0 +1,87 @@
+import type { Config } from '@react-native-harness/config';
+import { getConfig } from '@react-native-harness/config';
+
+type HarnessConfigResult = Awaited<ReturnType<typeof getConfig>>;
+
+type AddPlatformIgnorePatternOptions = {
+  argv: string[];
+  cwd: string;
+  loadConfig?: (cwd: string) => Promise<HarnessConfigResult>;
+};
+
+const escapeRegExp = (value: string): string =>
+  value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+
+const getCliFlagValue = (argv: string[], flagName: string): string | undefined => {
+  for (let index = 0; index < argv.length; index++) {
+    const arg = argv[index];
+    const prefix = `--${flagName}=`;
+
+    if (arg.startsWith(prefix)) {
+      return arg.slice(prefix.length);
+    }
+
+    if (arg === `--${flagName}`) {
+      return argv[index + 1];
+    }
+  }
+
+  return undefined;
+};
+
+export const createPlatformTestPathIgnorePattern = ({
+  knownPlatformIds,
+  platformId,
+}: {
+  knownPlatformIds: string[];
+  platformId: string;
+}): string | null => {
+  const ignoredPlatformIds = knownPlatformIds
+    .filter((knownPlatformId) => knownPlatformId !== platformId)
+    .map(escapeRegExp);
+
+  if (ignoredPlatformIds.length === 0) {
+    return null;
+  }
+
+  return `\\.(${ignoredPlatformIds.join('|')})\\.harness\\.(?:[mc]?[jt]sx?)$`;
+};
+
+export const addJestPlatformIgnorePatternArg = async ({
+  argv,
+  cwd,
+  loadConfig = getConfig,
+}: AddPlatformIgnorePatternOptions): Promise<boolean> => {
+  let configResult: HarnessConfigResult;
+  try {
+    configResult = await loadConfig(cwd);
+  } catch {
+    return false;
+  }
+
+  const selectedRunnerName =
+    getCliFlagValue(argv, 'harnessRunner') ?? configResult.config.defaultRunner;
+  if (!selectedRunnerName) {
+    return false;
+  }
+
+  const selectedRunner = configResult.config.runners.find(
+    (runner: Config['runners'][number]) => runner.name === selectedRunnerName,
+  );
+  if (!selectedRunner) {
+    return false;
+  }
+
+  const ignorePattern = createPlatformTestPathIgnorePattern({
+    knownPlatformIds: [
+      ...new Set(configResult.config.runners.map((runner) => runner.platformId)),
+    ],
+    platformId: selectedRunner.platformId,
+  });
+  if (!ignorePattern) {
+    return false;
+  }
+
+  argv.push('--testPathIgnorePatterns', ignorePattern);
+  return true;
+};

packages/jest/src/__tests__/execute-run.test.ts

@@ -98,8 +98,20 @@ const makeSession = (overrides: Partial<HarnessSession> = {}): HarnessSession =>
     host: undefined,
     resetEnvironmentBetweenTestFiles: false,
     detectNativeCrashes: true,
+    runners: [
+      { platformId: 'android', name: 'android' },
+      { platformId: 'ios', name: 'ios' },
+    ],
   } as HarnessSession['config'],
-  context: {} as HarnessSession['context'],
+  context: {
+    platform: {
+      platformId: 'android',
+      name: 'android',
+      runner: '/virtual/android-runner.js',
+      cli: '/virtual/android-cli.js',
+      config: {},
+    },
+  } as HarnessSession['context'],
   ensureAppReady: vi.fn(resolveUndefined),
   runTestFile: vi.fn(async () => makeHarnessResult()),
   restartApp: vi.fn(resolveUndefined),
@@ -431,6 +443,10 @@ describe('executeRun', () => {
           metroPort: 8081,
           resetEnvironmentBetweenTestFiles: true,
           detectNativeCrashes: false,
+          runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+          ],
         } as HarnessSession['config'],
       });
 
@@ -446,4 +462,65 @@ describe('executeRun', () => {
       expect(session.restartApp).toHaveBeenCalledTimes(2);
     });
   });
+
+  describe('platform-specific test files', () => {
+    it('skips files for other platforms without running them on the device', async () => {
+      const session = makeSession();
+      const { emitEvent, calls } = makeEmitEvent();
+
+      await executeRun(
+        session,
+        [
+          makeTest('/project/smoke.harness.ts'),
+          makeTest('/project/kotlin.android.harness.ts'),
+          makeTest('/project/swift.ios.harness.ts'),
+        ],
+        makeWatcher(),
+        emitEvent,
+        makeGlobalConfig(),
+      );
+
+      expect(mockRunHarnessTestFile).toHaveBeenCalledTimes(2);
+      expect(mockRunHarnessTestFile).toHaveBeenCalledWith(
+        expect.objectContaining({ testPath: '/project/smoke.harness.ts' }),
+      );
+      expect(mockRunHarnessTestFile).toHaveBeenCalledWith(
+        expect.objectContaining({ testPath: '/project/kotlin.android.harness.ts' }),
+      );
+      expect(session.ensureAppReady).toHaveBeenCalledTimes(2);
+      expect(calls).toContainEqual([
+        'test-file-success',
+        expect.objectContaining({ path: '/project/swift.ios.harness.ts' }),
+        expect.objectContaining({ skipped: true }),
+      ]);
+    });
+
+    it('does not restart the app for skipped platform-specific files', async () => {
+      const session = makeSession({
+        config: {
+          metroPort: 8081,
+          resetEnvironmentBetweenTestFiles: true,
+          detectNativeCrashes: false,
+          runners: [
+            { platformId: 'android', name: 'android' },
+            { platformId: 'ios', name: 'ios' },
+          ],
+        } as HarnessSession['config'],
+      });
+
+      await executeRun(
+        session,
+        [
+          makeTest('/project/swift.ios.harness.ts'),
+          makeTest('/project/kotlin.android.harness.ts'),
+        ],
+        makeWatcher(),
+        vi.fn(),
+        makeGlobalConfig(),
+      );
+
+      expect(session.restartApp).not.toHaveBeenCalled();
+      expect(mockRunHarnessTestFile).toHaveBeenCalledTimes(1);
+    });
+  });
 });