@exodus/test 1.0.0-rc.87 → 1.0.0-rc.89

package/bin/index.js

@@ -209,6 +209,9 @@ function parseOptions() {
         options.throttle = getNumber(args.shift())
         assert(Number.isInteger(options.throttle) && options.throttle > 0) // throttle x times, 1 is no throttle, 2 is 2x slowdown
         break
+      case '--debug-timers':
+        setEnv('EXODUS_TEST_TIMERS_TRACK', '1')
+        break
       case '--concurrency':
         options.concurrency = getNumber(args.shift())
         assert(Number.isInteger(options.concurrency) && options.concurrency >= 0)

package/bin/reporter.js

@@ -155,7 +155,7 @@ export default async function nodeTestReporterExodus(source) {
         break
       case 'test:fail':
         if (!pskip(path)) print(`${color('✖ FAIL ', 'red')}${pathstr(path)}${formatSuffix(data)}`)
-        assert(path.pop() === data.name)
+        if (path.length > 0) assert(path.pop() === data.name) // afterAll can generate failures too, with an empty path
         if (!data.todo) failedFiles.add(file)
         if (!notPrintedError(data.details.error)) {
           const { body, loc } = extractError(data, relative(cwd, data.file || data.name)) // might be different from current file if in subimport

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.87",
+  "version": "1.0.0-rc.89",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -96,6 +96,7 @@
     "src/replay.js",
     "src/tape.js",
     "src/tape.cjs",
+    "src/timers-track.js",
     "src/version.js",
     "expect.cjs",
     "jest.js",
@@ -148,7 +149,6 @@
   "dependencies": {
     "@chalker/queue": "^1.0.1",
     "@exodus/replay": "^1.0.0-rc.8",
-    "expect": "^29.7.0",
     "pretty-format": "^29.7.0"
   },
   "optionalDependencies": {
@@ -170,6 +170,7 @@
     "crypto-browserify": "^3.12.0",
     "esbuild": "~0.25.4",
     "events": "^3.3.0",
+    "expect": "^29.7.0",
     "fast-glob": "^3.2.11",
     "flow-remove-types": "^2.242.0",
     "jest-extended": "^4.0.2",

package/src/exodus.js

@@ -1,6 +1,7 @@
 import { mock } from './engine.js'
 import * as node from './engine.js'
 import { fetchReplay, fetchRecord, websocketRecord, websocketReplay } from './replay.js'
+import { timersTrack, timersList, timersDebug, timersAssert } from './timers-track.js'
 import { insideEsbuild } from './dark.cjs'
 import { haveValidTimers } from './version.js'
 
@@ -20,9 +21,8 @@ export const exodus = {
     concurrency: node.engine !== 'pure', // pure engine doesn't support concurrency
   },
   mock: {
-    fetchRecord,
-    fetchReplay,
-    websocketRecord,
-    websocketReplay,
+    ...{ timersTrack, timersList, timersDebug, timersAssert }, // eslint-disable-line unicorn/no-useless-spread
+    ...{ fetchRecord, fetchReplay }, // eslint-disable-line unicorn/no-useless-spread
+    ...{ websocketRecord, websocketReplay }, // eslint-disable-line unicorn/no-useless-spread
   },
 }

package/src/expect.cjs

@@ -11,10 +11,14 @@ function fixupAssertions() {
   assertionsDelta = 0
 }
 
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
 function loadExpect(loadReason) {
   if (expect) return expect
-  expect = require('expect').expect
+  try {
+    expect = require('expect').expect
+  } catch {
+    throw new Error(`Failed to load 'expect', required for ${loadReason}`)
+  }
+
   // console.log('expect load reason:', loadReason)
   try {
     expect.extend(require('jest-extended'))
@@ -82,7 +86,7 @@ function createExpect() {
           const matcher = matchers[name] || matchersFalseNegative[name]
           if (matcher) {
             return (...args) => {
-              if (!matcher(x, ...args)) return loadExpect(`.${name} fail`)(x)[name](...args)
+              if (!matcher(x, ...args)) return loadExpect(`.${name} check`)(x)[name](...args)
               assertionsDelta++
             }
           }

package/src/jest.js

@@ -9,8 +9,12 @@ import { createCallerLocationHook } from './dark.cjs'
 import { exodus } from './exodus.js'
 import { expect } from './expect.cjs'
 import { format as prettyFormat } from 'pretty-format'
+import { timersTrack, timersDebug } from './timers-track.js'
 
 const { getCallerLocation, installLocationInNextTest } = createCallerLocationHook()
+const { setTimeout } = globalThis
+
+if (process.env.EXODUS_TEST_TIMERS_TRACK) timersTrack()
 
 let inband = false
 if (process.env.EXODUS_TEST_ENVIRONMENT !== 'bundle') {
@@ -208,6 +212,7 @@ if (process.env.EXODUS_TEST_PLATFORM !== 'deno' && globalThis.process) {
     // give everything additional (configurable) defaultTimeout time to finish, otherwide fail
     const timeout = defaultTimeout
     setTimeout(() => {
+      if (process.env.EXODUS_TEST_TIMERS_TRACK) timersDebug()
       console.error(`${prefix} additional ${timeout}ms. Terminating with a failure...`)
       process.exit(1)
     }, timeout).unref()
@@ -216,6 +221,7 @@ if (process.env.EXODUS_TEST_PLATFORM !== 'deno' && globalThis.process) {
     const warnTimeout = 5000
     if (warnTimeout < timeout + 1000) {
       setTimeout(() => {
+        if (process.env.EXODUS_TEST_TIMERS_TRACK) timersDebug()
         console.warn(`${prefix} ${warnTimeout}ms. Waiting for ${timeout}ms to pass to finish...`)
       }, warnTimeout).unref()
     }

package/src/jest.timers.js

@@ -65,14 +65,24 @@ export function runOnlyPendingTimers() {
   return this
 }
 
+// We have to tick in divisors of 1000, or e.g. 6s will mismatch a bit from 1s + 5s
+const divisors1000 = [1000, 500, 250, 200, 125, 100, 50, 40, 25, 20, 10, 8, 5, 4, 2, 1]
+
+function divisor1000(x) {
+  if (x <= 1) return 1 // fast path
+  for (const d of divisors1000) if (x >= d) return d
+  return 1 // unreachable
+}
+
 // We split this into multiple steps to run timers scheduled during the time we are running
 function splitTime(time, min = 1000) {
   const minSteps = Math.min(min, time) // usually just split e.g. 5 seconds into 1000 * 5ms
-  const step = Number(Math.floor(time / minSteps).toPrecision(1))
+  const step = divisor1000(Math.floor(time / minSteps))
   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 }
+  // 6000 -> { step: 5, steps: 1200, last: 0 }
   return { step, steps, last }
 }
 

package/src/timers-track.js

@@ -0,0 +1,89 @@
+const getStack = (fn) => {
+  const { stackTraceLimit } = Error
+  Error.stackTraceLimit = 50
+  const err = {}
+  Error.captureStackTrace(err, fn)
+  const { stack } = err
+  Error.stackTraceLimit = stackTraceLimit
+  return stack.replace(/^Error\n/u, '')
+}
+
+const { setTimeout, setInterval, clearTimeout, clearInterval } = globalThis
+const timersMap = new Map()
+let timersMockEnabled = false
+
+export const timersTrack = () => {
+  const mock = {
+    __proto__: null,
+    setTimeout(callback, ms, ...args) {
+      const wrapped = function (...brgs) {
+        timersMap.delete(value)
+        return callback.apply(this, brgs)
+      }
+
+      const stack = getStack(mock.setTimeout)
+      const value = setTimeout(wrapped, ms, ...args)
+      timersMap.set(value, { start: Date.now(), ms, stack, callback, args })
+      return value
+    },
+    setInterval(callback, ms, ...args) {
+      const stack = getStack(mock.setInterval)
+      const value = setInterval(callback, ms, ...args)
+      timersMap.set(value, { start: Date.now(), ms, stack, callback, args, repeating: true })
+      return value
+    },
+    clearTimeout(id) {
+      timersMap.delete(id)
+      return clearTimeout(id)
+    },
+    clearInterval(id) {
+      timersMap.delete(id)
+      return clearInterval(id)
+    },
+  }
+
+  Object.assign(globalThis, mock)
+  timersMockEnabled = true
+}
+
+export const timersList = () => {
+  if (!timersMockEnabled) throw new Error('Use exodus.mock.timersTrack() to enable timer tracking')
+  const now = Date.now()
+  // we don't provide raw timer values, so this is not misused to clear them
+  return [...timersMap.values()].map((entry) =>
+    entry.repeating ? entry : { ...entry, remaining: entry.ms + entry.start - now }
+  )
+}
+
+const timersListFormatted = (comment = '') => {
+  const entries = timersList()
+  const head = `Timers ${comment}[at ${Date.now()}]: ${entries.length}`
+  if (entries.length === 0) return head
+  const first = (stack) => stack.split('\n')[0].replace(/^\s+at\s+/u, '') // doesn't have to be robust
+  const short = entries.map(
+    ({ ms, repeating, remaining, stack }, i) =>
+      `  #${i}: ${repeating ? `setInterval each ${ms}` : `setTimeout in ${remaining}`}ms from ${first(stack)}` // eslint-disable-line sonarjs/no-nested-template-literals
+  )
+  const full = entries.map(
+    ({ start, ms, stack, callback, args, repeating }, i) =>
+      `  #${i} [at ${start}]: ${repeating ? 'setInterval' : 'setTimeout'}(${callback}, ${ms}${['', ...args].join(', ')})\n${stack}`
+  )
+  const sep = (n) => '-'.repeat(n)
+  return `${sep(60)}\n${head}\n${short.join('\n')}\n ${sep(59)}\n${full.join('\n')}\n${sep(60)}`
+}
+
+export const timersDebug = async (...times) => {
+  if (!timersMockEnabled) throw new Error('Use exodus.mock.timersTrack() to enable timer tracking')
+  console.log(timersListFormatted())
+  for (const time of times) {
+    await new Promise((resolve) => setTimeout(resolve, time))
+    console.log(timersListFormatted(`after additional ${time}ms `))
+  }
+}
+
+export const timersAssert = () => {
+  if (!timersMockEnabled) throw new Error('Use exodus.mock.timersTrack() to enable timer tracking')
+  if (timersMap.size === 0) return
+  console.log(timersListFormatted())
+  throw new Error('timersAssert() failed: there are unfinished timers')
+}