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

package/test/query.test.js

@@ -1,10 +1,11 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { Query } = require('../src/query')
-const fixtures = require('./query.fixtures')
+import { Query } from '../source/query.js'
+import * as fixtures from './query.fixtures.js'
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 })
 
 describe('criteria', () => {
@@ -12,34 +13,110 @@ 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 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)
 
-    expect(query.criteria).toEqual(fixtures.samples.extended.parsed.criteria)
+    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)
 
-    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 +126,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 +134,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 +143,20 @@ 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 +164,20 @@ 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 {import('@toa.io/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 {import('@toa.io/core/types').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,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')
-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 '../source/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])
 
-/** @type {toa.core.Receiver} */
+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(() => {
-  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,28 +43,38 @@ 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)
+    definition.adaptive = adaptive
+    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
 
-  const payload = { foo: generate() }
-  const extension = { [generate()]: generate() }
-  const message = { payload, ...extension }
+    const payload = { foo: generate() }
+    const extension = { [generate()]: generate() }
+    const message = { payload, ...extension }
 
-  await receiver.receive(message)
+    await receiver.receive(message)
 
-  const request = adaptive ? await fixtures.bridge.request.mock.results[0].value : { input: payload }
-  const expected = merge(clone(request), extension)
+    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', () => {
   beforeEach(() => {
@@ -67,15 +86,27 @@ 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 +120,25 @@ 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,18 +1,19 @@
-'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 '../source/index.js'
 
 it('should export', () => {
-  expect(Reflection).toBeDefined()
+  assert.notStrictEqual(Reflection, undefined)
 })
 
-/** @type {toa.core.Reflection<string>} */
+/** @type {import('@toa.io/core').Reflection<string>} */
 let reflection
 
 const value = generate()
 
-/** @type {toa.core.reflection.Source<string>} */
+/** @type {import('@toa.io/core').ReflectionSource<string>} */
 const source = async () => value
 
 beforeEach(() => {
@@ -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)
 })

package/test/state.fixtures.js

@@ -1,47 +1,49 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const storage = {
+export const storage = {
   name: 'dummy',
-  get: jest.fn(() => ({ id: generate() })),
-  find: jest.fn(() => ([{ id: generate() }])),
-  add: jest.fn(() => true),
-  set: jest.fn(() => true),
-  store: jest.fn(() => true)
+  get: mock.fn(() => ({ id: generate() })),
+  find: mock.fn(() => [{ id: generate() }]),
+  add: mock.fn(() => true),
+  set: mock.fn(() => true),
+  store: mock.fn(() => true),
+  massStore: mock.fn(() => true),
+  upsert: mock.fn(() => ({ id: generate() })),
+  ensure: mock.fn((query, properties, state) => state)
 }
 
-const factory = {
-  object: jest.fn(() => ({ [generate()]: generate() })),
-  objects: jest.fn(() => ({ [generate()]: generate() }))
+export const factory = {
+  object: mock.fn(() => ({ [generate()]: generate() })),
+  objects: mock.fn(() => ({ [generate()]: generate() }))
 }
 
-const query = generate()
+export const query = generate()
 
-const entity = {
-  get: jest.fn(() => ({ [generate()]: generate() })),
-  event: jest.fn(() => ({
-    state: { [generate()]: generate() }, changeset: { [generate()]: generate() }
-  }))
+export const entity = {
+  get: mock.fn(() => ({ [generate()]: generate() })),
+  event: mock.fn(() => ({ state: { [generate()]: generate() } }))
 }
 
-const initial = {
-  initial: true, ...entity
+export const initial = {
+  initial: true,
+  ...entity
 }
 
-const unchanged = {
+export const unchanged = {
   ...entity,
-  event: jest.fn(() => ({ state: { [generate()]: generate() }, changeset: {} }))
+  event: mock.fn(() => ({ state: { [generate()]: generate() } }))
 }
 
-const emitter = {
-  emit: jest.fn()
+// a legacy outbox: no storage capability, so `publish` emits inline
+export const outbox = {
+  row: mock.fn((event) => ({
+    id: generate(),
+    lane: 0,
+    published: false,
+    pending: 0,
+    event
+  })),
+  publish: mock.fn()
 }
-
-exports.storage = storage
-exports.factory = factory
-exports.emitter = emitter
-exports.query = query
-exports.entity = entity
-exports.initial = initial
-exports.unchanged = unchanged