@exodus/test 1.0.0-rc.97 → 1.0.0-rc.98

package/bin/index.js

@@ -327,6 +327,9 @@ if (process.env.EXODUS_TEST_IGNORE) {
   ignore.push(process.env.EXODUS_TEST_IGNORE)
 }
 
+// This might be used in presets, so has to be loaded before jest
+if (options.flow && !options.bundle) args.push('--import', import.meta.resolve('../loader/flow.js'))
+
 // 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
 let jestConfig = null

package/loader/flow.js

@@ -0,0 +1,17 @@
+import { registerHooks } from 'node:module' // 22.15+
+import { readFileSync } from 'node:fs'
+import flowRemoveTypes from '@exodus/test-bundler/flow-remove-types'
+
+function load(url, context, nextLoad) {
+  if (url.startsWith('file://')) {
+    const source = readFileSync(new URL(url), 'utf8')
+    if (source.includes('@flow')) {
+      const stripped = flowRemoveTypes(source, { pretty: true }).toString()
+      return { format: context.format || 'commonjs', source: stripped, shortCircuit: true }
+    }
+  }
+
+  return nextLoad(url, context)
+}
+
+registerHooks({ load })

package/loader/jest.js

@@ -1,4 +1,2 @@
-const { loadJestConfig, installJestEnvironment } = await import('../src/jest.config.js')
-await loadJestConfig()
-const { should, ...jestGlobals } = await import('../src/jest.js') // eslint-disable-line @typescript-eslint/no-unused-vars
-await installJestEnvironment(jestGlobals)
+const { setupJest } = await import('../src/jest.setup.js')
+await setupJest()

package/loader/typescript.loader.js

@@ -1,4 +1,5 @@
 import { readFile } from 'node:fs/promises'
+import { stripTypeScriptTypes } from 'node:module' // 22.13.0+
 import { fileURLToPath } from 'node:url'
 
 const extensionsRegex = /\.[cm]?ts$/
@@ -12,18 +13,11 @@ function shouldProcessUrl(s) {
   }
 }
 
-let transformSync
-
 export async function load(url, context, nextLoad) {
   if (shouldProcessUrl(url)) {
-    if (!transformSync) {
-      const amaro = await import('amaro')
-      transformSync = amaro.transformSync
-    }
-
     const sourceBuf = await readFile(new URL(url))
     const source = sourceBuf.toString('utf8')
-    const { code: transformed } = transformSync(source, { isModule: true })
+    const transformed = stripTypeScriptTypes(source, { mode: 'strip' })
     const transformedBuf = Buffer.from(transformed)
     if (sourceBuf.length !== transformedBuf.length) throw new Error('length mismatch')
     // eslint-disable-next-line unicorn/no-for-loop

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.97",
+  "version": "1.0.0-rc.98",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -48,6 +48,7 @@
     "loader/babel.cjs",
     "loader/esbuild.js",
     "loader/esbuild.optional.js",
+    "loader/flow.js",
     "loader/jest.js",
     "loader/typescript.js",
     "loader/typescript.loader.js",
@@ -66,6 +67,7 @@
     "src/jest.environment.js",
     "src/jest.fn.js",
     "src/jest.mock.js",
+    "src/jest.setup.js",
     "src/jest.snapshot.js",
     "src/jest.timers.js",
     "src/node.js",
@@ -84,7 +86,7 @@
   "scripts": {
     "test:_bundle": "EXODUS_TEST_IGNORE='tests/{{jest-extended,inband}/**,jest-when/when.test.*,jest/jest.resetModules.*,jest/mock/jest.mock.mocks-dir.test.js}' npm run test --",
     "test": "npm run test:jest --",
-    "test:all": "npm run test:simple && npm run test:jest && npm run test:tape && npm run test:native && npm run test:esbuild && npm run test:pure && npm run test:typescript && npm run test:fetch && npm run test:jsdom && npm run test:bundle",
+    "test:all": "npm run test:simple && npm run test:jest && npm run test:tape && npm run test:native && npm run test:esbuild && npm run test:pure && 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": "node ./bin/index.js --jest --typescript tests/typescript.test.ts",
     "test:jest": "node ./bin/index.js --jest --esbuild=ts,user.test.js,sum.test.js",
@@ -128,8 +130,7 @@
   "optionalDependencies": {
     "@chalker/queue": "^1.0.1",
     "@exodus/replay": "^1.0.0-rc.9",
-    "@exodus/test-bundler": "1.0.0-rc.3",
-    "amaro": "^0.0.5",
+    "@exodus/test-bundler": "1.0.0-rc.4",
     "c8": "^9.1.0",
     "expect": "^29.7.0",
     "fast-glob": "^3.2.11",

package/src/jest.config.js

@@ -81,6 +81,8 @@ export async function loadJestConfig(...args) {
     if (config.globalTeardown) config.globalTeardown = req.resolve(config.globalTeardown) // eslint-disable-line @exodus/mutable/no-param-reassign-prop-only
   }
 
+  const presetExtension = /\.([cm]?js|json)$/u
+  const suffixes = ['/jest-preset.json', '/jest-preset.js', '/jest-preset.cjs', '/jest-preset.mjs']
   if (needPreset(rawConfig) || rawConfig.globalSetup || rawConfig.globalTeardown) {
     rawConfig.preset = cleanFile(rawConfig.preset) // relative to root dir only at top level, presets shouldn't use <rootDir>
     if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
@@ -93,15 +95,11 @@ export async function loadJestConfig(...args) {
       let requireConfig = createRequire(resolve(rawConfig.rootDir, 'package.json'))
       resolveGlobalSetup(rawConfig, requireConfig)
       while (needPreset(rawConfig)) {
-        const suffixes = rawConfig.preset.startsWith('.')
-          ? ['']
-          : ['/jest-preset.json', '/jest-preset.js', '/jest-preset.cjs', '/jest-preset.mjs']
-
         let baseConfig
-        for (const suffix of suffixes) {
-          if (baseConfig) break
+
+        const attemptLoad = async (file) => {
           try {
-            const resolved = requireConfig.resolve(`${rawConfig.preset}${suffix}`)
+            const resolved = requireConfig.resolve(file)
             // FIXME: fix linter to allow this
             // const meta = resolved.toLowerCase().endsWith('.json') ? { with: { type: 'json' } } : undefined
             // const presetModule = await import(pathToFileURL(resolved), meta)
@@ -111,6 +109,17 @@ export async function loadJestConfig(...args) {
           } catch {}
         }
 
+        // Even if it is relative, it could be a path to module
+        for (const suffix of suffixes) {
+          if (!baseConfig) await attemptLoad(`${rawConfig.preset}${suffix}`)
+        }
+
+        // If it's a path to a file
+        if (!baseConfig && rawConfig.preset[0] === '.' && presetExtension.test(rawConfig.preset)) {
+          const { statSync } = await import('node:fs')
+          if (statSync(rawConfig.preset).isFile()) await attemptLoad(rawConfig.preset)
+        }
+
         assert(baseConfig, `Could not load preset: ${rawConfig.preset} `)
         resolveGlobalSetup(baseConfig, requireConfig)
         rawConfig = {

package/src/jest.mock.js

@@ -11,44 +11,55 @@ import {
 import { jestfn } from './jest.fn.js'
 import { loadExpect } from './expect.cjs'
 import { loadPrettyFormat } from './pretty-format.cjs'
-import { makeEsbuildMockable, insideEsbuild } from './dark.cjs'
+import { makeEsbuildMockable, insideEsbuild, createCallerLocationHook } from './dark.cjs'
 
 const mapMocks = new Map()
 const mapActual = new Map()
 const nodeMocks = new Map()
 const overridenBuiltins = new Set()
 
-function wrap(impl) {
-  return function (...args) {
-    impl(...args)
-    return this
-  }
-}
-
+// TODO: support correct relative locations in other engines too (and bundles)
+const { getCallerLocation: getLoc } = createCallerLocationHook()
 export const jestModuleMocks = {
-  mock: wrap((name, mock) => jestmock(name, mock, { override: true })),
-  doMock: wrap((name, mock) => jestmock(name, mock)),
-  setMock: wrap((name, mock) => jestmock(name, () => mock)), // like doMock, does not hoist to top, tested
-  unmock: wrap(unmock),
-  dontMock: wrap(unmock),
-  createMockFromModule: (name) => mockClone(requireActual(name)),
-  requireMock,
-  requireActual,
+  mock(name, mock) {
+    jestmock(name, mock, { override: true, loc: getLoc() })
+    return this
+  },
+  doMock(name, mock) {
+    jestmock(name, mock, { loc: getLoc() })
+    return this
+  },
+  setMock(name, mock) {
+    jestmock(name, () => mock, { loc: getLoc() }) // like doMock, does not hoist to top, tested
+    return this
+  },
+  unmock(name) {
+    unmock(name, { loc: getLoc() })
+    return this
+  },
+  createMockFromModule: (name) => mockClone(requireActual(name, { loc: getLoc() })),
+  requireMock: (name) => requireMock(name, { loc: getLoc() }),
+  requireActual: (name) => requireActual(name, { loc: getLoc() }),
   resetModules,
 }
 
+jestModuleMocks.dontMock = jestModuleMocks.unmock
+
 if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
   globalThis.EXODUS_TEST_MOCK_BUILTINS = new Map()
   Object.assign(jestModuleMocks, {
-    __mockBundle: wrap((name, builtin, actual, mock) =>
+    __mockBundle(name, builtin, actual, mock) {
       jestmock(name, mock, { actual, builtin, override: true })
-    ),
-    __doMockBundle: wrap((name, builtin, actual, mock) =>
+      return this
+    },
+    __doMockBundle(name, builtin, actual, mock) {
       jestmock(name, mock, { actual, builtin })
-    ),
-    __setMockBundle: wrap((name, builtin, actual, mock) =>
+      return this
+    },
+    __setMockBundle(name, builtin, actual, mock) {
       jestmock(name, () => mock, { actual, builtin })
-    ),
+      return this
+    },
   })
 }
 
@@ -56,7 +67,7 @@ if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
 const cjsSet = typeof __mocksCJSPossible === 'undefined' ? null : __mocksCJSPossible // eslint-disable-line no-undef
 const esmSet = typeof __mocksESMPossible === 'undefined' ? null : __mocksESMPossible // eslint-disable-line no-undef
 
-function resolveModule(name) {
+function resolveModule(name, loc) {
   if (process.env.EXODUS_TEST_ENVIRONMENT === 'bundle') {
     assert(name.startsWith('bundle:'), `Can't mock unresolved ${name} in bundle, use static syntax`)
     assert(cjsSet && esmSet, 'Module mocking not installed correctly in bundle')
@@ -72,30 +83,33 @@ function resolveModule(name) {
     return id
   }
 
-  assert(requireIsRelative || /^[@a-zA-Z]/u.test(name), 'Mocking relative paths is not possible')
   const unprefixed = name.replace(/^node:/, '')
   if (builtinModules.includes(unprefixed)) return unprefixed
+  if (loc?.[2]) return require('node:module').createRequire(loc?.[2]).resolve(name)
+  assert(requireIsRelative || /^[@a-zA-Z]/u.test(name), 'Mocking relative paths is not possible')
   return require.resolve(name)
 }
 
-function resolveImport(name) {
+function resolveImport(name, loc) {
   try {
-    const { fileURLToPath } = require('node:url')
-    return fileURLToPath(import.meta.resolve(name))
+    const { fileURLToPath, pathToFileURL } = require('node:url')
+    let parent
+    if (loc?.[2]) parent = loc[2].startsWith('file:') ? loc[2] : pathToFileURL(loc[2])
+    return fileURLToPath(import.meta.resolve(name, parent))
   } catch {
     return null
   }
 }
 
-function requireActual(name) {
-  const resolved = resolveModule(name)
+function requireActual(name, { loc } = {}) {
+  const resolved = resolveModule(name, loc)
   if (mapActual.has(resolved)) return mapActual.get(resolved)
   if (!mapMocks.has(resolved)) return require(resolved)
   throw new Error('Module can not been loaded')
 }
 
-function requireMock(name) {
-  const resolved = resolveModule(name)
+function requireMock(name, { loc } = {}) {
+  const resolved = resolveModule(name, loc)
   assert(mapMocks.has(resolved), 'Module is not mocked')
   return mapMocks.get(resolved)
 }
@@ -112,8 +126,8 @@ function resetModules() {
   }
 }
 
-function unmock(name) {
-  const resolved = resolveModule(name)
+function unmock(name, { loc } = {}) {
+  const resolved = resolveModule(name, loc)
   assert(mapMocks.has(resolved), 'Module is not mocked')
   if (mockModule) nodeMocks.get(resolved).restore()
   delete require.cache[resolved]
@@ -281,7 +295,7 @@ if (process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle') {
   }
 }
 
-function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
+function jestmock(name, mocker, { override = false, actual, builtin, loc } = {}) {
   // Loaded ESM: isn't mocked
   // Loaded CJS: mocked via object overriding
   // Loaded built-ins: mocked via object overriding where possible
@@ -294,7 +308,7 @@ function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
 
   const mockFromMocks = mocker ? undefined : loadMocksDirMock?.(name)
 
-  const resolved = resolveModule(name)
+  const resolved = resolveModule(name, loc)
   const isBuiltIn = builtinModules.includes(resolved)
   if (!mocker && mockFromMocks && mapMocks.get(resolved) === mockFromMocks) return
   assert(!mapMocks.has(resolved), 'Re-mocking the same module is not supported')
@@ -346,8 +360,8 @@ function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
     return this
   }
 
-  const topLevelESM = isTopLevelESM()
-  let likelyESM = topLevelESM && !insideEsbuild() && ![null, resolved].includes(resolveImport(name))
+  const topESM = isTopLevelESM()
+  let likelyESM = topESM && !insideEsbuild() && ![null, resolved].includes(resolveImport(name, loc))
   let isOverridenBuiltinSynchedWithESM = false
   const isNodeCache = (x) => x && x.id && x.path && x.filename && x.children && x.paths && x.loaded
   if (isBuiltIn && !isNodeCache(require.cache[resolved])) {
@@ -386,7 +400,7 @@ function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
   }
 
   const mocksNodeVersionNote = 'mocks are available only on Node.js >=20.18 <21 || >=22.3'
-  if (likelyESM || (!isOverridenBuiltinSynchedWithESM && topLevelESM)) {
+  if (likelyESM || (!isOverridenBuiltinSynchedWithESM && topESM)) {
     // 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
@@ -395,17 +409,19 @@ function jestmock(name, mocker, { override = false, actual, builtin } = {}) {
     assert(mockModule, `Native non-overriding node:* ${mocksNodeVersionNote}`)
   }
 
-  if (value[Symbol.toStringTag] === 'Module') value.__esModule = true
+  if (value?.[Symbol.toStringTag] === 'Module') value.__esModule = true
   const obj = { defaultExport: value }
   if (isBuiltIn && isObject(value)) obj.namedExports = value
   if (insideEsbuild()) {
     // esbuild handles unwrapping just default exports for us
     assert(!likelyESM) // should not be reachable
-    const { default: defaultExport, __esModule, ...namedExports } = value // eslint-disable-line @typescript-eslint/no-unused-vars
-    // Don't override defaultExport, as that's processed with esbuild
-    // Add named exports though for further static named imports from that module
-    // type:module and esbuild can be combined e.g. when testing typescript packages
-    if (__esModule) obj.namedExports = namedExports
+    if (isObject(value)) {
+      const { default: defaultExport, __esModule, ...namedExports } = value // eslint-disable-line @typescript-eslint/no-unused-vars
+      // Don't override defaultExport, as that's processed with esbuild
+      // Add named exports though for further static named imports from that module
+      // type:module and esbuild can be combined e.g. when testing typescript packages
+      if (__esModule) obj.namedExports = namedExports
+    }
   } else if (likelyESM && isObject(value) && value.__esModule === true) {
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
     const { default: defaultExport, __esModule, ...namedExports } = value

package/src/jest.setup.js

@@ -0,0 +1,7 @@
+import { loadJestConfig, installJestEnvironment } from './jest.config.js'
+
+export async function setupJest() {
+  await loadJestConfig()
+  const { should, ...jestGlobals } = await import('./jest.js') // eslint-disable-line @typescript-eslint/no-unused-vars
+  await installJestEnvironment(jestGlobals)
+}