feat(test): add stress-testing to known flaky tests reruns

Author: JoshuaKGoldberg

knip.config.ts

@@ -31,6 +31,7 @@ const testingEntryPoints = [
   'static/**/*.spec.{js,ts,tsx}',
   'static/**/*.snapshots.tsx',
   'tests/js/**/*.spec.{js,ts,tsx}',
+  'tests/js/sentry-test/isKnownFlake/index.ts',
   // jest uses this
   'tests/js/test-balancer/index.js',
 ];

tests/js/sentry-test/isKnownFlake.d.ts

@@ -1,9 +1,9 @@
 declare namespace jest {
   interface It {
     /**
-     * Marks a test as a known flake. When the RERUN_KNOWN_FLAKY_TESTS env var
-     * is set (via the "Frontend: Rerun Flaky Tests" PR label), the test runs
-     * 50x to validate that a fix is stable. Otherwise it runs once, normally.
+     * When RERUN_KNOWN_FLAKY_TESTS is "true" (set by the "Frontend: Rerun Flaky
+     * Tests" PR label), the test runs several times under each stress profile.
+     * Otherwise it runs once, behaving identically to a normal `it()`.
      *
      * Available globally — no import needed.
      */

tests/js/sentry-test/isKnownFlake/flakeStress.ts

@@ -0,0 +1,13 @@
+import {withDelayedFetch} from './withDelayedFetch';
+import {withMainThreadCpuLoad} from './withMainThreadCpuLoad';
+import {withMemoryPressure} from './withMemoryPressure';
+import {withMicrotaskChurn} from './withMicrotaskChurn';
+import {withRealWallClockDelay} from './withRealWallClockDelay';
+
+export const flakeStressProfiles = [
+  ['mainThreadCpu', withMainThreadCpuLoad],
+  ['microtaskChurn', withMicrotaskChurn],
+  ['realWallClock', withRealWallClockDelay],
+  ['delayedFetch', withDelayedFetch],
+  ['memoryPressure', withMemoryPressure],
+] as const;

tests/js/sentry-test/isKnownFlake/flakeStressUtils.ts

@@ -0,0 +1,10 @@
+export async function invokeProvidesCallback(
+  fn: jest.ProvidesCallback,
+  thisArg: unknown
+) {
+  await (fn as (this: unknown) => unknown).call(thisArg);
+}
+
+export function delay(ms: number) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}

tests/js/sentry-test/isKnownFlake/index.ts

@@ -0,0 +1,30 @@
+/* eslint-disable jest/no-export -- setup helper: only imported by tests/js/setup.ts */
+import {flakeStressProfiles} from './flakeStress';
+
+const flakyRunsTotal = 50;
+
+const flakyRunsPerProfile = flakyRunsTotal / flakeStressProfiles.length;
+
+/**
+ * it.isKnownFlake — wraps a known-flaky test for stress-testing in CI.
+ *
+ * When RERUN_KNOWN_FLAKY_TESTS is "true" (set by the "Frontend: Rerun Flaky
+ * Tests" PR label), the test runs several times under each stress profile.
+ * Otherwise it runs once, behaving identically to a normal `it()`.
+ */
+export function isKnownFlake(name: string, fn: jest.ProvidesCallback, timeout?: number) {
+  /* eslint-disable jest/valid-title -- describe titles include dynamic profile labels */
+  if (process.env.RERUN_KNOWN_FLAKY_TESTS !== 'true') {
+    it(name, fn, timeout);
+    return;
+  }
+
+  for (const [label, wrapper] of flakeStressProfiles) {
+    describe(`[flaky rerun ${label} x${flakyRunsPerProfile}] ${name}`, () => {
+      for (let i = 1; i <= flakyRunsPerProfile; i++) {
+        it(`run ${i}/${flakyRunsPerProfile}`, wrapper(fn), timeout);
+      }
+    });
+  }
+  /* eslint-enable jest/valid-title */
+}

tests/js/sentry-test/isKnownFlake/withDelayedFetch.ts

@@ -0,0 +1,30 @@
+import {delay, invokeProvidesCallback} from './flakeStressUtils';
+
+const fetchDelayMs = 5;
+
+/**
+ * Simulates a slow network by adding delays to global fetch calls.
+ */
+export function withDelayedFetch(fn: jest.ProvidesCallback): jest.ProvidesCallback {
+  const originalFetch = globalThis.fetch;
+
+  return function wrapped(this: unknown) {
+    return (async () => {
+      if (typeof originalFetch !== 'function') {
+        await invokeProvidesCallback(fn, this);
+        return;
+      }
+
+      globalThis.fetch = (async (...args: Parameters<typeof fetch>) => {
+        await delay(fetchDelayMs);
+        return originalFetch.apply(globalThis, args);
+      }) as typeof fetch;
+
+      try {
+        await invokeProvidesCallback(fn, this);
+      } finally {
+        globalThis.fetch = originalFetch;
+      }
+    })();
+  };
+}

tests/js/sentry-test/isKnownFlake/withMainThreadCpuLoad.ts

@@ -0,0 +1,29 @@
+import {invokeProvidesCallback} from './flakeStressUtils';
+
+const mainThreadIntervalMs = 4;
+const mainThreadSpinIterations = 200_000;
+
+/**
+ * Simulates an overloaded main thread by doing busy-work on a fixed interval.
+ */
+export function withMainThreadCpuLoad(fn: jest.ProvidesCallback): jest.ProvidesCallback {
+  return function wrapped(this: unknown) {
+    const spin = () => {
+      let sink = 0;
+      for (let i = 0; i < mainThreadSpinIterations; i++) {
+        sink ^= i;
+      }
+      sink.toLocaleString();
+    };
+
+    const id = setInterval(spin, mainThreadIntervalMs);
+
+    return (async () => {
+      try {
+        await invokeProvidesCallback(fn, this);
+      } finally {
+        clearInterval(id);
+      }
+    })();
+  };
+}

tests/js/sentry-test/isKnownFlake/withMemoryPressure.ts

@@ -0,0 +1,21 @@
+import {invokeProvidesCallback} from './flakeStressUtils';
+
+const memoryPressureBytes = 8 * 1024 * 1024;
+
+/**
+ * Simulates low available memory by retaining a large buffer of bytes data.
+ */
+export function withMemoryPressure(fn: jest.ProvidesCallback): jest.ProvidesCallback {
+  return function wrapped(this: unknown) {
+    return (async () => {
+      const hog = new Uint8Array(memoryPressureBytes);
+      hog[0] = 1;
+
+      try {
+        await invokeProvidesCallback(fn, this);
+      } finally {
+        hog.fill(0);
+      }
+    })();
+  };
+}

tests/js/sentry-test/isKnownFlake/withMicrotaskChurn.ts

@@ -0,0 +1,25 @@
+import {invokeProvidesCallback} from './flakeStressUtils';
+
+const microtaskIntervalMs = 5;
+const microtasksPerTick = 50;
+
+/**
+ * Simulates a busy machine by continuously queueing microtasks.
+ */
+export function withMicrotaskChurn(fn: jest.ProvidesCallback): jest.ProvidesCallback {
+  return function wrapped(this: unknown) {
+    const id = setInterval(() => {
+      for (let i = 0; i < microtasksPerTick; i++) {
+        queueMicrotask(() => {});
+      }
+    }, microtaskIntervalMs);
+
+    return (async () => {
+      try {
+        await invokeProvidesCallback(fn, this);
+      } finally {
+        clearInterval(id);
+      }
+    })();
+  };
+}

tests/js/sentry-test/isKnownFlake/withRealWallClockDelay.ts

@@ -0,0 +1,30 @@
+import {delay, invokeProvidesCallback} from './flakeStressUtils';
+
+const wallClockTickDelayMs = 3;
+const wallClockPaddingMs = 5;
+
+/**
+ * Simulates a slow machine with many timers by continuously running no-op async delays.
+ */
+export function withRealWallClockDelay(fn: jest.ProvidesCallback): jest.ProvidesCallback {
+  return function wrapped(this: unknown) {
+    return (async () => {
+      const abortController = new AbortController();
+
+      const background = (async () => {
+        while (!abortController.signal.aborted) {
+          await delay(wallClockTickDelayMs);
+        }
+      })();
+
+      try {
+        await delay(wallClockPaddingMs);
+        await invokeProvidesCallback(fn, this);
+        await delay(wallClockPaddingMs);
+      } finally {
+        abortController.abort();
+        await background.catch(() => {});
+      }
+    })();
+  };
+}