@exodus/test 1.0.0-rc.0

package/CHANGELOG.md

@@ -0,0 +1,3 @@
+## 1.0.0
+
+Initial release

package/README.md

@@ -0,0 +1,60 @@
+# @exodus/test
+
+Most likely it will just work on your simple jest tests as as drop-in replacement
+
+## Library
+
+### Moving from jest
+
+`import { describe, it, assert, jest, expect } from '@exodus/test'`
+
+Replace `.calls` with `.callsArguments`, as the former one now contains more detailed information
+
+### Moving from tap/tape
+
+`import { tap as test } from '@exodus/test'`
+
+Not all features might be supported
+
+### Running tests asynchronously
+
+Add `{ concurrency: true }`, like this: `describe('my testsuite', { concurrency: true }, () => {`
+
+### List of exports
+
+Adapters:
+
+- `jest` -- jest mock adapter
+- `tap` -- tap/tape adapter
+- `mock`
+
+Assertions:
+
+- `assert` -- alias for `node:assert/strict`
+- `expect` -- expect with additional features for function mocks
+
+Suite:
+
+- `describe`
+- `test`
+- `it` -- alias for `test`
+- `beforeEach`
+- `afterEach`
+- `before` -- alias for `beforeAll`
+- `after` -- alias for `afterAll`
+
+## Binary
+
+Just use `"test: "exodus-test"`
+
+### Options
+
+- `--global` -- register all test helpers as global variables
+
+- `--typescript` -- enable typescript support
+
+- `--coverage` -- enable coverage, prints coverage output (varies by coverage engine)
+
+- `--coverage-engine c8` -- use c8 coverage engine (default), also generates `./coverage/` dirs
+
+- `--coverage-engine node` -- use Node.js builtint coverage engine

package/bin/index.js

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+import { spawn } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { basename, dirname, resolve } from 'node:path'
+import { createRequire } from 'node:module'
+import assert from 'node:assert/strict'
+import glob from 'fast-glob' // Only for Node.js <22 support
+
+const bindir = dirname(fileURLToPath(import.meta.url))
+
+const DEFAULT_PATTERNS = ['**/*.{test,spec}.?(c|m)js', '**/*.{test,spec}.ts']
+
+function versionCheck() {
+  const [major, minor, patch] = process.versions.node.split('.').map(Number)
+  assert((major === 18 && minor >= 13) || major >= 20, 'Node.js version too old!')
+  assert(major !== 21, 'Node.js version deprecated!')
+
+  return { major, minor, patch }
+}
+
+function parseOptions() {
+  const options = {
+    global: false,
+    typescript: false,
+    coverage: false,
+    coverageEngine: 'c8', // c8 or node
+  }
+
+  const args = [...process.argv]
+
+  // First argument should be node
+  assert.equal(basename(args.shift()), 'node')
+  assert.equal(basename(process.argv0), 'node')
+
+  // Second argument should be this script
+  const jsname = args.shift()
+  assert(basename(jsname) === 'exodus-test' || jsname === fileURLToPath(import.meta.url))
+
+  while (args[0]?.startsWith('--')) {
+    const option = args.shift()
+    switch (option) {
+      case '--global':
+        options.global = true
+        break
+      case '--typescript':
+        options.typescript = true
+        break
+      case '--coverage-engine':
+        options.coverageEngine = args.shift()
+        break
+      case '--coverage':
+        options.coverage = true
+        break
+      default:
+        throw new Error(`Unknown option: ${option}`)
+    }
+  }
+
+  assert(
+    args.every((arg) => !arg.startsWith('--')),
+    'Options should come before patterns'
+  )
+
+  const patterns = [...args]
+  if (patterns.length === 0) patterns.push(...DEFAULT_PATTERNS) // defaults
+
+  return { options, patterns }
+}
+
+const { major, minor } = versionCheck()
+const { options, patterns } = parseOptions()
+
+let program = 'node'
+
+const require = createRequire(import.meta.url)
+const c8 = require.resolve('c8/bin/c8.js')
+
+const args = ['--test', '--enable-source-maps']
+if (options.coverage) {
+  if (options.coverageEngine === 'node') {
+    args.push('--experimental-test-coverage')
+  } else if (options.coverageEngine === 'c8') {
+    program = c8
+    args.unshift('node')
+    // perhaps use text-summary ?
+    args.unshift('-r', 'text', '-r', 'html')
+  } else {
+    throw new Error(`Unknown coverage engine: ${JSON.stringify(options.coverageEngine)}`)
+  }
+}
+
+if (options.global) {
+  if (major >= 20 || (major === 18 && minor >= 18)) {
+    args.push('--import', resolve(bindir, 'preload.js'))
+  } else {
+    throw new Error('Option --global requires Node.js >= v18.18.0')
+  }
+}
+
+if (options.typescript) {
+  if (major >= 22 || (major === 20 && minor >= 6) || (major === 18 && minor >= 18)) {
+    args.push('--import', '@swc-node/register/esm-register')
+  } else {
+    throw new Error('Option --typescript requires Node.js >=20.6.0 || 18 >=18.18.0')
+  }
+}
+
+if (major === 18 || major === 20) {
+  // We need to expand glob patterns for these
+  args.push(...(await glob(patterns)))
+} else if (major >= 22) {
+  // Yay we have native glob support
+  args.push(...patterns)
+} else {
+  throw new Error('Unreachable')
+}
+
+assert(program && ['node', c8].includes(program))
+const node = spawn(program, args, { stdio: 'inherit' })
+
+node.on('close', (code) => {
+  process.exitCode = code
+})

package/bin/preload.js

@@ -0,0 +1,3 @@
+import * as testUtils from '../src/index.js'
+
+Object.assign(globalThis, testUtils)

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@exodus/test",
+  "version": "1.0.0-rc.0",
+  "author": "Exodus Movement, Inc.",
+  "description": "A test suite runner",
+  "homepage": "https://github.com/ExodusMovement/exodus-hydra/tree/master/libraries/test",
+  "bugs": {
+    "url": "https://github.com/ExodusMovement/exodus-hydra/issues?q=is%3Aissue+is%3Aopen+label%3Aexodus-test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ExodusMovement/exodus-hydra.git"
+  },
+  "keywords": [
+    "test",
+    "expect",
+    "jest",
+    "node-test"
+  ],
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "restricted"
+  },
+  "type": "module",
+  "bin": {
+    "exodus-test": "bin/index.js"
+  },
+  "main": "src/index.js",
+  "files": [
+    "bin/preload.js",
+    "!__tests__",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "test": "exodus-test --global --typescript",
+    "lint": "run -T eslint ."
+  },
+  "dependencies": {
+    "@swc-node/register": "^1.8.0",
+    "c8": "^9.1.0",
+    "expect": "^29.7.0",
+    "fast-glob": "^3.2.11"
+  }
+}

package/src/index.js

@@ -0,0 +1,119 @@
+import { mock, describe, test, it } from 'node:test'
+import { expect } from 'expect'
+import assert from 'node:assert/strict'
+
+const MockFunctionContext = mock.fn().mock.constructor
+
+Object.defineProperty(MockFunctionContext.prototype, 'callsArguments', {
+  get() {
+    return this.calls.map((call) => call.arguments)
+  },
+})
+
+const mockImplementationOrig = MockFunctionContext.prototype.mockImplementation
+MockFunctionContext.prototype.mockImplementation = function (...args) {
+  mockImplementationOrig.call(this, ...args)
+  return this
+}
+
+MockFunctionContext.prototype.mockRestore = MockFunctionContext.prototype.restore
+
+const makeEach = (impl) => (list) => (template, fn) => {
+  for (const args of list) {
+    let name = template
+
+    if (!args || typeof args === 'string' || typeof args === 'number') {
+      name = name.replace('%s', args)
+    } else {
+      for (const [key, value] of Object.entries(args)) {
+        name = name.replace(`$${key}`, value) // can collide but we don't care much yet
+      }
+
+      if (Array.isArray(args)) {
+        for (const arg of args) name = name.replace('%s', arg)
+      }
+    }
+
+    impl(name, () => (Array.isArray(args) ? fn(...args) : fn(args)))
+  }
+}
+
+describe.each = makeEach(describe)
+test.each = makeEach(test)
+it.each = makeEach(it)
+
+const jest = {
+  fn: (...args) => mock.fn(...args),
+  spyOn: (obj, name) => {
+    assert(Object.hasOwn(obj, name))
+    // eslint-disable-next-line @exodus/mutable/no-param-reassign-prop-only
+    obj[name] = mock.fn(obj[name])
+    return obj[name].mock
+  },
+  useFakeTimers: () => {
+    mock.timers.enable()
+  },
+  runAllTimers: () => {
+    mock.timers.tick(100_000_000_000) // > 3 years
+  },
+  advanceTimersByTime: (time) => {
+    mock.timers.tick(time)
+  },
+}
+
+expect.extend({
+  toHaveBeenCalled: (fn) => {
+    assert.equal(fn?.mock?.constructor, MockFunctionContext)
+    return { pass: fn.mock.callCount() > 0 }
+  },
+  toHaveBeenCalledTimes: (fn, count) => {
+    assert.equal(fn?.mock?.constructor, MockFunctionContext)
+    return { pass: fn.mock.callCount() === count }
+  },
+  toHaveBeenCalledWith: (fn, ...expected) => {
+    assert.equal(fn?.mock?.constructor, MockFunctionContext)
+    for (const call of fn.mock.calls) {
+      try {
+        expect(call.arguments).toEqual(expected)
+        return { pass: true }
+      } catch {}
+    }
+
+    return { pass: false }
+  },
+  toHaveBeenLastCalledWith: (fn, ...expected) => {
+    assert.equal(fn?.mock?.constructor, MockFunctionContext)
+    try {
+      expect(fn.mock.calls.at(-1).arguments).toEqual(expected)
+      return { pass: true }
+    } catch (e) {
+      return { pass: false, message: () => e.message }
+    }
+  },
+})
+
+function tap(name, fn) {
+  test(name, () =>
+    fn({
+      ...assert,
+      end: () => {},
+    })
+  )
+}
+
+export { tap, jest }
+export { expect } from 'expect'
+export {
+  mock,
+  beforeEach,
+  before,
+  afterEach,
+  after,
+  before as beforeAll,
+  after as afterAll,
+  describe,
+  test,
+  it,
+} from 'node:test'
+
+export { default as assert } from 'node:assert/strict'