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

package/bin/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 import { spawn } from 'node:child_process'
+import { once } from 'node:events'
 import { fileURLToPath } from 'node:url'
 import { basename, dirname, resolve } from 'node:path'
 import { createRequire } from 'node:module'
@@ -25,6 +26,7 @@ function parseOptions() {
     only: false,
     passWithNoTests: false,
     writeSnapshots: false,
+    pure: false,
     debug: { files: false },
   }
 
@@ -79,6 +81,9 @@ function parseOptions() {
       case '--forceExit':
         options.forceExit = true
         break
+      case '--pure':
+        options.pure = true
+        break
       case '--debug-files':
         options.debug.files = true
         break
@@ -108,26 +113,36 @@ const resolveImport = import.meta.resolve && ((query) => fileURLToPath(import.me
 const c8 = resolveRequire('c8/bin/c8.js')
 if (resolveImport) assert.equal(c8, resolveImport('c8/bin/c8.js'))
 
-const args = ['--test', '--no-warnings=ExperimentalWarning', '--test-reporter=spec']
+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 {
+  args.push('--test', '--no-warnings=ExperimentalWarning', '--test-reporter=spec')
+
+  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 (haveModuleMocks) args.push('--experimental-test-module-mocks')
-if (haveSnapshots) args.push('--experimental-test-snapshots')
+  if (options.forceExit) {
+    assert(haveForceExit, 'For forceExit, use Node.js >= 20.14.0')
+    args.push('--test-force-exit')
+  }
 
-if (options.writeSnapshots) {
-  assert(haveSnapshots, 'For snapshots, use Node.js >=22.3.0')
-  args.push('--test-update-snapshots')
-}
+  if (options.watch) args.push('--watch')
+  if (options.only) args.push('--test-only')
 
-if (options.forceExit) {
-  assert(haveForceExit, 'For forceExit, use Node.js >= 20.14.0')
-  args.push('--test-force-exit')
+  args.push('--expose-internals') // this is unoptimal and hopefully temporary, see rationale in src/dark.cjs
 }
 
-if (options.watch) args.push('--watch')
-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')
@@ -176,6 +191,7 @@ if (options.jest) {
     patterns.push(...(Array.isArray(config.testMatch) ? config.testMatch : [config.testMatch]))
   }
 
+  if (config.passWithNoTests) options.passWithNoTests = true
   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) {
@@ -260,14 +276,36 @@ if (tsTests.length > 0 && !options.esbuild) {
   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(files.length > 0) // otherwise we can run recursively
 assert(program && ['node', c8].includes(program))
-const node = spawn(program, args, { stdio: 'inherit' })
 
-node.on('close', (code) => {
+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'
+  )
+  const failures = []
+  for (const file of files) {
+    const node = spawn(program, [...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) {
+    console.log('Failed test suites:')
+    for (const file of failures) console.log(`  ${file}`) // joining with \n can get truncated, too big
+  }
+} else {
+  process.env.EXODUS_TEST_CONTEXT = 'node --test'
+  const node = spawn(program, [...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.24",
+  "version": "1.0.0-rc.25",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -37,6 +37,9 @@
     "bin/babel.cjs",
     "bin/jest.js",
     "src/dark.cjs",
+    "src/engine.js",
+    "src/engine.node.cjs",
+    "src/engine.select.cjs",
     "src/jest.js",
     "src/jest.config.js",
     "src/jest.environment.js",

package/src/dark.cjs

@@ -1,7 +1,3 @@
-const { fileURLToPath } = require('node:url')
-
-const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str) : str)
-
 let locForNextTest
 
 const installLocationInNextTest = function (loc) {
@@ -26,6 +22,8 @@ function createCallerLocationHook() {
 
   try {
     const { Test } = require('node:internal/test_runner/test')
+    const { fileURLToPath } = require('node:url')
+    const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str) : str)
     const locStorage = new Map()
     Object.defineProperty(Test.prototype, 'loc', {
       get() {

package/src/engine.js

@@ -0,0 +1,19 @@
+import engine from './engine.select.cjs' // need to be sync for non-preloaded imports into cjs
+
+const { assert, assertLoose } = engine
+export { assert, assertLoose }
+
+const { mock, describe, test, beforeEach, afterEach, before, after } = engine
+export { mock, describe, test, beforeEach, afterEach, before, after }
+
+const { builtinModules, syncBuiltinESMExports } = engine
+export { builtinModules, syncBuiltinESMExports }
+
+const { utilFormat, isPromise, nodeVersion } = engine
+export { utilFormat, isPromise, nodeVersion }
+
+const { baseFile, relativeRequire, isTopLevelESM } = engine
+export { baseFile, relativeRequire, isTopLevelESM }
+
+const { snapshot, readSnapshot, setSnapshotSerializers, setSnapshotResolver } = engine
+export { snapshot, readSnapshot, setSnapshotSerializers, setSnapshotResolver }

package/src/engine.node.cjs

@@ -0,0 +1,38 @@
+const assert = require('node:assert/strict')
+const assertLoose = require('node:assert')
+const { types, format: utilFormat } = require('node:util')
+const { existsSync, readFileSync } = require('node:fs')
+const { normalize, basename, dirname, join: pathJoin } = require('node:path')
+const { createRequire, builtinModules, syncBuiltinESMExports } = require('node:module')
+const nodeTest = require('node:test')
+
+const { mock, describe, test, beforeEach, afterEach, before, after } = nodeTest
+
+const isPromise = types.isPromise
+const nodeVersion = process.versions.node
+
+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 || !Object.hasOwn(relativeRequire.cache, baseFile) // assume ESM otherwise
+
+const snapshot = nodeTest.snapshot
+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 = (list) => snapshot?.setDefaultSnapshotSerializers(list)
+const setSnapshotResolver = (fn) => {
+  snapshotResolver = fn
+  snapshot?.setResolveSnapshotPath(resolveSnapshot)
+}
+
+/* eslint-disable unicorn/no-useless-spread */
+module.exports = {
+  ...{ assert, assertLoose },
+  ...{ mock, describe, test, beforeEach, afterEach, before, after },
+  ...{ builtinModules, syncBuiltinESMExports },
+  ...{ utilFormat, isPromise, nodeVersion },
+  ...{ baseFile, relativeRequire, isTopLevelESM },
+  ...{ snapshot, readSnapshot, setSnapshotSerializers, setSnapshotResolver },
+}
+/* eslint-enable unicorn/no-useless-spread */

package/src/engine.select.cjs

@@ -0,0 +1 @@
+module.exports = require('./engine.node.cjs')

package/src/jest.config.js

@@ -1,3 +1,4 @@
+// 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'
@@ -54,6 +55,7 @@ const normalizeJestConfig = (config) => ({
   testEnvironment: 'node',
   testTimeout: 5000,
   testPathIgnorePatterns: [],
+  passWithNoTests: false,
   snapshotSerializers: [],
   injectGlobals: true,
   maxConcurrency: 5,
@@ -76,7 +78,8 @@ const normalizeJestConfig = (config) => ({
 function verifyJestConfig(c) {
   assert(!configUsed, 'Can not apply new config as the current one was already used')
 
-  if (!Object.hasOwn(specialEnvironments, c.testEnvironment)) {
+  const nodeEnvs = new Set(['ts-jest', 'ts-jest/presets/js-with-ts'])
+  if (!Object.hasOwn(specialEnvironments, c.testEnvironment) && !nodeEnvs.has(c.testEnvironment)) {
     assert.equal(c.testEnvironment, 'node', 'Only "node" testEnvironment is supported')
   }
 

package/src/jest.fn.js

@@ -1,5 +1,4 @@
-import { mock } from 'node:test'
-import assert from 'node:assert/strict'
+import { mock, assert } from './engine.js'
 
 const registry = new Set()
 let callId = 0

package/src/jest.js

@@ -1,6 +1,12 @@
-import assert from 'node:assert/strict'
-import { describe as nodeDescribe, test as nodeTest, afterEach, after } from 'node:test'
-import { format, types } from 'node:util'
+import {
+  describe as nodeDescribe,
+  test as nodeTest,
+  afterEach,
+  after,
+  assert,
+  utilFormat,
+  isPromise,
+} from './engine.js'
 import { jestConfig } from './jest.config.js'
 import { jestFunctionMocks } from './jest.fn.js'
 import { jestModuleMocks } from './jest.mock.js'
@@ -75,7 +81,7 @@ const makeEach =
 
       if (Array.isArray(args)) {
         const length = [...name.replaceAll('%%', '').matchAll(/%[psdifjo]/gu)].length
-        if (length > 0) name = format(name, ...args.slice(0, length).map(formatArg))
+        if (length > 0) name = utilFormat(name, ...args.slice(0, length).map(formatArg))
       }
 
       impl(name, () => (Array.isArray(args) ? fn(...args) : fn(args)))
@@ -122,7 +128,7 @@ const testRaw = (callerLocation, testBase, name, fn, testTimeout) => {
   return testBase(name, { timeout }, async (t) => {
     const res = fn()
     assert(
-      types.isPromise(res),
+      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.`
@@ -184,4 +190,4 @@ const jest = {
 
 export { jest, describe, test, test as it }
 export { expect } from 'expect'
-export { beforeEach, afterEach, before as beforeAll, after as afterAll } from 'node:test'
+export { beforeEach, afterEach, before as beforeAll, after as afterAll } from './engine.js'

package/src/jest.mock.js

@@ -1,19 +1,18 @@
-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 {
+  mock,
+  assert,
+  baseFile,
+  relativeRequire as require,
+  isTopLevelESM,
+  builtinModules,
+  syncBuiltinESMExports,
+} from './engine.js'
 import { jestfn } from './jest.fn.js'
 import { makeEsbuildMockable } from './dark.cjs'
 
-const files = process.argv.slice(1)
-const baseUrl = files.length === 1 && existsSync(files[0]) ? normalize(files[0]) : undefined
 const mapMocks = new Map()
 const mapActual = new Map()
 
-const require = createRequire(baseUrl || import.meta.url)
-const isTopLevelESM = () => !baseUrl || !Object.hasOwn(require.cache, baseUrl) // assume ESM otherwise
-
 export const jestModuleMocks = {
   mock: jestmock,
   createMockFromModule: (name) => mockClone(requireActual(name)),
@@ -22,10 +21,8 @@ export const jestModuleMocks = {
   resetModules,
 }
 
-export const relativeRequire = require
-
 export function resolveModule(name) {
-  assert(baseUrl || /^[@a-zA-Z]/u.test(name), 'Mocking relative paths is not possible')
+  assert(baseFile || /^[@a-zA-Z]/u.test(name), 'Mocking relative paths is not possible')
   const unprefixed = name.replace(/^node:/, '')
   if (builtinModules.includes(unprefixed)) return unprefixed
   return require.resolve(name)

package/src/jest.snapshot.js

@@ -1,25 +1,24 @@
-import { beforeEach } from 'node:test'
-import { createRequire } from 'node:module'
+import {
+  beforeEach,
+  assert,
+  setSnapshotResolver,
+  setSnapshotSerializers,
+  readSnapshot,
+  relativeRequire,
+} from './engine.js'
 import { expect } from 'expect'
 import { format, plugins as builtinPlugins } from 'pretty-format'
-import assert from 'node:assert/strict'
-import { basename, dirname, join, normalize } from 'node:path'
-import { readFileSync } from 'node:fs'
 import { jestConfig } from './jest.config.js'
-import { relativeRequire } from './jest.mock.js'
 import { getTestNamePath } from './dark.cjs'
 
 const { snapshotFormat, snapshotSerializers } = jestConfig()
 const plugins = Object.values(builtinPlugins)
 const serialize = (val) => format(val, { ...snapshotFormat, plugins }).replaceAll(/\r\n|\r/gu, '\n')
-const resolveSnapshot = (f) => join(dirname(f), '__snapshots__', `${basename(f)}.snap`)
 
 let serializersAreSetup = false
-let snapshotsAreJest
+let snapshotsAreJest = false
 
 // For manually loading the snapshot
-const files = process.argv.slice(1)
-const snapshotLocation = files.length === 1 ? resolveSnapshot(normalize(files[0])) : undefined
 const nameCounts = new Map()
 let snapshotText
 
@@ -32,20 +31,11 @@ function maybeSetupSerializers() {
 
 // We want to setup snapshots to behave like jest only when first used from jest API
 function maybeSetupJestSnapshots() {
-  if (snapshotsAreJest !== undefined) return snapshotsAreJest
-  try {
-    maybeSetupSerializers()
-    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(resolveSnapshot)
-    snapshotsAreJest = true
-  } catch {
-    snapshotsAreJest = false
-  }
-
-  return snapshotsAreJest
+  if (snapshotsAreJest) return
+  setSnapshotResolver((dir, name) => [dir, '__snapshots__', `${name}.snap`])
+  setSnapshotSerializers([serialize])
+  maybeSetupSerializers()
+  snapshotsAreJest = true
 }
 
 const wrap = (check) => {
@@ -118,11 +108,14 @@ const snapOnDisk = (orig, matcher) => {
   const obj = matcher ? { ...orig, ...matcher } : orig
   const escape = (str) => str.replaceAll(/([\\`])/gu, '\\$1')
 
-  if (!maybeSetupJestSnapshots()) {
+  maybeSetupJestSnapshots()
+
+  if (!context?.assert?.snapshot) {
     // We don't have native snapshots, polyfill reading
-    if (snapshotLocation && snapshotText !== null) {
+    if (snapshotText !== null) {
       try {
-        snapshotText = `\n${readFileSync(snapshotLocation, 'utf8')}\n` // we'll search wrapped in \n
+        const snapshotRaw = readSnapshot()
+        snapshotText = snapshotRaw ? `\n${snapshotRaw}\n` : null // we'll search wrapped in \n
       } catch {
         snapshotText = null
       }

package/src/jest.timers.js

@@ -1,5 +1,4 @@
-import assert from 'node:assert/strict'
-import { mock } from 'node:test'
+import { mock, assert } from './engine.js'
 import { jestConfig } from './jest.config.js'
 import { haveValidTimers, haveNoTimerInfiniteLoopBug } from './version.js'
 

package/src/tape.js

@@ -1,6 +1,4 @@
-import assert from 'node:assert/strict'
-import assertLoose from 'node:assert'
-import { test } from 'node:test'
+import { assert, assertLoose, test } from './engine.js'
 import { createCallerLocationHook } from './dark.cjs'
 import './version.js'
 

package/src/version.js

@@ -1,6 +1,6 @@
-import assert from 'node:assert/strict'
+import { assert, nodeVersion } from './engine.js'
 
-const [major, minor, patch] = process.versions.node.split('.').map(Number)
+const [major, minor, patch] = nodeVersion.split('.').map(Number)
 assert(major !== 21, 'Node.js 21.x is deprecated!') // reached EOL, no reason to even test
 // older versions are glitchy with before/after on top-level, which is a deal-breaker
 // 20.7.0 is fine for node:test but broken with tsx, so we bump to 20.8.0