@exodus/test 1.0.0-rc.90 → 1.0.0-rc.92

package/README.md

@@ -14,7 +14,8 @@ It can run your existing tests on [all runtimes and also browsers](#engines), wi
   [v8 CLI](https://v8.dev/docs/d8), JSC, [Hermes](https://hermesengine.dev), [SpiderMonkey](https://spidermonkey.dev/),
   Chrome, Firefox, WebKit, Brave, Microsoft Edge,
   [QuickJS](https://github.com/quickjs-ng/quickjs), [XS](https://github.com/Moddable-OpenSource/moddable-xst),
-  [GraalJS](https://github.com/oracle/graaljs) and [Escargot](https://github.com/Samsung/escargot).
+  [GraalJS](https://github.com/oracle/graaljs), [Escargot](https://github.com/Samsung/escargot),
+  and even [engine262](https://github.com/engine262/engine262).
 - Testsuite-agnostic — can run any file as long as it sets exit code based on test results
 - Built-in [Jest](https://jestjs.io) compatibility (with `--jest`), including `jest.*` global
   - Up to ~10x faster depending on the original setup
@@ -24,7 +25,6 @@ It can run your existing tests on [all runtimes and also browsers](#engines), wi
   - [test.concurrent](https://jestjs.io/docs/api#testconcurrentname-fn-timeout)
   - Module mocks, including for ESM modules (already loaded ESM modules can be mocked only on `node:test`)
   - Loads Jest configuration
-  - It works on Hermes too!
 - Built-in network record/replay for offline tests, mocking `fetch` and `WebSocket` sessions
 - `--drop-network` support for guaranteed offline testing
 - Native code coverage via v8 (Node.js or [c8](https://github.com/bcoe/c8)), with istanbul reporters
@@ -64,15 +64,17 @@ Use `--engine` (or `EXODUS_TEST_ENGINE=`) to specify one of:
     - `firefox:puppeteer` — Firefox
     - `brave:puppeteer` — Brave
     - `msedge:puppeteer` — Microsoft Edge
-- Barebone engines (system-provided or installed with `npx jsvu`):
+- Barebone engines (system-provided or installed with `npx jsvu` / `npx esvu`):
   - `d8:bundle` — [v8 CLI](https://v8.dev/docs/d8) (Chrome/Blink/Node.js JavaScript engine)
   - `jsc:bundle` — [JavaScriptCore](https://docs.webkit.org/Deep%20Dive/JSC/JavaScriptCore.html) (Safari/WebKit JavaScript engine)
   - `hermes:bundle` — [Hermes](https://hermesengine.dev) (React Native JavaScript engine)
   - `spidermonkey:bundle` — [SpiderMonkey](https://spidermonkey.dev/) (Firefox/Gecko JavaScript engine)
-  - `quickjs:bundle` — [QuickJS](https://github.com/quickjs-ng/quickjs) (note [quickjs-ng/quickjs#39](https://github.com/quickjs-ng/quickjs/issues/39) though)
+  - `quickjs:bundle` — [QuickJS](https://github.com/quickjs-ng/quickjs)
   - `xs:bundle` — [XS](https://github.com/Moddable-OpenSource/moddable-xst)
   - `graaljs:bundle` — [GraalJS](https://github.com/oracle/graaljs)
   - `escargot:bundle` — [Escargot](https://github.com/Samsung/escargot)
+  - `engine262:bundle` - [engine262](https://github.com/engine262/engine262), the per-spec implementation of ECMA-262
+    (install with [esvu](https://npmjs.com/package/esvu))
 
 ## Reporter samples
 

package/bin/browsers.js

@@ -72,7 +72,7 @@ export async function run(runner, args, { binary, devtools, dropNetwork, timeout
   const [stdout, stderr] = [[], []]
 
   assert(Object.hasOwn(launchers, runner), 'Unexpected runner')
-  if (!launched[runner]) launched[runner] = launchers[runner]({ binary, devtools })
+  if (!launched[runner]) launched[runner] = launchers[runner]({ binary, devtools: !!devtools })
   const { page, context } = await newPage(runner, await launched[runner], { binary, dropNetwork })
 
   if (throttle) {

package/bin/find-binary.js

@@ -6,6 +6,7 @@ import { createRequire } from 'node:module'
 const require = createRequire(import.meta.url)
 const nvm = process.env.NVM_BIN ? (x) => join(process.env.NVM_BIN, '../lib/node_modules', x) : null
 const jsvu = (x) => join(homedir(), '.jsvu/bin', x)
+const esvu = (x) => join(homedir(), '.esvu/bin', x)
 
 // Can modify PATH to add the binary to it!
 function findBinaryOnce(name) {
@@ -46,18 +47,21 @@ function findBinaryOnce(name) {
     case 'jsc':
       return findFile([
         (bin) => jsvu(bin), // prefer jsvu
+        (bin) => esvu(bin),
         (bin) => `/System/Library/Frameworks/JavaScriptCore.framework/Versions/A/Helpers/${bin}`,
         (bin) => `/System/Library/Frameworks/JavaScriptCore.framework/Versions/A/Resources/${bin}`,
       ])
     case 'd8':
-      return findFile([() => jsvu('v8')]) // jsvu names it v8
+      return findFile([() => jsvu('v8'), () => esvu('v8')]) // jsvu/esvu name it v8
     case 'spidermonkey':
     case 'quickjs':
     case 'graaljs':
     case 'escargot':
-      return findFile([jsvu])
+    case 'ladybird-js': // naming by esvu
+    case 'engine262':
+      return findFile([jsvu, esvu])
     case 'xs':
-      return findFile([jsvu], false)
+      return findFile([jsvu, esvu], false)
     case 'electron':
       return require('electron')
     case 'c8':

package/bin/index.js

@@ -40,6 +40,7 @@ const ENGINES = new Map(
     'jsc:bundle': { binary: 'jsc', target: 'safari13', ...bareboneOpts },
     'hermes:bundle': { binary: 'hermes', binaryArgs: hermesAv, target: 'es2018', ...bareboneOpts },
     'spidermonkey:bundle': { binary: 'spidermonkey', ...bareboneOpts },
+    'engine262:bundle': { binary: 'engine262', ...bareboneOpts },
     'quickjs:bundle': { binary: 'quickjs', binaryArgs: ['--std'], ...bareboneOpts },
     'xs:bundle': { binary: 'xs', ...bareboneOpts },
     'graaljs:bundle': { binary: 'graaljs', ...bareboneOpts },
@@ -56,6 +57,8 @@ const ENGINES = new Map(
     'msedge:playwright': { binary: 'msedge', browsers: 'playwright', ...bundleOpts },
   })
 )
+const barebonesOk = ['d8', 'spidermonkey', 'quickjs', 'xs', 'hermes']
+const barebonesUnhandled = ['jsc', 'escargot', 'graaljs', 'engine262']
 
 const getEnvFlag = (name) => {
   if (!Object.hasOwn(process.env, name)) return false
@@ -185,7 +188,11 @@ function parseOptions() {
         options.flagEngine = true
         break
       case '--devtools':
-        options.devtools = true
+      case '--inspect-brk':
+        options.devtools = '--inspect-brk'
+        break
+      case '--inspect':
+        if (!options.devtools) options.devtools = '--inspect'
         break
       case '--debug-files':
         options.debug.files = true
@@ -256,6 +263,7 @@ if (!process.env.FORCE_COLOR && process.stdout.hasColors?.() && process.stderr.h
 }
 
 const engineName = `${options.engine} engine` // used for warnings to user
+const engineFlagError = (flag) => `${engineName} does not support --${flag}`
 const engineOptions = ENGINES.get(options.engine)
 assert(engineOptions, `Unknown engine: ${options.engine}`)
 Object.assign(options, engineOptions)
@@ -269,8 +277,8 @@ setEnv('EXODUS_TEST_IS_BROWSER', isBrowserLike ? '1' : '')
 setEnv('EXODUS_TEST_IS_BAREBONE', options.barebone ? '1' : '')
 setEnv('EXODUS_TEST_ENVIRONMENT', options.bundle ? 'bundle' : '') // perhaps switch to _IS_BUNDLED?
 
-assert(!options.devtools || isBrowserLike, '--devtools can be only used with browser engines')
-assert(!options.throttle || options.browsers, `${engineName} does not support --throttle-cpu`)
+assert(!options.devtools || isBrowserLike || !options.pure, engineFlagError('devtools'))
+assert(!options.throttle || options.browsers, engineFlagError('throttle-cpu'))
 
 const require = createRequire(import.meta.url)
 const resolveRequire = (query) => require.resolve(query)
@@ -577,7 +585,7 @@ async function launch(binary, args, opts = {}, buffering = false) {
     return browsers.run(runner, args, { binary, devtools, dropNetwork, timeout, throttle })
   }
 
-  const barebones = ['d8', 'jsc', 'spidermonkey', 'quickjs', 'xs', 'escargot', 'graaljs', 'hermes']
+  const barebones = [...barebonesOk, ...barebonesUnhandled]
   assertBinary(binary, ['node', 'bun', 'deno', 'electron', ...barebones, 'v8']) // v8 is an alias to d8
   if (options.dropNetwork) {
     switch (process.platform) {
@@ -601,7 +609,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', 'escargot', 'graaljs'].includes(options.platform) || isBrowserLike
+  const missUnhandled = barebonesUnhandled.includes(options.platform) || isBrowserLike
   if (missUnhandled) warnHuman(`Warning: ${engineName} does not have unhandled rejections tracking`)
 
   const runOne = async (inputFile, attempt = 0) => {
@@ -690,6 +698,15 @@ if (options.pure) {
   assert(files.length > 0) // otherwise we can run recursively
   assert(!options.binaryArgs)
   if (options.concurrency) args.push('--test-concurrency', options.concurrency)
+  if (['--inspect', '--inspect-brk'].includes(options.devtools)) {
+    args.push(options.devtools)
+    console.warn(
+      options.devtools === '--inspect-brk'
+        ? 'Open chrome://inspect/ to connect devtools, waiting'
+        : 'Open chrome://inspect/ to connect devtools\nUse --inspect-brk to wait for inspector'
+    )
+  }
+
   const { code } = await launch(options.binary, [...args, ...files])
   process.exitCode = code
 }

package/bundler/bundle.js

@@ -38,6 +38,17 @@ const loadPipeline = [
       .replace(/\b(__dirname|import\.meta\.dirname)\b/g, JSON.stringify(dirname(filepath)))
       .replace(/\b(__filename|import\.meta\.filename)\b/g, JSON.stringify(filepath))
 
+    if (filepath.endsWith('/node_modules/chalk/source/templates.js')) {
+      // It has an invalid regex on which engine262 fails
+      res = res.replace(
+        'const ESCAPE_REGEX = /\\\\(u(?:[a-f\\d]{4}|{[a-f\\d]{1,6}})|x[a-f\\d]{2}|.)|([^\\\\])/gi;',
+        'const ESCAPE_REGEX = /\\\\(u(?:[a-f\\d]{4}|\\{[a-f\\d]{1,6}\\})|x[a-f\\d]{2}|.)|([^\\\\])/giu;'
+      )
+    } else if (filepath.endsWith('/node_modules/qs/lib/parse.js')) {
+      res = res.replace('var brackets = /(\\[[^[\\]]*])/;', 'var brackets = /(\\[[^[\\]]*\\])/;')
+      res = res.replace('var child = /(\\[[^[\\]]*])/g;', 'var child = /(\\[[^[\\]]*\\])/g;')
+    }
+
     // Unneded polyfills
     for (const [a, b] of Object.entries({
       'is-nan': 'Number.isNaN', // https://www.npmjs.com/package/is-nan description: ES2015-compliant shim for Number.isNaN

package/bundler/modules/globals.cjs

@@ -6,6 +6,7 @@ if (!globalThis.Buffer) globalThis.Buffer = require('buffer').Buffer
 
 const consoleKeys = ['log', 'error', 'warn', 'info', 'debug', 'trace']
 const { print } = globalThis
+if (process.env.EXODUS_TEST_PLATFORM === 'engine262') delete globalThis.console // prints [object Object] on everything
 if (!globalThis.console) globalThis.console = Object.fromEntries(consoleKeys.map((k) => [k, print])) // eslint-disable-line no-undef
 for (const k of consoleKeys) if (!console[k]) console[k] = console.log // SpiderMonkey has console but no console.error
 
@@ -139,7 +140,8 @@ if (
 
   // TODO: use interrupt timers on jsc
 
-  const schedule = setTimeoutOriginal || ((x) => tickTimes(50).then(() => x())) // e.g. SpiderMonkey doesn't even have setTimeout
+  const tickPromiseInterval = process.env.EXODUS_TEST_PLATFORM === 'engine262' ? 5 : 50 // engine262 is slow
+  const schedule = setTimeoutOriginal || ((x) => tickTimes(tickPromiseInterval).then(() => x())) // e.g. SpiderMonkey doesn't even have setTimeout
   const dateNow = Date.now.bind(Date)
   const precision = clearTimeoutOriginal ? Infinity : 10 // have to tick this fast for clearTimeout to work
   let current = 0
@@ -197,7 +199,7 @@ if (
   const queueTick = () => {
     current++ // safeguard
     while (queueMicrotick() !== null);
-    if (queue.length > 1) restartLoop()
+    if (queue.length > 0) restartLoop()
   }
 
   globalThis.setTimeout = (callback, delay, ...args) =>

package/bundler/modules/url.cjs

@@ -27,6 +27,6 @@ function fileURLToPath(url, options) {
 
 module.exports = { ...urlLib, pathToFileURL, fileURLToPath }
 
-const defineExport = (k, get) => Object.defineProperty(module.exports, k, { get, enumerable: true })
-defineExport('URL', () => globalThis.URL)
-defineExport('URLSearchParams', () => globalThis.URLSearchParams)
+for (const name of ['URL', 'URLSearchParams']) {
+  Object.defineProperty(module.exports, name, { get: () => globalThis[name], enumerable: true })
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@exodus/test",
-  "version": "1.0.0-rc.90",
+  "version": "1.0.0-rc.92",
   "author": "Exodus Movement, Inc.",
   "description": "A test suite runner",
   "homepage": "https://github.com/ExodusMovement/test",
@@ -134,6 +134,7 @@
     "test:jsc": "EXODUS_TEST_ENGINE=jsc:bundle npm run test:_bundle --",
     "test:hermes": "EXODUS_TEST_ENGINE=hermes:bundle npm run test:_bundle --",
     "test:spidermonkey": "EXODUS_TEST_ENGINE=spidermonkey:bundle npm run test:_bundle --",
+    "test:engine262": "EXODUS_TEST_ENGINE=engine262:bundle npm run test:_bundle --",
     "test:quickjs": "EXODUS_TEST_ENGINE=quickjs:bundle npm run test:_bundle --",
     "test:xs": "EXODUS_TEST_ENGINE=xs:bundle npm run test:_bundle --",
     "test:graaljs": "EXODUS_TEST_ENGINE=graaljs:bundle npm run test:_bundle --",
@@ -157,7 +158,7 @@
     "@babel/plugin-transform-private-methods": "^7.0.0",
     "@babel/register": "^7.0.0",
     "@chalker/queue": "^1.0.1",
-    "@exodus/replay": "^1.0.0-rc.8",
+    "@exodus/replay": "^1.0.0-rc.9",
     "@ungap/url-search-params": "^0.2.2",
     "amaro": "^0.0.5",
     "assert": "^2.1.0",

package/src/engine.pure.cjs

@@ -133,6 +133,12 @@ async function runContext(context) {
     const guard = { id: null, failed: false }
     const timeout = options.timeout || Number(process.env.EXODUS_TEST_TIMEOUT) || 5000
     guard.promise = new Promise((resolve) => {
+      if (process.env.EXODUS_TEST_PLATFORM === 'engine262') {
+        // parallel timeouts are slowing down everything on engine262
+        // so we let only the host timeout to catch us, not individual test timeout
+        return
+      }
+
       guard.id = setTimeout(() => {
         guard.failed = true
         resolve()
@@ -304,13 +310,14 @@ class MockTimers {
   }
 
   async tickAsync(milliseconds = 1) {
-    let shouldAwait = true
-    for (let i = 0; i < milliseconds; i++) {
-      if (shouldAwait) await awaitForMicrotaskQueue()
-      this.#elapsed += 1
-      shouldAwait = this.#microtick() !== null
-      if (shouldAwait) while (this.#microtick() !== null);
+    const finish = this.#elapsed + milliseconds
+    await awaitForMicrotaskQueue()
+    while (this.#queue[0] && this.#queue[0].runAt <= finish) {
+      this.#elapsed = Math.max(this.#elapsed, this.#queue[0].runAt)
+      while (this.#microtick() !== null) await awaitForMicrotaskQueue()
     }
+
+    this.#elapsed = finish
   }
 
   #microtick() {
@@ -483,8 +490,10 @@ const awaitForMicrotaskQueue = async () => {
   // Do not rely on setTimeout here! it will tick actual time and is terribly slow (i.e. timers no longer fake)
   // 50_000 should be enough to flush everything that's going on in the microtask queue
   // E.g. JSC and SpiderMonkey hit this currently
+  // engine262 is extremely slow, tick just above 100 on it
   const promise = Promise.resolve()
-  for (let i = 0; i < 50_000; i++) await promise
+  const tickPromiseRounds = process.env.EXODUS_TEST_PLATFORM === 'engine262' ? 110 : 50_000
+  for (let i = 0; i < tickPromiseRounds; i++) await promise
 }
 
 let builtinModules = []

package/src/exodus.js

@@ -5,6 +5,29 @@ import { timersTrack, timersList, timersDebug, timersAssert } from './timers-tra
 import { insideEsbuild } from './dark.cjs'
 import { haveValidTimers } from './version.js'
 
+const timersSpeedup = (rate, { apis = ['setTimeout', 'setInterval', 'Date'] } = {}) => {
+  if (!(typeof rate === 'number' && rate > 0)) throw new TypeError('Expected a positive rate')
+  const { setTimeout, setInterval, Date: OrigDate } = globalThis
+  for (const api of apis) {
+    // eslint-disable-next-line unicorn/prefer-switch
+    if (api === 'setTimeout') {
+      globalThis.setTimeout = (fn, ms, ...args) => setTimeout(fn, Math.ceil(ms / rate), ...args)
+    } else if (api === 'setInterval') {
+      globalThis.setInterval = (fn, ms, ...args) => setInterval(fn, Math.ceil(ms / rate), ...args)
+    } else if (api === 'Date') {
+      const base = OrigDate.now()
+      globalThis.Date = class Date extends OrigDate {
+        static now = () => base + Math.floor((OrigDate.now() - base) * rate)
+        constructor(first = globalThis.Date.now(), ...rest) {
+          super(first, ...rest)
+        }
+      }
+    } else {
+      throw new Error(`Unknown or unsupported API in timersSpeedup(): ${api}`)
+    }
+  }
+}
+
 const isBundle = process.env.EXODUS_TEST_ENVIRONMENT === 'bundle' // TODO: improve mocking from bundle
 export const exodus = {
   __proto__: null,
@@ -21,7 +44,7 @@ export const exodus = {
     concurrency: node.engine !== 'pure', // pure engine doesn't support concurrency
   },
   mock: {
-    ...{ timersTrack, timersList, timersDebug, timersAssert }, // eslint-disable-line unicorn/no-useless-spread
+    ...{ timersTrack, timersList, timersDebug, timersAssert, timersSpeedup }, // 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/jest.js

@@ -204,6 +204,19 @@ node.afterEach(() => {
 
 if (process.env.EXODUS_TEST_PLATFORM !== 'deno' && globalThis.process) {
   // TODO: deno, other engines
+
+  const reportActivity = () => {
+    if (process.env.EXODUS_TEST_TIMERS_TRACK) timersDebug()
+    if (process?.getActiveResourcesInfo) {
+      const all = process.getActiveResourcesInfo().filter((r) => r !== 'PipeWrap')
+      if (all.length > 0) {
+        const entries = [...new Set(all)].map((k) => [k, all.filter((x) => x === k).length])
+        const pretty = prettyFormat(Object.fromEntries(entries), { min: true })
+        console.log(`Active resources: { ${pretty.slice(1, -1).replaceAll('"', '')} }`)
+      }
+    }
+  }
+
   // This doesn't work with async imported tests, so for inband, we delay
   const after = () => {
     jestTimers.useRealTimers()
@@ -212,7 +225,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()
+      reportActivity()
       console.error(`${prefix} additional ${timeout}ms. Terminating with a failure...`)
       process.exit(1)
     }, timeout).unref()
@@ -221,7 +234,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()
+        reportActivity()
         console.warn(`${prefix} ${warnTimeout}ms. Waiting for ${timeout}ms to pass to finish...`)
       }, warnTimeout).unref()
     }

package/src/jest.timers.js

@@ -52,9 +52,11 @@ export function useFakeTimers({ doNotFake = doNotFakeDefault, ...rest } = {}) {
   return this
 }
 
+const runAllTimersTime = 100_000_000_000 // > 3 years
+const runAllTimersSplit = { step: 50_000_000, steps: 2000, last: 0 }
 export function runAllTimers() {
   assertEnabledTimers()
-  advanceTimersByTime(100_000_000_000) // > 3 years
+  advanceTimersByTime(runAllTimersTime) // > 3 years
   return this
 }
 
@@ -95,7 +97,7 @@ export function advanceTimersByTime(time) {
     return this
   }
 
-  const { step, steps, last } = splitTime(time)
+  const { step, steps, last } = time === runAllTimersTime ? runAllTimersSplit : splitTime(time)
   for (let i = 0; i < steps; i++) {
     if (!enabled) break // got disabled while looping
     mock.timers.tick(step)
@@ -122,7 +124,7 @@ export async function runOnlyPendingTimersAsync() {
 export async function advanceTimersByTimeAsync(time) {
   assertEnabledTimers()
   if (mock.timers.tickAsync) {
-    await mock.timers.tickAsync(time)
+    await mock.timers.tickAsync(time) // runs microtasks at start and end
   } else {
     const { step, steps, last } = splitTime(time)
     for (let i = 0; i < steps; i++) {
@@ -133,9 +135,9 @@ export async function advanceTimersByTimeAsync(time) {
 
     if (last > 0 && enabled) await awaitForMicrotaskQueue()
     if (last > 0 && enabled) mock.timers.tick(last)
+    await awaitForMicrotaskQueue() // jest doc is misleading and it also does this after running timers
   }
 
-  await awaitForMicrotaskQueue() // jest doc is misleading and it also does this after running timers
   return this
 }