@exodus/test 1.0.0-rc.14 → 1.0.0-rc.16

package/package.json

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

package/src/dark.cjs

@@ -1,5 +1,7 @@
 const { fileURLToPath } = require('node:url')
 
+const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str) : str)
+
 let locForNextTest
 
 let installLocationInNextTest = function (loc) {
@@ -9,9 +11,7 @@ let installLocationInNextTest = function (loc) {
 // WARNING
 // Do not refactor, do not wrap
 // This function has to be called unwrapped directly inside our test() impl
-let getCallerLocation = () => {}
-
-const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str) : str)
+let getCallerLocation
 
 // This is unoptimal
 // Ideally, an option for overriding file locations should be added to Node.js,
@@ -21,28 +21,90 @@ const mayBeUrlToPath = (str) => (str.startsWith('file://') ? fileURLToPath(str)
 // This whole logic is limited only to updating caller locations for reports
 // We don't do use exposed Node.js internas for anything else
 
-try {
-  const { Test } = require('node:internal/test_runner/test')
-  const locStorage = new Map()
-  Object.defineProperty(Test.prototype, 'loc', {
-    get() {
-      return locStorage.get(this)
-    },
-    set(val) {
-      locStorage.set(this, val)
-      if (locForNextTest) {
-        const loc = locForNextTest
-        locForNextTest = undefined
-        locStorage.set(this, { line: loc[0], column: loc[1], file: mayBeUrlToPath(loc[2]) })
+function createCallerLocationHook() {
+  if (getCallerLocation) return { installLocationInNextTest, getCallerLocation }
+
+  try {
+    const { Test } = require('node:internal/test_runner/test')
+    const locStorage = new Map()
+    Object.defineProperty(Test.prototype, 'loc', {
+      get() {
+        return locStorage.get(this)
+      },
+      set(val) {
+        locStorage.set(this, val)
+        if (locForNextTest) {
+          const loc = locForNextTest
+          locForNextTest = undefined
+          locStorage.set(this, { line: loc[0], column: loc[1], file: mayBeUrlToPath(loc[2]) })
+        }
+      },
+    })
+
+    // We can replicate getCallerLocation() with public V8 Error CallSite API, but we won't
+    // need it anyway if we don't have a path for hook into internal Test implementation
+
+    const { internalBinding } = require('node:internal/test/binding')
+    getCallerLocation = internalBinding('util').getCallerLocation
+  } catch {
+    getCallerLocation = () => {}
+  }
+
+  return { installLocationInNextTest, getCallerLocation }
+}
+
+// Easy on Node.js >= 22.3.0, but we polyfill for the rest
+function getTestNamePath(t) {
+  // No implementation in Node.js yet, will have to PR
+  if (t.fullName) return t.fullName.split(' > ')
+
+  // We are on Node.js < 22.3.0 where even t.fullName doesn't exist yet, polyfill
+  const namePath = Symbol('namePath')
+  const getNamePath = Symbol('getNamePath')
+  try {
+    if (t[namePath]) return t[namePath]
+
+    // Sigh, ok, whatever
+    const { Test } = require('node:internal/test_runner/test')
+
+    const usePathName = Symbol('usePathName')
+    const restoreName = Symbol('restoreName')
+    Test.prototype[getNamePath] = function () {
+      if (this === this.root) return []
+      return [...(this.parent?.[getNamePath]() || []), this.name]
+    }
+
+    const diagnostic = Test.prototype.diagnostic
+    Test.prototype.diagnostic = function (...args) {
+      if (args[0] === usePathName) {
+        this[restoreName] = this.name
+        this.name = this[getNamePath]()
+        return
       }
-    },
-  })
 
-  // We can replicate getCallerLocation() with public V8 Error CallSite API, but we won't
-  // need it anyway if we don't have a path for hook into internal Test implementation
+      if (args[0] === restoreName) {
+        this.name = this[restoreName]
+        delete this[restoreName]
+        return
+      }
 
-  const { internalBinding } = require('node:internal/test/binding')
-  getCallerLocation = internalBinding('util').getCallerLocation
-} catch {}
+      return diagnostic.apply(this, args)
+    }
+
+    const TestContextProto = Object.getPrototypeOf(t)
+    Object.defineProperty(TestContextProto, namePath, {
+      get() {
+        this.diagnostic(usePathName)
+        const result = this.name
+        this.diagnostic(restoreName)
+        return result
+      },
+    })
+
+    return t[namePath]
+  } catch {}
+
+  return [t.name] // last resort
+}
 
-module.exports = { installLocationInNextTest, getCallerLocation }
+module.exports = { createCallerLocationHook, getTestNamePath }

package/src/jest.config.js

@@ -1,5 +1,6 @@
 import assert from 'node:assert/strict'
 import { readFile } from 'node:fs/promises'
+import { existsSync } from 'node:fs'
 import path from 'node:path'
 import { createRequire } from 'node:module'
 import { specialEnvironments } from './jest.environment.js'
@@ -10,36 +11,39 @@ const baseDir = files.length === 1 ? path.dirname(path.resolve(files[0])) : unde
 async function getJestConfig(dir) {
   if (!dir) return
 
-  try {
-    const pkg = JSON.parse(await readFile(path.resolve(dir, 'package.json'), 'utf8'))
+  const configPath = (ext) => path.resolve(dir, `jest.config.${ext}`)
 
-    // Only if package.json is found
-    let dynamic
-    for (const type of ['mjs', 'cjs', 'js']) {
-      try {
-        const { default: config } = await import(path.resolve(dir, `jest.config.${type}`))
-        dynamic = config
-        break
-      } catch (e) {
-        if (e.code !== 'ERR_MODULE_NOT_FOUND') throw e
-      }
-    }
+  assert(!existsSync(configPath('ts')), 'jest.config.ts is not supported yet with .ts extension')
 
-    if (dynamic === undefined) {
-      try {
-        dynamic = JSON.parse(await readFile(path.resolve(dir, 'jest.config.json'), 'utf8'))
-      } catch (e) {
-        if (e.code !== 'ENOENT') throw e
+  const configs = []
+  for (const type of ['js', 'ts', 'mjs', 'cjs', 'json']) {
+    try {
+      if (type === 'json') {
+        configs.push(JSON.parse(await readFile(configPath('json'), 'utf8')))
+      } else {
+        const { default: config } = await import(configPath(type))
+        configs.push(config)
       }
+    } catch (e) {
+      if (!['ERR_MODULE_NOT_FOUND', 'ENOENT'].includes(e.code)) throw e
     }
+  }
+
+  try {
+    const pkg = JSON.parse(await readFile(path.resolve(dir, 'package.json'), 'utf8'))
+    assert(typeof pkg.jest !== 'string', 'String package.json["jest"] values are not supported yet')
+    if (pkg.jest) configs.push(pkg.jest)
+  } catch (e) {
+    if (e.code !== 'ENOENT') throw e
+  }
 
-    // We don't deep merge (yet?)
-    const conf = { ...pkg.jest, ...dynamic }
+  assert(configs.length < 2, `Multiple jest configs found in ${dir} dir, use only a single one`)
+
+  if (configs.length > 0) {
+    const conf = { ...configs[0] }
     assert(!conf.rootDir, 'Jest config.rootDir is not supported yet')
     conf.rootDir = dir
     return conf
-  } catch (e) {
-    if (e.code !== 'ENOENT') throw e
   }
 
   const parent = path.dirname(dir)
@@ -124,7 +128,9 @@ export async function installJestEnvironment(jestGlobals) {
   if (c.restoreMocks) beforeEach(() => jest.restoreAllMocks())
   if (c.resetModules) beforeEach(() => jest.resetModules())
 
-  const require = createRequire(config.rootDir)
+  const require = config.rootDir
+    ? createRequire(path.resolve(config.rootDir, 'package.json'))
+    : () => assert.fail('Unreachable: requiring plugins without a rootDir')
 
   if (Object.hasOwn(specialEnvironments, c.testEnvironment)) {
     specialEnvironments[c.testEnvironment](require, jestGlobals, c.testEnvironmentOptions)

package/src/jest.environment.js

@@ -1,56 +1,4 @@
-// Shoult not import src/ stuff here, as this goes into runner too (to check config)
-
-function getTestNamePath(t, { require } = {}) {
-  // No implementation in Node.js yet, will have to PR
-  if (t.fullName) return t.fullName.split(' > ')
-
-  // We are on Node.js < 22.3.0 where even t.fullName doesn't exist yet, polyfill
-  const namePath = Symbol('namePath')
-  try {
-    if (t[namePath]) return t[namePath]
-
-    // Sigh, ok, whatever
-    const { Test } = require('node:internal/test_runner/test')
-
-    const usePathName = Symbol('usePathName')
-    const restoreName = Symbol('restoreName')
-    Test.prototype.getNamePath = function () {
-      if (this === this.root) return []
-      return [...(this.parent?.getNamePath() || []), this.name]
-    }
-
-    const diagnostic = Test.prototype.diagnostic
-    Test.prototype.diagnostic = function (...args) {
-      if (args[0] === usePathName) {
-        this[restoreName] = this.name
-        this.name = this.getNamePath()
-        return
-      }
-
-      if (args[0] === restoreName) {
-        this.name = this[restoreName]
-        delete this[restoreName]
-        return
-      }
-
-      return diagnostic.apply(this, args)
-    }
-
-    const TestContextProto = Object.getPrototypeOf(t)
-    Object.defineProperty(TestContextProto, namePath, {
-      get() {
-        this.diagnostic(usePathName)
-        const result = this.name
-        this.diagnostic(restoreName)
-        return result
-      },
-    })
-
-    return t[namePath]
-  } catch {}
-
-  return [t.name] // last resort
-}
+import { getTestNamePath } from './dark.cjs'
 
 export const specialEnvironments = {
   __proto__: null,
@@ -80,7 +28,7 @@ export const specialEnvironments = {
 
     jestGlobals.beforeEach((t) => {
       if (!pollyGlobals.isPollyActive) return
-      const name = getTestNamePath(t, { require }).join('/')
+      const name = getTestNamePath(t).join('/')
       pollyGlobals.pollyContext.polly = new Polly(name, pollyGlobals.pollyContext.options)
     })
 

package/src/jest.js

@@ -6,10 +6,12 @@ import { jestfn, allMocks } from './jest.fn.js'
 import { jestmock, requireActual, requireMock, resetModules } from './jest.mock.js'
 import * as jestTimers from './jest.timers.js'
 import './jest.snapshot.js'
-import { getCallerLocation, installLocationInNextTest } from './dark.cjs'
+import { createCallerLocationHook } from './dark.cjs'
 import { expect } from 'expect'
 import matchers from 'jest-extended'
 
+const { getCallerLocation, installLocationInNextTest } = createCallerLocationHook()
+
 expect.extend(matchers)
 
 let defaultTimeout = jestConfig().testTimeout // overridable via jest.setTimeout()

package/src/jest.snapshot.js

@@ -3,16 +3,25 @@ import { createRequire } from 'node:module'
 import { expect } from 'expect'
 import { format } from 'pretty-format'
 import assert from 'node:assert/strict'
-import { basename, dirname, join } from 'node:path'
+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 = []
 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 = false
+let snapshotsAreJest
+
+// 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
 
 function maybeSetupSerializers() {
   if (serializersAreSetup) return
@@ -23,14 +32,20 @@ function maybeSetupSerializers() {
 
 // We want to setup snapshots to behave like jest only when first used from jest API
 function maybeSetupJestSnapshots() {
-  if (snapshotsAreJest) return
-  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((f) => join(dirname(f), '__snapshots__', `${basename(f)}.snap`))
-  snapshotsAreJest = true
+  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
 }
 
 const wrap = (check) => {
@@ -91,22 +106,48 @@ const snapInline = (obj, inline) => {
   getAssert().strictEqual(serialize(obj).trim(), inline.trim())
 }
 
-const snapOnDisk = (obj) =>
-  wrapContextName(() => {
-    maybeSetupJestSnapshots()
+const snapOnDisk = (obj) => {
+  const escape = (str) => str.replaceAll(/([\\`])/gu, '\\$1')
 
-    if (!serialize(obj).includes('\n')) {
-      // Node.js always wraps with newlines, while jest wraps only those that are already multiline
+  if (!maybeSetupJestSnapshots()) {
+    // We don't have native snapshots, polyfill reading
+    if (snapshotLocation && snapshotText !== null) {
       try {
-        getAssert().snapshot(obj)
-      } catch (e) {
-        if (`\n${e.expected}\n` === e.actual) return
-        throw e
+        snapshotText = `\n${readFileSync(snapshotLocation, 'utf8')}\n` // we'll search wrapped in \n
+      } catch {
+        snapshotText = null
       }
     }
 
-    return getAssert().snapshot(obj)
-  })
+    const addFail = `Adding new snapshots requires Node.js >=22.3.0`
+
+    // We don't support polyfilled snapshot generation here, only parsing
+    // Also be careful with assertion plan counters
+    if (!snapshotText) getAssert().fail(`Could not find snapshot file. ${addFail}`)
+
+    const name = getTestNamePath(context).join(' ')
+    const count = (nameCounts.get(name) || 0) + 1
+    nameCounts.set(name, count)
+    const escaped = escape(serialize(obj))
+    const key = `${name} ${count}`
+    const makeEntry = (x) => `\nexports[\`${escape(key)}\`] = \`${x}\`;\n`
+    const final = escaped.includes('\n') ? `\n${escaped}\n` : escaped
+    if (snapshotText.includes(makeEntry(final))) return
+    // Perhaps wrapped with newlines from Node.js snapshots?
+    if (!final.includes('\n') && snapshotText.includes(makeEntry(`\n${final}\n`))) return
+    return getAssert().fail(`Could not match "${key}" in snapshot. ${addFail}`)
+  }
+
+  // Node.js always wraps with newlines, while jest wraps only those that are already multiline
+  try {
+    wrapContextName(() => getAssert().snapshot(obj))
+  } catch (e) {
+    const escaped = escape(e.expected)
+    const final = escaped.includes('\n') ? escaped : `\n${escaped}\n`
+    if (final === e.actual) return
+    throw e
+  }
+}
 
 expect.extend({
   toMatchInlineSnapshot: (obj, i) => wrap(() => snapInline(obj, i)),

package/src/tape.js

@@ -1,7 +1,7 @@
 import assert from 'node:assert/strict'
 import assertLoose from 'node:assert'
 import { test } from 'node:test'
-import { getCallerLocation, installLocationInNextTest } from './dark.cjs'
+import { createCallerLocationHook } from './dark.cjs'
 
 const knownOptions = new Set(['skip', 'todo', 'concurrency', 'timeout'])
 
@@ -134,6 +134,8 @@ function tapeWrapAssert(t, callback) {
 
 const AsyncFunction = (async () => {}).constructor
 
+const { getCallerLocation, installLocationInNextTest } = createCallerLocationHook()
+
 function tapeWrap(test) {
   const tap = (...args) => {
     const fn = args.pop()