@exodus/test 1.0.0-rc.20 → 1.0.0-rc.21

package/bin/index.js

@@ -141,16 +141,6 @@ 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) {
@@ -159,7 +149,8 @@ if (process.env.EXODUS_TEST_IGNORE) {
   ignore.push(process.env.EXODUS_TEST_IGNORE)
 }
 
-// Our loader should be last, as enabling module mocks confuses other loaders
+// The comment below is disabled, we don't auto-mock @jest/globals anymore, and having our loader first is faster
+// [Disabled] 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())
@@ -196,6 +187,16 @@ if (options.jest) {
   }
 }
 
+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'))
+}
+
 if (patterns.length === 0) patterns.push(...DEFAULT_PATTERNS) // defaults
 const globbed = await glob(patterns, { ignore })
 const allfiles = filter ? globbed.filter(filter) : globbed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.20",
+  "version": "1.0.0-rc.21",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",

package/src/dark.cjs

@@ -4,7 +4,7 @@ const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str)
 
 let locForNextTest
 
-let installLocationInNextTest = function (loc) {
+const installLocationInNextTest = function (loc) {
   locForNextTest = loc
 }
 
@@ -107,4 +107,31 @@ function getTestNamePath(t) {
   return [t.name] // last resort
 }
 
-module.exports = { createCallerLocationHook, getTestNamePath }
+function makeEsbuildMockable() {
+  const usingTsx = process.execArgv.some((x) => x.endsWith('node_modules/tsx/dist/loader.mjs'))
+  if (!usingTsx) return
+  // Hook into tsx/esbuild transpiled module conversion magic to make loaded modules mockable in runtime
+  // We want all modules to be .configurable = true, so we can override them
+  const defineProperty = Object.defineProperty
+  const obj = Object.create(null)
+  Object.defineProperty = (target, name, options) => {
+    if (options.get) {
+      const stackTraceLimit = Error.stackTraceLimit
+      Error.stackTraceLimit = 2
+      Error.captureStackTrace(obj, Object.defineProperty)
+      Error.stackTraceLimit = stackTraceLimit
+      // This is for speed, we don't want to work with text
+      const prepareStackTrace = Error.prepareStackTrace
+      // eslint-disable-next-line handle-callback-err
+      Error.prepareStackTrace = (err, callsites) => callsites.map((site) => site.getFunctionName())
+      const stack = obj.stack
+      Error.prepareStackTrace = prepareStackTrace
+      // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+      if (stack[0] === '__copyProps' && stack[1] === '__toCommonJS') options.configurable = true
+    }
+
+    return defineProperty(target, name, options)
+  }
+}
+
+module.exports = { createCallerLocationHook, getTestNamePath, makeEsbuildMockable }

package/src/jest.mock.js

@@ -4,6 +4,7 @@ import { existsSync } from 'node:fs'
 import { normalize } from 'node:path'
 import { mock } from 'node:test'
 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
@@ -11,6 +12,7 @@ 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 relativeRequire = require
 
@@ -62,7 +64,9 @@ function override(resolved, lax = false) {
   Object.defineProperties(current, definitions)
   const proto = Object.getPrototypeOf(value)
   if (Object.getPrototypeOf(current) !== proto) Object.setPrototypeOf(current, proto)
-  if (!lax) assert.deepEqual({ ...current }, value)
+  const checked = { ...current }
+  if (current.__esModule === true) checked.__esModule = current.__esModule
+  if (!lax) assert.deepEqual(checked, value)
 }
 
 function mockClone(obj, cache = new Map()) {
@@ -86,6 +90,12 @@ function mockCloneItem(obj, cache) {
   }
 
   if (typeof obj === 'object') {
+    // Special path, as .default might be a getter and we want to unwrap it
+    if (obj.__esModule === true) {
+      const { __esModule, default: def, ...rest } = obj
+      return { __esModule, ...mockClone({ default: def, ...rest }, cache) }
+    }
+
     const prototype = Object.getPrototypeOf(obj)
     const clone = Object.create(prototype === null ? null : Object.prototype)
     cache.set(obj, clone)
@@ -142,23 +152,37 @@ export function jestmock(name, mocker) {
   const value = mocker ? { ...mocker() } : mockClone(mapActual.get(resolved))
   mapMocks.set(resolved, value)
 
+  let likelyESM = false
+  const isBuiltIn = builtinModules.includes(resolved)
   if (Object.hasOwn(require.cache, resolved)) {
     assert.equal(mapActual.get(resolved), require.cache[resolved].exports)
     // If we did't have this prior but have now, it means we just loaded it and there are no leaked instances
     if (havePrior) override(resolved)
     require.cache[resolved].exports = value
-  } else if (builtinModules.includes(resolved)) {
+  } else if (isBuiltIn) {
     override(resolved, true) // Override builtin modules
     syncBuiltinESMExports()
   } else {
     // The module doesn't exist or is ESM
-    assert(mock.module, 'ESM module mocks are available only on Node.js >=22.3')
+    likelyESM = true
   }
 
-  mock.module?.(resolved, {
-    defaultExport: value.default ?? value,
-    namedExports: isObject(value) ? value : {},
-  })
+  if (!mock.module && !isBuiltIn) {
+    // Native module mocks is required if loading ESM or __from__ ESM
+    // No good way to check the locations that import the module, but we can check top-level file
+    // Built-in modules are fine though
+    assert(!likelyESM && !isTopLevelESM(), 'ESM module mocks are available only on Node.js >=22.3')
+  }
+
+  if (likelyESM && isObject(value) && value.__esModule === true) {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { default: defaultExport, __esModule, ...namedExports } = value
+    mock.module?.(resolved, { defaultExport, namedExports })
+  } else {
+    mock.module?.(resolved, { defaultExport: value })
+  }
 
   return this
 }
+
+makeEsbuildMockable()