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

package/test/locator.test.js

@@ -1,7 +1,8 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { generate } = require('randomstring')
-const { Locator } = require('../src/locator')
+import { generate } from 'randomstring'
+import { Locator } from '../src/locator.js'
 
 /** @type {string} */
 let name
@@ -20,37 +21,37 @@ beforeEach(() => {
 })
 
 it('should expose name and namespace', () => {
-  expect(locator.name).toStrictEqual(name)
-  expect(locator.namespace).toStrictEqual(namespace)
+  assert.deepStrictEqual(locator.name, name)
+  assert.deepStrictEqual(locator.namespace, namespace)
 })
 
 it('should expose id, label', () => {
   const id = locator.namespace + '.' + locator.name
   const label = locator.namespace.toLowerCase() + '-' + locator.name.toLowerCase()
 
-  expect(locator.id).toStrictEqual(id)
-  expect(locator.label).toStrictEqual(label)
+  assert.deepStrictEqual(locator.id, id)
+  assert.deepStrictEqual(locator.label, label)
 })
 
 it('should expose uppercase', () => {
-  expect(locator.uppercase).toStrictEqual((locator.namespace + '_' + locator.name).toUpperCase())
+  assert.deepStrictEqual(locator.uppercase, (locator.namespace + '_' + locator.name).toUpperCase())
 })
 
 it('should throw if name is undefined', () => {
-  expect(() => new Locator(undefined, namespace)).toThrow(TypeError)
+  assert.throws(() => new Locator(undefined, namespace), TypeError)
 
   // noinspection JSCheckFunctionSignatures
-  expect(() => new Locator()).toThrow(TypeError)
+  assert.throws(() => new Locator(), TypeError)
 })
 
 it('should expose host', () => {
-  expect(locator.hostname()).toStrictEqual((namespace + '-' + name).toLowerCase())
+  assert.deepStrictEqual(locator.hostname(), (namespace + '-' + name).toLowerCase())
 })
 
 it('should expose host with given prefix', () => {
   const prefix = generate()
 
-  expect(locator.hostname(prefix)).toStrictEqual((prefix + '-' + namespace + '-' + name).toLowerCase())
+  assert.deepStrictEqual(locator.hostname(prefix), (prefix + '-' + namespace + '-' + name).toLowerCase())
 })
 
 describe('global', () => {
@@ -61,28 +62,28 @@ describe('global', () => {
   it('should not throw', () => undefined)
 
   it('should expose id', () => {
-    expect(locator.id).toStrictEqual(name)
+    assert.deepStrictEqual(locator.id, name)
   })
 
   it('should expose label', () => {
-    expect(locator.label).toStrictEqual(name.toLowerCase())
+    assert.deepStrictEqual(locator.label, name.toLowerCase())
   })
 
   it('should expose uppercase', () => {
-    expect(locator.uppercase).toStrictEqual(name.toUpperCase())
+    assert.deepStrictEqual(locator.uppercase, name.toUpperCase())
   })
 
   it('should expose hostname', () => {
     const type = generate()
 
-    expect(locator.hostname(type)).toStrictEqual((type + '-' + name).toLowerCase())
-    expect(locator.hostname()).toStrictEqual(name.toLowerCase())
+    assert.deepStrictEqual(locator.hostname(type), (type + '-' + name).toLowerCase())
+    assert.deepStrictEqual(locator.hostname(), name.toLowerCase())
   })
 })
 
 describe('parse', () => {
   it('should be', async () => {
-    expect(Locator.parse).toBeInstanceOf(Function)
+    assert.ok(Locator.parse instanceof Function)
   })
 
   const namespace = generate()
@@ -92,22 +93,22 @@ describe('parse', () => {
   it('should parse id', async () => {
     const locator = Locator.parse(id)
 
-    expect(locator.namespace).toStrictEqual(namespace)
-    expect(locator.name).toStrictEqual(name)
+    assert.deepStrictEqual(locator.namespace, namespace)
+    assert.deepStrictEqual(locator.name, name)
   })
 
   it('should parse endpoint', async () => {
     const endpoint = `${id}.${generate()}`
     const locator = Locator.parse(endpoint)
 
-    expect(locator.namespace).toStrictEqual(namespace)
-    expect(locator.name).toStrictEqual(name)
+    assert.deepStrictEqual(locator.namespace, namespace)
+    assert.deepStrictEqual(locator.name, name)
   })
 
   it('should parse token as global', async () => {
     const locator = Locator.parse(name)
 
-    expect(locator.namespace).toBeUndefined()
-    expect(locator.name).toStrictEqual(name)
+    assert.strictEqual(locator.namespace, undefined)
+    assert.deepStrictEqual(locator.name, name)
   })
 })

package/test/outbox.test.js

@@ -1,6 +1,7 @@
-'use strict'
+import { it, beforeEach, afterEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { Outbox } = require('../src/outbox')
+import { Outbox } from '../src/outbox/index.js'
 
 let emission, storage, atom, outbox
 
@@ -14,101 +15,107 @@ const page = (from, count) =>
   }))
 
 beforeEach(() => {
-  jest.clearAllMocks()
-  jest.useFakeTimers()
+  resetCalls()
+  mock.timers.enable()
 
-  emission = { emit: jest.fn(async () => undefined), link: jest.fn() }
+  emission = { emit: mock.fn(async () => undefined), link: mock.fn() }
 
   storage = {
-    link: jest.fn(),
+    link: mock.fn(),
     outbox: {
-      pending: jest.fn(async () => []),
-      settle: jest.fn(async () => undefined)
+      pending: mock.fn(async () => []),
+      settle: mock.fn(async () => undefined)
     }
   }
 
-  atom = { slots: jest.fn(() => [0]), link: jest.fn() }
+  atom = { slots: mock.fn(() => [0]), link: mock.fn() }
   outbox = new Outbox(emission, storage, atom, { interval: 1000, batch: BATCH })
 })
 
 afterEach(() => {
-  jest.useRealTimers()
+  mock.timers.reset()
 })
 
 /** one cycle, and everything it awaited */
 const cycle = async () => {
-  jest.advanceTimersByTime(1000)
+  mock.timers.tick(1000)
 
   for (let i = 0; i < 20; i++) await Promise.resolve()
 }
 
 it('should read nothing more when the first page is short', async () => {
-  storage.outbox.pending.mockResolvedValueOnce(page(0, 3))
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, 3))
 
   await outbox.open()
   await cycle()
 
-  expect(storage.outbox.pending).toHaveBeenCalledTimes(1)
-  expect(emission.emit).toHaveBeenCalledTimes(3)
+  assert.strictEqual(storage.outbox.pending.mock.callCount(), 1)
+  assert.strictEqual(emission.emit.mock.callCount(), 3)
 })
 
 it('should keep reading while a page comes back full', async () => {
-  storage.outbox.pending
-    .mockResolvedValueOnce(page(0, BATCH))
-    .mockResolvedValueOnce(page(BATCH, BATCH))
-    .mockResolvedValueOnce(page(2 * BATCH, 5))
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, BATCH), storage.outbox.pending.mock.callCount())
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(BATCH, BATCH), storage.outbox.pending.mock.callCount() + 1)
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(2 * BATCH, 5), storage.outbox.pending.mock.callCount() + 2)
 
   await outbox.open()
   await cycle()
 
-  expect(storage.outbox.pending).toHaveBeenCalledTimes(3)
-  expect(emission.emit).toHaveBeenCalledTimes(2 * BATCH + 5)
+  assert.strictEqual(storage.outbox.pending.mock.callCount(), 3)
+  assert.strictEqual(emission.emit.mock.callCount(), 2 * BATCH + 5)
 })
 
 it('should continue each page from the id the one before ended on', async () => {
-  storage.outbox.pending
-    .mockResolvedValueOnce(page(0, BATCH))
-    .mockResolvedValueOnce(page(BATCH, 1))
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, BATCH), storage.outbox.pending.mock.callCount())
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(BATCH, 1), storage.outbox.pending.mock.callCount() + 1)
 
   await outbox.open()
   await cycle()
 
   const [, second] = storage.outbox.pending.mock.calls
 
-  expect(storage.outbox.pending.mock.calls[0][3]).toBeUndefined()
-  expect(second[3]).toStrictEqual(String(BATCH - 1).padStart(4, '0'))
+  assert.strictEqual(storage.outbox.pending.mock.calls[0].arguments[3], undefined)
+  assert.deepStrictEqual(second.arguments[3], String(BATCH - 1).padStart(4, '0'))
 })
 
 it('should mark what it published, once, after the last page', async () => {
-  storage.outbox.pending
-    .mockResolvedValueOnce(page(0, BATCH))
-    .mockResolvedValueOnce(page(BATCH, 2))
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, BATCH), storage.outbox.pending.mock.callCount())
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(BATCH, 2), storage.outbox.pending.mock.callCount() + 1)
 
   await outbox.open()
   await cycle()
 
-  expect(storage.outbox.settle).toHaveBeenCalledTimes(1)
-  expect(storage.outbox.settle.mock.calls[0][0]).toHaveLength(BATCH + 2)
+  assert.strictEqual(storage.outbox.settle.mock.callCount(), 1)
+  assert.strictEqual(storage.outbox.settle.mock.calls[0].arguments[0].length, BATCH + 2)
 })
 
 it('should not publish a row it has published and not yet marked', async () => {
-  storage.outbox.settle.mockRejectedValueOnce(new Error('mongo is out'))
-  storage.outbox.pending
-    .mockResolvedValueOnce(page(0, 2))
-    .mockResolvedValueOnce(page(0, 2))
+  storage.outbox.settle.mock.mockImplementationOnce(async () => { throw new Error('mongo is out') })
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, 2), storage.outbox.pending.mock.callCount())
+  storage.outbox.pending.mock.mockImplementationOnce(async () => page(0, 2), storage.outbox.pending.mock.callCount() + 1)
 
   await outbox.open()
   await cycle()
   await cycle()
 
-  expect(emission.emit).toHaveBeenCalledTimes(2)
+  assert.strictEqual(emission.emit.mock.callCount(), 2)
 })
 
 it('should read nothing while it owns no slots', async () => {
-  atom.slots.mockReturnValue(null)
+  atom.slots.mock.mockImplementation(() => null)
 
   await outbox.open()
   await cycle()
 
-  expect(storage.outbox.pending).not.toHaveBeenCalled()
+  assert.strictEqual(storage.outbox.pending.mock.callCount(), 0)
 })
+
+function resetCalls (target = [assert, BATCH, page, cycle], 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/query.fixtures.js

@@ -1,6 +1,4 @@
-'use strict'
-
-const samples = {
+export const samples = {
   simple: {
     query: {
       criteria: 'name==Eddie'
@@ -96,5 +94,3 @@ const samples = {
     }
   }
 }
-
-exports.samples = samples

package/test/query.test.js

@@ -1,10 +1,11 @@
-'use strict'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { Query } = require('../src/query')
-const fixtures = require('./query.fixtures')
+import { Query } from '../src/query.js'
+import * as fixtures from './query.fixtures.js'
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 })
 
 describe('criteria', () => {
@@ -12,14 +13,14 @@ describe('criteria', () => {
     const instance = new Query(fixtures.samples.simple.properties)
     const query = instance.parse({})
 
-    expect(query.criteria).toBeUndefined()
+    assert.strictEqual(query.criteria, undefined)
   })
 
   it('should parse criteria', () => {
     const instance = new Query(fixtures.samples.simple.properties)
     const query = instance.parse(fixtures.samples.simple.query)
 
-    expect(query.criteria).toEqual(fixtures.samples.simple.parsed.criteria)
+    assert.deepStrictEqual(query.criteria, fixtures.samples.simple.parsed.criteria)
   })
 
   it('should keep a parsed criteria', () => {
@@ -28,35 +29,35 @@ describe('criteria', () => {
     const first = instance.parse(fixtures.samples.simple.query).criteria
     const second = instance.parse(fixtures.samples.simple.query).criteria
 
-    expect(second).toBe(first)
+    assert.strictEqual(second, first)
   })
 
   it('should not keep an invalid criteria', () => {
     const instance = new Query(fixtures.samples.simple.properties)
     const query = { criteria: 'nonexistent==1' }
 
-    expect(() => instance.parse(query)).toThrow()
-    expect(() => instance.parse(query)).toThrow()
+    assert.throws(() => instance.parse(query))
+    assert.throws(() => instance.parse(query))
   })
 
   it('should parse criteria with type coercion', () => {
     const instance = new Query(fixtures.samples.extended.properties)
     const query = instance.parse(fixtures.samples.extended.query)
 
-    expect(query.criteria).toEqual(fixtures.samples.extended.parsed.criteria)
+    assert.deepStrictEqual(query.criteria, fixtures.samples.extended.parsed.criteria)
   })
 
   it('should throw on unknown properties', () => {
     const instance = new Query(fixtures.samples.simple.properties)
 
-    expect(() => instance.parse({ criteria: 'lastname==Johnson' })).toThrow(/not defined/)
+    assert.throws(() => instance.parse({ criteria: 'lastname==Johnson' }), (error) => /not defined/.test(error.message))
   })
 
   it('should parse id', () => {
     const instance = new Query(fixtures.samples.id.properties)
     const query = instance.parse({ ...fixtures.samples.id.query })
 
-    expect(query).toStrictEqual(fixtures.samples.id.parsed)
+    assert.deepStrictEqual(query, fixtures.samples.id.parsed)
   })
 })
 
@@ -66,7 +67,7 @@ describe('options', () => {
   it('should not throw if no options', () => {
     const query = instance.parse({})
 
-    expect(query.options).toBeUndefined()
+    assert.strictEqual(query.options, undefined)
   })
 
   describe('omit, limit', () => {
@@ -74,7 +75,7 @@ describe('options', () => {
       const input = { omit: 1, limit: 1 }
       const query = instance.parse(input)
 
-      expect(query.options).toStrictEqual(input)
+      assert.deepStrictEqual(query.options, input)
     })
   })
 
@@ -83,13 +84,13 @@ describe('options', () => {
       const sort = ['a', 'b:desc', 'c']
       const query = instance.parse({ sort })
 
-      expect(query.options.sort).toStrictEqual([['a', 'asc'], ['b', 'desc'], ['c', 'asc']])
+      assert.deepStrictEqual(query.options.sort, [['a', 'asc'], ['b', 'desc'], ['c', 'asc']])
     })
 
     it('should throw on unknown properties', () => {
       const sort = ['d:asc']
 
-      expect(() => instance.parse({ sort })).toThrow(/not defined/)
+      assert.throws(() => instance.parse({ sort }), (error) => /not defined/.test(error.message))
     })
   })
 
@@ -97,7 +98,17 @@ describe('options', () => {
     it('should throw on unknown properties', () => {
       const projection = ['a', 'b', 'c', 'd']
 
-      expect(() => instance.parse({ projection })).toThrow(/not defined/)
+      assert.throws(() => instance.parse({ projection }), (error) => /not defined/.test(error.message))
     })
   })
 })
+
+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/receiver.fixtures.js

@@ -1,24 +1,20 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const definition = /** @type {toa.norm.component.Receiver} */ {
+export const definition = /** @type {toa.norm.component.Receiver} */ {
   operation: generate(),
   conditioned: false,
   adaptive: false
 }
 
-const local = /** @type {toa.core.Component} */ {
+export const local = /** @type {toa.core.Component} */ {
   locator: { id: 'default.dummy' },
-  invoke: jest.fn()
+  invoke: mock.fn()
 }
 
 // noinspection JSCheckFunctionSignatures
-const bridge = /** @type {toa.core.bridges.Event} */ {
-  condition: jest.fn(async (payload) => !(payload.reject === true)),
-  request: jest.fn(async () => ({ input: generate() }))
+export const bridge = /** @type {toa.core.bridges.Event} */ {
+  condition: mock.fn(async (payload) => !(payload.reject === true)),
+  request: mock.fn(async () => ({ input: generate() }))
 }
-
-exports.definition = definition
-exports.local = local
-exports.bridge = bridge

package/test/receiver.test.js

@@ -1,15 +1,22 @@
-'use strict'
+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')
-const { merge } = require('@toa.io/generic')
+import clone from 'clone-deep'
+import { generate } from 'randomstring'
+import { merge } from '@toa.io/generic'
 
-jest.mock('../src/connector')
+import { Connector } from '../src/connector.js'
 
-const { Connector } = /** @type {{ Connector: jest.Mock<toa.core.Connector>}} */ require('../src/connector')
+// the fixtures are not connectors, so a dependency is recorded rather than linked
+const depends = mock.method(Connector.prototype, 'depends', () => undefined)
 
-const { Receiver } = require('../src/receiver')
-const fixtures = require('./receiver.fixtures')
+const dependencies = (instance) => depends.mock.calls
+  .filter((call) => call.this === instance)
+  .map((call) => call.arguments[0])
+
+import { Receiver } from '../src/receiver.js'
+import * as fixtures from './receiver.fixtures.js'
 
 /** @type {toa.core.Receiver} */
 let receiver
@@ -18,15 +25,16 @@ let receiver
 let definition
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  depends.mock.resetCalls()
 
   definition = clone(fixtures.definition)
   receiver = new Receiver(fixtures.definition, fixtures.local, fixtures.bridge)
 })
 
 it('should depend on local, bridge', () => {
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.local)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridge)
+  assert.ok(dependencies(receiver).some((one) => isDeepStrictEqual(one, fixtures.local)))
+  assert.ok(dependencies(receiver).some((one) => isDeepStrictEqual(one, fixtures.bridge)))
 })
 
 it('should apply', async () => {
@@ -34,11 +42,12 @@ it('should apply', async () => {
 
   await receiver.receive({ payload })
 
-  expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.operation, { input: payload })
+  assert.ok(fixtures.local.invoke.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], definition.operation) && isDeepStrictEqual(call.arguments[1], { input: payload })))
 })
 
-it.each([[false], [true]])('should pass UI extensions (adaptive: %s)', async (adaptive) => {
-  jest.clearAllMocks()
+for (const [adaptive] of [[false], [true]])
+   it(`should pass UI extensions (adaptive: ${adaptive})`, async () => {
+  resetCalls()
 
   definition.adaptive = adaptive
   receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
@@ -49,12 +58,12 @@ it.each([[false], [true]])('should pass UI extensions (adaptive: %s)', async (ad
 
   await receiver.receive(message)
 
-  const request = adaptive ? await fixtures.bridge.request.mock.results[0].value : { input: payload }
+  const request = adaptive ? await fixtures.bridge.request.mock.calls[0].result : { input: payload }
   const expected = merge(clone(request), extension)
 
-  const argument = fixtures.local.invoke.mock.calls[0][1]
+  const argument = fixtures.local.invoke.mock.calls[0].arguments[1]
 
-  expect(argument).toStrictEqual(expected)
+  assert.deepStrictEqual(argument, expected)
 })
 
 describe('conditioned', () => {
@@ -67,15 +76,15 @@ describe('conditioned', () => {
     const payload = { foo: 'bar' }
     await receiver.receive({ payload })
 
-    expect(fixtures.bridge.condition).toHaveBeenCalledWith(payload)
-    expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.operation, { input: payload })
+    assert.ok(fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], payload)))
+    assert.ok(fixtures.local.invoke.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], definition.operation) && isDeepStrictEqual(call.arguments[1], { input: payload })))
   })
 
   it('should not apply if condition is false', async () => {
     const payload = { reject: true }
     await receiver.receive({ payload })
 
-    expect(fixtures.local.invoke).not.toHaveBeenCalled()
+    assert.strictEqual(fixtures.local.invoke.mock.callCount(), 0)
   })
 })
 
@@ -89,7 +98,21 @@ describe('adaptive', () => {
     const payload = { reject: true }
     await receiver.receive({ payload })
 
-    expect(fixtures.local.invoke)
-      .toHaveBeenCalledWith(definition.operation, await fixtures.bridge.request.mock.results[0].value)
+    const request = await fixtures.bridge.request.mock.calls[0].result
+
+    assert.ok(fixtures.local.invoke.mock.calls.some((call) =>
+      call.arguments.length === 2 &&
+      isDeepStrictEqual(call.arguments[0], definition.operation) &&
+      isDeepStrictEqual(call.arguments[1], request)))
   })
 })
+
+function resetCalls (target = [assert, clone, 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/reflection.test.js

@@ -1,10 +1,11 @@
-'use strict'
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { generate } = require('randomstring')
-const { Reflection, Connector } = require('../')
+import { generate } from 'randomstring'
+import { Reflection, Connector } from '../src/index.js'
 
 it('should export', () => {
-  expect(Reflection).toBeDefined()
+  assert.notStrictEqual(Reflection, undefined)
 })
 
 /** @type {toa.core.Reflection<string>} */
@@ -20,11 +21,11 @@ beforeEach(() => {
 })
 
 it('should be a Connector', () => {
-  expect(reflection).toBeInstanceOf(Connector)
+  assert.ok(reflection instanceof Connector)
 })
 
 it('should reflect', async () => {
   await reflection.connect()
 
-  expect(reflection.value).toStrictEqual(value)
+  assert.deepStrictEqual(reflection.value, value)
 })