@exodus/test 1.0.0-rc.18 → 1.0.0-rc.2

package/README.md

@@ -1,44 +1,20 @@
 # @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
 
-### Using with `node:test` natively
-
-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)!
-
 ### Moving from jest
 
-```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 { describe, it, assert, jest, expect } from '@exodus/test'`
+
+Replace `.calls` with `.callsArguments`, as the former one now contains more detailed information
 
 ### Moving from tap/tape
 
-```js
-import test from '@exodus/test/tap'
-```
+`import { tap as test } from '@exodus/test'`
+
+Not all features might be supported
 
 ### Running tests asynchronously
 
@@ -46,32 +22,39 @@ Add `{ concurrency: true }`, like this: `describe('my testsuite', { concurrency:
 
 ### List of exports
 
-- `@exodus/test/jest` -- `jest` mock
+Adapters:
+
+- `jest` -- jest mock adapter
+- `tap` -- tap/tape adapter
+- `mock`
 
-- `@exodus/test/tape` -- `tape` mock (can also be helpful when moving from `tap`)
+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`
 
 ## Binary
 
-Just use `"test": "exodus-test"`
+Just use `"test: "exodus-test"`
 
 ### Options
 
-- `--jest` -- register jest test helpers as global variables, also load `jest.config.*` configuration options
-
-- `--esbuild` -- use esbuild loader, also enables Typescript support
+- `--global` -- register all test helpers as global variables
 
-- `--babel` -- use babel loader (slower than `--esbuild`, makes sense if you have a special config)
+- `--typescript` -- enable typescript support
 
 - `--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/index.js

@@ -5,26 +5,26 @@ 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'
-import { haveModuleMocks, haveSnapshots, haveForceExit } from '../src/version.js'
+import glob from 'fast-glob' // Only for Node.js <22 support
 
 const bindir = dirname(fileURLToPath(import.meta.url))
 
-const EXTS = `.?([cm])[jt]s?(x)` // we differt from jest, allowing [cm] before everything
-const DEFAULT_PATTERNS = [`**/__tests__/**/*${EXTS}`, `**/?(*.)+(spec|test)${EXTS}`]
+const DEFAULT_PATTERNS = ['**/*.{test,spec}.?(c|m)js', '**/*.{test,spec}.ts']
+
+function versionCheck() {
+  const [major, minor, patch] = process.versions.node.split('.').map(Number)
+  assert((major === 18 && minor >= 13) || major >= 20, 'Node.js version too old!')
+  assert(major !== 21, 'Node.js version deprecated!')
+
+  return { major, minor, patch }
+}
 
 function parseOptions() {
   const options = {
-    jest: false,
+    global: false,
     typescript: false,
-    esbuild: false,
-    babel: false,
     coverage: false,
     coverageEngine: 'c8', // c8 or node
-    watch: false,
-    passWithNoTests: false,
-    writeSnapshots: false,
-    debug: { files: false },
   }
 
   const args = [...process.argv]
@@ -40,20 +40,11 @@ function parseOptions() {
   while (args[0]?.startsWith('--')) {
     const option = args.shift()
     switch (option) {
-      case '--global': // compat, will be removed in release
-      case '--jest':
-        options.jest = true
+      case '--global':
+        options.global = true
         break
       case '--typescript':
-        console.warn('Option --typescript is going to be gone or changed. Use --esbuild instead')
         options.typescript = true
-        options.esbuild = true
-        break
-      case '--esbuild':
-        options.esbuild = true
-        break
-      case '--babel':
-        options.babel = true
         break
       case '--coverage-engine':
         options.coverageEngine = args.shift()
@@ -61,23 +52,6 @@ function parseOptions() {
       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
-      case '--debug-files':
-        options.debug.files = true
-        break
       default:
         throw new Error(`Unknown option: ${option}`)
     }
@@ -89,40 +63,20 @@ function parseOptions() {
   )
 
   const patterns = [...args]
+  if (patterns.length === 0) patterns.push(...DEFAULT_PATTERNS) // defaults
 
   return { options, patterns }
 }
 
+const { major, minor } = versionCheck()
 const { options, patterns } = parseOptions()
 
 let program = 'node'
 
 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 = ['--test', '--no-warnings=ExperimentalWarning']
-
-if (haveModuleMocks) args.push('--experimental-test-module-mocks')
-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(haveForceExit, 'For forceExit, use Node.js >= 20.14.0')
-  args.push('--test-force-exit')
-}
-
-if (options.watch) args.push('--watch')
-
-args.push('--expose-internals') // this is unoptimal and hopefully temporary, see rationale in src/dark.cjs
+const c8 = require.resolve('c8/bin/c8.js')
 
+const args = ['--test', '--enable-source-maps']
 if (options.coverage) {
   if (options.coverageEngine === 'node') {
     args.push('--experimental-test-coverage')
@@ -136,129 +90,35 @@ if (options.coverage) {
   }
 }
 
-if (options.esbuild) {
-  assert(resolveImport)
-  args.push('--import', resolveImport('tsx'))
-}
-
-if (options.babel) {
-  assert(!options.esbuild, 'Options --babel and --esbuild are mutually exclusive')
-  args.push('-r', resolveRequire('./babel.cjs'))
-}
-
-const ignore = ['**/node_modules']
-let filter
-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)
-}
-
-// Our loader should be last, as enabling module mocks confuses other loaders
-if (options.jest) {
-  const { loadJestConfig } = await import('../src/jest.config.js')
-  const config = await loadJestConfig(process.cwd())
-  args.push('--import', resolve(bindir, 'jest.js'))
-
-  if (config.testFailureExitCode !== undefined) {
-    if (Number(config.testFailureExitCode) === 0) {
-      console.warn('Jest is configured to succeed with exit code 0 on test failures!')
-    }
-
-    process.on('exit', (code) => {
-      if (code !== 0) process.exitCode = config.testFailureExitCode
-    })
-  }
-
-  if (patterns.length > 0) {
-    // skip, we already have patterns via argv
-  } else if (config.testRegex) {
-    assert(typeof config.testRegex === 'string', `config.testRegex should be a string`)
-    assert(!config.testMatch, 'config.testRegex can not be used together with config.testMatch')
-    patterns.push('**/*')
-  } else if (config.testMatch) {
-    patterns.push(...(Array.isArray(config.testMatch) ? config.testMatch : [config.testMatch]))
-  }
-
-  const testRegex = config.testRegex ? new RegExp(config.testRegex, 'u') : null
-  const ignoreRegexes = config.testPathIgnorePatterns.map((x) => new RegExp(x, 'u'))
-  if (testRegex || ignoreRegexes.length > 0) {
-    filter = (x) => {
-      const resolved = `<rootDir>/${x}` // don't actually include cwd, that should be irrelevant
-      if (testRegex && !testRegex.test(resolved)) return false
-      return !ignoreRegexes.some((r) => r.test(resolved))
-    }
-  }
-}
-
-if (patterns.length === 0) patterns.push(...DEFAULT_PATTERNS) // defaults
-const globbed = await glob(patterns, { ignore })
-const allfiles = filter ? globbed.filter(filter) : globbed
-
-if (allfiles.length === 0) {
-  if (options.passWithNoTests) {
-    console.warn('No test files found, but passing due to --passWithNoTests')
-    process.exit(0)
+if (options.global) {
+  if (major >= 20 || (major === 18 && minor >= 18)) {
+    args.push('--import', resolve(bindir, 'preload.js'))
+  } else {
+    throw new Error('Option --global requires Node.js >= v18.18.0')
   }
-
-  console.error('No test 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 test files selected due to EXODUS_TEST_SELECT, passing')
-    process.exit(0)
+if (options.typescript) {
+  if (major >= 22 || (major === 20 && minor >= 6) || (major === 18 && minor >= 18)) {
+    args.push('--import', '@swc-node/register/esm-register')
+  } else {
+    throw new Error('Option --typescript requires Node.js >=20.6.0 || 18 >=18.18.0')
   }
 }
 
-const files = subfiles ?? allfiles
-
-files.sort((a, b) => {
-  const [al, bl] = [a.split('/'), b.split('/')]
-  while (al[0] === bl[0]) {
-    al.shift()
-    bl.shift()
-  }
-
-  // First process each file in dir, then subdirs
-  if (al.length < 2) return -1
-  if (bl.length < 2) return 1
-  // Prefer example/ over example-something/
-  const [an, bn] = [al, bl].map((list) => list.join(String.fromCodePoint(0)))
-  if (an < bn) return -1
-  if (an > bn) return 1
+if (major === 18 || major === 20) {
+  // We need to expand glob patterns for these
+  const ignore = ['node_modules']
+  const files = await glob(patterns, { ignore })
+  assert(files.length > 0, 'No tests found!')
+  args.push(...files)
+} else if (major >= 22) {
+  // Yay we have native glob support
+  args.push(...patterns)
+} else {
   throw new Error('Unreachable')
-})
-
-if (options.debug.files) {
-  for (const f of files) console.log(f) // joining with \n can get truncated, too big
-  process.exit(1) // do not succeed!
-}
-
-const tsTests = files.filter((file) => /\.[mc]?tsx?$/u.test(file))
-if (tsTests.length > 0 && !options.esbuild) {
-  console.error(`Some tests require --esbuild 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/preload.js

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

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.18",
+  "version": "1.0.0-rc.2",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
-  "homepage": "https://github.com/ExodusMovement/test",
+  "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"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/ExodusMovement/test.git"
-  },
-  "bugs": {
-    "url": "https://github.com/ExodusMovement/test/issues"
+    "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
   },
   "keywords": [
     "test",
@@ -25,53 +25,20 @@
   "bin": {
     "exodus-test": "bin/index.js"
   },
-  "exports": {
-    "./jest": "./src/jest.js",
-    "./tape": "./src/tape.js"
-  },
-  "prettier": "@exodus/prettier",
+  "main": "src/index.js",
   "files": [
-    "bin/babel.cjs",
-    "bin/jest.js",
-    "src/dark.cjs",
-    "src/jest.js",
-    "src/jest.config.js",
-    "src/jest.environment.js",
-    "src/jest.fn.js",
-    "src/jest.mock.js",
-    "src/jest.snapshot.js",
-    "src/jest.timers.js",
-    "src/tape.js",
-    "src/version.js",
+    "bin/preload.js",
     "!__tests__",
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test": "./bin/index.js --jest --esbuild",
-    "test:tape": "./bin/index.js --esbuild '__test__/tape/test/*.js' __test__/tape.test.js",
-    "coverage": "./bin/index.js --jest --esbuild --coverage",
-    "lint": "prettier --list-different . && eslint .",
-    "lint:fix": "prettier --write . && eslint --fix ."
+    "test": "exodus-test --global --typescript",
+    "lint": "run -T eslint ."
   },
   "dependencies": {
-    "@babel/register": "^7.0.0",
+    "@swc-node/register": "^1.8.0",
     "c8": "^9.1.0",
     "expect": "^29.7.0",
-    "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-matcher-utils": "^29.7.0",
-    "jest-serializer-ansi-escapes": "^3.0.0",
-    "jest-when": "^3.6.0"
-  },
-  "packageManager": "pnpm@9.4.0+sha1.9217c800d4ab947a7aee520242a7b70d64fc7638"
+    "fast-glob": "^3.2.11"
+  }
 }

package/src/index.js

@@ -0,0 +1,163 @@
+import { mock, describe, test, it } from 'node:test'
+import { expect } from 'expect'
+import assert from 'node:assert/strict'
+import { format } from 'node:util'
+
+const MockFunctionContext = mock.fn().mock.constructor
+
+Object.defineProperties(MockFunctionContext.prototype, {
+  // this getter is called just .calls in jest, we document this difference
+  callsArguments: {
+    get() {
+      return this.calls.map((call) => call.arguments)
+    },
+  },
+  lastCall: {
+    get() {
+      return this.calls.at(-1)?.arguments
+    },
+  },
+  results: {
+    get() {
+      return this.calls.map((call) => ({ value: call.result }))
+    },
+  },
+})
+
+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 = format(name, 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)) {
+        name = format(name, ...args)
+      }
+    }
+
+    impl(name, () => (Array.isArray(args) ? fn(...args) : fn(args)))
+  }
+}
+
+describe.each = makeEach(describe)
+test.each = makeEach(test)
+it.each = makeEach(it)
+
+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')
+}
+
+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: () => {
+    assertHaveTimers()
+    warnOldTimers()
+    try {
+      mock.timers.enable()
+    } catch (e) {
+      // We allow calling this multiple times and swallow the "MockTimers is already enabled!" error
+      if (e.code !== 'ERR_INVALID_STATE') throw e
+    }
+  },
+  runAllTimers: () => {
+    assertHaveTimers()
+    warnOldTimers()
+    mock.timers.tick(100_000_000_000) // > 3 years
+  },
+  runOnlyPendingTimers: () => {
+    const noInfiniteLoopBug = major >= 22 || (major === 20 && minor >= 11)
+    assert(noInfiniteLoopBug, 'runOnlyPendingTimers requires Node.js >=20.11.0')
+    mock.timers.runAll()
+  },
+  advanceTimersByTime: (time) => {
+    assertHaveTimers()
+    warnOldTimers()
+    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,
+      pass: (name) => it(true, name),
+      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'

package/bin/babel.cjs

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

package/bin/jest.js

@@ -1,5 +0,0 @@
-import { loadJestConfig, installJestEnvironment } from '../src/jest.config.js'
-
-await loadJestConfig()
-const jestGlobals = await import('../src/jest.js')
-await installJestEnvironment(jestGlobals)