@exodus/test 1.0.0-rc.25 → 1.0.0-rc.27

package/bin/index.js

@@ -14,6 +14,14 @@ const bindir = dirname(fileURLToPath(import.meta.url))
 const EXTS = `.?([cm])[jt]s?(x)` // we differ from jest, allowing [cm] before everything
 const DEFAULT_PATTERNS = [`**/__tests__/**/*${EXTS}`, `**/?(*.)+(spec|test)${EXTS}`]
 
+const ENGINES = new Map(
+  Object.entries({
+    'node:test': { binary: 'node', pure: false, hasImportLoader: true },
+    'node:pure': { binary: 'node', pure: true, hasImportLoader: true },
+    'bun:pure': { binary: 'bun', pure: true, hasImportLoader: false },
+  })
+)
+
 function parseOptions() {
   const options = {
     jest: false,
@@ -26,8 +34,9 @@ function parseOptions() {
     only: false,
     passWithNoTests: false,
     writeSnapshots: false,
-    pure: false,
     debug: { files: false },
+    ideaCompat: false,
+    engine: process.env.EXODUS_TEST_ENGINE ?? 'node:test',
   }
 
   const args = [...process.argv]
@@ -42,6 +51,20 @@ function parseOptions() {
 
   while (args[0]?.startsWith('--')) {
     const option = args.shift()
+    if (options.ideaCompat) {
+      // Ignore some options IntelliJ IDEA is passing
+      switch (option) {
+        case '--reporters':
+          args.shift()
+          continue
+        case '--verbose':
+        case '--runTestsByPath':
+        case '--runInBand':
+        case '--testTimeout=7200000':
+          continue
+      }
+    }
+
     switch (option) {
       case '--global': // compat, will be removed in release
       case '--jest':
@@ -81,12 +104,23 @@ function parseOptions() {
       case '--forceExit':
         options.forceExit = true
         break
-      case '--pure':
-        options.pure = true
+      case '--engine':
+        options.engine = args.shift()
         break
       case '--debug-files':
         options.debug.files = true
         break
+      case '--colors':
+        process.env.FORCE_COLOR = '1'
+        break
+      case '--no-colors':
+        process.env.FORCE_COLOR = '0'
+        process.env.NO_COLOR = '1'
+        process.env.NODE_DISABLE_COLORS = '1'
+        break
+      case '--idea-compat':
+        options.ideaCompat = true
+        break
       default:
         throw new Error(`Unknown option: ${option}`)
     }
@@ -104,24 +138,23 @@ function parseOptions() {
 
 const { options, patterns } = parseOptions()
 
-let program = 'node'
+const engineOptions = ENGINES.get(options.engine)
+assert(engineOptions, `Unknown engine: ${options.engine}`)
+Object.assign(options, engineOptions)
 
 const require = createRequire(import.meta.url)
 const resolveRequire = (query) => require.resolve(query)
 const resolveImport = import.meta.resolve && ((query) => fileURLToPath(import.meta.resolve(query)))
 
-const c8 = resolveRequire('c8/bin/c8.js')
-if (resolveImport) assert.equal(c8, resolveImport('c8/bin/c8.js'))
-
 const args = []
 if (options.pure) {
   const requiresNodeCoverage = options.coverage && options.coverageEngine === 'node'
-  assert(!requiresNodeCoverage, 'Can not use "node" coverage engine with --pure')
-  assert(!options.writeSnapshots, 'Can not use write snapshots with --pure')
-  assert(!options.forceExit, 'Can not use --force-exit with --pure') // TODO
-  assert(!options.watch, 'Can not use --watch with --pure')
-  assert(!options.only, 'Can not use --only with --pure') // TODO
-} else {
+  assert(!requiresNodeCoverage, '"--coverage-engine node" requires "--engine node:test" (default)')
+  assert(!options.writeSnapshots, `Can not use write snapshots with ${options.engine} engine`)
+  assert(!options.forceExit, `Can not use --force-exit with ${options.engine} engine yet`) // TODO
+  assert(!options.watch, `Can not use --watch with with ${options.engine} engine`)
+  assert(!options.only, `Can not use --only with with ${options.engine} engine yet`) // TODO
+} else if (options.engine === 'node:test') {
   args.push('--test', '--no-warnings=ExperimentalWarning', '--test-reporter=spec')
 
   if (haveModuleMocks) args.push('--experimental-test-module-mocks')
@@ -141,19 +174,8 @@ if (options.pure) {
   if (options.only) args.push('--test-only')
 
   args.push('--expose-internals') // this is unoptimal and hopefully temporary, see rationale in src/dark.cjs
-}
-
-if (options.coverage) {
-  if (options.coverageEngine === 'node') {
-    args.push('--experimental-test-coverage')
-  } else if (options.coverageEngine === 'c8') {
-    program = c8
-    args.unshift('node')
-    // perhaps use text-summary ?
-    args.unshift('-r', 'text', '-r', 'html')
-  } else {
-    throw new Error(`Unknown coverage engine: ${JSON.stringify(options.coverageEngine)}`)
-  }
+} else {
+  throw new Error('Unreachable')
 }
 
 const ignore = ['**/node_modules']
@@ -169,7 +191,7 @@ if (process.env.EXODUS_TEST_IGNORE) {
 if (options.jest) {
   const { loadJestConfig } = await import('../src/jest.config.js')
   const config = await loadJestConfig(process.cwd())
-  args.push('--import', resolve(bindir, 'jest.js'))
+  args.push(options.hasImportLoader ? '--import' : '-r', resolve(bindir, 'jest.js'))
 
   if (config.testFailureExitCode !== undefined) {
     if (Number(config.testFailureExitCode) === 0) {
@@ -205,7 +227,14 @@ if (options.jest) {
 
 if (options.esbuild) {
   assert(resolveImport)
-  args.push('--import', resolveImport('tsx'))
+  if (options.hasImportLoader) {
+    args.push('--import', resolveImport('tsx'))
+  } else if (options.engine === process.env.EXODUS_TEST_ENGINE) {
+    console.warn(`Warning: ${options.engine} engine does not support --esbuild option`)
+  } else {
+    console.error(`Error: ${options.engine} engine does not support --esbuild option`)
+    process.exit(1)
+  }
 }
 
 if (options.babel) {
@@ -277,35 +306,53 @@ if (tsTests.length > 0 && !options.esbuild) {
 }
 
 if (!Object.hasOwn(process.env, 'NODE_ENV')) process.env.NODE_ENV = 'test'
+process.env.EXODUS_TEST_PLATFORM = options.binary
+
+const c8 = resolveRequire('c8/bin/c8.js')
+if (resolveImport) assert.equal(c8, resolveImport('c8/bin/c8.js'))
+
+if (options.coverage) {
+  assert.equal(options.binary, 'node', 'Coverage is only supported with Node.js')
+  if (options.coverageEngine === 'node') {
+    args.push('--experimental-test-coverage')
+  } else if (options.coverageEngine === 'c8') {
+    args.unshift(options.binary)
+    options.binary = c8
+    // perhaps use text-summary ?
+    args.unshift('-r', 'text', '-r', 'html')
+  } else {
+    throw new Error(`Unknown coverage engine: ${JSON.stringify(options.coverageEngine)}`)
+  }
+}
 
 assert(files.length > 0) // otherwise we can run recursively
-assert(program && ['node', c8].includes(program))
+assert(options.binary && ['node', 'bun', c8].includes(options.binary))
+process.env.EXODUS_TEST_EXECARGV = JSON.stringify(args)
 
 if (options.pure) {
   process.env.EXODUS_TEST_CONTEXT = 'pure'
-  console.warn(
-    '--pure mode is experimental and may not work an expected / might be removed at any time'
-  )
+  console.warn(`\n${options.engine} engine is experimental and may not work an expected\n\n`)
   const failures = []
   for (const file of files) {
-    const node = spawn(program, [...args, file], { stdio: 'inherit' })
+    const node = spawn(options.binary, [...args, file], { stdio: 'inherit' })
     const [code] = await once(node, 'close')
     if (code !== 0) failures.push(file)
   }
 
-  if (failures.length > 0) process.exitCode = 1
-  console.log(
-    failures === 0
-      ? `All ${files.length} test suites passed`
-      : `Test suites failed: ${failures.length} / ${files.length}`
-  )
   if (failures.length > 0) {
+    process.exitCode = 1
+    const [total, passed, failed] = [files.length, files.length - failures.length, failures.length]
+    console.log(`Test suites failed: ${failed} / ${total} (passed: ${passed} / ${total})`)
     console.log('Failed test suites:')
     for (const file of failures) console.log(`  ${file}`) // joining with \n can get truncated, too big
+  } else {
+    console.log(`All ${files.length} test suites passed`)
   }
 } else {
-  process.env.EXODUS_TEST_CONTEXT = 'node --test'
-  const node = spawn(program, [...args, ...files], { stdio: 'inherit' })
+  assert(['node', c8].includes(options.binary), `Unexpected native engine: ${options.binary}`)
+  assert(['node:test'].includes(options.engine))
+  process.env.EXODUS_TEST_CONTEXT = options.engine
+  const node = spawn(options.binary, [...args, ...files], { stdio: 'inherit' })
   const [code] = await once(node, 'close')
   process.exitCode = code
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.25",
+  "version": "1.0.0-rc.27",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -30,6 +30,7 @@
   },
   "exports": {
     "./jest": "./src/jest.js",
+    "./node": "./src/node.js",
     "./tape": "./src/tape.js"
   },
   "prettier": "@exodus/prettier",
@@ -39,14 +40,17 @@
     "src/dark.cjs",
     "src/engine.js",
     "src/engine.node.cjs",
+    "src/engine.pure.cjs",
     "src/engine.select.cjs",
     "src/jest.js",
     "src/jest.config.js",
+    "src/jest.config.fs.js",
     "src/jest.environment.js",
     "src/jest.fn.js",
     "src/jest.mock.js",
     "src/jest.snapshot.js",
     "src/jest.timers.js",
+    "src/node.js",
     "src/tape.js",
     "src/version.js",
     "!__tests__",
@@ -54,9 +58,12 @@
   ],
   "scripts": {
     "test": "npm run test:jest",
-    "test:all": "npm run test:jest && npm run test:tape",
+    "test:all": "npm run test:jest && npm run test:tape && npm run test:native",
+    "test:native": "EXODUS_TEST_IGNORE='{**/typescript/**,**/jest-repo/**/user.test.js}' ./bin/index.js --jest '__test__/**/*.test.{js,cjs,mjs}'",
     "test:jest": "./bin/index.js --jest --esbuild",
     "test:tape": "./bin/index.js --esbuild '__test__/tape/test/*.js' __test__/tape.test.js",
+    "test:pure": "EXODUS_TEST_ENGINE=node:pure npm run test",
+    "test:bun:pure": "EXODUS_TEST_ENGINE=bun:pure npm run test",
     "coverage": "./bin/index.js --jest --esbuild --coverage",
     "lint": "prettier --list-different . && eslint .",
     "lint:fix": "prettier --write . && eslint --fix ."
@@ -64,9 +71,11 @@
   "dependencies": {
     "@babel/register": "^7.0.0",
     "c8": "^9.1.0",
+    "esbuild": "~0.21.5",
     "expect": "^29.7.0",
     "fast-glob": "^3.2.11",
     "jest-extended": "^4.0.2",
+    "jsdom": "^24.1.0",
     "pretty-format": "^29.7.0",
     "tsx": "^4.16.2"
   },

package/src/dark.cjs

@@ -105,9 +105,13 @@ function getTestNamePath(t) {
   return [t.name] // last resort
 }
 
+const execArgv = process.env.EXODUS_TEST_EXECARGV
+  ? JSON.parse(process.env.EXODUS_TEST_EXECARGV)
+  : process.execArgv
+const insideEsbuild = execArgv.some((x) => x.endsWith('node_modules/tsx/dist/loader.mjs'))
+
 function makeEsbuildMockable() {
-  const usingTsx = process.execArgv.some((x) => x.endsWith('node_modules/tsx/dist/loader.mjs'))
-  if (!usingTsx) return
+  if (!insideEsbuild) return
   // Hook into tsx/esbuild transpiled module conversion magic to make loaded modules mockable in runtime
   // We want all modules to be .configurable = true, so we can override them
   const defineProperty = Object.defineProperty
@@ -138,4 +142,4 @@ function makeEsbuildMockable() {
   }
 }
 
-module.exports = { createCallerLocationHook, getTestNamePath, makeEsbuildMockable }
+module.exports = { createCallerLocationHook, getTestNamePath, insideEsbuild, makeEsbuildMockable }

package/src/engine.js

@@ -1,5 +1,8 @@
 import engine from './engine.select.cjs' // need to be sync for non-preloaded imports into cjs
 
+const { engine: name } = engine
+export { name as engine }
+
 const { assert, assertLoose } = engine
 export { assert, assertLoose }
 
@@ -15,5 +18,5 @@ export { utilFormat, isPromise, nodeVersion }
 const { baseFile, relativeRequire, isTopLevelESM } = engine
 export { baseFile, relativeRequire, isTopLevelESM }
 
-const { snapshot, readSnapshot, setSnapshotSerializers, setSnapshotResolver } = engine
-export { snapshot, readSnapshot, setSnapshotSerializers, setSnapshotResolver }
+const { readSnapshot, setSnapshotSerializers, setSnapshotResolver } = engine
+export { readSnapshot, setSnapshotSerializers, setSnapshotResolver }

package/src/engine.node.cjs

@@ -28,11 +28,12 @@ const setSnapshotResolver = (fn) => {
 
 /* eslint-disable unicorn/no-useless-spread */
 module.exports = {
+  engine: 'node:test',
   ...{ assert, assertLoose },
   ...{ mock, describe, test, beforeEach, afterEach, before, after },
   ...{ builtinModules, syncBuiltinESMExports },
   ...{ utilFormat, isPromise, nodeVersion },
   ...{ baseFile, relativeRequire, isTopLevelESM },
-  ...{ snapshot, readSnapshot, setSnapshotSerializers, setSnapshotResolver },
+  ...{ readSnapshot, setSnapshotSerializers, setSnapshotResolver },
 }
 /* eslint-enable unicorn/no-useless-spread */

package/src/engine.pure.cjs

@@ -0,0 +1,342 @@
+const assert = require('node:assert/strict')
+const assertLoose = require('node:assert')
+const { existsSync, readFileSync } = require('node:fs')
+const { normalize, basename, dirname, join: pathJoin } = require('node:path')
+const { format: utilFormat } = require('node:util')
+const {
+  createRequire,
+  builtinModules,
+  syncBuiltinESMExports,
+  syncBuiltinExports, // bun has it under a different name (also a no-op and always synced atm)
+} = require('node:module')
+
+const { setTimeout, setInterval, setImmediate, Date } = globalThis
+const { clearTimeout, clearInterval, clearImmediate } = globalThis
+
+Error.stackTraceLimit = 100
+
+let context
+let running
+let willstart
+
+function parseArgs(args) {
+  assert(args.length <= 3)
+  const name = typeof args[0] === 'string' ? args.shift() : 'test'
+  const fn = args.pop()
+  const options = args.pop() || {}
+  return { name, options, fn }
+}
+
+function enterContext(name, options = {}) {
+  assert(!running)
+  if (willstart) clearTimeout(willstart) // have to he accurate for engines like Hermes
+  context = {
+    root: context?.root,
+    parent: context,
+    name,
+    options,
+    fullName: context && context !== context.root ? `${context.fullName} > ${name}` : name,
+    assert: { ...assertLoose, snapshot: undefined },
+    hooks: { __proto__: null, before: [], after: [], beforeEach: [], afterEach: [] },
+    test, // todo: bind to context
+    describe, // todo: bind to context
+    children: [],
+  }
+  if (context.root) {
+    context.parent.children.push(context)
+  } else {
+    assert((context.name = '<root>'))
+    assert(!context.parent)
+    context.root = context
+  }
+}
+
+function exitContext() {
+  assert(context !== context.root)
+  context = context.parent
+  if (context === context.root) willstart = setTimeout(run, 0)
+}
+
+async function runFunction(fn, context) {
+  if (fn.length < 2) return fn(context)
+  return new Promise((resolve, reject) => fn(context, (err) => (err ? reject(err) : resolve())))
+}
+
+async function runContext(context) {
+  const { options, children, hooks, fn } = context
+  assert(!context.running, 'Can not run twice')
+  // 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 (context.fn) {
+    let error
+    const stack = [context]
+    while (stack[0].parent) stack.unshift(stack[0].parent)
+
+    // TODO: try/catch for hooks?
+    for (const c of stack) for (const hook of c.hooks.beforeEach) await runFunction(hook, context)
+    try {
+      await runFunction(fn, context)
+    } catch (e) {
+      error = e ?? 'Unknown error'
+    }
+
+    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)
+    if (error) {
+      console.log(' ', error)
+      if (globalThis.process) globalThis.process.exitCode = 1
+    }
+  } else {
+    // if (context !== context.root) console.log(`▶ ${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}`)
+  }
+}
+
+async function run() {
+  assert(!running)
+  running = true
+  assert(context === context.root)
+  runContext(context).catch((error) => {
+    // Should not throw under regular circumstances
+    console.log('Fatal: ', error)
+    if (globalThis.process) globalThis.process.exitCode = 1
+  })
+}
+
+function describe(...args) {
+  const { name, options, fn } = parseArgs(args)
+  enterContext(name, options)
+  context.options = options
+  if (!options.skip) fn(context) // todo: callback
+  exitContext()
+}
+
+describe.skip = (...args) => {
+  const { name, options, fn } = parseArgs(args)
+  return describe(name, { ...options, skip: true }, fn)
+}
+
+function test(...args) {
+  const { name, options, fn } = parseArgs(args)
+  enterContext(name, options)
+  context.fn = fn
+  exitContext()
+}
+
+test.skip = (...args) => {
+  const { name, options, fn } = parseArgs(args)
+  return test(name, { ...options, skip: true }, fn)
+}
+
+class MockTimers {
+  #enabled = false
+  #base = 0
+  #elapsed = 0
+  #queue = []
+  enable({ now = 0, apis = ['setInterval', 'setTimeout', 'setImmediate', 'Date'] } = {}) {
+    assert(!this.#enabled, 'MockTimers is already enabled!')
+    this.#base = +now
+    this.#elapsed = 0
+    if (apis.includes('setInterval')) {
+      globalThis.setInterval = this.#setInterval.bind(this)
+      globalThis.clearInterval = this.#clearInterval.bind(this)
+    }
+
+    if (apis.includes('setTimeout')) {
+      globalThis.setTimeout = this.#setTimeout.bind(this)
+      globalThis.clearTimeout = this.#clearTimeout.bind(this)
+    }
+
+    if (apis.includes('setImmediate')) {
+      globalThis.setImmediate = this.#setImmediate.bind(this)
+      globalThis.clearImmediate = this.#clearImmediate.bind(this)
+    }
+
+    const OrigDate = Date
+    if (apis.includes('Date')) {
+      const now = () => this.#base + this.#elapsed
+      globalThis.Date = class Date extends OrigDate {
+        static now = () => now()
+        constructor(first = globalThis.Date.now(), ...rest) {
+          super(first, ...rest)
+        }
+      }
+    }
+  }
+
+  reset() {
+    this.#enabled = false
+    Object.assign(globalThis, { setTimeout, setInterval, setImmediate, Date })
+    Object.assign(globalThis, { clearTimeout, clearInterval, clearImmediate })
+  }
+
+  [Symbol.dispose]() {
+    this.reset()
+  }
+
+  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)
+      }
+
+      next.fn(...next.args)
+    }
+  }
+
+  runAll() {
+    this.tick(Math.max(0, ...this.#queue.map((x) => x.at)))
+  }
+
+  setTime(milliseconds) {
+    this.#base = milliseconds
+  }
+
+  #setTimeout(fn, delay, ...args) {
+    this.#queue.push({ type: 'timeout', fn, at: delay + this.#elapsed, args })
+  }
+
+  #setInterval(fn, delay, ...args) {
+    this.#queue.push({ type: 'interval', fn, at: delay + this.#elapsed, interval: delay, args })
+  }
+
+  #setImmediate(fn, ...args) {
+    this.#queue.push({ type: 'immediate', fn, args })
+  }
+
+  #clearTimeout(id) {
+    this.#queue = this.#queue.filter((x) => x !== id)
+  }
+
+  #clearInterval(id) {
+    this.#clearTimeout(id)
+  }
+
+  #clearImmediate(id) {
+    this.#clearTimeout(id)
+  }
+}
+
+class MockedFunction extends Function {
+  get mock() {
+    return this._mock
+  }
+}
+
+const mock = {
+  module: undefined,
+  timers: new MockTimers(),
+  fn: (original = () => {}, implementation = original) => {
+    let impl = implementation
+    const mocked = function (...args) {
+      const call = {
+        arguments: args,
+        // eslint-disable-next-line unicorn/error-message
+        stack: new Error(), // todo: recheck location
+        target: undefined,
+        this: this,
+      }
+
+      mocked.mock.calls.push(call)
+
+      try {
+        // todo: what's if it a promise
+        if (this instanceof mocked) {
+          impl.apply(this, args)
+          call.result = call.target = this
+        } else {
+          call.result = impl.apply(this, args)
+        }
+
+        call.error = undefined
+      } catch (err) {
+        call.result = undefined
+        call.error = err
+        throw err
+      }
+
+      return call.result
+    }
+
+    Object.setPrototypeOf(mocked, MockedFunction.prototype)
+
+    mocked._mock = {
+      calls: [],
+      get callCount() {
+        return this.calls.length
+      },
+      mockImplementation: (fn) => {
+        impl = fn
+      },
+      mockImplementationOnce: (fn) => {
+        const prev = impl
+        impl = (...args) => {
+          impl = prev
+          return fn.apply(this, args)
+        }
+      },
+      resetCalls: () => {
+        mocked._mock.calls.length = 0
+      },
+      restore: () => {
+        impl = original
+      },
+    }
+
+    return mocked
+  },
+}
+
+const beforeEach = (fn) => context.hooks.beforeEach.push(fn)
+const afterEach = (fn) => context.hooks.afterEach.push(fn)
+const before = (fn) => context.hooks.before.push(fn)
+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 files = process.argv.slice(1)
+const baseFile = files.length === 1 && existsSync(files[0]) ? normalize(files[0]) : undefined
+const relativeRequire = baseFile ? createRequire(baseFile) : require
+const isTopLevelESM = () =>
+  !baseFile || // assume ESM otherwise
+  !Object.hasOwn(relativeRequire.cache, baseFile) || // node esm
+  relativeRequire.cache[baseFile].exports[Symbol.toStringTag] === 'Module' // bun esm
+
+let snapshotResolver = (dir, name) => [dir, `${name}.snapshot`] // default per Node.js docs
+const resolveSnapshot = (f) => pathJoin(...snapshotResolver(dirname(f), basename(f)))
+const readSnapshot = (f = baseFile) => (f ? readFileSync(resolveSnapshot(f), 'utf8') : null)
+const setSnapshotSerializers = () => {}
+const setSnapshotResolver = (fn) => {
+  snapshotResolver = fn
+}
+
+enterContext('<root>')
+
+/* eslint-disable unicorn/no-useless-spread */
+module.exports = {
+  engine: 'pure',
+  ...{ assert, assertLoose },
+  ...{ mock, describe, test, beforeEach, afterEach, before, after },
+  ...{ builtinModules, syncBuiltinESMExports: syncBuiltinESMExports || syncBuiltinExports },
+  ...{ utilFormat, isPromise, nodeVersion },
+  ...{ baseFile, relativeRequire, isTopLevelESM },
+  ...{ readSnapshot, setSnapshotSerializers, setSnapshotResolver },
+}
+/* eslint-enable unicorn/no-useless-spread */

package/src/engine.select.cjs

@@ -1 +1,5 @@
-module.exports = require('./engine.node.cjs')
+// Needs to be inlined for bundler to optimize it out correctly
+module.exports =
+  process.env.EXODUS_TEST_CONTEXT === 'pure'
+    ? require('./engine.pure.cjs')
+    : require('./engine.node.cjs')

package/src/jest.config.fs.js

@@ -0,0 +1,54 @@
+import assert from 'node:assert/strict'
+import { readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
+import path from 'node:path'
+
+async function getJestConfig(dir) {
+  if (!dir) return
+
+  const configPath = (ext) => path.resolve(dir, `jest.config.${ext}`)
+
+  assert(!existsSync(configPath('ts')), 'jest.config.ts is not supported yet with .ts extension')
+
+  const configs = []
+  for (const type of ['js', 'ts', 'mjs', 'cjs', 'json']) {
+    try {
+      if (type === 'json') {
+        configs.push(JSON.parse(await readFile(configPath('json'), 'utf8')))
+      } else {
+        const { default: config } = await import(configPath(type))
+        configs.push(config)
+      }
+    } catch (e) {
+      if (!['ERR_MODULE_NOT_FOUND', 'ENOENT'].includes(e.code)) throw e
+    }
+  }
+
+  try {
+    const pkg = JSON.parse(await readFile(path.resolve(dir, 'package.json'), 'utf8'))
+    assert(typeof pkg.jest !== 'string', 'String package.json["jest"] values are not supported yet')
+    if (pkg.jest) configs.push(pkg.jest)
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e
+  }
+
+  assert(configs.length < 2, `Multiple jest configs found in ${dir} dir, use only a single one`)
+
+  if (configs.length > 0) {
+    const conf = { ...configs[0] }
+    if (conf.rootDir && ['.', './'].includes(conf.rootDir)) {
+      assert.equal(path.resolve(dir, conf.rootDir), dir, 'Jest config.rootDir is not supported yet')
+    }
+
+    conf.rootDir = dir
+    return conf
+  }
+
+  const parent = path.dirname(dir)
+  return parent === dir ? undefined : getJestConfig(parent)
+}
+
+const files = process.argv.slice(1)
+const baseDir = files.length === 1 ? path.dirname(path.resolve(files[0])) : undefined
+
+export const readJestConfig = async (dir = baseDir) => getJestConfig(dir)

package/src/jest.config.js

@@ -1,56 +1,9 @@
 // Not using ./engine.js yet, might pass / embed already loaded config instead
 import assert from 'node:assert/strict'
-import { readFile } from 'node:fs/promises'
-import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { createRequire } from 'node:module'
 import { specialEnvironments } from './jest.environment.js'
 
-const files = process.argv.slice(1)
-const baseDir = files.length === 1 ? path.dirname(path.resolve(files[0])) : undefined
-
-async function getJestConfig(dir) {
-  if (!dir) return
-
-  const configPath = (ext) => path.resolve(dir, `jest.config.${ext}`)
-
-  assert(!existsSync(configPath('ts')), 'jest.config.ts is not supported yet with .ts extension')
-
-  const configs = []
-  for (const type of ['js', 'ts', 'mjs', 'cjs', 'json']) {
-    try {
-      if (type === 'json') {
-        configs.push(JSON.parse(await readFile(configPath('json'), 'utf8')))
-      } else {
-        const { default: config } = await import(configPath(type))
-        configs.push(config)
-      }
-    } catch (e) {
-      if (!['ERR_MODULE_NOT_FOUND', 'ENOENT'].includes(e.code)) throw e
-    }
-  }
-
-  try {
-    const pkg = JSON.parse(await readFile(path.resolve(dir, 'package.json'), 'utf8'))
-    assert(typeof pkg.jest !== 'string', 'String package.json["jest"] values are not supported yet')
-    if (pkg.jest) configs.push(pkg.jest)
-  } catch (e) {
-    if (e.code !== 'ENOENT') throw e
-  }
-
-  assert(configs.length < 2, `Multiple jest configs found in ${dir} dir, use only a single one`)
-
-  if (configs.length > 0) {
-    const conf = { ...configs[0] }
-    assert(!conf.rootDir, 'Jest config.rootDir is not supported yet')
-    conf.rootDir = dir
-    return conf
-  }
-
-  const parent = path.dirname(dir)
-  return parent === dir ? undefined : getJestConfig(parent)
-}
-
 const normalizeJestConfig = (config) => ({
   testEnvironment: 'node',
   testTimeout: 5000,
@@ -78,8 +31,7 @@ const normalizeJestConfig = (config) => ({
 function verifyJestConfig(c) {
   assert(!configUsed, 'Can not apply new config as the current one was already used')
 
-  const nodeEnvs = new Set(['ts-jest', 'ts-jest/presets/js-with-ts'])
-  if (!Object.hasOwn(specialEnvironments, c.testEnvironment) && !nodeEnvs.has(c.testEnvironment)) {
+  if (!Object.hasOwn(specialEnvironments, c.testEnvironment)) {
     assert.equal(c.testEnvironment, 'node', 'Only "node" testEnvironment is supported')
   }
 
@@ -87,12 +39,14 @@ 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')
   if (c.moduleDirectories) {
     const valid = ['node_modules']
     assert.deepEqual(c.moduleDirectories, valid, 'Jest config.moduleDirectories is not supported')
   }
 
-  assert(!c.preset, 'Jest config.preset is not supported')
+  const pre = new Set(['ts-jest'])
+  assert(!c.preset || pre.has(c.preset.split('/')[0]), 'Jest config.preset is not supported')
 
   // TODO
   const TODO = ['globalSetup', 'globalTeardown', 'randomize', 'projects', 'roots']
@@ -110,14 +64,25 @@ export const jestConfig = () => {
 
 // Methods loadJestConfig() and installJestEnvironment() below are for --jest flag
 
-export async function loadJestConfig(dir = baseDir) {
-  config = normalizeJestConfig(await getJestConfig(dir))
+export async function loadJestConfig(...args) {
+  let rawConfig
+  if (process.env.EXODUS_TEST_JEST_CONFIG) {
+    rawConfig = JSON.parse(process.env.EXODUS_TEST_JEST_CONFIG)
+  } else {
+    const { readJestConfig } = await import('./jest.config.fs.js')
+    rawConfig = await readJestConfig(...args)
+  }
+
+  config = normalizeJestConfig(rawConfig)
   verifyJestConfig(config)
   return config
 }
 
 export async function installJestEnvironment(jestGlobals) {
-  const { jest, beforeEach } = jestGlobals
+  const engine = await import('./engine.js')
+
+  const { beforeEach } = engine
+  const { jest } = jestGlobals
   const c = config
 
   Error.stackTraceLimit = 100
@@ -135,11 +100,12 @@ export async function installJestEnvironment(jestGlobals) {
     : () => assert.fail('Unreachable: requiring plugins without a rootDir')
 
   if (Object.hasOwn(specialEnvironments, c.testEnvironment)) {
-    specialEnvironments[c.testEnvironment](require, jestGlobals, c.testEnvironmentOptions)
+    specialEnvironments[c.testEnvironment](require, engine, jestGlobals, c.testEnvironmentOptions)
   }
 
-  for (const file of c.setupFiles || []) require(file)
-  for (const file of c.setupFilesAfterEnv || []) require(file)
+  // require is already relative to rootDir
+  for (const file of c.setupFiles || []) require(file.replace(/^<rootDir>\//g, './'))
+  for (const file of c.setupFilesAfterEnv || []) require(file.replace(/^<rootDir>\//g, './'))
 
   // @jest/globals import auto-mocking is disabled until https://github.com/nodejs/node/issues/53807 is resolved
   /*

package/src/jest.environment.js

@@ -3,8 +3,31 @@ import { getTestNamePath } from './dark.cjs'
 export const specialEnvironments = {
   __proto__: null,
 
+  jsdom: (require) => {
+    const { JSDOM, VirtualConsole } = require('jsdom')
+    const virtualConsole = new VirtualConsole()
+    const { window } = new JSDOM('<!DOCTYPE html>', {
+      url: 'http://localhost/',
+      pretendToBeVisual: true,
+      runScripts: 'dangerously',
+      virtualConsole,
+    })
+    virtualConsole.sendTo(console, { omitJSDOMErrors: true })
+    virtualConsole.on('jsdomError', (error) => {
+      throw error
+    })
+    const assignMissing = (target, source) => {
+      const entries = Object.entries(source).filter(([key]) => !Object.hasOwn(target, key))
+      Object.assign(target, Object.fromEntries(entries))
+    }
+
+    assignMissing(globalThis, window)
+    assignMissing(console, window.console)
+    Object.setPrototypeOf(global, Object.getPrototypeOf(window))
+  },
+
   // Reproduces setup-polly-jest/jest-environment-node ad hacks into 'setup-polly-jest'.pollyJest
-  'setup-polly-jest/jest-environment-node': (require, jestGlobals) => {
+  'setup-polly-jest/jest-environment-node': (require, engine) => {
     const { Polly } = require('@pollyjs/core')
     const pollyJest = require('setup-polly-jest')
     const { JestPollyGlobals, createPollyContextAccessor } = require('setup-polly-jest/lib/common')
@@ -13,12 +36,12 @@ export const specialEnvironments = {
     pollyJest.setupPolly = (options) => {
       if (!pollyGlobals.isJestPollyEnvironment) return
 
-      jestGlobals.beforeAll(() => {
+      engine.before(() => {
         pollyGlobals.isPollyActive = true
         pollyGlobals.pollyContext.options = options
       })
 
-      jestGlobals.afterAll(() => {
+      engine.after(() => {
         pollyGlobals.isPollyActive = false
         pollyGlobals.pollyContext.options = null
       })
@@ -26,13 +49,13 @@ export const specialEnvironments = {
       return createPollyContextAccessor(pollyGlobals)
     }
 
-    jestGlobals.beforeEach((t) => {
+    engine.beforeEach((t) => {
       if (!pollyGlobals.isPollyActive) return
       const name = getTestNamePath(t).join('/')
       pollyGlobals.pollyContext.polly = new Polly(name, pollyGlobals.pollyContext.options)
     })
 
-    jestGlobals.afterEach(async () => {
+    engine.afterEach(async () => {
       if (!pollyGlobals.pollyContext.polly) return
       await pollyGlobals.pollyContext.polly.stop()
       pollyGlobals.pollyContext.polly = null

package/src/jest.js

@@ -1,19 +1,12 @@
-import {
-  describe as nodeDescribe,
-  test as nodeTest,
-  afterEach,
-  after,
-  assert,
-  utilFormat,
-  isPromise,
-} from './engine.js'
+import { assert, utilFormat, isPromise, mock } from './engine.js'
+import * as node from './engine.js'
 import { jestConfig } from './jest.config.js'
 import { jestFunctionMocks } from './jest.fn.js'
 import { jestModuleMocks } from './jest.mock.js'
 import * as jestTimers from './jest.timers.js'
 import './jest.snapshot.js'
-import { createCallerLocationHook } from './dark.cjs'
-import './version.js'
+import { createCallerLocationHook, insideEsbuild } from './dark.cjs'
+import { haveValidTimers } from './version.js'
 import { expect } from 'expect'
 import matchers from 'jest-extended'
 import { format as prettyFormat } from 'pretty-format'
@@ -98,7 +91,7 @@ const describe = (...args) => {
   inDescribe.push(fn)
   const optionsConcurrent = args?.at(-1)?.concurrency > 1
   if (optionsConcurrent) inConcurrent.push(fn)
-  const result = nodeDescribe(...args, async () => {
+  const result = node.describe(...args, async () => {
     const res = fn()
 
     // We do only block-level concurrency, not file-level
@@ -137,26 +130,26 @@ Also, using expect.assertions() to ensure the planned number of assertions is be
   })
 }
 
-const test = (...args) => testRaw(getCallerLocation(), nodeTest, ...args)
-test.only = (...args) => testRaw(getCallerLocation(), nodeTest.only, ...args)
+const test = (...args) => testRaw(getCallerLocation(), node.test, ...args)
+test.only = (...args) => testRaw(getCallerLocation(), node.test.only, ...args)
 
 describe.each = makeEach(describe)
 test.each = makeEach(test) // TODO: pass caller location
 test.concurrent = (...args) => {
   assert(inDescribe.length > 0, 'test.concurrent is supported only within a describe block')
   if (inConcurrent.length > 0) return test(...args)
-  concurrent.push([getCallerLocation(), nodeTest, ...args])
+  concurrent.push([getCallerLocation(), node.test, ...args])
 }
 
 test.concurrent.each = makeEach(test.concurrent)
-describe.skip = (...args) => nodeDescribe.skip(...args)
-test.skip = (...args) => nodeTest.skip(...args)
+describe.skip = (...args) => node.describe.skip(...args)
+test.skip = (...args) => node.test.skip(...args)
 
-afterEach(() => {
+node.afterEach(() => {
   for (const { error } of expect.extractExpectedAssertionsErrors()) throw error
 })
 
-after(() => {
+node.after(() => {
   jestTimers.useRealTimers()
   const prefix = `Tests completed, but still have asynchronous activity after`
 
@@ -176,8 +169,20 @@ after(() => {
   }
 })
 
-const jest = {
-  exodus: Object.create(null), // declare ourselves
+export const jest = {
+  exodus: {
+    __proto__: null,
+    features: {
+      __proto__: null,
+      platform: String(process.env.EXODUS_TEST_PLATFORM),
+      engine: String(node.engine),
+      timers: Boolean(mock.timers && haveValidTimers),
+      esmMocks: Boolean(mock.module), // full support for ESM mocks
+      esmInterop: Boolean(insideEsbuild), // loading/using ESM as CJS, ESM mocks creation without a mocker function
+      esmNamedBuiltinMocks: Boolean(mock.module || insideEsbuild), // support for named ESM imports from builtin module mocks
+      concurrency: node.engine !== 'pure', // pure engine doesn't support concurrency
+    },
+  },
   setTimeout: (x) => {
     assert.equal(typeof x, 'number')
     defaultTimeout = x
@@ -188,6 +193,12 @@ const jest = {
   ...jestTimers,
 }
 
-export { jest, describe, test, test as it }
+const wrapCallback = (fn) => (fn.length > 0 ? (t, c) => fn(c) : () => fn())
+
+export const beforeEach = (fn) => node.beforeEach(wrapCallback(fn))
+export const afterEach = (fn) => node.afterEach(wrapCallback(fn))
+export const beforeAll = (fn) => node.before(wrapCallback(fn))
+export const afterAll = (fn) => node.after(wrapCallback(fn))
+
+export { describe, test, test as it }
 export { expect } from 'expect'
-export { beforeEach, afterEach, before as beforeAll, after as afterAll } from './engine.js'

package/src/jest.mock.js

@@ -8,13 +8,25 @@ import {
   syncBuiltinESMExports,
 } from './engine.js'
 import { jestfn } from './jest.fn.js'
-import { makeEsbuildMockable } from './dark.cjs'
+import { makeEsbuildMockable, insideEsbuild } from './dark.cjs'
 
 const mapMocks = new Map()
 const mapActual = new Map()
+const nodeMocks = new Map()
+const overridenBuiltins = new Set()
+
+function wrap(impl) {
+  return function (...args) {
+    impl(...args)
+    return this
+  }
+}
 
 export const jestModuleMocks = {
-  mock: jestmock,
+  mock: wrap((name, mock) => jestmock(name, mock, { override: true })),
+  doMock: wrap((name, mock) => jestmock(name, mock)),
+  unmock: wrap(unmock),
+  dontMock: wrap(unmock),
   createMockFromModule: (name) => mockClone(requireActual(name)),
   requireMock,
   requireActual,
@@ -42,13 +54,33 @@ export function requireMock(name) {
 }
 
 export function resetModules() {
-  // Caveat: only resets CJS modules, not ESM
-  for (const key of Object.keys(require.cache)) delete require.cache[key]
+  for (const [, ctx] of nodeMocks) {
+    if (mock.module) ctx.restore()
+  }
+
+  for (const resolved of Object.keys(require.cache)) {
+    delete require.cache[resolved]
+    mapMocks.delete(resolved)
+  }
+}
+
+function unmock(name) {
+  const resolved = resolveModule(name)
+  assert(mapMocks.has(resolved), 'Module is not mocked')
+  if (mock.module) nodeMocks.get(resolved).restore()
+  delete require.cache[resolved]
+  delete require.cache[`node:${resolved}`]
+  mapMocks.delete(resolved)
+  nodeMocks.delete(resolved)
+  assert(
+    !overridenBuiltins.has(resolved),
+    'Built-in modules mocked with jest.mock can not be unmocked, use jest.doMock'
+  )
 }
 
-const isObject = (obj) => [Object.prototype, null].includes(Object.getPrototypeOf(obj))
+const isObject = (obj) => obj && [Object.prototype, null].includes(Object.getPrototypeOf(obj))
 
-function override(resolved, lax = false) {
+function overrideModule(resolved, lax = false) {
   const value = mapMocks.get(resolved)
   const current = mapActual.get(resolved)
   if (current === value) return
@@ -100,7 +132,9 @@ function mockCloneItem(obj, cache) {
     // Special path, as .default might be a getter and we want to unwrap it
     if (obj.__esModule === true) {
       const { __esModule, default: def, ...rest } = obj
-      return { __esModule, ...mockClone({ default: def, ...rest }, cache) }
+      const proto = Object.getPrototypeOf(obj)
+      const toClone = proto?.[Symbol.toStringTag] === 'Module' ? proto : { default: def, ...rest } // unwrap bun modules for proper cloning
+      return { __esModule, ...mockClone(toClone, cache) }
     }
 
     const prototype = Object.getPrototypeOf(obj)
@@ -137,7 +171,7 @@ function mockCloneItem(obj, cache) {
   return null
 }
 
-export function jestmock(name, mocker) {
+export function jestmock(name, mocker, { override = false } = {}) {
   // Loaded ESM: isn't mocked
   // Loaded CJS: mocked via object overriding
   // Loaded built-ins: mocked via object overriding where possible
@@ -147,6 +181,10 @@ export function jestmock(name, mocker) {
 
   const resolved = resolveModule(name)
   assert(!mapMocks.has(resolved), 'Re-mocking the same module is not supported')
+  assert(
+    !overridenBuiltins.has(resolved),
+    'Built-in modules mocked with jest.mock can not be remocked, use jest.doMock'
+  )
 
   // Attempt to load it
   // Jest also loads modules on mock
@@ -154,41 +192,70 @@ export function jestmock(name, mocker) {
   const havePrior = Object.hasOwn(require.cache, resolved)
   try {
     mapActual.set(resolved, require(resolved))
-  } catch {}
+  } catch {
+    assert(mocker, 'Can not auto-clone a native ESM module without --esbuild or newer Node.js')
+  }
 
   const value = mocker ? { ...mocker() } : mockClone(mapActual.get(resolved))
   mapMocks.set(resolved, value)
 
   let likelyESM = false
+  let okFromESM = false
   const isBuiltIn = builtinModules.includes(resolved)
-  if (Object.hasOwn(require.cache, resolved)) {
-    assert.equal(mapActual.get(resolved), require.cache[resolved].exports)
-    // If we did't have this prior but have now, it means we just loaded it and there are no leaked instances
-    if (havePrior) override(resolved)
-    require.cache[resolved].exports = value
-  } else if (isBuiltIn) {
-    override(resolved, true) // Override builtin modules
-    syncBuiltinESMExports()
+  const isNodeCache = (x) => x && x.id && x.path && x.filename && x.children && x.paths && x.loaded
+  if (isBuiltIn && !isNodeCache(require.cache[resolved])) {
+    if (!value.default && !value.__esModule) {
+      value.__esModule = true // allows esbuild to unwrap it to named mocks
+      value.default = value
+    }
+
+    if (override) {
+      overridenBuiltins.add(resolved)
+      overrideModule(resolved, true) // Override builtin modules
+      if (syncBuiltinESMExports) {
+        syncBuiltinESMExports()
+        okFromESM = true
+      }
+    }
+
+    require.cache[resolved] = require.cache[`node:${resolved}`] = { exports: value }
+  } else if (Object.hasOwn(require.cache, resolved)) {
+    if (isNodeCache(require.cache[resolved]) || !require.cache[resolved].exports?.__esModule) {
+      assert.equal(mapActual.get(resolved), require.cache[resolved].exports)
+      // If we did't have this prior but have now, it means we just loaded it and there are no leaked instances
+      if (havePrior && override) overrideModule(resolved)
+      require.cache[resolved].exports = value
+    } else {
+      // If it's non-Node.js and has __esModule tag, assume it's ESM
+      likelyESM = true
+    }
   } else {
     // The module doesn't exist or is ESM
     likelyESM = true
   }
 
-  if (!mock.module && !isBuiltIn) {
+  if (likelyESM || (!okFromESM && isTopLevelESM())) {
     // Native module mocks is required if loading ESM or __from__ ESM
     // No good way to check the locations that import the module, but we can check top-level file
     // Built-in modules are fine though
-    assert(!likelyESM && !isTopLevelESM(), 'ESM module mocks are available only on Node.js >=22.3')
+    assert(mock.module, 'ESM module mocks are available only on Node.js >=22.3')
+  } else if (isBuiltIn && name.startsWith('node:') && !override) {
+    assert(mock.module, 'Native non-overriding node:* mocks are available only on Node.js >=22.3')
   }
 
-  if (likelyESM && isObject(value) && value.__esModule === true) {
+  const obj = { defaultExport: value }
+  if (isBuiltIn && isObject(value)) obj.namedExports = value
+  if (insideEsbuild) {
+    // esbuild handles unwrapping just default exports for us
+    assert(!likelyESM) // should not be reachable
+  } else if (likelyESM && isObject(value) && value.__esModule === true) {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { default: defaultExport, __esModule, ...namedExports } = value
-    mock.module?.(resolved, { defaultExport, namedExports })
-  } else {
-    mock.module?.(resolved, { defaultExport: value })
+    Object.assign(obj, { defaultExport, namedExports })
   }
 
+  nodeMocks.set(resolved, mock.module?.(resolved, obj))
+
   return this
 }
 

package/src/jest.snapshot.js

@@ -63,7 +63,7 @@ function wrapContextName(fn) {
     configurable: true,
     get() {
       assert.equal(this, context)
-      return value.replaceAll(' > ', ' ')
+      return value.replaceAll(' > ', ' ').replaceAll('<anonymous>', '')
     },
   })
   try {
@@ -127,7 +127,8 @@ const snapOnDisk = (orig, matcher) => {
     // Also be careful with assertion plan counters
     if (!snapshotText) getAssert().fail(`Could not find snapshot file. ${addFail}`)
 
-    const name = getTestNamePath(context).join(' ')
+    const namePath = getTestNamePath(context).map((x) => (x === '<anonymous>' ? '' : x))
+    const name = namePath.join(' ')
     const count = (nameCounts.get(name) || 0) + 1
     nameCounts.set(name, count)
     const escaped = escape(serialize(obj))

package/src/node.js

@@ -0,0 +1,10 @@
+import { setSnapshotSerializers as setDefaultSnapshotSerializers } from './engine.js'
+
+function setResolveSnapshotPath() {
+  // TODO: might want to test it and allow if it's pure / doesn't depend on fs
+  throw new Error('Unsupported due to possible environment differences')
+}
+
+export const snapshot = { setDefaultSnapshotSerializers, setResolveSnapshotPath }
+
+export { mock, describe, test, beforeEach, afterEach, before, after } from './engine.js'