@toa.io/core 1.0.0-alpha.29 → 1.0.0-alpha.291

package/test/event.test.js

@@ -1,32 +1,44 @@
-'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 '../source/connector.js'
+import { Event } from '../source/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 +46,20 @@ 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 +69,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)
     })
   })
 
@@ -66,14 +83,18 @@ 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()
-
-      const payload = await fixtures.bridge.payload.mock.results[0].value
-      const message = { payload }
-
-      expect(fixtures.binding.emit).toHaveBeenCalledWith(message)
+      await event.emit(
+        fixtures.event.origin,
+        fixtures.event.changeset,
+        fixtures.event.state
+      )
+
+      assert.ok(
+        !fixtures.bridge.condition.mock.calls.some((call) => call.arguments.length === 0)
+      )
+
+      const payload = await fixtures.bridge.payload.mock.calls[0].result
+      assertEmitted(payload)
     })
   })
 })
@@ -83,10 +104,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 +122,41 @@ 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 '../source/locator.js'
 
 /** @type {string} */
 let name
@@ -9,7 +10,7 @@ let name
 /** @type {string} */
 let namespace
 
-/** @type {toa.core.Locator} */
+/** @type {import('@toa.io/core').Locator} */
 let locator
 
 beforeEach(() => {
@@ -20,37 +21,43 @@ 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 +68,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 +99,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,202 @@
+import { it, beforeEach, afterEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { Outbox } from '../source/outbox/index.js'
+
+let emission, storage, atom, outbox, listeners
+
+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)
+    }
+  }
+
+  listeners = []
+
+  atom = {
+    slots: mock.fn(() => [0]),
+    onassigned: (listener) => {
+      listeners.push(listener)
+      listener({ i: 0, n: 1 })
+
+      return () => {
+        listeners = listeners.filter((one) => one !== listener)
+      }
+    },
+    link: mock.fn()
+  }
+  outbox = new Outbox(emission, storage, atom, { interval: 1000, batch: BATCH })
+})
+
+afterEach(() => {
+  mock.timers.reset()
+})
+
+/** everything the current turn awaited, without moving the clock */
+const settled = async () => {
+  for (let i = 0; i < 20; i++) await Promise.resolve()
+}
+
+/** 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)
+}
+
+it('should read as soon as a claim arrives, rather than on its next cycle', async () => {
+  atom.slots.mock.mockImplementation(() => null)
+
+  await outbox.open()
+  await settled()
+
+  assert.strictEqual(storage.outbox.pending.mock.callCount(), 0, 'nothing is owned yet')
+
+  atom.slots.mock.mockImplementation(() => [0])
+
+  for (const listener of listeners) listener({ i: 0, n: 1 })
+
+  await settled()
+
+  assert.strictEqual(
+    storage.outbox.pending.mock.callCount(),
+    1,
+    'the lane is its own now, and the cycle is up to five seconds away'
+  )
+})
+
+it('should read the lanes it inherits when the group resizes', async () => {
+  await outbox.open()
+  await settled()
+
+  const before = storage.outbox.pending.mock.callCount()
+
+  for (const listener of listeners) listener({ i: 0, n: 2 })
+
+  await settled()
+
+  assert.strictEqual(storage.outbox.pending.mock.callCount(), before + 1)
+})

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