@exodus/test 1.0.0-rc.37 → 1.0.0-rc.39

package/bin/babel-worker.cjs

@@ -36,8 +36,20 @@ if (isMainThread) {
   module.exports = { transformAsync }
 } else {
   const babel = require('@babel/core')
+  const tryLoadPlugin = (name) => {
+    // Try unwrapping plugin names, as otherwise Babel tries to require them from the wrong dir,
+    // which breaks strict directory structure under pnpm in some setups
+    try {
+      if (typeof name === 'string' && name.startsWith('@babel/plugin-')) return require(name)
+    } catch {}
+
+    return name
+  }
+
   parentPort.on('message', ({ port, code: input, options }) => {
     try {
+      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      if (options.plugins) options.plugins = options.plugins.map((name) => tryLoadPlugin(name))
       const { code, sourcetype, map } = babel.transformSync(input, options) // async here is useless and slower
       // additional properties are deleted as we don't want to transfer e.g. Plugin instances
       port.postMessage({ result: { code, sourcetype, map } })

package/bin/bundle.js

@@ -139,7 +139,6 @@ export const build = async (...files) => {
 
   if (options.jest) {
     const { jestConfig } = options
-    assert(jestConfig.rootDir)
     const preload = [...(jestConfig.setupFiles || []), ...(jestConfig.setupFilesAfterEnv || [])]
     if (jestConfig.testEnvironment && jestConfig.testEnvironment !== 'node') {
       const { specialEnvironments } = await import('../src/jest.environment.js')
@@ -147,9 +146,15 @@ export const build = async (...files) => {
       preload.push(...(specialEnvironments[jestConfig.testEnvironment].dependencies || []))
     }
 
-    const local = createRequire(resolve(jestConfig.rootDir, 'package.json'))
-    const w = (f) => `[${stringify(f)}, () => require(${stringify(local.resolve(f))})]`
-    input.push(`globalThis.EXODUS_TEST_PRELOADED = [${preload.map((f) => w(f)).join(', ')}]`)
+    if (preload.length === 0) {
+      input.push(`globalThis.EXODUS_TEST_PRELOADED = []`)
+    } else {
+      assert(jestConfig.rootDir)
+      const local = createRequire(resolve(jestConfig.rootDir, 'package.json'))
+      const w = (f) => `[${stringify(f)}, () => require(${stringify(local.resolve(f))})]`
+      input.push(`globalThis.EXODUS_TEST_PRELOADED = [${preload.map((f) => w(f)).join(', ')}]`)
+    }
+
     await importSource('./jest.js')
   }
 

package/bin/index.js

@@ -7,7 +7,7 @@ import { fileURLToPath } from 'node:url'
 import { basename, dirname, resolve, join } from 'node:path'
 import { createRequire } from 'node:module'
 import { randomUUID } from 'node:crypto'
-import { existsSync, rmSync } from 'node:fs'
+import { existsSync, rmSync, realpathSync } from 'node:fs'
 import { unlink } from 'node:fs/promises'
 import { tmpdir, availableParallelism } from 'node:os'
 import assert from 'node:assert/strict'
@@ -21,6 +21,7 @@ const EXTS = `.?([cm])[jt]s?(x)` // we differ from jest, allowing [cm] before ev
 const DEFAULT_PATTERNS = [`**/__tests__/**/*${EXTS}`, `**/?(*.)+(spec|test)${EXTS}`]
 
 const bundleOptions = { pure: true, bundle: true, esbuild: true, ts: 'auto' }
+const hermesAv = ['-Og', '-Xmicrotask-queue']
 const ENGINES = new Map(
   Object.entries({
     'node:test': { binary: 'node', pure: false, hasImportLoader: true, ts: 'flag' },
@@ -30,7 +31,7 @@ const ENGINES = new Map(
     'bun:bundle': { binary: 'bun', ...bundleOptions },
     'deno:bundle': { binary: 'deno', binaryArgs: ['run'], target: 'deno1', ...bundleOptions },
     'jsc:bundle': { binary: 'jsc', ...bundleOptions, target: 'safari13' },
-    'hermes:bundle': { binary: 'hermes', binaryArgs: ['-Og'], target: 'es2018', ...bundleOptions },
+    'hermes:bundle': { binary: 'hermes', binaryArgs: hermesAv, target: 'es2018', ...bundleOptions },
   })
 )
 
@@ -51,6 +52,7 @@ function parseOptions() {
     dropNetwork: ![undefined, '', '0'].includes(process.env.EXODUS_TEST_DROP_NETWORK),
     ideaCompat: false,
     engine: process.env.EXODUS_TEST_ENGINE ?? 'node:test',
+    require: [],
   }
 
   const args = [...process.argv]
@@ -61,9 +63,10 @@ function parseOptions() {
 
   // Second argument should be this script
   const jsname = args.shift()
-  assert(basename(jsname) === 'exodus-test' || jsname === fileURLToPath(import.meta.url))
+  const pathsEqual = (a, b) => a === b || (existsSync(a) && realpathSync(a) === b) // resolve symlinks
+  assert(basename(jsname) === 'exodus-test' || pathsEqual(jsname, fileURLToPath(import.meta.url)))
 
-  while (args[0]?.startsWith('--')) {
+  while (args[0]?.startsWith('-')) {
     const option = args.shift()
     if (options.ideaCompat) {
       // Ignore some options IntelliJ IDEA is passing
@@ -96,6 +99,9 @@ function parseOptions() {
       case '--babel':
         options.babel = true
         break
+      case '--require':
+        options.require.push(args.shift())
+        break
       case '--coverage-engine':
         options.coverageEngine = args.shift()
         break
@@ -284,6 +290,11 @@ if (options.typescript) {
   }
 }
 
+for (const r of options.require) {
+  assert(!options.bundle, 'Can not use -r with *:bundle engines')
+  args.push('-r', r)
+}
+
 if (patterns.length === 0) patterns.push(...DEFAULT_PATTERNS) // defaults
 const globbed = await glob(patterns, { ignore })
 const allfiles = filter ? globbed.filter(filter) : globbed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.37",
+  "version": "1.0.0-rc.39",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -104,7 +104,7 @@
     "@babel/plugin-transform-private-methods": "^7.0.0",
     "@babel/register": "^7.0.0",
     "@chalker/queue": "^1.0.0",
-    "@exodus/replay": "1.0.0-rc.1",
+    "@exodus/replay": "1.0.0-rc.3",
     "@ungap/url-search-params": "^0.2.2",
     "amaro": "^0.0.5",
     "assert": "^2.1.0",

package/src/bundle-apis/globals.cjs

@@ -76,18 +76,19 @@ if (typeof process === 'undefined') {
 }
 
 if (process.env.EXODUS_TEST_PLATFORM === 'hermes') {
+  const print = console.log.bind(console) // we don not want overrides
   let headerLogged = false
   globalThis.HermesInternal?.enablePromiseRejectionTracker({
     allRejections: true,
     onUnhandled: (i, err) => {
       globalThis.EXODUS_TEST_PROCESS.exitCode = 1
       if (!headerLogged) {
-        console.log(`‼ FATAL Tests generated asynchronous activity after they ended.
+        print(`‼ FATAL Tests generated asynchronous activity after they ended.
 This activity created errors and would have caused tests to fail, but instead triggered unhandledRejection events`)
         headerLogged = true
       }
 
-      console.log(`Uncaught error #${i}: ${err}`)
+      print(`Uncaught error #${i}: ${err}`)
       globalThis.EXODUS_TEST_PROCESS._maybeProcessExitCode()
     },
   })

package/src/engine.js

@@ -12,8 +12,8 @@ export { mock, describe, test, beforeEach, afterEach, before, after }
 const { builtinModules, syncBuiltinESMExports } = engine
 export { builtinModules, syncBuiltinESMExports }
 
-const { utilFormat, isPromise, nodeVersion } = engine
-export { utilFormat, isPromise, nodeVersion }
+const { utilFormat, isPromise, nodeVersion, awaitForMicrotaskQueue } = engine
+export { utilFormat, isPromise, nodeVersion, awaitForMicrotaskQueue }
 
 const { requireIsRelative, relativeRequire, isTopLevelESM } = engine
 export { requireIsRelative, relativeRequire, isTopLevelESM }

package/src/engine.node.cjs

@@ -10,6 +10,7 @@ const { mock, describe, test, beforeEach, afterEach, before, after } = nodeTest
 
 const isPromise = types.isPromise
 const nodeVersion = process.versions.node
+const awaitForMicrotaskQueue = () => new Promise((resolve) => process.nextTick(resolve))
 
 const files = process.argv.slice(1)
 const baseFile = files.length === 1 && existsSync(files[0]) ? normalize(files[0]) : undefined
@@ -33,7 +34,7 @@ module.exports = {
   ...{ assert, assertLoose },
   ...{ mock, describe, test, beforeEach, afterEach, before, after },
   ...{ builtinModules, syncBuiltinESMExports },
-  ...{ utilFormat, isPromise, nodeVersion },
+  ...{ utilFormat, isPromise, nodeVersion, awaitForMicrotaskQueue },
   ...{ requireIsRelative, relativeRequire, isTopLevelESM },
   ...{ readSnapshot, setSnapshotSerializers, setSnapshotResolver },
 }

package/src/engine.pure.cjs

@@ -4,6 +4,7 @@ const assertLoose = require('node:assert')
 const { setTimeout, setInterval, setImmediate, Date } = globalThis
 const { clearTimeout, clearInterval, clearImmediate } = globalThis
 
+const print = console.log.bind(console) // we don not want overrides
 Error.stackTraceLimit = 100
 
 let context
@@ -72,12 +73,12 @@ async function runContext(context) {
   // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
   context.running = true
   assert(children.length === 0 || !fn)
-  if (options.skip) return console.log('⏭ SKIP', context.fullName)
+  if (options.skip) return print('⏭ SKIP', context.fullName)
   if (context.fn) {
     if (runOnly) {
-      if (!context.only) return console.log('⏭ SKIP', context.fullName)
+      if (!context.only) return print('⏭ SKIP', context.fullName)
     } else if (options.only) {
-      console.log(`⚠ WARN test.only requires the --only command-line option`)
+      print(`⚠ WARN test.only requires the --only command-line option`)
     }
 
     let error
@@ -104,23 +105,23 @@ async function runContext(context) {
     stack.reverse()
     for (const c of stack) for (const hook of c.hooks.afterEach) await runFunction(hook, context)
 
-    console.log(error === undefined ? '✔ PASS' : '✖ FAIL', context.fullName)
+    print(error === undefined ? '✔ PASS' : '✖ FAIL', context.fullName)
     if (error) {
-      console.log(' ', error)
+      print(' ', error)
       abstractProcess.exitCode = 1
     }
   } else {
     if (options.only && !runOnly) {
-      console.log(`⚠ WARN describe.only requires the --only command-line option`)
+      print(`⚠ WARN describe.only requires the --only command-line option`)
     }
 
-    // if (context !== context.root) console.log(`▶ ${context.fullName}`)
+    // if (context !== context.root) print(`▶ ${context.fullName}`)
     // TODO: try/catch for hooks?
     // TODO: flatten recursion before running?
     for (const hook of hooks.before) await runFunction(hook, context)
     for (const child of children) await runContext(child)
     for (const hook of hooks.after) await runFunction(hook, context)
-    // if (context !== context.root) console.log(`▶ ${context.fullName}`)
+    // if (context !== context.root) print(`▶ ${context.fullName}`)
   }
 }
 
@@ -130,7 +131,7 @@ async function run() {
   assert(context === context.root)
   await runContext(context).catch((error) => {
     // Should not throw under regular circumstances
-    console.log('‼ FATAL', error)
+    print('‼ FATAL', error)
     abstractProcess.exitCode = 1
   })
   abstractProcess._maybeProcessExitCode?.()
@@ -146,8 +147,8 @@ async function describe(...args) {
       // we don't need to be async if fn is sync
       if (isPromise(res)) await res
     } catch (error) {
-      console.log('✖ FAIL', context.fullName)
-      console.log('  describe() body threw an error:', error)
+      print('✖ FAIL', context.fullName)
+      print('  describe() body threw an error:', error)
       abstractProcess.exitCode = 1
     }
   }
@@ -242,19 +243,31 @@ class MockTimers {
 
   tick(milliseconds = 1) {
     this.#elapsed += milliseconds
-    while (true) {
-      const next =
-        this.#queue.find((x) => x.type === 'immediate') ||
-        this.#queue.find((x) => x.at <= this.#elapsed)
-      if (!next) break
-      if (next.type === 'interval') {
-        next.at += next.interval
-      } else {
-        this.#queue = this.#queue.filter((x) => x !== next)
-      }
+    while (this.#microtick() !== null);
+  }
+
+  async tickAsync(milliseconds = 1) {
+    let shouldAwait = true
+    for (let i = 0; i < milliseconds; i++) {
+      if (shouldAwait) await awaitForMicrotaskQueue()
+      this.#elapsed += 1
+      shouldAwait = this.#microtick() !== null
+      if (shouldAwait) while (this.#microtick() !== null);
+    }
+  }
 
-      next.fn(...next.args)
+  #microtick() {
+    const next =
+      this.#queue.find((x) => x.type === 'immediate') ||
+      this.#queue.find((x) => x.at <= this.#elapsed)
+    if (!next) return null
+    if (next.type === 'interval') {
+      next.at += next.interval
+    } else {
+      this.#queue = this.#queue.filter((x) => x !== next)
     }
+
+    next.fn(...next.args)
   }
 
   runAll() {
@@ -385,6 +398,22 @@ const after = (fn) => context.hooks.after.push(fn)
 
 const isPromise = (x) => Boolean(x && x.then && x.catch && x.finally)
 const nodeVersion = '9999.99.99'
+const awaitForMicrotaskQueue = async () => {
+  if (globalThis?.process?.nextTick) {
+    // We are in microtasks, awaiting for "next" tick will get us out of here
+    return new Promise((resolve) => globalThis.process.nextTick(resolve))
+  }
+
+  // If that is not available, we can wait for the actual next cycle
+  // For Hermes, we use -Xmicrotask-queue for this to act not like just a Promise.resolve().then(
+  // TODO: recheck if setImmediate is not faked with setTimeout if we enable a polyfill for it for JSC?
+  if (setImmediate) return new Promise((resolve) => setImmediate(resolve))
+
+  // Do not rely on setTimeout here! it will tick actual time and is terribly slow (i.e. timers no longer fake)
+  // 100_000 should be enough to flush everything that's going on in the microtask queue
+  // Only JSC hits this currently
+  for (let i = 0; i < 100_000; i++) await Promise.resolve()
+}
 
 let builtinModules = []
 let requireIsRelative = false
@@ -433,7 +462,7 @@ module.exports = {
   ...{ assert, assertLoose },
   ...{ mock, describe, test, beforeEach, afterEach, before, after },
   ...{ builtinModules, syncBuiltinESMExports },
-  ...{ utilFormat, isPromise, nodeVersion },
+  ...{ utilFormat, isPromise, nodeVersion, awaitForMicrotaskQueue },
   ...{ requireIsRelative, relativeRequire, isTopLevelESM },
   ...{ readSnapshot, setSnapshotSerializers, setSnapshotResolver },
 }

package/src/jest.config.js

@@ -26,6 +26,10 @@ const normalizeJestConfig = (config) => ({
   },
 })
 
+function checkModuleNameMapper(mapper) {
+  return !mapper || JSON.stringify(mapper) === '{"^(\\\\.{1,2}/.*)\\\\.js$":"$1"}' // extension stripping is fine
+}
+
 function verifyJestConfig(c) {
   assert(!configUsed, 'Can not apply new config as the current one was already used')
 
@@ -37,7 +41,7 @@ function verifyJestConfig(c) {
   assert.deepEqual(environmentOptions, {}, 'Jest config.testEnvironmentOptions is not supported')
 
   assert(!c.automock, 'Automocking all modules is not currently supported (config.automock)')
-  assert(!c.moduleNameMapper, 'Jest config.moduleNameMapper is not supported')
+  assert(checkModuleNameMapper(c.moduleNameMapper), 'Jest config.moduleNameMapper is not supported')
   if (c.moduleDirectories) {
     const valid = ['node_modules']
     assert.deepEqual(c.moduleDirectories, valid, 'Jest config.moduleDirectories is not supported')

package/src/jest.timers.js

@@ -1,4 +1,4 @@
-import { mock, assert } from './engine.js'
+import { mock, assert, awaitForMicrotaskQueue } from './engine.js'
 import { jestConfig } from './jest.config.js'
 import { haveValidTimers, haveNoTimerInfiniteLoopBug } from './version.js'
 
@@ -65,7 +65,19 @@ export function advanceTimersByTime(time) {
 }
 
 export async function advanceTimersByTimeAsync(time) {
-  return this.advanceTimersByTime(time)
+  assertHaveTimers()
+  warnOldTimers()
+
+  if (mock.timers.tickAsync) {
+    await mock.timers.tickAsync(time)
+  } else {
+    for (let i = 0; i < time; i++) {
+      await awaitForMicrotaskQueue()
+      mock.timers.tick(1)
+    }
+  }
+
+  return this
 }
 
 export function setSystemTime(time) {