@exodus/test 1.0.0-rc.0 → 1.0.0-rc.10

package/README.md

@@ -1,20 +1,44 @@
 # @exodus/test
 
+A runner for `node:test`, `jest`, and `tape` test suites on top of `node:test`
+
 Most likely it will just work on your simple jest tests as as drop-in replacement
 
+Comes with typescript support, optional esm/cjs interop, and also loading babel transforms!
+
+Use `--coverage` to generate coverage output
+
+Default `NODE_ENV` value is "test", use `NODE_ENV=` to override (e.g. to empty)
+
 ## Library
 
-### Moving from jest
+### Using with `node:test` natively
 
-`import { describe, it, assert, jest, expect } from '@exodus/test'`
+You can just use pure [`node:test`](https://nodejs.org/api/test.html) in your tests,
+this runner is fully compatible with that (and will set version-specific options for you)!
 
-Replace `.calls` with `.callsArguments`, as the former one now contains more detailed information
+### Moving from jest
 
-### Moving from tap/tape
+```js
+import {
+  jest,
+  expect,
+  describe,
+  it,
+  beforeEach,
+  afterEach,
+  beforeAll,
+  afterAll,
+} from '@exodus/test/jest'
+```
+
+Or, run with [`--jest` option](#options) to register jest globals
 
-`import { tap as test } from '@exodus/test'`
+### Moving from tap/tape
 
-Not all features might be supported
+```js
+import test from '@exodus/test/tap'
+```
 
 ### Running tests asynchronously
 
@@ -22,39 +46,34 @@ Add `{ concurrency: true }`, like this: `describe('my testsuite', { concurrency:
 
 ### List of exports
 
-Adapters:
-
-- `jest` -- jest mock adapter
-- `tap` -- tap/tape adapter
-- `mock`
+- `@exodus/test/jest` -- `jest` mock
 
-Assertions:
-
-- `assert` -- alias for `node:assert/strict`
-- `expect` -- expect with additional features for function mocks
-
-Suite:
-
-- `describe`
-- `test`
-- `it` -- alias for `test`
-- `beforeEach`
-- `afterEach`
-- `before` -- alias for `beforeAll`
-- `after` -- alias for `afterAll`
+- `@exodus/test/tape` -- `tape` mock (can also be helpful when moving from `tap`)
 
 ## Binary
 
-Just use `"test: "exodus-test"`
+Just use `"test": "exodus-test"`
 
 ### Options
 
-- `--global` -- register all test helpers as global variables
+- `--jest` -- register jest test helpers as global variables
+
+- `--typescript` -- use typescript loader (which also compiles esm to cjs where needed)
+
+- `--esbuild` -- use esbuild loader (currently an alias for `--typescript`)
 
-- `--typescript` -- enable typescript support
+- `--babel` -- use babel loader (slower than `--esbuild`, makes sense if you have a special config)
 
 - `--coverage` -- enable coverage, prints coverage output (varies by coverage engine)
 
 - `--coverage-engine c8` -- use c8 coverage engine (default), also generates `./coverage/` dirs
 
 - `--coverage-engine node` -- use Node.js builtint coverage engine
+
+- `--watch` -- operate in watch mode and re-run tests on file changes
+
+- `--passWithNoTests` -- do not error when no test files were found
+
+- `--write-snapshots` -- write snapshots instead of verifying them (has `--test-update-snapshots` alias)
+
+- `--test-force-exit` -- force exit after tests are done (useful in integration tests where it could be unfeasible to resolve all open handles)

package/bin/babel.cjs

@@ -0,0 +1,8 @@
+const register = require('@babel/register')
+
+register({
+  compact: false,
+  babelrc: false,
+  plugins: ['@babel/plugin-transform-modules-commonjs'],
+  ignore: [], // do not ignore node_modules
+})

package/bin/index.js

@@ -5,11 +5,11 @@ import { fileURLToPath } from 'node:url'
 import { basename, dirname, resolve } from 'node:path'
 import { createRequire } from 'node:module'
 import assert from 'node:assert/strict'
-import glob from 'fast-glob' // Only for Node.js <22 support
+import glob from 'fast-glob'
 
 const bindir = dirname(fileURLToPath(import.meta.url))
 
-const DEFAULT_PATTERNS = ['**/*.{test,spec}.?(c|m)js', '**/*.{test,spec}.ts']
+const DEFAULT_PATTERNS = ['**/*.{test,spec}.{js,cjs,mjs,ts}', '**/{test,spec}.{js,cjs,mjs,ts}']
 
 function versionCheck() {
   const [major, minor, patch] = process.versions.node.split('.').map(Number)
@@ -21,10 +21,15 @@ function versionCheck() {
 
 function parseOptions() {
   const options = {
-    global: false,
+    jest: false,
     typescript: false,
+    esbuild: false,
+    babel: false,
     coverage: false,
     coverageEngine: 'c8', // c8 or node
+    watch: false,
+    passWithNoTests: false,
+    writeSnapshots: false,
   }
 
   const args = [...process.argv]
@@ -40,18 +45,39 @@ function parseOptions() {
   while (args[0]?.startsWith('--')) {
     const option = args.shift()
     switch (option) {
-      case '--global':
-        options.global = true
+      case '--global': // compat, will be removed in release
+      case '--jest':
+        options.jest = true
         break
       case '--typescript':
         options.typescript = true
         break
+      case '--esbuild':
+        options.esbuild = true
+        break
+      case '--babel':
+        options.babel = true
+        break
       case '--coverage-engine':
         options.coverageEngine = args.shift()
         break
       case '--coverage':
         options.coverage = true
         break
+      case '--watch':
+        options.watch = true
+        break
+      case '--passWithNoTests':
+        options.passWithNoTests = true
+        break
+      case '--test-update-snapshots': // Node.js name for this, might get suggested in errors
+      case '--write-snapshots':
+        options.writeSnapshots = true
+        break
+      case '--test-force-exit':
+      case '--forceExit':
+        options.forceExit = true
+        break
       default:
         throw new Error(`Unknown option: ${option}`)
     }
@@ -74,9 +100,37 @@ const { options, patterns } = parseOptions()
 let program = 'node'
 
 const require = createRequire(import.meta.url)
-const c8 = require.resolve('c8/bin/c8.js')
+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 = ['--test', '--no-warnings=ExperimentalWarning']
+
+const haveModuleMocks = major > 22 || (major === 22 && minor >= 3)
+if (haveModuleMocks) args.push('--experimental-test-module-mocks')
+
+const haveSnapshots = major > 22 || (major === 22 && minor >= 3)
+if (haveSnapshots) args.push('--experimental-test-snapshots')
+
+if (options.writeSnapshots) {
+  assert(haveSnapshots, 'For snapshots, use Node.js >=22.3.0')
+  args.push('--test-update-snapshots')
+}
+
+if (options.forceExit) {
+  assert((major === 20 && minor > 13) || major >= 22, 'For forceExit, use Node.js >= 20.14.0')
+  args.push('--test-force-exit')
+}
+
+if (options.watch) {
+  assert((major === 18 && minor > 13) || major >= 20, 'For watch mode, use Node.js >= 18.13.0')
+  args.push('--watch')
+}
+
+args.push('--expose-internals') // this is unoptimal and hopefully temporary, see rationale in src/dark.cjs
 
-const args = ['--test', '--enable-source-maps']
 if (options.coverage) {
   if (options.coverageEngine === 'node') {
     args.push('--experimental-test-coverage')
@@ -90,32 +144,80 @@ if (options.coverage) {
   }
 }
 
-if (options.global) {
-  if (major >= 20 || (major === 18 && minor >= 18)) {
-    args.push('--import', resolve(bindir, 'preload.js'))
+if (options.typescript || options.esbuild) {
+  if (major >= 22 || (major === 20 && minor >= 6) || (major === 18 && minor >= 18)) {
+    assert(resolveImport)
+    args.push('--import', resolveImport('tsx'))
   } else {
-    throw new Error('Option --global requires Node.js >= v18.18.0')
+    args.push('-r', resolveRequire('tsx/cjs'))
   }
 }
 
-if (options.typescript) {
-  if (major >= 22 || (major === 20 && minor >= 6) || (major === 18 && minor >= 18)) {
-    args.push('--import', '@swc-node/register/esm-register')
+if (options.babel) {
+  assert(!options.typescript, 'Options --babel and --typescript are mutually exclusive')
+  args.push('-r', resolveRequire('./babel.cjs'))
+}
+
+// Our loader should be last, as enabling module mocks confuses other loaders
+if (options.jest) {
+  if (major >= 20 || (major === 18 && minor >= 18)) {
+    args.push('--import', resolve(bindir, 'jest.js'))
   } else {
-    throw new Error('Option --typescript requires Node.js >=20.6.0 || 18 >=18.18.0')
+    throw new Error('Option --jest requires Node.js >= v18.18.0')
   }
 }
 
-if (major === 18 || major === 20) {
-  // We need to expand glob patterns for these
-  args.push(...(await glob(patterns)))
-} else if (major >= 22) {
-  // Yay we have native glob support
-  args.push(...patterns)
-} else {
-  throw new Error('Unreachable')
+const ignore = ['node_modules']
+if (process.env.EXODUS_TEST_IGNORE) {
+  // fast-glob treats negative ignore patterns exactly the same as positive, let's not cause a confusion
+  assert(!process.env.EXODUS_TEST_IGNORE.startsWith('!'), 'Ignore pattern should not be negative')
+  ignore.push(process.env.EXODUS_TEST_IGNORE)
+}
+
+const allfiles = await glob(patterns, { ignore })
+
+if (allfiles.length === 0) {
+  if (options.passWithNoTests) {
+    console.warn('No tests files found, but passing due to --passWithNoTests')
+    process.exit(0)
+  }
+
+  console.error('No tests files found!')
+  process.exit(1)
 }
 
+let subfiles // must be a strict subset of allfiles
+if (process.env.EXODUS_TEST_SELECT) {
+  const subfiles = await glob(process.env.EXODUS_TEST_SELECT, { ignore })
+
+  const allSet = new Set(allfiles)
+  const stray = subfiles.filter((file) => !allSet.has(file))
+  if (stray.length > 0) {
+    console.error(`Selected tests should be a subset of all tests:\n  ${stray.join('\n  ')}`)
+    process.exit(1)
+  }
+
+  if (subfiles.length === 0) {
+    console.error('No tests files selected due to EXODUS_TEST_SELECT, passing')
+    process.exit(0)
+  }
+}
+
+const files = subfiles ?? allfiles
+
+const tsTests = files.filter((file) => file.endsWith('.ts'))
+if (tsTests.length > 0 && !options.typescript) {
+  console.error(`Some tests require --typescript flag:\n  ${tsTests.join('\n  ')}`)
+  process.exit(1)
+} else if (!allfiles.some((file) => file.endsWith('.ts')) && options.typescript) {
+  console.warn(`Flag --typescript has been used, but there were no TypeScript tests found!`)
+}
+
+assert(files.length > 0) // otherwise we can run recursively
+args.push(...files)
+
+if (!Object.hasOwn(process.env, 'NODE_ENV')) process.env.NODE_ENV = 'test'
+
 assert(program && ['node', c8].includes(program))
 const node = spawn(program, args, { stdio: 'inherit' })
 

package/bin/jest.js

@@ -0,0 +1,13 @@
+import * as globals from '../src/jest.js'
+// import { resolveModule } from '../src/jest.mock.js'
+// import { mock } from 'node:test'
+
+Object.assign(globalThis, globals)
+
+// @jest/globals import auto-mocking is disabled until https://github.com/nodejs/node/issues/53807 is resolved
+/*
+try {
+  const resolved = resolveModule('@jest/globals')
+  if (mock.module) mock.module(resolved, { defaultExport: globals, namedExports: globals })
+} catch {}
+*/

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.0",
+  "version": "1.0.0-rc.10",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
-  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/libraries/test",
-  "bugs": {
-    "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Aexodus-test"
-  },
+  "homepage": "https://github.com/ExodusMovement/test",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
+    "url": "https://github.com/ExodusMovement/test.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ExodusMovement/test/issues"
   },
   "keywords": [
     "test",
@@ -25,20 +25,48 @@
   "bin": {
     "exodus-test": "bin/index.js"
   },
-  "main": "src/index.js",
+  "exports": {
+    "./jest": "./src/jest.js",
+    "./tape": "./src/tape.js"
+  },
+  "prettier": "@exodus/prettier",
   "files": [
-    "bin/preload.js",
+    "bin/babel.cjs",
+    "bin/jest.js",
+    "src/dark.cjs",
+    "src/jest.js",
+    "src/jest.fn.js",
+    "src/jest.mock.js",
+    "src/jest.snapshot.js",
+    "src/jest.timers.js",
+    "src/tape.js",
     "!__tests__",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "exodus-test --global --typescript",
-    "lint": "run -T eslint ."
+    "test": "./bin/index.js --jest --typescript",
+    "test:tape": "./bin/index.js --esbuild '__test__/tape/test/*.js' __test__/tape.test.js",
+    "coverage": "./bin/index.js --jest --typescript --coverage",
+    "lint": "prettier --list-different . && eslint .",
+    "lint:fix": "prettier --write . && eslint --fix ."
   },
   "dependencies": {
-    "@swc-node/register": "^1.8.0",
+    "@babel/register": "^7.0.0",
     "c8": "^9.1.0",
     "expect": "^29.7.0",
-    "fast-glob": "^3.2.11"
-  }
+    "fast-glob": "^3.2.11",
+    "jest-extended": "^4.0.2",
+    "pretty-format": "^29.7.0",
+    "tsx": "^4.16.2"
+  },
+  "devDependencies": {
+    "@exodus/eslint-config": "^5.24.0",
+    "@exodus/prettier": "^1.0.0",
+    "@jest/globals": "^29.7.0",
+    "@types/jest-when": "^3.5.2",
+    "@typescript-eslint/eslint-plugin": "^7.15.0",
+    "eslint": "^8.44.0",
+    "jest-when": "^3.6.0"
+  },
+  "packageManager": "pnpm@9.4.0+sha1.9217c800d4ab947a7aee520242a7b70d64fc7638"
 }

package/src/dark.cjs

@@ -0,0 +1,48 @@
+const { fileURLToPath } = require('node:url')
+
+let locForNextTest
+
+let installLocationInNextTest = function (loc) {
+  locForNextTest = loc
+}
+
+// WARNING
+// Do not refactor, do not wrap
+// This function has to be called unwrapped directly inside our test() impl
+let getCallerLocation = () => {}
+
+const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str) : str)
+
+// This is unoptimal
+// Ideally, an option for overriding file locations should be added to Node.js,
+// instead of relying on the call location of the original test() impl
+// That could be even hardened by a simple option of how many frames up to look
+
+// This whole logic is limited only to updating caller locations for reports
+// We don't do use exposed Node.js internas for anything else
+
+try {
+  const { Test } = require('node:internal/test_runner/test')
+  const locStorage = new Map()
+  Object.defineProperty(Test.prototype, 'loc', {
+    get() {
+      return locStorage.get(this)
+    },
+    set(val) {
+      locStorage.set(this, val)
+      if (locForNextTest) {
+        const loc = locForNextTest
+        locForNextTest = undefined
+        locStorage.set(this, { line: loc[0], column: loc[1], file: mayBeUrlToPath(loc[2]) })
+      }
+    },
+  })
+
+  // We can replicate getCallerLocation() with public V8 Error CallSite API, but we won't
+  // need it anyway if we don't have a path for hook into internal Test implementation
+
+  const { internalBinding } = require('node:internal/test/binding')
+  getCallerLocation = internalBinding('util').getCallerLocation
+} catch {}
+
+module.exports = { installLocationInNextTest, getCallerLocation }

package/src/jest.fn.js

@@ -0,0 +1,169 @@
+import { mock } from 'node:test'
+import assert from 'node:assert/strict'
+
+const registry = new Set()
+
+const applyAllWrap = (method) =>
+  function () {
+    assert(['mockClear', 'mockReset', 'mockRestore'].includes(method))
+    for (const obj of registry) obj[method]()
+    return this
+  }
+
+export const allMocks = {
+  clearAllMocks: applyAllWrap('mockClear'),
+  resetAllMocks: applyAllWrap('mockReset'),
+  restoreAllMocks: applyAllWrap('mockRestore'),
+}
+
+// We need parent and property for jest.spyOn and mockfn.mockRestore()
+export const jestfn = (baseimpl, parent, property) => {
+  // not an arrow as might be used as a constructor
+  // also, should be isolated between jest.fn calls
+  const noop = function () {}
+
+  let mockname
+  let mockimpl = baseimpl || noop
+  let reportedmockimpl = baseimpl || undefined
+  const onceStack = []
+
+  const fn = mock.fn(mockimpl)
+  const fnmock = fn.mock
+
+  const queuedMockClear = () => fnmock.resetCalls()
+  const queuedMockReset = () => {
+    queuedMockClear()
+    onceStack.length = 0
+    mockimpl = noop
+    mockname = undefined
+    reportedmockimpl = undefined
+    fnmock.mockImplementation(mockimpl)
+  }
+
+  const queuedMockRestore = () => {
+    queuedMockReset()
+    // mocked function resets to noop, the original resets to baseimpl
+    if (parent && property) {
+      assert(property in parent && !(property in {}) && !(property in Object.prototype))
+      if (parent[property] === fnproxy) {
+        // we need to handle the case when that came from prototype
+        // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+        delete parent[property]
+        // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+        if (parent[property] !== baseimpl) parent[property] = baseimpl
+      }
+    }
+  }
+
+  const queuedMock = (impl) => {
+    mockimpl = impl || noop
+    onceStack.length = 0
+    fnmock.mockImplementation(mockimpl)
+  }
+
+  // getMockImplementation() is undocumented and is changed only in real mockImplementation() call
+  const queuedMockReported = (impl) => {
+    queuedMock(impl)
+    reportedmockimpl = impl
+  }
+
+  const queuedMockOnce = (impl) => {
+    onceStack.push(impl)
+    fnmock.mockImplementation(queueImplementation)
+  }
+
+  const queueImplementation = function (...args) {
+    try {
+      const impl = onceStack.shift() || mockimpl
+      return impl.call(this, ...args)
+    } finally {
+      // load fast path if we are done with the queue
+      if (onceStack.length === 0) {
+        assert(mockimpl)
+        fnmock.mockImplementation(mockimpl)
+      }
+    }
+  }
+
+  const jestfnmock = {
+    get calls() {
+      return fnmock.calls.map((call) => call.arguments)
+    },
+    get results() {
+      return fnmock.calls.map((call) =>
+        call.error ? { type: 'throw', value: call.error } : { type: 'return', value: call.result }
+      )
+    },
+    get instances() {
+      return fnmock.calls.map((call) => {
+        // only return valid instances
+        assert(call.result && call.result === call.this)
+        return call.this
+      })
+    },
+    get contexts() {
+      return fnmock.calls.map((call) => call.this)
+    },
+    get lastCall() {
+      return fnmock.calls.at(-1)?.arguments
+    },
+  }
+
+  const fnProxyGet = (obj, key) => {
+    const wrap =
+      (body) =>
+      (...args) => {
+        body(...args)
+        return fnproxy
+      }
+
+    if (Object.hasOwn(obj, key)) return obj[key]
+
+    switch (key) {
+      case 'bind':
+        // No need to add this to the registy as we already have the base instance
+        return (...args) => new Proxy(obj.bind(...args), { get: fnProxyGet })
+      case 'mock':
+        return jestfnmock
+      case '_isMockFunction':
+        return true
+      case 'getMockName':
+        return () => mockname ?? 'jest.fn()'
+      case 'mockName':
+        return wrap((name) => {
+          mockname = name
+        })
+      case 'getMockImplementation':
+        return () => reportedmockimpl
+      case 'mockClear':
+        return wrap(() => queuedMockClear())
+      case 'mockReset':
+        return wrap(() => queuedMockReset())
+      case 'mockRestore':
+        return wrap(() => queuedMockRestore())
+      case 'mockImplementation':
+        return wrap((impl) => queuedMockReported(impl))
+      case 'mockImplementationOnce':
+        return wrap((impl) => queuedMockOnce(impl))
+      case 'mockReturnValue':
+        return wrap((val) => queuedMock(() => val))
+      case 'mockReturnValueOnce':
+        return wrap((val) => queuedMockOnce(() => val))
+      case 'mockResolvedValue':
+        return wrap((val) => queuedMock(() => Promise.resolve(val)))
+      case 'mockResolvedValueOnce':
+        return wrap((val) => queuedMockOnce(() => Promise.resolve(val)))
+      case 'mockRejectedValue':
+        return wrap((val) => queuedMock(() => Promise.reject(val)))
+      case 'mockRejectedValueOnce':
+        return wrap((val) => queuedMockOnce(() => Promise.reject(val)))
+    }
+
+    return obj[key]
+  }
+
+  const fnproxy = new Proxy(fn, { get: fnProxyGet })
+  registry.add(fnproxy)
+
+  return fnproxy
+}

package/src/jest.js

@@ -0,0 +1,89 @@
+import assert from 'node:assert/strict'
+import { describe as nodeDescribe, test as nodeTest, afterEach } from 'node:test'
+import { format, types } from 'node:util'
+import { jestfn, allMocks } from './jest.fn.js'
+import { jestmock, requireActual, requireMock, resetModules } from './jest.mock.js'
+import * as jestTimers from './jest.timers.js'
+import './jest.snapshot.js'
+import { getCallerLocation, installLocationInNextTest } from './dark.cjs'
+import { expect } from 'expect'
+import matchers from 'jest-extended'
+
+expect.extend(matchers)
+
+let defaultTimeout = 5000
+
+const makeEach = (impl) => (list) => (template, fn) => {
+  for (const arg of list) {
+    let name = template
+
+    const args = !arg || typeof arg !== 'object' ? [arg] : arg
+
+    for (const [key, value] of Object.entries(args)) {
+      name = name.replace(`$${key}`, value) // can collide but we don't care much yet
+    }
+
+    if (Array.isArray(args)) {
+      const length = [...name.replaceAll('%%', '').matchAll(/%./gu)].length
+      if (length > 0) name = format(name, ...args.slice(0, length))
+    }
+
+    impl(name, () => (Array.isArray(args) ? fn(...args) : fn(args)))
+  }
+}
+
+const forceExit = process.execArgv.map((x) => x.replaceAll('_', '-')).includes('--test-force-exit')
+
+const describe = (...args) => nodeDescribe(...args)
+const test = (name, fn, testTimeout) => {
+  const timeout = testTimeout ?? defaultTimeout
+  installLocationInNextTest(getCallerLocation())
+  if (fn.length > 0) return nodeTest(name, (t, c) => fn(c))
+  if (!forceExit) return nodeTest(name, fn)
+  return nodeTest(name, { timeout }, async (t) => {
+    const res = fn()
+    assert(
+      types.isPromise(res),
+      `Test "${t.fullName}" did not return a Promise or supply a callback, which is required in force-exit mode.
+For tests to not end abruptly, use either async functions (recommended), Promises, or specify callbacks to test() / it().
+Also, using expect.assertions() to ensure the planned number of assertions is being called is advised for async code.`
+    )
+    return res
+  })
+}
+
+describe.each = makeEach(describe)
+test.each = makeEach(test)
+describe.skip = (...args) => nodeDescribe.skip(...args)
+test.skip = (...args) => nodeTest.skip(...args)
+
+afterEach(() => {
+  for (const { error } of expect.extractExpectedAssertionsErrors()) throw error
+})
+
+const jest = {
+  fn: (impl) => jestfn(impl), // hide extra arguments
+  ...allMocks,
+  spyOn: (obj, name, accessType) => {
+    assert(!accessType, `accessType "${accessType}" is not supported`)
+    assert(obj && name && name in obj && !(name in {}) && !(name in Object.prototype))
+    const fn = jestfn(obj[name], obj, name)
+    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+    obj[name] = fn
+    return fn
+  },
+  setTimeout: (x) => {
+    assert.equal(typeof x, 'number')
+    defaultTimeout = x
+    return this
+  },
+  mock: jestmock,
+  requireMock,
+  requireActual,
+  resetModules,
+  ...jestTimers,
+}
+
+export { jest, describe, test, test as it }
+export { expect } from 'expect'
+export { beforeEach, afterEach, before as beforeAll, after as afterAll } from 'node:test'

package/src/jest.mock.js

@@ -0,0 +1,133 @@
+import assert from 'node:assert/strict'
+import { createRequire, builtinModules, syncBuiltinESMExports } from 'node:module'
+import { existsSync } from 'node:fs'
+import { normalize } from 'node:path'
+import { mock } from 'node:test'
+import { jestfn } from './jest.fn.js'
+
+const files = process.argv.slice(1)
+const baseUrl = files.length === 1 && existsSync(files[0]) ? normalize(files[0]) : undefined
+const require = createRequire(baseUrl || import.meta.url)
+const mapMocks = new Map()
+const mapActual = new Map()
+
+export function resolveModule(name) {
+  assert(baseUrl || /^[@a-zA-Z]/u.test(name), 'Mocking relative paths is not possible')
+  return require.resolve(name)
+}
+
+export function requireActual(name) {
+  const resolved = resolveModule(name)
+  if (mapActual.has(resolved)) return mapActual.get(resolved)
+  if (!mapMocks.has(resolved)) return require(resolved)
+  throw new Error('Module can not been loaded')
+}
+
+export function requireMock(name) {
+  const resolved = resolveModule(name)
+  assert(mapMocks.has(resolved), 'Module is not mocked')
+  return mapMocks.get(resolved)
+}
+
+export function resetModules() {
+  // Caveat: only resets CJS modules, not ESM
+  for (const key of Object.keys(require.cache)) delete require.cache[key]
+}
+
+const isObject = (obj) => [Object.prototype, null].includes(Object.getPrototypeOf(obj))
+
+function override(resolved, lax = false) {
+  const value = mapMocks.get(resolved)
+  const current = mapActual.get(resolved)
+  assert(isObject(current), 'Modules that export a default non-object can not be mocked')
+  assert(isObject(value), 'Overriding loaded or internal modules is possible with objects only')
+  mapActual.set(resolved, { ...current })
+  for (const key of Object.keys(current)) {
+    try {
+      delete current[key]
+    } catch {}
+  }
+
+  // We want to skip overriding frozen properties that already match, e.g. fs.constants
+  const filtered = Object.entries(value).filter(([k, v]) => !(k in {}) && current[k] !== v)
+  const access = { configurable: true, enumerable: true, writable: true }
+  const definitions = Object.fromEntries(filtered.map(([k, value]) => [k, { value, ...access }]))
+  Object.defineProperties(current, definitions)
+  if (!lax) assert.deepEqual({ ...current }, value)
+}
+
+function mockClone(root) {
+  assert(isObject(root), 'Can not do a full mock on a non-object module')
+  const seen = new Map()
+  const simple = new Set()
+  const TypedArray = Object.getPrototypeOf(Int8Array)
+  const walk = (obj) => {
+    if (!obj || ['number', 'boolean', 'string', 'bigint'].includes(typeof obj)) return [obj, false]
+    if (Array.isArray(obj) || obj instanceof TypedArray) return [[], false] // this is what jest does apparently
+    if (obj instanceof RegExp) return [new RegExp(), false] // this is what jest does apparently
+    if (seen.has(obj)) return [seen.get(obj), !simple.has(obj)]
+    if (obj instanceof Function) {
+      seen.set(obj, jestfn(obj))
+      return [seen.get(obj), true]
+    }
+
+    if (isObject(obj)) {
+      const clone = Object.create(Object.getPrototypeOf(obj))
+      seen.set(obj, clone)
+      let modified = false
+      for (const [k, v] of Object.entries(obj)) {
+        const res = walk(v)
+        if (!res && !(k in clone)) continue
+        clone[k] = res[0]
+        modified ||= res[1]
+      }
+
+      if (modified) simple.add(obj)
+      return [modified ? clone : obj, modified]
+    }
+
+    return null
+  }
+
+  return walk(root)[0]
+}
+
+export function jestmock(name, mocker) {
+  assert(mock.module, 'ESM module mocks are available only on Node.js >=22.3')
+
+  // Loaded ESM: isn't mocked
+  // Loaded CJS: mocked via object overriding
+  // Loaded built-ins: mocked via object overriding where possible
+  // New CJS: mocked via mock.module + require.cache
+  // New ESM: mocked via mock.module
+  // New built-ins: mocked via mock.module
+
+  const resolved = resolveModule(name)
+  assert(!mapMocks.has(resolved), 'Re-mocking the same module is not supported')
+
+  // Attempt to load it
+  // Jest also loads modules on mock
+  // Can be ESM, so let it fail silently
+  const havePrior = Object.hasOwn(require.cache, resolved)
+  try {
+    mapActual.set(resolved, require(resolved))
+  } catch {}
+
+  const value = mocker ? { ...mocker() } : mockClone(mapActual.get(resolved))
+  mapMocks.set(resolved, value)
+
+  // fall through when e.g. this module doesn't exist or is ESM
+  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 (builtinModules.includes(resolved.replace(/^node:/, ''))) {
+    override(resolved, true) // Override builtin modules
+    syncBuiltinESMExports()
+  }
+
+  mock.module(name, { defaultExport: value.default, namedExports: value })
+
+  return this
+}

package/src/jest.snapshot.js

@@ -0,0 +1,98 @@
+import { beforeEach } from 'node:test'
+import { createRequire } from 'node:module'
+import { expect } from 'expect'
+import { format } from 'pretty-format'
+import assert from 'node:assert/strict'
+import { basename, dirname, join } from 'node:path'
+
+const plugins = []
+const opts = { indent: 2, escapeRegex: true, printFunctionName: false, printBasicPrototype: false }
+const serialize = (val) => format(val, { ...opts, plugins }).replaceAll(/\r\n|\r/gu, '\n')
+
+let snapshotsAreJest = false
+
+// We want to setup snapshots to behave like jest only when first used from jest API
+function maybeSetupJestSnapshots() {
+  if (snapshotsAreJest) return
+  const require = createRequire(import.meta.url)
+  const { snapshot } = require('node:test') // attempt to load them, and we need to do that synchronously
+  assert(snapshot, 'snapshots require Node.js >=22.3.0')
+  snapshot.setDefaultSnapshotSerializers([serialize])
+  snapshot.setResolveSnapshotPath((f) => join(dirname(f), '__snapshots__', `${basename(f)}.snap`))
+  snapshotsAreJest = true
+}
+
+const wrap = (check) => {
+  try {
+    check()
+    return { pass: true }
+  } catch (e) {
+    return { pass: false, message: () => e.message }
+  }
+}
+
+let context
+beforeEach((t) => (context = t))
+const getAssert = () => context?.assert ?? assert // do not use non-strict comparisons on this!
+
+// Wrap reported context.fullName so that snapshots are placed/looked for under jest-compatible keys
+function wrapContextName(fn) {
+  if (context.fullName === context.name) return fn() // fast path
+  const value = context.fullName
+  assert(typeof value === 'string' && value.endsWith(` > ${context.name}`))
+  const SuiteContext = Object.getPrototypeOf(context)
+  const fullNameDescriptor = Object.getOwnPropertyDescriptor(SuiteContext, 'fullName')
+  assert(fullNameDescriptor && fullNameDescriptor.configurable)
+  Object.defineProperty(context, 'fullName', {
+    configurable: true,
+    get() {
+      assert.equal(this, context)
+      return value.replaceAll(' > ', ' ')
+    },
+  })
+  try {
+    return fn()
+  } finally {
+    assert.notEqual(context.fullName, value)
+    delete context.fullName
+    assert.equal(context.fullName, value)
+  }
+}
+
+const throws = (fn, check) =>
+  getAssert().throws(fn, (e) => {
+    check(e.message) // jest stores only messages for errors
+    return true
+  })
+
+const snapInline = (obj, inline) => {
+  assert(inline !== undefined, 'Inline Snapshots generation is not supported')
+  assert(typeof inline === 'string')
+  getAssert().strictEqual(serialize(obj).trim(), inline.trim())
+}
+
+const snapOnDisk = (obj) =>
+  wrapContextName(() => {
+    maybeSetupJestSnapshots()
+
+    if (!serialize(obj).includes('\n')) {
+      // Node.js always wraps with newlines, while jest wraps only those that are already multiline
+      try {
+        getAssert().snapshot(obj)
+      } catch (e) {
+        if (`\n${e.expected}\n` === e.actual) return
+        throw e
+      }
+    }
+
+    return getAssert().snapshot(obj)
+  })
+
+expect.extend({
+  toMatchInlineSnapshot: (obj, i) => wrap(() => snapInline(obj, i)),
+  toMatchSnapshot: (obj) => wrap(() => snapOnDisk(obj)),
+  toThrowErrorMatchingInlineSnapshot: (f, i) => wrap(() => throws(f, (msg) => snapInline(msg, i))),
+  toThrowErrorMatchingSnapshot: (f) => wrap(() => throws(f, (msg) => snapOnDisk(msg))),
+})
+
+expect.addSnapshotSerializer = (plugin) => plugins.push(plugin)

package/src/jest.timers.js

@@ -0,0 +1,67 @@
+import assert from 'node:assert/strict'
+import { mock } from 'node:test'
+
+const [major, minor] = process.versions.node.split('.').map(Number)
+
+const assertHaveTimers = () =>
+  assert(mock.timers, 'Timer mocking requires Node.js >=20.4.0 || 18 >=18.19.0')
+
+let timersWarned = false
+const warnOldTimers = () => {
+  if (timersWarned) return
+  timersWarned = true
+  const ok = major >= 22 || (major === 20 && minor >= 11)
+  if (!ok) console.warn('Warning: timer mocks are known to be glitchy before Node.js >=20.11.0')
+}
+
+export function useRealTimers() {
+  mock.timers.reset()
+  return this
+}
+
+export function useFakeTimers({ doNotFake = [], ...rest } = {}) {
+  assertHaveTimers()
+  warnOldTimers()
+  assert.deepEqual(rest, {}, 'Unsupported options')
+  const allApis = ['setInterval', 'setTimeout', 'setImmediate', 'Date']
+  for (const name of doNotFake) assert(allApis.includes(name), `Unknown API: ${name}`)
+  const apis = allApis.filter((name) => !doNotFake.includes(name))
+  try {
+    mock.timers.enable({ apis })
+  } catch (e) {
+    // We allow calling this multiple times and swallow the "MockTimers is already enabled!" error
+    if (e.code !== 'ERR_INVALID_STATE') throw e
+  }
+
+  return this
+}
+
+export function runAllTimers() {
+  assertHaveTimers()
+  warnOldTimers()
+  mock.timers.tick(100_000_000_000) // > 3 years
+  return this
+}
+
+export function runOnlyPendingTimers() {
+  const noInfiniteLoopBug = major >= 22 || (major === 20 && minor >= 11)
+  assert(noInfiniteLoopBug, 'runOnlyPendingTimers requires Node.js >=20.11.0')
+  mock.timers.runAll()
+  return this
+}
+
+export function advanceTimersByTime(time) {
+  assertHaveTimers()
+  warnOldTimers()
+  mock.timers.tick(time)
+  return this
+}
+
+export async function advanceTimersByTimeAsync(time) {
+  return this.advanceTimersByTime(time)
+}
+
+export function setSystemTime(time) {
+  mock.timers.setTime(+time)
+  return this
+}

package/src/tape.js

@@ -0,0 +1,159 @@
+import assert from 'node:assert/strict'
+import assertLoose from 'node:assert'
+import { test } from 'node:test'
+import { getCallerLocation, installLocationInNextTest } from './dark.cjs'
+
+const knownOptions = new Set(['skip', 'todo', 'concurrency', 'timeout'])
+
+function verifyOptions(options) {
+  for (const key of Object.keys(options)) {
+    assert(knownOptions.has(key), `Unknown option: ${key}`)
+  }
+}
+
+// We don't seem to need it for jest, so let's let it live in this file
+function cleanAssertError(e, where) {
+  // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+  e.stack = e.stack
+    .split('\n')
+    .filter((x) => !x.startsWith(`at ${where}:`))
+    .filter((x) => !x.includes(` (${where}:`))
+    .filter((x) => !x.includes(` (node:async_hooks:`))
+    .filter((x) => !x.includes(` (node:internal/test_runner`))
+    .join('\n')
+}
+
+// key: assert method, values: names after which it'll be available
+// note that it's not available by the original key unless explicitly listed in names
+// e.g. we are strict by default
+// We follow tape, not tap, i.e. same/notSame aliases are strict, and there are no special strict versions
+// Most are taken from the doc: https://www.npmjs.com/package/tape#methods
+const aliases = {
+  __proto__: null,
+
+  ok: ['ok', 'true', 'assert'],
+  strictEqual: ['equal', 'equals', 'isEqual', 'strictEqual', 'strictEquals', 'is'],
+  notStrictEqual: [
+    'notEqual',
+    'notEquals',
+    'isNotEqual',
+    'doesNotEqual',
+    'isInequal',
+    'notStrictEqual',
+    'notStrictEquals',
+    'isNot',
+    'not',
+  ],
+  equal: ['looseEqual', 'looseEquals'],
+  notEqual: ['notLooseEqual', 'notLooseEquals'],
+  deepStrictEqual: ['deepEqual', 'deepEquals', 'isEquivalent', 'same'],
+  notDeepStrictEqual: [
+    'notDeepEqual',
+    'notDeepEquals',
+    'notEquivalent',
+    'notDeeply',
+    'notSame',
+    'isNotDeepEqual',
+    'isNotDeeply',
+    'isNotEquivalent',
+    'isInequivalent',
+  ],
+  deepEqual: ['deepLooseEqual'],
+  notDeepEqual: ['notDeepLooseEqual'],
+  throws: ['throws'],
+  doesNotThrow: ['doesNotThrow'],
+  fail: ['fail'],
+  rejects: ['rejects'],
+  doesNotReject: ['resolves'],
+
+  // specially handled ones as do not exist in t.assert / assert
+  notOk: ['notOk', 'false', 'notok'],
+  pass: ['pass'],
+  error: ['error', 'ifError', 'ifErr', 'iferror'], // tape
+  assertion: ['assertion'], // tape
+
+  // match/notMatch are confusing as operate on strings in some impls and objs in others. we skip them
+}
+
+function tapeWrapAssert(t, callback) {
+  // Auto-call api.end() on planned test count reaching zero
+  let plan = null
+  let count = 0
+  const track = (...calls) => {
+    count += calls.length
+    if (plan === count) api.end()
+    if (plan !== null) assert(plan >= count, `plan (${plan}) < count (${count})`)
+  }
+
+  const plannedAssert = () => (plan !== null && t.assert) || assertLoose // t.assert is cached and affected by t.plan
+
+  // Note: we must use plannedAssert instead of assert everywhere on user calls as we have t.plan
+  const api = {
+    test: tapeWrap(t.test.bind(t)),
+    plan: (total) => {
+      assert.equal(typeof total, 'number')
+      plan = total
+      assert(plan >= count, `plan (${plan}) < count (${count})`)
+      if (t.plan) t.plan(plan - count) // plan the remaining tests through node
+      track()
+    },
+    skip: (...r) => t.skip(...r),
+    todo: (...r) => t.todo(...r),
+    comment: (...r) => t.diagnostic(...r),
+    end: () => {
+      if (plan !== null) assert.equal(plan, count, `plan (${plan}) !== count (${count})`)
+      if (callback) callback()
+      api.end = () => {}
+    },
+  }
+
+  // Copy implementations from here if they exist, preferring over plannedAssert
+  const base = {
+    pass: (...r) => plannedAssert().ok(true, ...r),
+    notOk: (x, ...r) => plannedAssert().ok(!x, ...r),
+    error: (err, msg) => plannedAssert().ok(!err, msg || err?.message),
+    assertion: (fn, ...args) => fn.apply(plannedAssert(), args),
+  }
+
+  for (const [key, names] of Object.entries(aliases)) {
+    const impl = Object.hasOwn(base, key) ? base[key] : (...r) => plannedAssert()[key](...r)
+    const wrap = (...r) => {
+      try {
+        return impl(...r)
+      } catch (e) {
+        cleanAssertError(e, import.meta.url)
+        throw e
+      }
+    }
+
+    Object.assign(api, Object.fromEntries(names.map((name) => [name, (...r) => track(wrap(...r))])))
+  }
+
+  return api
+}
+
+const AsyncFunction = (async () => {}).constructor
+
+function tapeWrap(test) {
+  const tap = (...args) => {
+    const fn = args.pop()
+    const name = args.shift() || 'test'
+    assert(args.length <= 1)
+    const [opts = {}] = args
+    verifyOptions(opts)
+    assert(fn instanceof Function)
+    installLocationInNextTest(getCallerLocation())
+    if (fn instanceof AsyncFunction) {
+      test(name, opts, (t) => fn(tapeWrapAssert(t)))
+    } else {
+      test(name, opts, (t, callback) => fn(tapeWrapAssert(t, callback)))
+    }
+  }
+
+  tap.skip = (...args) => test.skip(...args)
+  if (test.only) tap.only = tapeWrap(test.only)
+  return tap
+}
+
+export const tape = tapeWrap(test)
+export default tape

package/bin/preload.js

@@ -1,3 +0,0 @@
-import * as testUtils from '../src/index.js'
-
-Object.assign(globalThis, testUtils)

package/src/index.js

@@ -1,119 +0,0 @@
-import { mock, describe, test, it } from 'node:test'
-import { expect } from 'expect'
-import assert from 'node:assert/strict'
-
-const MockFunctionContext = mock.fn().mock.constructor
-
-Object.defineProperty(MockFunctionContext.prototype, 'callsArguments', {
-  get() {
-    return this.calls.map((call) => call.arguments)
-  },
-})
-
-const mockImplementationOrig = MockFunctionContext.prototype.mockImplementation
-MockFunctionContext.prototype.mockImplementation = function (...args) {
-  mockImplementationOrig.call(this, ...args)
-  return this
-}
-
-MockFunctionContext.prototype.mockRestore = MockFunctionContext.prototype.restore
-
-const makeEach = (impl) => (list) => (template, fn) => {
-  for (const args of list) {
-    let name = template
-
-    if (!args || typeof args === 'string' || typeof args === 'number') {
-      name = name.replace('%s', args)
-    } else {
-      for (const [key, value] of Object.entries(args)) {
-        name = name.replace(`$${key}`, value) // can collide but we don't care much yet
-      }
-
-      if (Array.isArray(args)) {
-        for (const arg of args) name = name.replace('%s', arg)
-      }
-    }
-
-    impl(name, () => (Array.isArray(args) ? fn(...args) : fn(args)))
-  }
-}
-
-describe.each = makeEach(describe)
-test.each = makeEach(test)
-it.each = makeEach(it)
-
-const jest = {
-  fn: (...args) => mock.fn(...args),
-  spyOn: (obj, name) => {
-    assert(Object.hasOwn(obj, name))
-    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
-    obj[name] = mock.fn(obj[name])
-    return obj[name].mock
-  },
-  useFakeTimers: () => {
-    mock.timers.enable()
-  },
-  runAllTimers: () => {
-    mock.timers.tick(100_000_000_000) // > 3 years
-  },
-  advanceTimersByTime: (time) => {
-    mock.timers.tick(time)
-  },
-}
-
-expect.extend({
-  toHaveBeenCalled: (fn) => {
-    assert.equal(fn?.mock?.constructor, MockFunctionContext)
-    return { pass: fn.mock.callCount() > 0 }
-  },
-  toHaveBeenCalledTimes: (fn, count) => {
-    assert.equal(fn?.mock?.constructor, MockFunctionContext)
-    return { pass: fn.mock.callCount() === count }
-  },
-  toHaveBeenCalledWith: (fn, ...expected) => {
-    assert.equal(fn?.mock?.constructor, MockFunctionContext)
-    for (const call of fn.mock.calls) {
-      try {
-        expect(call.arguments).toEqual(expected)
-        return { pass: true }
-      } catch {}
-    }
-
-    return { pass: false }
-  },
-  toHaveBeenLastCalledWith: (fn, ...expected) => {
-    assert.equal(fn?.mock?.constructor, MockFunctionContext)
-    try {
-      expect(fn.mock.calls.at(-1).arguments).toEqual(expected)
-      return { pass: true }
-    } catch (e) {
-      return { pass: false, message: () => e.message }
-    }
-  },
-})
-
-function tap(name, fn) {
-  test(name, () =>
-    fn({
-      ...assert,
-      end: () => {},
-    })
-  )
-}
-
-export { tap, jest }
-export { expect } from 'expect'
-export {
-  mock,
-  beforeEach,
-  before,
-  afterEach,
-  after,
-  before as beforeAll,
-  after as afterAll,
-  describe,
-  test,
-  it,
-} from 'node:test'
-
-export { default as assert } from 'node:assert/strict'