@toa.io/core 1.0.0-alpha.272 → 1.0.0-alpha.277

package/test/connector.test.js

@@ -1,8 +1,9 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { timeout } = require('@toa.io/generic')
+import { timeout } from '@toa.io/generic'
 
-const fixtures = require('./connector.fixtures')
+import * as fixtures from './connector.fixtures.js'
 
 let sequence
 
@@ -19,14 +20,14 @@ describe('callbacks', () => {
 
   it('should call connection', async () => {
     await a.connect()
-    expect(sequence).toEqual(['+a'])
+    assert.deepStrictEqual(sequence, ['+a'])
   })
 
   it('should call disconnection', async () => {
     await a.connect()
     await a.disconnect()
 
-    expect(sequence.indexOf('+a')).toBeLessThan(sequence.indexOf('-a'))
+    assert.ok(sequence.indexOf('+a') < sequence.indexOf('-a'))
   })
 
   it('should reconnect', async () => {
@@ -34,7 +35,7 @@ describe('callbacks', () => {
     await a.reconnect()
     await a.reconnect()
 
-    expect(sequence).toEqual(['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
+    assert.deepStrictEqual(sequence, ['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
   })
 })
 
@@ -57,9 +58,9 @@ describe('dependencies', () => {
 
     await a.connect()
 
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+b'))
+    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+d') < sequence.indexOf('+a'))
   })
 
   it('should wait array of connectors', async () => {
@@ -69,10 +70,10 @@ describe('dependencies', () => {
 
     await a.connect()
 
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+b'))
+    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+d'))
+    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+d') < sequence.indexOf('+a'))
   })
 
   it('should wait array(1) of connectors', async () => {
@@ -81,12 +82,12 @@ describe('dependencies', () => {
 
     await a.connect()
 
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+b'))
+    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
   })
 
   it('should throw on empty array', async () => {
-    expect(() => a.depends([])).toThrow(/must not be empty/)
+    assert.throws(() => a.depends([]), (error) => /must not be empty/.test(error.message))
   })
 
   it('should await 2-way dependencies', async () => {
@@ -95,12 +96,12 @@ describe('dependencies', () => {
 
     await a.connect()
 
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+d') < sequence.indexOf('+a'))
 
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+d'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
+    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+d'))
+    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+d'))
   })
 
   it('should disconnect before dependencies', async () => {
@@ -110,9 +111,9 @@ describe('dependencies', () => {
     await a.connect()
     await a.disconnect()
 
-    expect(sequence.indexOf('-a')).toBeLessThan(sequence.indexOf('-b'))
-    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-c'))
-    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-d'))
+    assert.ok(sequence.indexOf('-a') < sequence.indexOf('-b'))
+    assert.ok(sequence.indexOf('-b') < sequence.indexOf('-c'))
+    assert.ok(sequence.indexOf('-b') < sequence.indexOf('-d'))
   })
 
   it('should call disconnected', async () => {
@@ -121,10 +122,10 @@ describe('dependencies', () => {
 
     await a.disconnect()
 
-    expect(sequence.indexOf('*c')).toBeLessThan(sequence.indexOf('*b'))
-    expect(sequence.indexOf('*b')).toBeLessThan(sequence.indexOf('*a'))
-    expect(sequence.indexOf('*d')).toBeLessThan(sequence.indexOf('*b'))
-    expect(sequence.indexOf('*a')).toBe(sequence.length - 1)
+    assert.ok(sequence.indexOf('*c') < sequence.indexOf('*b'))
+    assert.ok(sequence.indexOf('*b') < sequence.indexOf('*a'))
+    assert.ok(sequence.indexOf('*d') < sequence.indexOf('*b'))
+    assert.strictEqual(sequence.indexOf('*a'), sequence.length - 1)
   })
 
   it('should disconnect if no parents left', async () => {
@@ -134,19 +135,19 @@ describe('dependencies', () => {
     await a.connect()
     await b.connect()
 
-    expect(sequence).toEqual(['+c', '+a', '+b'])
+    assert.deepStrictEqual(sequence, ['+c', '+a', '+b'])
 
     await a.disconnect()
 
-    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a'])
+    assert.deepStrictEqual(sequence, ['+c', '+a', '+b', '-a', '*a'])
 
     await b.disconnect()
 
-    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a', '-b', '-c', '*c', '*b'])
+    assert.deepStrictEqual(sequence, ['+c', '+a', '+b', '-a', '*a', '-b', '-c', '*c', '*b'])
   })
 
   it('should throw if depends not on Connector', async () => {
-    expect(() => a.depends({})).toThrow()
+    assert.throws(() => a.depends({}))
   })
 
   it('should disconnect while still connecting', async () => {
@@ -159,11 +160,11 @@ describe('dependencies', () => {
     while (b.connected !== true) await timeout(1)
 
     // `a` never connects, and disconnecting must not wait for it to
-    expect(a.connected).toStrictEqual(false)
+    assert.deepStrictEqual(a.connected, false)
 
     await a.disconnect()
 
-    expect(sequence).toEqual(['+b', '-b', '*b', '*a'])
+    assert.deepStrictEqual(sequence, ['+b', '-b', '*b', '*a'])
   })
 
   describe('errors', () => {
@@ -176,21 +177,21 @@ describe('dependencies', () => {
     it('should disconnect on fail', async () => {
       f.depends(b).depends(c)
 
-      await expect(f.connect()).rejects.toThrow('FailingConnector')
-      expect(sequence).toEqual(['+c', '+b', '-b', '-c', '*c', '*b'])
+      await assert.rejects(f.connect(), (error) => /FailingConnector/.test(error.message))
+      assert.deepStrictEqual(sequence, ['+c', '+b', '-b', '-c', '*c', '*b'])
     })
 
     it('should interrupt connection chain', async () => {
       a.depends(f).depends(c)
       f.depends(d)
 
-      await expect(a.connect()).rejects.toThrow('FailingConnector')
+      await assert.rejects(a.connect(), (error) => /FailingConnector/.test(error.message))
 
-      expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('-c'))
-      expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('-d'))
+      assert.ok(sequence.indexOf('+c') < sequence.indexOf('-c'))
+      assert.ok(sequence.indexOf('+d') < sequence.indexOf('-d'))
 
-      expect(sequence.indexOf('+a')).toBe(-1)
-      expect(sequence.indexOf('-a')).toBe(-1)
+      assert.strictEqual(sequence.indexOf('+a'), -1)
+      assert.strictEqual(sequence.indexOf('-a'), -1)
     })
   })
 })

package/test/context.fixtures.js

@@ -1,18 +1,14 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { Connector } = require('../src/connector')
+import { Connector } from '../src/connector.js'
 
-const local = {
-  link: jest.fn()
+export const local = {
+  link: mock.fn()
 }
 
-const discover = jest.fn(() => ({
-  invoke: jest.fn(),
-  link: jest.fn()
+export const discover = mock.fn(() => ({
+  invoke: mock.fn(),
+  link: mock.fn()
 }))
 
-const aspects = [new Connector(), new Connector()]
-
-exports.local = local
-exports.discover = discover
-exports.aspects = aspects
+export const aspects = [new Connector(), new Connector()]

package/test/context.test.js

@@ -1,20 +1,21 @@
-'use strict'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
 
-const fixtures = require('./context.fixtures')
-const { Context } = require('../src/context')
+import * as fixtures from './context.fixtures.js'
+import { Context } from '../src/context.js'
 
 /** @type {toa.core.Context} */
 let context
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 
   context = new Context(fixtures.local, fixtures.discover, fixtures.aspects)
 })
 
 it('should expose aspects', () => {
-  expect(context.aspects).toBeDefined()
-  expect(context.aspects).toStrictEqual(fixtures.aspects)
+  assert.notStrictEqual(context.aspects, undefined)
+  assert.deepStrictEqual(context.aspects, fixtures.aspects)
 })
 
 describe('call', () => {
@@ -24,6 +25,16 @@ describe('call', () => {
     await context.call('a', 'b', 'c', request)
     await context.call('a', 'b', 'c', request)
 
-    expect(fixtures.discover).toHaveBeenCalledTimes(1)
+    assert.strictEqual(fixtures.discover.mock.callCount(), 1)
   })
 })
+
+function resetCalls (target = [assert, fixtures], seen = new Set()) {
+  if (target === null || typeof target !== 'object' || seen.has(target)) return
+
+  seen.add(target)
+
+  for (const value of Object.values(target))
+    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
+    else resetCalls(value, seen)
+}

package/test/contract/conditions.test.js

@@ -1,9 +1,11 @@
-'use strict'
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const { Contract } = require('../../src/contract/contract')
-const fixtures = require('./contract.fixtures')
+import { Contract } from '../../src/contract/contract.js'
+import * as fixtures from './contract.fixtures.js'
 
 let contract
 
@@ -16,11 +18,11 @@ it('should fit value', () => {
 
   contract.fit(value)
 
-  expect(fixtures.schema.fit).toHaveBeenCalledWith(value)
+  assert.ok(fixtures.schema.fit.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], value)))
 })
 
 it('should throw on invalid value', () => {
   const value = { invalid: true }
 
-  expect(() => contract.fit(value)).toThrow()
+  assert.throws(() => contract.fit(value))
 })

package/test/contract/contract.fixtures.js

@@ -1,33 +1,29 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
-const { load } = require('@toa.io/yaml')
-const { resolve } = require('path')
+import { generate } from 'randomstring'
+import { readFileSync } from 'node:fs'
+import { load as parseYAML } from 'js-yaml'
+import { resolve } from 'path'
 
 // noinspection JSCheckFunctionSignatures
-const schema = {
-  fit: jest.fn((input) => (input.invalid ? { message: generate() } : null))
+export const schema = {
+  fit: mock.fn((input) => (input.invalid ? { message: generate() } : null))
 }
 
-const query = {
-  parse: jest.fn(() => ({ [generate()]: generate() }))
+export const query = {
+  parse: mock.fn(() => ({ [generate()]: generate() }))
 }
 
-const declaration = {}
+export const declaration = {}
 
-const schemas = {
+export const schemas = {
   request: {
     type: 'object',
     properties: {
       input: { type: 'null' },
-      query: load.sync(resolve(__dirname, '../../src/contract/schemas/query.yaml')),
+      query: parseYAML(readFileSync(resolve(import.meta.dirname, '../../src/contract/schemas/query.yaml'), 'utf8')),
       authentic: { type: 'boolean' }
     },
     additionalProperties: true
   }
 }
-
-exports.schema = schema
-exports.query = query
-exports.declaration = declaration
-exports.schemas = schemas

package/test/contract/request.test.js

@@ -1,18 +1,23 @@
-'use strict'
+import * as schemas from '@toa.io/schemas'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
+import clone from 'clone-deep'
+import { generate } from 'randomstring'
 
-jest.mock('../../src/contract/contract')
+import { Request } from '../../src/contract/request.js'
+import { Contract } from '../../src/contract/contract.js'
+import * as fixtures from './contract.fixtures.js'
 
-const { Request } = require('../../src/contract/request')
-const { Contract } = require('../../src/contract/contract')
-const fixtures = require('./contract.fixtures')
+// the base is real; what it was constructed with and told to fit is observable
+const fit = mock.method(Contract.prototype, 'fit', () => undefined)
 
 let contract
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  fit.mock.resetCalls()
 
   contract = new Request(fixtures.schema, {})
 })
@@ -20,8 +25,8 @@ beforeEach(() => {
 const dummy = { schema: { properties: {} } }
 
 it('should extend Conditions', () => {
-  expect(contract).toBeInstanceOf(Contract)
-  expect(Contract).toHaveBeenCalledWith(fixtures.schema)
+  assert.ok(contract instanceof Contract)
+  assert.strictEqual(contract.schema, fixtures.schema)
 })
 
 it('should fit request', () => {
@@ -29,7 +34,8 @@ it('should fit request', () => {
 
   contract.fit(request)
 
-  expect(Contract.mock.instances[0].fit).toHaveBeenCalledWith(request)
+  assert.ok(fit.mock.calls.some((call) =>
+    call.this === contract && isDeepStrictEqual(call.arguments[0], request)))
 })
 
 describe('schema', () => {
@@ -40,79 +46,74 @@ describe('schema', () => {
   })
 
   it('should provide schema', () => {
-    expect(Request.schema({}, dummy)).toBeDefined()
+    assert.notStrictEqual(Request.schema({}, dummy), undefined)
   })
 
   it('should add required input if defined', () => {
     const input = { type: 'number' }
 
-    expect(Request.schema({ input }, dummy).properties.input).toStrictEqual(input)
+    assert.deepStrictEqual(Request.schema({ input }, dummy).properties.input, input)
   })
 
   it('should set input as null if undefined', async () => {
-    expect(Request.schema({}, dummy).properties.input).toStrictEqual({ type: 'null' })
+    assert.deepStrictEqual(Request.schema({}, dummy).properties.input, { type: 'null' })
   })
 
   it('should contain query if declaration.query is not defined', () => {
-    expect(Request.schema({}, dummy).properties.query).toBeDefined()
+    assert.notStrictEqual(Request.schema({}, dummy).properties.query, undefined)
   })
 
   it('should not contain query if declaration.query is false', () => {
     schema.properties.query = { type: 'null' }
-    expect(Request.schema({ query: false }, dummy)).toMatchObject(schema)
+    assert.partialDeepStrictEqual(Request.schema({ query: false }, dummy), schema)
   })
 
   it('should require query if declaration.query is true', () => {
     schema.required = ['query']
-    expect(Request.schema({ query: true }, dummy).required).toStrictEqual(expect.arrayContaining(['query']))
+    assert.ok(['query'].every((item) => Request.schema({ query: true }, dummy).required.some((candidate) => isDeepStrictEqual(candidate, item))))
   })
 
   it('should forbid projection for non observations', () => {
-    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.projection)
-      .toBe(undefined)
+    assert.strictEqual(Request.schema({ type: 'transition' }, dummy).properties.query.properties.projection, undefined)
 
-    expect(Request.schema({ type: 'assignment' }, dummy).properties.query.properties.projection)
-      .toBe(undefined)
+    assert.strictEqual(Request.schema({ type: 'assignment' }, dummy).properties.query.properties.projection, undefined)
 
-    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.projection)
-      .toBeDefined()
+    assert.notStrictEqual(Request.schema({ type: 'observation' }, dummy).properties.query.properties.projection, undefined)
   })
 
   it('should forbid version for observations', () => {
-    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.version)
-      .toBeDefined()
+    assert.notStrictEqual(Request.schema({ type: 'transition' }, dummy).properties.query.properties.version, undefined)
 
-    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.version)
-      .toBe(undefined)
+    assert.strictEqual(Request.schema({ type: 'observation' }, dummy).properties.query.properties.version, undefined)
   })
 
   it('should allow omit, limit only for set observations', () => {
     const schema = Request.schema({ type: 'transition' }, dummy)
     const transition = schema.properties.query.properties
 
-    expect(transition.omit).toBeUndefined()
-    expect(transition.limit).toBeUndefined()
+    assert.strictEqual(transition.omit, undefined)
+    assert.strictEqual(transition.limit, undefined)
 
     const object = Request.schema({
       type: 'observation',
       scope: 'object'
     }, dummy).properties.query.properties
 
-    expect(object.omit).toBeUndefined()
-    expect(object.limit).toBeUndefined()
+    assert.strictEqual(object.omit, undefined)
+    assert.strictEqual(object.limit, undefined)
 
     const objects = Request.schema({
       type: 'observation',
       scope: 'objects'
     }, dummy).properties.query.properties
 
-    expect(objects.omit).toBeDefined()
-    expect(objects.limit).toBeDefined()
+    assert.notStrictEqual(objects.omit, undefined)
+    assert.notStrictEqual(objects.limit, undefined)
   })
 })
 
 describe('source', () => {
-  const schemas = require('@toa.io/schemas')
+
 
   const compile = (definition, entity) =>
     schemas.schema(Request.schema(definition, entity), { removeAdditional: true })
@@ -120,8 +121,8 @@ describe('source', () => {
   it('should declare source', () => {
     const schema = Request.schema({}, dummy)
 
-    expect(schema.properties.source).toBeDefined()
-    expect(schema.properties.source.additionalProperties).toStrictEqual(false)
+    assert.notStrictEqual(schema.properties.source, undefined)
+    assert.deepStrictEqual(schema.properties.source.additionalProperties, false)
   })
 
   it('should pass known source variants', () => {
@@ -134,8 +135,8 @@ describe('source', () => {
     ]) {
       const request = { input: null, query: null, source }
 
-      expect(schema.fit(request)).toStrictEqual(null)
-      expect(request.source).toStrictEqual(source)
+      assert.deepStrictEqual(schema.fit(request), null)
+      assert.deepStrictEqual(request.source, source)
     }
   })
 
@@ -145,7 +146,17 @@ describe('source', () => {
     const schema = compile({}, undefined)
     const request = { input: null, query: null, source: { service: 'exposition', evil: 'x' } }
 
-    expect(schema.fit(request)).toStrictEqual(null)
-    expect(request.source).toStrictEqual({ service: 'exposition' })
+    assert.deepStrictEqual(schema.fit(request), null)
+    assert.deepStrictEqual(request.source, { service: 'exposition' })
   })
 })
+
+function resetCalls (target = [assert, clone, fixtures, dummy], seen = new Set()) {
+  if (target === null || typeof target !== 'object' || seen.has(target)) return
+
+  seen.add(target)
+
+  for (const value of Object.values(target))
+    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
+    else resetCalls(value, seen)
+}

package/test/discovery.test.js

@@ -1,11 +1,13 @@
-'use strict'
+import { it, beforeEach, afterEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { console } = require('openspan')
-const { Connector } = require('../src/connector')
-const { Discovery } = require('../src/discovery')
+import { console } from 'openspan'
+import { Connector } from '../src/connector.js'
+import { Discovery } from '../src/discovery.js'
 
 class Lookup extends Connector {
-  invoke = jest.fn(async () => ({ operations: {} }))
+  invoke = mock.fn(async () => ({ operations: {} }))
 }
 
 /** @type {Lookup} */
@@ -14,15 +16,15 @@ let lookup
 /** @type {Discovery} */
 let discovery
 
-/** @type {jest.SpyInstance} */
+/** @type {import('node:test').Mock<any>} */
 let warn
 
 const locator = { id: 'dummies.one' }
 
 beforeEach(async () => {
-  jest.useFakeTimers()
+  mock.timers.enable()
 
-  warn = jest.spyOn(console, 'warn').mockImplementation(() => undefined)
+  warn = mock.method(console, 'warn', () => undefined)
   lookup = new Lookup()
   discovery = new Discovery(async () => lookup)
 
@@ -30,27 +32,33 @@ beforeEach(async () => {
 })
 
 afterEach(() => {
-  warn.mockRestore()
-  jest.useRealTimers()
+  warn.mock.restore()
+  mock.timers.reset()
 })
 
 it('should not warn if a lookup is answered', async () => {
   await discovery.lookup(locator)
 
-  jest.advanceTimersByTime(60_000)
+  mock.timers.tick(60_000)
 
-  expect(warn).not.toHaveBeenCalled()
+  assert.strictEqual(warn.mock.callCount(), 0)
 })
 
 it('should keep warning while a lookup is unanswered', async () => {
-  lookup.invoke.mockImplementation(() => new Promise(() => undefined))
+  lookup.invoke.mock.mockImplementation(() => new Promise(() => undefined))
 
   void discovery.lookup(locator)
 
-  await jest.advanceTimersByTimeAsync(12_000)
+  // the interval is set after the lookup is resolved, so it has to exist
+  // before time is advanced
+  await new Promise((resolve) => process.nextTick(resolve))
 
-  expect(warn).toHaveBeenCalledTimes(2)
+  // node:test moves the clock before running the callbacks it releases, so the
+  // elapsed time each warning reports is only right when time advances by steps
+  mock.timers.tick(5_000)
+  mock.timers.tick(5_000)
 
-  expect(warn).toHaveBeenLastCalledWith('Waiting for lookup response',
-    { component: locator.id, waiting: 10 })
+  assert.strictEqual(warn.mock.callCount(), 2)
+
+  assert.ok(((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], 'Waiting for lookup response') && isDeepStrictEqual(call.arguments[1], { component: locator.id, waiting: 10 }))(warn.mock.calls.at(-1) ?? { arguments: [] }))
 })

package/test/emission.fixtures.js

@@ -1,16 +1,13 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
 // noinspection JSCheckFunctionSignatures
-const events = [0, 1, 2].map((index) => ({
-  emit: jest.fn(async (state) => ({ ...state, event: index }))
+export const events = [0, 1, 2].map((index) => ({
+  emit: mock.fn(async (state) => ({ ...state, event: index }))
 }))
 
-const event = {
+export const event = {
   origin: { [generate()]: generate() },
   state: { [generate()]: generate() }
 }
-
-exports.events = events
-exports.event = event