@toa.io/core 1.0.0-alpha.292 → 1.0.0-alpha.299

package/test/outbox.test.js

@@ -1,202 +0,0 @@
-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,96 +0,0 @@
-export const samples = {
-  simple: {
-    query: {
-      criteria: 'name==Eddie'
-    },
-    parsed: {
-      criteria: {
-        type: 'COMPARISON',
-        left: { type: 'SELECTOR', selector: 'name' },
-        operator: '==',
-        right: { type: 'VALUE', value: 'Eddie' }
-      }
-    },
-    properties: {
-      name: {
-        type: 'string'
-      }
-    }
-  },
-
-  extended: {
-    query: {
-      criteria: 'flag==true;volume>2.1'
-    },
-    parsed: {
-      criteria: {
-        type: 'LOGIC',
-        left: {
-          type: 'COMPARISON',
-          left: { type: 'SELECTOR', selector: 'flag' },
-          operator: '==',
-          right: { type: 'VALUE', value: true }
-        },
-        operator: ';',
-        right: {
-          type: 'COMPARISON',
-          left: { type: 'SELECTOR', selector: 'volume' },
-          operator: '>',
-          right: { type: 'VALUE', value: 2.1 }
-        }
-      }
-    },
-    properties: {
-      flag: {
-        type: 'boolean'
-      },
-      volume: {
-        type: 'number'
-      }
-    }
-  },
-
-  abc: {
-    properties: {
-      a: {
-        type: 'string'
-      },
-      b: {
-        type: 'string'
-      },
-      c: {
-        type: 'string'
-      }
-    }
-  },
-
-  id: {
-    properties: {
-      id: {
-        type: 'string'
-      },
-      name: {
-        type: 'string'
-      }
-    },
-    query: {
-      id: '123',
-      criteria: 'name==Eddie'
-    },
-    parsed: {
-      id: '123',
-      criteria: {
-        type: 'COMPARISON',
-        left: {
-          type: 'SELECTOR',
-          selector: 'name'
-        },
-        operator: '==',
-        right: {
-          type: 'VALUE',
-          value: 'Eddie'
-        }
-      }
-    }
-  }
-}

package/test/query.test.js

@@ -1,183 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { Query } from '../source/query.js'
-import * as fixtures from './query.fixtures.js'
-
-beforeEach(() => {
-  resetCalls()
-})
-
-describe('criteria', () => {
-  it('should not throw if no criteria', () => {
-    const instance = new Query(fixtures.samples.simple.properties)
-    const query = instance.parse({})
-
-    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)
-
-    assert.deepStrictEqual(query.criteria, fixtures.samples.simple.parsed.criteria)
-  })
-
-  it('should coerce every value of a list', () => {
-    const instance = new Query({ n: { type: 'integer' } })
-    const query = instance.parse({ criteria: 'n=in=(1,2,3)' })
-
-    assert.deepStrictEqual(query.criteria.right.value, [1, 2, 3])
-  })
-
-  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)
-
-    assert.deepStrictEqual(query.criteria, fixtures.samples.extended.parsed.criteria)
-  })
-
-  it('should refuse a value the property cannot hold', () => {
-    const strict = new Query({
-      volume: { type: 'number' },
-      count: { type: 'integer' },
-      booked: { type: 'boolean' }
-    })
-
-    const refused = [
-      ['volume>abc', /takes a number/],
-      ['volume==1.5kg', /takes a number/],
-      ['count==1.5', /takes an integer/],
-      ['count==12kg', /takes an integer/],
-      ['booked==yes', /takes a boolean/],
-      ['booked==TRUE', /takes a boolean/],
-      ['volume=in=(1,two)', /'two' is not one/]
-    ]
-
-    for (const [criteria, message] of refused)
-      assert.throws(
-        () => strict.parse({ criteria }),
-        (error) => message.test(error.message),
-        criteria
-      )
-  })
-
-  it('should read a value the property can hold', () => {
-    const strict = new Query({
-      volume: { type: 'number' },
-      count: { type: 'integer' },
-      booked: { type: 'boolean' },
-      title: { type: 'string' }
-    })
-
-    const read = [
-      ['volume>1.5', 1.5],
-      ['volume>-1.5', -1.5],
-      ['count==12', 12],
-      ['booked==false', false],
-      ['title==12kg', '12kg']
-    ]
-
-    for (const [criteria, value] of read)
-      assert.deepStrictEqual(
-        strict.parse({ criteria }).criteria.right.value,
-        value,
-        criteria
-      )
-  })
-
-  it('should throw on unknown properties', () => {
-    const instance = new Query(fixtures.samples.simple.properties)
-
-    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 })
-
-    assert.deepStrictEqual(query, fixtures.samples.id.parsed)
-  })
-})
-
-describe('options', () => {
-  const instance = new Query(fixtures.samples.abc.properties)
-
-  it('should not throw if no options', () => {
-    const query = instance.parse({})
-
-    assert.strictEqual(query.options, undefined)
-  })
-
-  describe('omit, limit', () => {
-    it('should pass', () => {
-      const input = { omit: 1, limit: 1 }
-      const query = instance.parse(input)
-
-      assert.deepStrictEqual(query.options, input)
-    })
-  })
-
-  describe('sort', () => {
-    it('should set default values', () => {
-      const sort = ['a', 'b:desc', 'c']
-      const query = instance.parse({ sort })
-
-      assert.deepStrictEqual(query.options.sort, [
-        ['a', 'asc'],
-        ['b', 'desc'],
-        ['c', 'asc']
-      ])
-    })
-
-    it('should throw on unknown properties', () => {
-      const sort = ['d:asc']
-
-      assert.throws(
-        () => instance.parse({ sort }),
-        (error) => /not defined/.test(error.message)
-      )
-    })
-  })
-
-  describe('projection', () => {
-    it('should throw on unknown properties', () => {
-      const projection = ['a', 'b', 'c', 'd']
-
-      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,20 +0,0 @@
-import { mock } from 'node:test'
-
-import { generate } from 'randomstring'
-
-export const definition = /** @type {toa.norm.component.Receiver} */ {
-  operation: generate(),
-  conditioned: false,
-  adaptive: false
-}
-
-export const local = /** @type {import('@toa.io/core').Component} */ {
-  locator: { id: 'default.dummy' },
-  invoke: mock.fn()
-}
-
-// noinspection JSCheckFunctionSignatures
-export const bridge = /** @type {import('@toa.io/core/types').bridges.Event} */ {
-  condition: mock.fn(async (payload) => !(payload.reject === true)),
-  request: mock.fn(async () => ({ input: generate() }))
-}

package/test/receiver.test.js

@@ -1,144 +0,0 @@
-import { describe, it, beforeEach, mock } from 'node:test'
-import assert from 'node:assert/strict'
-import { isDeepStrictEqual } from 'node:util'
-
-import clone from 'clone-deep'
-import { generate } from 'randomstring'
-import { merge } from '@toa.io/generic'
-
-import { Connector } from '../source/connector.js'
-
-// the fixtures are not connectors, so a 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])
-
-import { Receiver } from '../source/receiver.js'
-import * as fixtures from './receiver.fixtures.js'
-
-/** @type {import('@toa.io/core/types').Receiver} */
-let receiver
-
-/** @type {toa.norm.component.Receiver} */
-let definition
-
-beforeEach(() => {
-  resetCalls()
-  depends.mock.resetCalls()
-
-  definition = clone(fixtures.definition)
-  receiver = new Receiver(fixtures.definition, fixtures.local, fixtures.bridge)
-})
-
-it('should depend on local, 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 () => {
-  const payload = { foo: 'bar' }
-
-  await receiver.receive({ 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 })
-    )
-  )
-})
-
-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)
-
-    const payload = { foo: generate() }
-    const extension = { [generate()]: generate() }
-    const message = { payload, ...extension }
-
-    await receiver.receive(message)
-
-    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].arguments[1]
-
-    assert.deepStrictEqual(argument, expected)
-  })
-
-describe('conditioned', () => {
-  beforeEach(() => {
-    definition.conditioned = true
-    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
-  })
-
-  it('should test condition', async () => {
-    const payload = { foo: 'bar' }
-    await receiver.receive({ 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 })
-
-    assert.strictEqual(fixtures.local.invoke.mock.callCount(), 0)
-  })
-})
-
-describe('adaptive', () => {
-  beforeEach(() => {
-    definition.adaptive = true
-    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
-  })
-
-  it('should apply', async () => {
-    const payload = { reject: true }
-    await receiver.receive({ payload })
-
-    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,31 +0,0 @@
-import { it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { generate } from 'randomstring'
-import { Reflection, Connector } from '../source/index.js'
-
-it('should export', () => {
-  assert.notStrictEqual(Reflection, undefined)
-})
-
-/** @type {import('@toa.io/core').Reflection<string>} */
-let reflection
-
-const value = generate()
-
-/** @type {import('@toa.io/core').ReflectionSource<string>} */
-const source = async () => value
-
-beforeEach(() => {
-  reflection = new Reflection(source)
-})
-
-it('should be a Connector', () => {
-  assert.ok(reflection instanceof Connector)
-})
-
-it('should reflect', async () => {
-  await reflection.connect()
-
-  assert.deepStrictEqual(reflection.value, value)
-})