@exodus/test 1.0.0-rc.74 → 1.0.0-rc.76

package/bin/index.js

@@ -229,7 +229,6 @@ function parseOptions() {
 
 const isTTY = process.stdout.isTTY
 const isCI = process.env.CI
-const { options, patterns } = parseOptions()
 const warnHuman = isTTY && !isCI ? (...args) => console.warn(...args) : () => {}
 if (isCI) process.env.FORCE_COLOR = '1' // should support colored output even though not a TTY, overridable with --no-color
 
@@ -239,6 +238,11 @@ const setEnv = (name, value) => {
   process.env[name] = value === undefined ? '' : value
 }
 
+const { options, patterns } = parseOptions()
+if (!process.env.FORCE_COLOR && process.stdout.hasColors?.() && process.stderr.hasColors?.()) {
+  setEnv('FORCE_COLOR', '1') // Default to color output for subprocesses if our stream supports it
+}
+
 const engineName = `${options.engine} engine` // used for warnings to user
 const engineOptions = ENGINES.get(options.engine)
 assert(engineOptions, `Unknown engine: ${options.engine}`)
@@ -565,7 +569,7 @@ async function launch(binary, args, opts = {}, buffering = false) {
 if (options.pure) {
   setEnv('EXODUS_TEST_CONTEXT', 'pure')
   warnHuman(`${engineName} is experimental and may not work an expected`)
-  const missUnhandled = ['jsc', 'quickjs'].includes(options.platform) || options.browsers
+  const missUnhandled = ['jsc'].includes(options.platform) || options.browsers
   if (missUnhandled) warnHuman(`Warning: ${engineName} does not have unhandled rejections tracking`)
 
   const runOne = async (inputFile) => {

package/bundler/modules/globals.node.cjs

@@ -1,2 +1,8 @@
 // A slimmed-down version of globals.cjs specifically for Node.js bundle
 Object.assign(process, { argv: process.argv })
+
+if (!globalThis.crypto) {
+  // Old Node.js, we polyfill it as our bundler polyfills crypto module using webcrypto RNG
+  const r = require // prevent embed
+  globalThis.crypto = r('node:crypto').webcrypto
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.74",
+  "version": "1.0.0-rc.76",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -100,26 +100,28 @@
     "CHANGELOG.md"
   ],
   "scripts": {
-    "test:_pure": "EXODUS_TEST_IGNORE='tests/jest-extended/**' npm run test",
     "test:_bundle": "EXODUS_TEST_IGNORE='tests/{{jest-extended,inband}/**,jest-when/when.test.*,jest/jest.resetModules.*}' npm run test --",
     "test": "npm run test:jest --",
-    "test:all": "npm run test:jest && npm run test:tape && npm run test:native && npm run test:pure && npm run test:typescript && npm run test:fetch && npm run test:jsdom",
+    "test:all": "npm run test:jest && npm run test:tape && npm run test:native && npm run test:pure && npm run test:typescript && npm run test:fetch && npm run test:jsdom && npm run test:bundle",
     "test:native": "EXODUS_TEST_IGNORE='{**/typescript/**,**/jest-repo/**/user.test.js}' ./bin/index.js --jest 'tests/**/*.test.{js,cjs,mjs}'",
     "test:typescript": "./bin/index.js --jest --typescript tests/typescript.test.ts",
     "test:jest": "./bin/index.js --jest --esbuild",
-    "test:tape": "./bin/index.js --esbuild 'tests/tape/tests/*.js' tests/tape.test.js",
-    "test:pure": "EXODUS_TEST_ENGINE=node:pure npm run test:_pure",
-    "test:bun": "EXODUS_TEST_ENGINE=bun:pure npm run test:_pure",
+    "test:tape": "./bin/index.js 'tests/tape/tests/*.js' tests/tape.test.js",
+    "test:pure": "EXODUS_TEST_ENGINE=node:pure npm run test --",
+    "test:bundle": "EXODUS_TEST_ENGINE=node:bundle npm run test:_bundle --",
+    "test:bun:pure": "EXODUS_TEST_ENGINE=bun:pure npm run test --",
+    "test:bun:bundle": "EXODUS_TEST_ENGINE=bun:bundle npm run test:_bundle",
     "test:deno": "EXODUS_TEST_ENGINE=deno:bundle npm run test:_bundle --",
     "test:electron": "EXODUS_TEST_ENGINE=electron-as-node:test npm run test",
-    "test:electron:pure": "EXODUS_TEST_ENGINE=electron-as-node:pure npm run test:_pure",
+    "test:electron:pure": "EXODUS_TEST_ENGINE=electron-as-node:pure npm run test --",
     "test:electron:bundle": "EXODUS_TEST_ENGINE=electron-as-node:bundle npm run test:_bundle",
     "test:chrome:puppeteer": "EXODUS_TEST_ENGINE=chrome:puppeteer npm run test:_bundle --",
     "test:firefox:puppeteer": "EXODUS_TEST_ENGINE=firefox:puppeteer npm run test:_bundle --",
     "test:chromium:playwright": "EXODUS_TEST_ENGINE=chromium:playwright npm run test:_bundle --",
     "test:firefox:playwright": "EXODUS_TEST_ENGINE=firefox:playwright npm run test:_bundle --",
     "test:webkit:playwright": "EXODUS_TEST_ENGINE=webkit:playwright npm run test:_bundle --",
-    "test:bundle": "EXODUS_TEST_ENGINE=node:bundle npm run test:_bundle --",
+    "test:v8": "npm run test:d8 --",
+    "test:javascriptcore": "npm run test:jsc --",
     "test:d8": "EXODUS_TEST_ENGINE=d8:bundle npm run test:_bundle --",
     "test:jsc": "EXODUS_TEST_ENGINE=jsc:bundle npm run test:_bundle --",
     "test:hermes": "EXODUS_TEST_ENGINE=hermes:bundle npm run test:_bundle --",
@@ -129,6 +131,7 @@
     "test:fetch": "./bin/index.js --jest --drop-network --engine node:pure tests/fetch.test.js tests/websocket.test.js",
     "test:jsdom": "EXODUS_TEST_JEST_CONFIG='{\"testMatch\":[\"**/*.jsdom-test.js\"],\"testEnvironment\":\"jsdom\", \"rootDir\": \".\"}' ./bin/index.js --jest",
     "coverage": "./bin/index.js --jest --esbuild --coverage",
+    "playwright": "./bin/index.js --playwright",
     "jsvu": "jsvu",
     "jest": "NODE_OPTIONS=--experimental-vm-modules jest tests/jest/ tests/jest-when/",
     "lint": "prettier --list-different . && eslint .",
@@ -178,7 +181,7 @@
     "@jest/globals": "^29.7.0",
     "@types/jest-when": "^3.5.2",
     "@typescript-eslint/eslint-plugin": "^7.15.0",
-    "electron": "^35.1.4",
+    "electron": "^35.2.2",
     "eslint": "^8.44.0",
     "jest": "^29.7.0",
     "jest-matcher-utils": "^29.7.0",

package/src/engine.pure.cjs

@@ -308,19 +308,23 @@ class MockTimers {
   }
 
   #microtick() {
-    const next =
-      this.#queue.find((x) => x.runAt === -1) || // immediates are first
-      this.#queue.find((x) => x.runAt <= this.#elapsed)
+    const next = this.#queue.find((x) => x.runAt <= this.#elapsed) // sorted
     if (!next) return null
-    if (next.interval === undefined) {
-      this.#queue = this.#queue.filter((x) => x !== next)
-    } else {
+    this.#queue = this.#queue.filter((x) => x !== next)
+    if (next.interval !== undefined) {
       next.runAt += next.interval
+      this.#schedule(next)
     }
 
     next.callback(...next.args)
   }
 
+  #schedule(entry) {
+    const before = this.#queue.findIndex((x) => x.runAt > entry.runAt)
+    if (before === -1) return this.#queue.push(entry)
+    this.#queue.splice(before, 0, entry)
+  }
+
   runAll() {
     this.tick(Math.max(0, ...this.#queue.map((x) => x.runAt - this.#elapsed)))
   }
@@ -331,19 +335,19 @@ class MockTimers {
 
   #setTimeout(callback, delay, ...args) {
     const id = { callback, runAt: delay + this.#elapsed, args }
-    this.#queue.push(id)
+    this.#schedule(id)
     return id
   }
 
   #setInterval(callback, delay, ...args) {
     const id = { callback, runAt: delay + this.#elapsed, interval: delay, args }
-    this.#queue.push(id)
+    this.#schedule(id)
     return id
   }
 
   #setImmediate(callback, ...args) {
     const id = { callback, runAt: -1, args }
-    this.#queue.push(id)
+    this.#schedule(id)
     return id
   }
 
@@ -462,6 +466,7 @@ const isPromise = (x) => Boolean(x && x.then && x.catch && x.finally)
 const nodeVersion = '9999.99.99'
 const awaitForMicrotaskQueue = async () => {
   if (globalThis?.process?.nextTick) {
+    if (globalThis.Bun) await Promise.resolve() // No idea what's up with Bun microtasks
     // We are in microtasks, awaiting for "next" tick will get us out of here
     return new Promise((resolve) => globalThis.process.nextTick(resolve))
   }

package/src/exodus.js

@@ -15,8 +15,8 @@ export const exodus = {
     timers: Boolean(mock.timers && haveValidTimers),
     dynamicRequire: Boolean(!isBundle), // require(non-literal-non-glob), createRequire()(non-builtin)
     esmMocks: Boolean(mock.module || isBundle), // support for ESM mocks
+    esmNamedBuiltinMocks: Boolean(mock.module || isBundle || insideEsbuild), // support for named ESM imports from builtin module mocks: also fine in --esbuild
     esmInterop: Boolean(insideEsbuild && !isBundle), // loading/using ESM as CJS, ESM mocks creation without a mocker function
-    esmNamedBuiltinMocks: Boolean(mock.module || insideEsbuild || isBundle), // support for named ESM imports from builtin module mocks
     concurrency: node.engine !== 'pure', // pure engine doesn't support concurrency
   },
   mock: {

package/src/expect.cjs

@@ -11,9 +11,11 @@ function fixupAssertions() {
   assertionsDelta = 0
 }
 
-function loadExpect() {
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+function loadExpect(loadReason) {
   if (expect) return expect
   expect = require('expect').expect
+  // console.log('expect load reason:', loadReason)
   const matchers = require('jest-extended')
   expect.extend(matchers)
   for (const x of extend) expect.extend(...x)
@@ -26,7 +28,7 @@ const areNumeric = (...args) => args.every((a) => typeof a === 'number' || typeo
 
 const matchers = {
   __proto__: null,
-  toBe: (x, y) => x === y,
+  toBe: (x, y) => Object.is(x, y),
   toBeNull: (x) => x === null,
   toBeTruthy: (x) => x,
   toBeFalsy: (x) => !x,
@@ -53,42 +55,76 @@ const matchers = {
 
 const matchersFalseNegative = {
   __proto__: null,
-  toEqual: (x, y) => x === y,
-  toStrictEqual: (x, y) => x === y,
+  toEqual: (x, y) => Object.is(x, y),
+  toStrictEqual: (x, y) => Object.is(x, y),
   toContain: (x, c) => Array.isArray(x) && [...x].includes(c),
   toBeEven: (x) => Number.isSafeInteger(x) && x % 2 === 0,
   toBeOdd: (x) => Number.isSafeInteger(x) && x % 2 === 1,
 }
 
+const doesNotThrow = (x) => {
+  try {
+    x()
+    return [true]
+  } catch (err) {
+    return [false, err]
+  }
+}
+
 function createExpect() {
   return new Proxy(() => {}, {
     apply: (target, that, [x, ...rest]) => {
-      if (rest.length > 0) return loadExpect()(x, ...rest)
+      if (rest.length > 0) return loadExpect('rest')(x, ...rest)
       return new Proxy(Object.create(null), {
         get: (_, name) => {
           const matcher = matchers[name] || matchersFalseNegative[name]
-          if (matcher)
+          if (matcher) {
+            return (...args) => {
+              if (!matcher(x, ...args)) return loadExpect(`.${name} fail`)(x)[name](...args)
+              assertionsDelta++
+            }
+          }
+
+          if (name === 'toThrow') {
             return (...args) => {
-              if (!matcher(x, ...args)) return loadExpect()(x)[name](...args)
+              if (args.length > 0) return loadExpect('.toThrow args')(x)[name](...args)
+              const [passed] = doesNotThrow(x)
+              if (passed) return loadExpect('.toThrow fail')(() => {})[name](...args)
               assertionsDelta++
             }
+          }
 
           if (name === 'not')
             return new Proxy(Object.create(null), {
               get: (_, not) => {
-                if (matchers[not])
+                if (not === 'toThrow') {
                   return (...args) => {
-                    if (matchers[not](x, ...args)) return loadExpect()(x).not[not](...args)
+                    const [passed, err] = doesNotThrow(x)
+                    if (!passed) {
+                      return loadExpect('.not.toThrow fail')(() => {
+                        throw err
+                      }).not.toThrow(...args)
+                    }
+
+                    assertionsDelta++
+                  }
+                }
+
+                if (matchers[not]) {
+                  return (...args) => {
+                    if (matchers[not](x, ...args)) {
+                      return loadExpect(`.not.${not} fail`)(x).not[not](...args)
+                    }
+
                     assertionsDelta++
                   }
+                }
 
-                // console.log ({ loadReason: 'not', name: not })
-                return loadExpect()(x).not[not]
+                return loadExpect(`.not.${not}`)(x).not[not]
               },
             })
 
-          // console.log ({ loadReason: 'expect', name })
-          return loadExpect()(x)[name]
+          return loadExpect(`.${name}`)(x)[name]
         },
       })
     },
@@ -106,8 +142,7 @@ function createExpect() {
             }
       }
 
-      // console.log({ loadReason: 'get', name })
-      return loadExpect()[name]
+      return loadExpect(`get ${name}`)[name]
     },
     set: (_, name, value) => {
       if (expect) {

package/src/jest.js

@@ -46,14 +46,22 @@ function parseArgs(list, targs) {
   return result
 }
 
+// Hack for common testing with simple arrow functions
+const formatArg = (x) => {
+  if (x && x instanceof Function) {
+    if (`${x}` === '()=>{}') return '() => {}' // likely minified by esbuild
+    if (globalThis.Bun && `${x}`.replace(/\s/g, '') === '()=>{}') return '() => {}' // Bun breaks formatting
+  }
+
+  return x
+}
+
 const eachCallerLocation = []
 const makeEach =
   (impl) =>
   (list, ...rest) =>
   (template, fn, ...restArgs) => {
     eachCallerLocation.unshift(getCallerLocation())
-    // Hack for common testing with simple arrow functions, until we can disable esbuild minification
-    const formatArg = (x) => (x && x instanceof Function && `${x}` === '()=>{}' ? '() => {}' : x)
     // better than nothing
     const printed = (x) =>
       x && [null, Array.prototype, Object.prototype].includes(Object.getPrototypeOf(x))

package/src/jest.mock.js

@@ -190,7 +190,13 @@ function mockCloneItem(obj, cache) {
     for (let c = obj; c && c !== Object.prototype; c = Object.getPrototypeOf(c)) stack.unshift(c)
     let modified = stack.length > 1
     for (const level of stack) {
-      for (const [name, desc] of Object.entries(Object.getOwnPropertyDescriptors(level))) {
+      const descriptors = Object.getOwnPropertyDescriptors(level)
+      const entries = Object.entries(descriptors)
+      for (const sym of [Symbol.toStringTag]) {
+        if (sym && Object.hasOwn(descriptors, sym)) entries.push([sym, descriptors[sym]]) // Missed by Object.entries
+      }
+
+      for (const [name, desc] of entries) {
         if (name === 'constructor') continue
 
         for (const key of ['get', 'set', 'value']) {
@@ -255,7 +261,7 @@ function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
   const value = mocker ? expand(mocker()) : mockClone(mapActual.get(resolved))
   mapMocks.set(resolved, value)
 
-  loadExpect() // we need to do this as we don't want mocks affecting expect
+  loadExpect('jest.mock') // we need to do this as we don't want mocks affecting expect
 
   if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
     if (builtin) globalThis.EXODUS_TEST_MOCK_BUILTINS.set(builtin, value)
@@ -274,7 +280,7 @@ function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
 
   const topLevelESM = isTopLevelESM()
   let likelyESM = topLevelESM && !insideEsbuild && ![null, resolved].includes(resolveImport(name))
-  let okFromESM = false
+  let isOverridenBuiltinSynchedWithESM = false
   const isBuiltIn = builtinModules.includes(resolved)
   const isNodeCache = (x) => x && x.id && x.path && x.filename && x.children && x.paths && x.loaded
   if (isBuiltIn && !isNodeCache(require.cache[resolved])) {
@@ -288,7 +294,7 @@ function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
       overrideModule(resolved, true) // Override builtin modules
       if (syncBuiltinESMExports) {
         syncBuiltinESMExports()
-        okFromESM = true
+        isOverridenBuiltinSynchedWithESM = true
       }
     }
 
@@ -310,15 +316,17 @@ function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
     likelyESM = true
   }
 
-  if (likelyESM || (!okFromESM && topLevelESM)) {
+  const mocksNodeVersionNote = 'mocks are available only on Node.js >=20.18 <21 || >=22.3'
+  if (likelyESM || (!isOverridenBuiltinSynchedWithESM && topLevelESM)) {
     // 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(mock.module, 'ESM module mocks are available only on Node.js >=22.3')
+    assert(mock.module, `ESM module ${mocksNodeVersionNote}`)
   } else if (isBuiltIn && name.startsWith('node:') && !override) {
-    assert(mock.module, 'Native non-overriding node:* mocks are available only on Node.js >=22.3')
+    assert(mock.module, `Native non-overriding node:* ${mocksNodeVersionNote}`)
   }
 
+  if (value[Symbol.toStringTag] === 'Module') value.__esModule = true
   const obj = { defaultExport: value }
   if (isBuiltIn && isObject(value)) obj.namedExports = value
   if (insideEsbuild) {

package/src/jest.timers.js

@@ -12,8 +12,15 @@ const warnOldTimers = () => {
   console.warn('Warning: timer mocks are known to be glitchy before Node.js >=20.11.0')
 }
 
+let enabled = false
+const assertEnabledTimers = () => {
+  assertHaveTimers()
+  assert(enabled, 'You should enable MockTimers first by calling useFakeTimers()')
+}
+
 export function useRealTimers() {
   mock.timers?.reset()
+  enabled = false
   return this
 }
 
@@ -41,26 +48,39 @@ export function useFakeTimers({ doNotFake = doNotFakeDefault, ...rest } = {}) {
     globalThis[name] = (id) => id && fn(id)
   }
 
+  enabled = true
   return this
 }
 
 export function runAllTimers() {
-  assertHaveTimers()
-  warnOldTimers()
-  mock.timers.tick(100_000_000_000) // > 3 years
+  assertEnabledTimers()
+  advanceTimersByTime(100_000_000_000) // > 3 years
   return this
 }
 
 export function runOnlyPendingTimers() {
+  assertEnabledTimers()
   assert(haveNoTimerInfiniteLoopBug, 'runOnlyPendingTimers requires Node.js >=20.11.0')
   mock.timers.runAll()
   return this
 }
 
 export function advanceTimersByTime(time) {
-  assertHaveTimers()
-  warnOldTimers()
-  mock.timers.tick(time)
+  assert(Number.isSafeInteger(time) && time > 0)
+  assertEnabledTimers()
+  // We split this into multiple steps to run timers scheduled during the time we are running
+  const minSteps = Math.min(1000, time) // usually just split e.g. 5 seconds into 1000 * 5ms
+  const step = Number(Math.floor(time / minSteps).toPrecision(1))
+  const steps = Math.floor(time / step) // up to 2x higher than minSteps
+  const last = time - steps * step
+  // 1999 -> { step: 1, steps: 1999, last: 0 }
+  // 2001 -> { step: 2, steps: 1000, last: 1 }
+  for (let i = 0; i < steps; i++) {
+    if (!enabled) break // got disabled while looping
+    mock.timers.tick(step)
+  }
+
+  if (last > 0 && enabled) mock.timers.tick(last)
   return this
 }
 
@@ -79,14 +99,13 @@ export async function runOnlyPendingTimersAsync() {
 }
 
 export async function advanceTimersByTimeAsync(time) {
-  assertHaveTimers()
-  warnOldTimers()
-
+  assertEnabledTimers()
   if (mock.timers.tickAsync) {
     await mock.timers.tickAsync(time)
   } else {
     for (let i = 0; i < time; i++) {
       await awaitForMicrotaskQueue()
+      if (!enabled) break // got disabled while looping
       mock.timers.tick(1)
     }
   }
@@ -96,6 +115,7 @@ export async function advanceTimersByTimeAsync(time) {
 }
 
 export function setSystemTime(time) {
+  assertEnabledTimers()
   mock.timers.setTime(+time)
   return this
 }

package/src/version.js

@@ -1,7 +1,6 @@
 import { assert, nodeVersion } from './engine.js'
 
 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
 const ok = (major === 18 && minor >= 19) || (major === 20 && minor >= 8) || major >= 22
@@ -10,7 +9,8 @@ assert(major !== 22 || minor !== 3, 'Refusing to run on Node.js 22.3.0 specifica
 
 export { major, minor, patch }
 
-export const haveModuleMocks = (major === 22 && minor >= 3) || major > 22
+export const haveModuleMocks =
+  (major === 20 && minor >= 18) || (major === 22 && minor >= 3) || major > 22
 export const haveSnapshots = (major === 22 && minor >= 3) || major > 22
 export const haveSnapshotsReportUnescaped = (major === 22 && minor >= 5) || major > 22
 export const haveForceExit = (major === 20 && minor > 13) || major >= 22