@toa.io/core 1.0.0-alpha.28 → 1.0.0-alpha.282

package/test/entities/set.fixtures.js

@@ -1,11 +1,9 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const set = [
-  { get: jest.fn(() => ({ [generate()]: generate() })) },
-  { get: jest.fn(() => ({ [generate()]: generate() })) },
-  { get: jest.fn(() => ({ [generate()]: generate() })) }
+export const set = [
+  { get: mock.fn(() => ({ [generate()]: generate() })) },
+  { get: mock.fn(() => ({ [generate()]: generate() })) },
+  { get: mock.fn(() => ({ [generate()]: generate() })) }
 ]
-
-exports.set = set

package/test/entities/set.test.js

@@ -1,12 +1,13 @@
-'use strict'
+import { it } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { EntitySet } = require('../../src/entities/set')
-const fixtures = require('./set.fixtures')
+import { EntitySet } from '../../src/entities/set.js'
+import * as fixtures from './set.fixtures.js'
 
 it('should provide state', () => {
   const set = new EntitySet(fixtures.set)
   const state = set.get()
-  const expected = fixtures.set.map((entity) => entity.get.mock.results[0].value)
+  const expected = fixtures.set.map((entity) => entity.get.mock.calls[0].result)
 
-  expect(state).toStrictEqual(expected)
+  assert.deepStrictEqual(state, expected)
 })

package/test/event.fixtures.js

@@ -1,29 +1,24 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const definition = {
+export const definition = {
   conditioned: true,
   subjective: true
 }
 
 // noinspection JSCheckFunctionSignatures
-const bridge = {
-  condition: jest.fn(async (origin) => !origin.falsy),
-  payload: jest.fn(async () => ({ [generate()]: generate() }))
+export const bridge = {
+  condition: mock.fn(async (origin) => !origin.falsy),
+  payload: mock.fn(async () => ({ [generate()]: generate() }))
 }
 
-const binding = {
-  emit: jest.fn()
+export const binding = {
+  emit: mock.fn()
 }
 
-const event = {
+export const event = {
   origin: { [generate()]: generate() },
   state: { [generate()]: generate() },
   changeset: { [generate()]: generate() }
 }
-
-exports.bridge = bridge
-exports.binding = binding
-exports.definition = definition
-exports.event = event

package/test/event.test.js

@@ -1,32 +1,41 @@
-'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')
+import clone from 'clone-deep'
 
-jest.mock('../src/connector')
-
-const { Connector } = require('../src/connector')
-const { Event } = require('../src/event')
-const fixtures = require('./event.fixtures')
+import { Connector } from '../src/connector.js'
+import { Event } from '../src/event.js'
+import * as fixtures from './event.fixtures.js'
 
 let event, emit
 
+// the fixtures are not connectors, so the dependency is recorded rather than linked
+const depends = mock.method(Connector.prototype, 'depends', () => undefined)
+
+const dependencies = (instance) => depends.mock.calls
+  .filter((call) => call.this === instance)
+  .map((call) => call.arguments[0])
+
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  depends.mock.resetCalls()
 
   event = new Event(fixtures.definition, fixtures.binding, fixtures.bridge)
   emit = () => event.emit(fixtures.event)
 })
 
 it('should depend on binding', () => {
-  expect(event).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.binding)
+  assert.ok(event instanceof Connector)
+  assert.ok(dependencies(event).some((one) => isDeepStrictEqual(one, fixtures.binding)))
 })
 
 it('should depend on bridge if provided', () => {
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridge)
+  assert.ok(dependencies(event).some((one) => isDeepStrictEqual(one, fixtures.bridge)))
+
+  const bridgeless = new Event(fixtures.definition, fixtures.binding)
 
-  event = new Event(fixtures.definition, fixtures.binding)
-  expect(Connector.mock.instances[1].depends).not.toHaveBeenCalledWith(fixtures.bridge)
+  assert.ok(!dependencies(bridgeless).some((one) => isDeepStrictEqual(one, fixtures.bridge)))
 })
 
 describe('condition', () => {
@@ -34,15 +43,14 @@ describe('condition', () => {
     it('should call condition', async () => {
       await emit()
 
-      expect(fixtures.bridge.condition).toHaveBeenCalledWith(fixtures.event)
+      assert.ok(fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.event)))
     })
 
     it('should emit if condition returns true', async () => {
       await emit()
 
-      const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
+      const payload = await fixtures.bridge.payload.mock.calls[0].result
+      assertEmitted(payload)
     })
 
     it('should not emit if condition returns false', async () => {
@@ -52,7 +60,7 @@ describe('condition', () => {
 
       await event.emit(origin, fixtures.event.changeset, fixtures.event.state)
 
-      expect(fixtures.binding.emit).not.toHaveBeenCalled()
+      assert.strictEqual(fixtures.binding.emit.mock.callCount(), 0)
     })
   })
 
@@ -68,12 +76,10 @@ describe('condition', () => {
     it('should not call condition', async () => {
       await event.emit(fixtures.event.origin, fixtures.event.changeset, fixtures.event.state)
 
-      expect(fixtures.bridge.condition).not.toHaveBeenCalledWith()
+      assert.ok(!(fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 0)))
 
-      const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
-
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
+      const payload = await fixtures.bridge.payload.mock.calls[0].result
+      assertEmitted(payload)
     })
   })
 })
@@ -83,10 +89,8 @@ describe('payload', () => {
     it('should emit payload', async () => {
       await emit()
 
-      const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
-
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
+      const payload = await fixtures.bridge.payload.mock.calls[0].result
+      assertEmitted(payload)
     })
   })
 
@@ -103,16 +107,38 @@ describe('payload', () => {
     it('should not call payload', async () => {
       await emit()
 
-      expect(fixtures.bridge.payload).not.toHaveBeenCalled()
+      assert.strictEqual(fixtures.bridge.payload.mock.callCount(), 0)
     })
 
     it('should return state as payload', async () => {
       await emit()
 
       const payload = fixtures.event.state
-      const message = { payload }
-
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
+      assertEmitted(payload)
     })
   })
 })
+
+function resetCalls (target = [assert, clone, fixtures, depends, dependencies], 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)
+}
+
+/** The message carries the payload and a telemetry token generated per emission. */
+function assertEmitted (payload) {
+  const emitted = fixtures.binding.emit.mock.calls
+    .map((call) => call.arguments[0])
+    .filter((message) => isDeepStrictEqual(message.payload, payload))
+
+  assert.notStrictEqual(emitted.length, 0)
+
+  for (const message of emitted) {
+    assert.strictEqual(typeof message.telemetry, 'string')
+    assert.deepStrictEqual(Object.keys(message).sort(), ['payload', 'telemetry'])
+  }
+}

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

@@ -0,0 +1,121 @@
+import { it, beforeEach, afterEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Outbox } from '../src/outbox/index.js'
+
+let emission, storage, atom, outbox
+
+const BATCH = 4
+
+/** rows as the storage hands them back, ids ascending like the uuid v7 they are */
+const page = (from, count) =>
+  Array.from({ length: count }, (_, i) => ({
+    id: String(from + i).padStart(4, '0'),
+    event: { state: {} }
+  }))
+
+beforeEach(() => {
+  resetCalls()
+  mock.timers.enable()
+
+  emission = { emit: mock.fn(async () => undefined), link: mock.fn() }
+
+  storage = {
+    link: mock.fn(),
+    outbox: {
+      pending: mock.fn(async () => []),
+      settle: mock.fn(async () => undefined)
+    }
+  }
+
+  atom = { slots: mock.fn(() => [0]), link: mock.fn() }
+  outbox = new Outbox(emission, storage, atom, { interval: 1000, batch: BATCH })
+})
+
+afterEach(() => {
+  mock.timers.reset()
+})
+
+/** one cycle, and everything it awaited */
+const cycle = async () => {
+  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.mock.mockImplementationOnce(async () => page(0, 3))
+
+  await outbox.open()
+  await cycle()
+
+  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.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()
+
+  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.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
+
+  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.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()
+
+  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.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()
+
+  assert.strictEqual(emission.emit.mock.callCount(), 2)
+})
+
+it('should read nothing while it owns no slots', async () => {
+  atom.slots.mock.mockImplementation(() => null)
+
+  await outbox.open()
+  await cycle()
+
+  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,34 +13,51 @@ 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', () => {
+    const instance = new Query(fixtures.samples.simple.properties)
+
+    const first = instance.parse(fixtures.samples.simple.query).criteria
+    const second = instance.parse(fixtures.samples.simple.query).criteria
+
+    assert.strictEqual(second, first)
+  })
+
+  it('should not keep an invalid criteria', () => {
+    const instance = new Query(fixtures.samples.simple.properties)
+    const query = { criteria: 'nonexistent==1' }
+
+    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)
   })
 })
 
@@ -49,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', () => {
@@ -57,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)
     })
   })
 
@@ -66,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))
     })
   })
 
@@ -80,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,23 +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} */ {
-  invoke: jest.fn()
+export const local = /** @type {toa.core.Component} */ {
+  locator: { id: 'default.dummy' },
+  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