fix(core): late-bind hooks and onTestFinished to current file under isolate: false

Continues the #1376 family: under `isolate: false` a context-bound
`@rstest/core` API value-copied into a module shared across files goes stale.
The file-level hooks (`afterAll`/`beforeAll`/`afterEach`/`beforeEach`) were left
bound to the first file's runner, so a shared helper re-exporting a hook (e.g.
`export const beforeEach = beforeEach`) silently registered into the first
file's torn-down collector from the second file on. `onTestFinished`/
`onTestFailed` had the same staleness against the per-file test runner and threw
"can only be called inside a test".

Route the hooks through `currentRuntime()` (the per-file `RSTEST_RUNTIME`, like
`it`/`describe`), and `onTestFinished`/`onTestFailed` through a new per-file
`globalThis.RSTEST_RUNNER` resolved at call time. The remaining `rstest`/`rs`
utilities object is the one known, non-idiomatic residual (re-exporting the whole
namespace), deferred until a real repro surfaces.

Refs #1376.

Author: fi3ework

e2e/no-isolate/fixtures/sharing/finishedA.test.ts

@@ -0,0 +1,15 @@
+import { expect } from '@rstest/core';
+import { onTestFinished, test } from './sharedFinished';
+
+let finishedRan = false;
+
+test('finishedA: shared onTestFinished registers without throwing', () => {
+  onTestFinished(() => {
+    finishedRan = true;
+  });
+  expect(finishedRan).toBe(false);
+});
+
+test('finishedA: shared onTestFinished ran after the previous test', () => {
+  expect(finishedRan).toBe(true);
+});

e2e/no-isolate/fixtures/sharing/finishedB.test.ts

@@ -0,0 +1,15 @@
+import { expect } from '@rstest/core';
+import { onTestFinished, test } from './sharedFinished';
+
+let finishedRan = false;
+
+test('finishedB: shared onTestFinished still registers without throwing', () => {
+  onTestFinished(() => {
+    finishedRan = true;
+  });
+  expect(finishedRan).toBe(false);
+});
+
+test('finishedB: shared onTestFinished still ran after the previous test', () => {
+  expect(finishedRan).toBe(true);
+});

e2e/no-isolate/fixtures/sharing/hookA.test.ts

@@ -0,0 +1,11 @@
+import { expect } from '@rstest/core';
+import { beforeEach, test } from './sharedHooks';
+
+let ran = false;
+beforeEach(() => {
+  ran = true;
+});
+
+test('hookA: shared beforeEach ran for this file', () => {
+  expect(ran).toBe(true);
+});

e2e/no-isolate/fixtures/sharing/hookB.test.ts

@@ -0,0 +1,25 @@
+import { expect } from '@rstest/core';
+import { beforeAll, beforeEach, afterEach, test } from './sharedHooks';
+
+let beforeAllRan = false;
+let beforeEachRan = false;
+let afterEachRuns = 0;
+
+beforeAll(() => {
+  beforeAllRan = true;
+});
+beforeEach(() => {
+  beforeEachRan = true;
+});
+afterEach(() => {
+  afterEachRuns += 1;
+});
+
+test('hookB: shared beforeAll/beforeEach ran for this file', () => {
+  expect(beforeAllRan).toBe(true);
+  expect(beforeEachRan).toBe(true);
+});
+
+test('hookB: shared afterEach ran after the previous test', () => {
+  expect(afterEachRuns).toBe(1);
+});

e2e/no-isolate/fixtures/sharing/sharedFinished.ts

@@ -0,0 +1,10 @@
+// A shared helper that value-captures `@rstest/core`'s `onTestFinished` at
+// module top-level. Under `isolate: false` this module is evaluated once per
+// worker, but `@rstest/core` is reset per file. A captured `onTestFinished`
+// must resolve the CURRENT file's runner — otherwise from the second file on it
+// throws "onTestFinished() can only be called inside a test" (the stale runner's
+// current test is undefined). See https://github.com/web-infra-dev/rstest/issues/1376.
+import { onTestFinished as rstestOnTestFinished, test } from '@rstest/core';
+
+export const onTestFinished = rstestOnTestFinished;
+export { test };

e2e/no-isolate/fixtures/sharing/sharedHooks.ts

@@ -0,0 +1,20 @@
+// A shared helper that value-captures `@rstest/core`'s file-level hooks at
+// module top-level — the common pattern of re-exporting hooks (often bundled
+// onto an extended `test`) from one workspace module.
+//
+// Under `isolate: false` this module is evaluated once per worker (#1373), but
+// `@rstest/core` is reset per file. A captured `beforeEach` must still register
+// against the CURRENT file's runner — otherwise from the second file on the
+// hook silently registers into the first file's torn-down collector and never
+// runs. See https://github.com/web-infra-dev/rstest/issues/1376.
+import {
+  afterEach as rstestAfterEach,
+  beforeAll as rstestBeforeAll,
+  beforeEach as rstestBeforeEach,
+  test,
+} from '@rstest/core';
+
+export const beforeEach = rstestBeforeEach;
+export const afterEach = rstestAfterEach;
+export const beforeAll = rstestBeforeAll;
+export { test };

e2e/no-isolate/moduleSharing.test.ts

@@ -16,8 +16,9 @@ describe('module state sharing under isolate: false', () => {
   //   `@rstest/core` API captured in a module shared across files must still
   //   resolve the current file's context, not the first file's torn-down one —
   //   `test.extend(...)` against the current runner (extendA/extendB +
-  //   sharedFixture.ts) and `expect.poll(...)` against the current test
-  //   (pollA/pollB + sharedExpect.ts).
+  //   sharedFixture.ts), `expect.poll(...)` against the current test (pollA/pollB
+  //   + sharedExpect.ts), the file-level hooks (hookA/hookB + sharedHooks.ts),
+  //   and `onTestFinished` (finishedA/finishedB + sharedFinished.ts).
   it('shares imported module state across files while re-running setup', async ({
     onTestFinished,
   }) => {

packages/core/src/runtime/runner/index.ts

@@ -12,6 +12,27 @@ import { TestRunner } from './runner';
 import { createRuntimeAPI } from './runtime';
 import { traverseUpdateTest } from './task';
 
+declare global {
+  /**
+   * The current test file's `TestRunner`. Reassigned per file (see
+   * `createRunner`), so `onTestFinished`/`onTestFailed` captured by value in a
+   * module shared across files under `isolate: false` (e.g.
+   * `export const onTestFinished = onTestFinished`) resolve the running file's
+   * runner instead of a torn-down one — the execution-phase sibling of
+   * `RSTEST_RUNTIME`. See https://github.com/web-infra-dev/rstest/issues/1376.
+   */
+  var RSTEST_RUNNER: TestRunner | undefined;
+}
+
+const currentRunner = (): TestRunner => {
+  if (!globalThis.RSTEST_RUNNER) {
+    throw new Error(
+      'Rstest runner is not registered yet, please make sure you are running in a rstest environment.',
+    );
+  }
+  return globalThis.RSTEST_RUNNER;
+};
+
 export const getFileTaskId = (testPath: string): string => {
   return `file:${testPath}`;
 };
@@ -45,15 +66,21 @@ export function createRunner({
     runtimeConfig: workerState.runtimeConfig,
   });
   const testRunner: TestRunner = new TestRunner(taskContext);
+  // Publish this file's runner as the live indirection target (mirrors
+  // `RSTEST_RUNTIME`), so a stale cross-file `onTestFinished`/`onTestFailed`
+  // resolves the running file's runner. See FIX above and #1376.
+  globalThis.RSTEST_RUNNER = testRunner;
 
   return {
     api: {
       ...runtime.api,
-      onTestFinished: (fn, timeout) => {
-        testRunner.onTestFinished(testRunner.getCurrentTest(), fn, timeout);
+      onTestFinished: (...args) => {
+        const runner = currentRunner();
+        runner.onTestFinished(runner.getCurrentTest(), ...args);
       },
-      onTestFailed: (fn, timeout) => {
-        testRunner.onTestFailed(testRunner.getCurrentTest(), fn, timeout);
+      onTestFailed: (...args) => {
+        const runner = currentRunner();
+        runner.onTestFailed(runner.getCurrentTest(), ...args);
       },
     },
     runner: {

packages/core/src/runtime/runner/runtime.ts

@@ -729,16 +729,16 @@ export const createRuntimeAPI = ({
       describe,
       it,
       test: it,
-      // Hooks bind eagerly to this file's `runtimeInstance` (not `currentRuntime()`)
-      // because they are never reachable through a persisted `test.extend(...)`
-      // result — `createTestAPI` exposes only test/each/for/extend, never hooks —
-      // so they only flow through the per-file-reassigned `RSTEST_API` proxy. If a
-      // hook is ever attached to the test API, switch these to `currentRuntime()`
-      // too, or it would reopen https://github.com/web-infra-dev/rstest/issues/1376.
-      afterAll: runtimeInstance.afterAll,
-      beforeAll: runtimeInstance.beforeAll,
-      afterEach: runtimeInstance.afterEach,
-      beforeEach: runtimeInstance.beforeEach,
+      // Hooks are late-bound through `currentRuntime()` for the same reason as
+      // `it`/`describe`: a hook captured by value in a module shared across
+      // files under `isolate: false` (e.g. `export const beforeEach = beforeEach`,
+      // or attached onto an extended `test`) must register against the current
+      // file's runner, not the file that first evaluated the helper.
+      // See https://github.com/web-infra-dev/rstest/issues/1376.
+      afterAll: (...args) => currentRuntime().afterAll(...args),
+      beforeAll: (...args) => currentRuntime().beforeAll(...args),
+      afterEach: (...args) => currentRuntime().afterEach(...args),
+      beforeEach: (...args) => currentRuntime().beforeEach(...args),
     },
     instance: runtimeInstance,
   };