@rstest/browser 0.11.6 → 0.11.8

package/src/concurrency.ts

@@ -1,65 +0,0 @@
-import {
-  getNumCpus,
-  parseWorkers,
-  resolveWorkerCount,
-} from '@rstest/core/internal/browser';
-import type { Rstest } from '@rstest/core/internal/browser';
-
-// Re-export the shared worker primitives so existing consumers (and unit tests
-// importing from `../src/concurrency`) keep a stable import surface.
-export { getNumCpus, parseWorkers };
-
-// The browser headless path caps CPU-derived workers at 12 and halves that
-// capped base in watch; the shared `resolveWorkerCount` helper owns the
-// `maxWorkers` override and workload clamp.
-const DEFAULT_MAX_HEADLESS_WORKERS = 12;
-
-type HeadlessConcurrencyContext = Pick<Rstest, 'command'> & {
-  normalizedConfig: {
-    pool: {
-      maxWorkers?: string | number;
-    };
-  };
-};
-
-const resolveHeadlessWorkerCount = ({
-  command,
-  maxWorkers,
-  totalTasks,
-  numCpus = getNumCpus(),
-}: {
-  command: HeadlessConcurrencyContext['command'];
-  maxWorkers?: string | number;
-  totalTasks: number;
-  numCpus?: number;
-}): number => {
-  const base = Math.max(Math.min(DEFAULT_MAX_HEADLESS_WORKERS, numCpus - 1), 1);
-  return resolveWorkerCount({
-    command,
-    maxWorkers,
-    totalTasks,
-    recommended: base,
-    watchRecommended: Math.max(Math.floor(base / 2), 1),
-    numCpus,
-  });
-};
-
-export const resolveDefaultHeadlessWorkers = (
-  command: HeadlessConcurrencyContext['command'],
-  numCpus: number = getNumCpus(),
-): number =>
-  resolveHeadlessWorkerCount({
-    command,
-    totalTasks: Number.POSITIVE_INFINITY,
-    numCpus,
-  });
-
-export const getHeadlessConcurrency = (
-  context: HeadlessConcurrencyContext,
-  totalTests: number,
-): number =>
-  resolveHeadlessWorkerCount({
-    command: context.command,
-    maxWorkers: context.normalizedConfig.pool.maxWorkers,
-    totalTasks: totalTests,
-  });

package/src/configValidation.ts

@@ -1,263 +0,0 @@
-import {
-  browserIgnoredRuntimeConfigKeys,
-  color,
-  logger,
-  type RstestContext,
-  type RuntimeConfig,
-} from '@rstest/core/internal/browser';
-import { resolveBrowserViewportPreset } from './viewportPresets';
-
-type BrowserProjectConfig =
-  RstestContext['projects'][number]['normalizedConfig'];
-
-/**
- * Per-key warning for a browser-ignored RuntimeConfig field, keyed by the exact
- * RuntimeConfig keys the `executorCapabilities` table marks 'ignored-warn' /
- * 'stripped'. {@link reportUnsupportedBrowserOptions} iterates the table's
- * {@link browserIgnoredRuntimeConfigKeys} and looks each key up here, so the
- * warnings are genuinely table-driven.
- */
-const ignoredKeyWarnings: Partial<
-  Record<
-    keyof RuntimeConfig,
-    {
-      /** True when the project's value is non-default (worth warning about). */
-      isNonDefault: (config: BrowserProjectConfig) => boolean;
-      message: (config: BrowserProjectConfig) => string;
-      /**
-       * Warn only on browser-only runs. Global-only config (copied onto every
-       * project) that a mixed repo may legitimately set for its node projects.
-       */
-      browserOnly?: boolean;
-    }
-  >
-> = {
-  testEnvironment: {
-    isNonDefault: (config) => config.testEnvironment.name !== 'node',
-    message: (config) =>
-      `Ignoring testEnvironment '${config.testEnvironment.name}' in browser ` +
-      'mode: the browser itself is the test environment.',
-  },
-  isolate: {
-    isNonDefault: (config) => config.isolate === false,
-    message: () =>
-      'Ignoring isolate: false in browser mode: each test file still runs in ' +
-      'a fresh context.',
-    browserOnly: true,
-  },
-  federation: {
-    isNonDefault: (config) => config.federation === true,
-    message: () =>
-      'Ignoring federation in browser mode: it only applies to the Node runner.',
-    browserOnly: true,
-  },
-  detectAsyncLeaks: {
-    isNonDefault: (config) => config.detectAsyncLeaks === true,
-    message: () =>
-      'Ignoring detectAsyncLeaks in browser mode: it relies on node ' +
-      'async_hooks.',
-  },
-  logHeapUsage: {
-    isNonDefault: (config) => config.logHeapUsage === true,
-    message: () => 'Ignoring logHeapUsage in browser mode.',
-  },
-};
-
-/**
- * Browser-ignored keys handled outside the generic warn loop: `coverage` is
- * 'stripped' but gets the dedicated provider check in
- * {@link reportUnsupportedBrowserOptions} (a v8 hard error on browser-only
- * runs, a warning in mixed runs), not a plain "set → warn".
- */
-const speciallyHandledIgnoredKeys: (keyof RuntimeConfig)[] = ['coverage'];
-
-/**
- * Every browser-ignored RuntimeConfig key this module checks — the union of the
- * warn descriptors and the specially-handled keys. Exported for the lockstep
- * test that asserts it covers {@link browserIgnoredRuntimeConfigKeys}.
- */
-export const browserValidatedIgnoredKeys: (keyof RuntimeConfig)[] = [
-  ...(Object.keys(ignoredKeyWarnings) as (keyof RuntimeConfig)[]),
-  ...speciallyHandledIgnoredKeys,
-];
-
-// Anti-#1389 lockstep (runs at module load): fail loudly if the
-// `executorCapabilities` table gains an 'ignored-warn' / 'stripped' browser key
-// that this validation does not cover, instead of it becoming a silent no-op.
-const assertIgnoredKeysCovered = (): void => {
-  const covered = new Set<string>(browserValidatedIgnoredKeys);
-  const uncovered = browserIgnoredRuntimeConfigKeys.filter(
-    (key) => !covered.has(key),
-  );
-  if (uncovered.length > 0) {
-    throw new Error(
-      'Browser config validation is out of sync with executorCapabilities: ' +
-        `no check for ignored RuntimeConfig field(s): ${uncovered.join(', ')}. ` +
-        'Add a descriptor to `ignoredKeyWarnings` or `speciallyHandledIgnoredKeys`.',
-    );
-  }
-};
-assertIgnoredKeysCovered();
-
-const SUPPORTED_PROVIDERS = ['playwright'] as const;
-
-const isPlainObject = (value: unknown): value is Record<string, unknown> => {
-  return Object.prototype.toString.call(value) === '[object Object]';
-};
-
-const validateViewport = (viewport: unknown): void => {
-  if (viewport == null) {
-    return;
-  }
-
-  if (typeof viewport === 'string') {
-    const presetId = viewport.trim();
-    if (!presetId) {
-      throw new Error('browser.viewport must be a non-empty preset id.');
-    }
-    if (!resolveBrowserViewportPreset(presetId)) {
-      throw new Error(
-        `browser.viewport must be a valid preset id. Received: ${viewport}`,
-      );
-    }
-    return;
-  }
-
-  if (isPlainObject(viewport)) {
-    const width = (viewport as any).width;
-    const height = (viewport as any).height;
-    if (!Number.isFinite(width) || width <= 0) {
-      throw new Error('browser.viewport.width must be a positive number.');
-    }
-    if (!Number.isFinite(height) || height <= 0) {
-      throw new Error('browser.viewport.height must be a positive number.');
-    }
-    return;
-  }
-
-  throw new Error(
-    'browser.viewport must be either a preset id or { width, height }.',
-  );
-};
-
-/**
- * Warn (or hard-error) on node-only config that is silently ignored under
- * `browser.enabled`. Prevents the #1389 class of silent no-ops. The per-key
- * warnings are driven by the `executorCapabilities` table: the loop iterates
- * {@link browserIgnoredRuntimeConfigKeys} and looks each key up in
- * {@link ignoredKeyWarnings}; `coverage` (and `pool`, which is not a
- * RuntimeConfig field) keep bespoke handling below.
- *
- * Scoping rules: `coverage` and `isolate` are global-only config copied onto
- * every project, so a v8 hard-error / isolate warning is gated to browser-only
- * runs — a mixed repo legitimately sets them for its node projects and must not
- * get unsilenceable noise on a correct configuration.
- */
-const reportUnsupportedBrowserOptions = (context: RstestContext): void => {
-  const browserProjects = context.projects.filter(
-    (project) => project.normalizedConfig.browser.enabled,
-  );
-  if (browserProjects.length === 0) {
-    return;
-  }
-  const isBrowserOnlyRun = browserProjects.length === context.projects.length;
-
-  // `coverage`, `pool` and `isolate` are global-only config (not settable per
-  // project), read from the root normalized config.
-  const globalConfig = context.normalizedConfig;
-
-  const { coverage } = globalConfig;
-  // `list` never collects coverage, so the v8 guard must not block listing.
-  if (
-    context.command !== 'list' &&
-    coverage.enabled &&
-    coverage.provider === 'v8'
-  ) {
-    if (isBrowserOnlyRun) {
-      throw new Error(
-        "Coverage provider 'v8' is not supported in browser mode: browser " +
-          'projects produce no v8 coverage. Use the default istanbul provider ' +
-          "(coverage.provider: 'istanbul') for browser coverage.",
-      );
-    }
-    logger.warn(
-      color.yellow(
-        "Coverage provider 'v8' produces no coverage for browser project " +
-          "files; use the 'istanbul' provider to collect browser coverage. " +
-          'Node projects will still use v8.',
-      ),
-    );
-  }
-
-  // Node-only options silently ignored under browser.enabled. Collected into a
-  // Set so each distinct warning is emitted once, not per project.
-  const warnings = new Set<string>();
-
-  if (globalConfig.pool.type !== 'forks') {
-    warnings.add(
-      `Ignoring pool.type '${globalConfig.pool.type}' in browser mode.`,
-    );
-  }
-  if (globalConfig.pool.execArgv && globalConfig.pool.execArgv.length > 0) {
-    warnings.add('Ignoring pool.execArgv in browser mode.');
-  }
-  // Table-driven warnings: for every browser-ignored RuntimeConfig key, warn
-  // when a browser project sets it to a non-default value. `isolate` (and any
-  // other global-only key) is copied onto every project, so reading it per
-  // project matches the old global read; the Set dedupes the repeats.
-  for (const project of browserProjects) {
-    const config = project.normalizedConfig;
-    for (const key of browserIgnoredRuntimeConfigKeys) {
-      const descriptor = ignoredKeyWarnings[key];
-      if (!descriptor) {
-        // Specially handled elsewhere (e.g. `coverage`).
-        continue;
-      }
-      if (descriptor.browserOnly && !isBrowserOnlyRun) {
-        continue;
-      }
-      if (descriptor.isNonDefault(config)) {
-        warnings.add(descriptor.message(config));
-      }
-    }
-  }
-
-  for (const message of warnings) {
-    logger.warn(color.yellow(message));
-  }
-};
-
-export const validateBrowserConfig = (context: RstestContext): void => {
-  for (const project of context.projects) {
-    const { browser, output } = project.normalizedConfig;
-    if (!browser.enabled) {
-      continue;
-    }
-
-    if (!browser.provider) {
-      throw new Error(
-        'browser.provider is required when browser.enabled is true.',
-      );
-    }
-
-    if (!SUPPORTED_PROVIDERS.includes(browser.provider)) {
-      throw new Error(
-        `browser.provider must be one of: ${SUPPORTED_PROVIDERS.join(', ')}.`,
-      );
-    }
-
-    validateViewport(browser.viewport);
-
-    if (!isPlainObject(browser.providerOptions)) {
-      throw new Error('browser.providerOptions must be a plain object.');
-    }
-
-    if (output?.bundleDependencies === false) {
-      throw new Error(
-        'output.bundleDependencies false is not supported in browser mode.',
-      );
-    }
-  }
-
-  reportUnsupportedBrowserOptions(context);
-};

package/src/containerRpc.ts

@@ -1,206 +0,0 @@
-import { logger, type TestResult } from '@rstest/core/internal/browser';
-import { type BirpcReturn, createBirpc } from 'birpc';
-import { type WebSocket, WebSocketServer } from 'ws';
-import type {
-  BrowserDispatchRequest,
-  BrowserDispatchResponse,
-  BrowserHostConfig,
-  TestFileInfo,
-} from './protocol';
-import type {
-  FatalPayload,
-  HeadedTestFileCompletePayload,
-  LogPayload,
-  ReloadTestFileAck,
-  TestFileStartPayload,
-} from './hostPayloads';
-
-/** RPC methods exposed by the host (server) to the container (client) */
-export type HostRpcMethods = {
-  rerunTest: (testFile: string, testNamePattern?: string) => Promise<void>;
-  getTestFiles: () => Promise<TestFileInfo[]>;
-  onRunnerFramesReady: (testFiles: string[]) => Promise<void>;
-  // Test result callbacks from container
-  onTestFileStart: (payload: TestFileStartPayload) => Promise<void>;
-  onTestCaseResult: (payload: TestResult) => Promise<void>;
-  onTestFileComplete: (payload: HeadedTestFileCompletePayload) => Promise<void>;
-  onLog: (payload: LogPayload) => Promise<void>;
-  onFatal: (payload: FatalPayload) => Promise<void>;
-  // Generic dispatch endpoint used by runner RPC requests.
-  dispatch: (
-    request: BrowserDispatchRequest,
-  ) => Promise<BrowserDispatchResponse>;
-};
-
-/** RPC methods exposed by the container (client) to the host (server) */
-export type ContainerRpcMethods = {
-  onTestFileUpdate: (testFiles: TestFileInfo[]) => Promise<void>;
-  reloadTestFile: (
-    testFile: string,
-    testNamePattern?: string,
-  ) => Promise<ReloadTestFileAck>;
-  /**
-   * Replace the container's copy of the host config so runner iframes loaded
-   * from now on receive fresh values (e.g. the 'u' shortcut flipping
-   * `snapshot.updateSnapshot` between watch reruns).
-   */
-  onHostConfigUpdate: (config: BrowserHostConfig) => Promise<void>;
-};
-
-export type ContainerRpc = BirpcReturn<ContainerRpcMethods, HostRpcMethods>;
-
-// ============================================================================
-// RPC Manager - Encapsulates WebSocket and birpc management
-// ============================================================================
-
-/**
- * Manages the WebSocket connection and birpc communication with the container UI.
- * Provides a clean interface for sending RPC calls and handling connections.
- */
-export class ContainerRpcManager {
-  private wss: WebSocketServer;
-  private ws: WebSocket | null = null;
-  private rpc: ContainerRpc | null = null;
-  private methods: HostRpcMethods;
-  private onDisconnect?: (error: Error) => void;
-  private detachActiveSocketListeners: (() => void) | null = null;
-
-  constructor(
-    wss: WebSocketServer,
-    methods: HostRpcMethods,
-    onDisconnect?: (error: Error) => void,
-  ) {
-    this.wss = wss;
-    this.methods = methods;
-    this.onDisconnect = onDisconnect;
-    this.setupConnectionHandler();
-  }
-
-  /** Update the RPC methods (used when starting a new test run) */
-  updateMethods(
-    methods: HostRpcMethods,
-    onDisconnect?: (error: Error) => void,
-  ): void {
-    this.methods = methods;
-    this.onDisconnect = onDisconnect;
-    // Re-create birpc with new methods if already connected
-    if (this.ws && this.ws.readyState === this.ws.OPEN) {
-      this.attachWebSocket(this.ws);
-    }
-  }
-
-  private setupConnectionHandler(): void {
-    this.wss.on('connection', (ws: WebSocket) => {
-      logger.debug('[Browser UI] Container WebSocket connected');
-      logger.debug(
-        `[Browser UI] Current ws: ${this.ws ? 'exists' : 'null'}, new ws: ${ws ? 'exists' : 'null'}`,
-      );
-      this.attachWebSocket(ws);
-    });
-  }
-
-  private attachWebSocket(ws: WebSocket): void {
-    this.detachActiveSocketListeners?.();
-    if (this.rpc && !this.rpc.$closed) {
-      this.rpc.$close(new Error('Container RPC transport reattached'));
-    }
-    this.ws = ws;
-    const messageHandlers = new WeakMap<
-      (data: any) => void,
-      (message: any) => void
-    >();
-
-    this.rpc = createBirpc<ContainerRpcMethods, HostRpcMethods>(this.methods, {
-      timeout: -1,
-      post: (data) => {
-        if (ws.readyState === ws.OPEN) {
-          ws.send(JSON.stringify(data));
-        }
-      },
-      on: (fn) => {
-        const handler = (message: any) => {
-          try {
-            const data = JSON.parse(message.toString());
-            fn(data);
-          } catch {
-            // ignore invalid messages
-          }
-        };
-        messageHandlers.set(fn, handler);
-        ws.on('message', handler);
-      },
-      off: (fn) => {
-        const handler = messageHandlers.get(fn);
-        if (!handler) {
-          return;
-        }
-        ws.off('message', handler);
-        messageHandlers.delete(fn);
-      },
-    });
-
-    const handleClose = () => {
-      // Only clear if this is still the active connection
-      // This prevents a race condition when a new connection is established
-      // before the old one's close event fires
-      if (this.ws === ws) {
-        this.ws = null;
-      }
-      this.detachActiveSocketListeners?.();
-      this.detachActiveSocketListeners = null;
-      if (this.rpc && !this.rpc.$closed) {
-        const disconnectError = new Error(
-          'Browser UI WebSocket disconnected before reload completed',
-        );
-        this.rpc.$close(disconnectError);
-        this.onDisconnect?.(disconnectError);
-      }
-      this.rpc = null;
-    };
-
-    ws.on('close', handleClose);
-    this.detachActiveSocketListeners = () => {
-      ws.off('close', handleClose);
-    };
-  }
-
-  /** Check if a container is currently connected */
-  get isConnected(): boolean {
-    return this.ws !== null && this.ws.readyState === this.ws.OPEN;
-  }
-
-  /** Get the current WebSocket instance (for reuse in watch mode) */
-  get currentWebSocket(): WebSocket | null {
-    return this.ws;
-  }
-
-  /** Reattach an existing WebSocket (for watch mode reuse) */
-  reattach(ws: WebSocket): void {
-    this.attachWebSocket(ws);
-  }
-
-  /** Notify container of test file changes */
-  async notifyTestFileUpdate(files: TestFileInfo[]): Promise<void> {
-    await this.rpc?.onTestFileUpdate(files);
-  }
-
-  /** Push a refreshed host config to the container (watch reruns) */
-  async updateHostConfig(config: BrowserHostConfig): Promise<void> {
-    await this.rpc?.onHostConfigUpdate(config);
-  }
-
-  /** Request container to reload a specific test file */
-  async reloadTestFile(
-    testFile: string,
-    testNamePattern?: string,
-  ): Promise<ReloadTestFileAck> {
-    logger.debug(
-      `[Browser UI] reloadTestFile called, rpc: ${this.rpc ? 'exists' : 'null'}, ws: ${this.ws ? 'exists' : 'null'}`,
-    );
-    if (!this.rpc) {
-      throw new Error('Browser UI RPC not available for reloadTestFile');
-    }
-    logger.debug(`[Browser UI] Calling reloadTestFile: ${testFile}`);
-    return this.rpc.reloadTestFile(testFile, testNamePattern);
-  }
-}