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

package/test/contract/request.test.js

@@ -1,27 +1,32 @@
-'use strict'
+import * as schemas from '@toa.io/schemas'
+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')
+import clone from 'clone-deep'
+import { generate } from 'randomstring'
 
-jest.mock('../../src/contract/conditions')
+import { Request } from '../../src/contract/request.js'
+import { Contract } from '../../src/contract/contract.js'
+import * as fixtures from './contract.fixtures.js'
 
-const { Request } = require('../../src/contract/request')
-const { Conditions } = require('../../src/contract/conditions')
-const fixtures = require('./contract.fixtures')
+// the base is real; what it was constructed with and told to fit is observable
+const fit = mock.method(Contract.prototype, 'fit', () => undefined)
 
 let contract
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  fit.mock.resetCalls()
 
-  contract = new Request(fixtures.schema)
+  contract = new Request(fixtures.schema, {})
 })
 
 const dummy = { schema: { properties: {} } }
 
 it('should extend Conditions', () => {
-  expect(contract).toBeInstanceOf(Conditions)
-  expect(Conditions).toHaveBeenCalledWith(fixtures.schema)
+  assert.ok(contract instanceof Contract)
+  assert.strictEqual(contract.schema, fixtures.schema)
 })
 
 it('should fit request', () => {
@@ -29,7 +34,8 @@ it('should fit request', () => {
 
   contract.fit(request)
 
-  expect(Conditions.mock.instances[0].fit).toHaveBeenCalledWith(request)
+  assert.ok(fit.mock.calls.some((call) =>
+    call.this === contract && isDeepStrictEqual(call.arguments[0], request)))
 })
 
 describe('schema', () => {
@@ -40,73 +46,117 @@ describe('schema', () => {
   })
 
   it('should provide schema', () => {
-    expect(Request.schema({}, dummy)).toBeDefined()
+    assert.notStrictEqual(Request.schema({}, dummy), undefined)
   })
 
   it('should add required input if defined', () => {
     const input = { type: 'number' }
 
-    expect(Request.schema({ input }, dummy).properties.input).toStrictEqual(input)
+    assert.deepStrictEqual(Request.schema({ input }, dummy).properties.input, input)
   })
 
   it('should set input as null if undefined', async () => {
-    expect(Request.schema({}, dummy).properties.input).toStrictEqual({ type: 'null' })
+    assert.deepStrictEqual(Request.schema({}, dummy).properties.input, { type: 'null' })
   })
 
   it('should contain query if declaration.query is not defined', () => {
-    expect(Request.schema({}, dummy).properties.query).toBeDefined()
+    assert.notStrictEqual(Request.schema({}, dummy).properties.query, undefined)
   })
 
   it('should not contain query if declaration.query is false', () => {
     schema.properties.query = { type: 'null' }
-    expect(Request.schema({ query: false }, dummy)).toStrictEqual(schema)
+    assert.partialDeepStrictEqual(Request.schema({ query: false }, dummy), schema)
   })
 
   it('should require query if declaration.query is true', () => {
     schema.required = ['query']
-    expect(Request.schema({ query: true }, dummy).required).toStrictEqual(expect.arrayContaining(['query']))
+    assert.ok(['query'].every((item) => Request.schema({ query: true }, dummy).required.some((candidate) => isDeepStrictEqual(candidate, item))))
   })
 
   it('should forbid projection for non observations', () => {
-    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.projection)
-      .toBe(undefined)
+    assert.strictEqual(Request.schema({ type: 'transition' }, dummy).properties.query.properties.projection, undefined)
 
-    expect(Request.schema({ type: 'assignment' }, dummy).properties.query.properties.projection)
-      .toBe(undefined)
+    assert.strictEqual(Request.schema({ type: 'assignment' }, dummy).properties.query.properties.projection, undefined)
 
-    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.projection)
-      .toBeDefined()
+    assert.notStrictEqual(Request.schema({ type: 'observation' }, dummy).properties.query.properties.projection, undefined)
   })
 
   it('should forbid version for observations', () => {
-    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.version)
-      .toBeDefined()
+    assert.notStrictEqual(Request.schema({ type: 'transition' }, dummy).properties.query.properties.version, undefined)
 
-    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.version)
-      .toBe(undefined)
+    assert.strictEqual(Request.schema({ type: 'observation' }, dummy).properties.query.properties.version, undefined)
   })
 
   it('should allow omit, limit only for set observations', () => {
     const schema = Request.schema({ type: 'transition' }, dummy)
     const transition = schema.properties.query.properties
 
-    expect(transition.omit).toBeUndefined()
-    expect(transition.limit).toBeUndefined()
+    assert.strictEqual(transition.omit, undefined)
+    assert.strictEqual(transition.limit, undefined)
 
     const object = Request.schema({
       type: 'observation',
       scope: 'object'
     }, dummy).properties.query.properties
 
-    expect(object.omit).toBeUndefined()
-    expect(object.limit).toBeUndefined()
+    assert.strictEqual(object.omit, undefined)
+    assert.strictEqual(object.limit, undefined)
 
     const objects = Request.schema({
       type: 'observation',
       scope: 'objects'
     }, dummy).properties.query.properties
 
-    expect(objects.omit).toBeDefined()
-    expect(objects.limit).toBeDefined()
+    assert.notStrictEqual(objects.omit, undefined)
+    assert.notStrictEqual(objects.limit, undefined)
   })
 })
+
+describe('source', () => {
+
+
+  const compile = (definition, entity) =>
+    schemas.schema(Request.schema(definition, entity), { removeAdditional: true })
+
+  it('should declare source', () => {
+    const schema = Request.schema({}, dummy)
+
+    assert.notStrictEqual(schema.properties.source, undefined)
+    assert.deepStrictEqual(schema.properties.source.additionalProperties, false)
+  })
+
+  it('should pass known source variants', () => {
+    const schema = compile({}, undefined)
+
+    for (const source of [
+      { namespace: 'a', component: 'b', operation: 'c' },
+      { namespace: 'a', component: 'b', event: 'c' },
+      { service: 'exposition' }
+    ]) {
+      const request = { input: null, query: null, source }
+
+      assert.deepStrictEqual(schema.fit(request), null)
+      assert.deepStrictEqual(request.source, source)
+    }
+  })
+
+  // `source` crosses the wire and keys the introspection map, so whatever
+  // a peer adds to it must not survive
+  it('should strip unknown source properties', () => {
+    const schema = compile({}, undefined)
+    const request = { input: null, query: null, source: { service: 'exposition', evil: 'x' } }
+
+    assert.deepStrictEqual(schema.fit(request), null)
+    assert.deepStrictEqual(request.source, { service: 'exposition' })
+  })
+})
+
+function resetCalls (target = [assert, clone, fixtures, dummy], 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/discovery.test.js

@@ -0,0 +1,64 @@
+import { it, beforeEach, afterEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
+
+import { console } from 'openspan'
+import { Connector } from '../src/connector.js'
+import { Discovery } from '../src/discovery.js'
+
+class Lookup extends Connector {
+  invoke = mock.fn(async () => ({ operations: {} }))
+}
+
+/** @type {Lookup} */
+let lookup
+
+/** @type {Discovery} */
+let discovery
+
+/** @type {import('node:test').Mock<any>} */
+let warn
+
+const locator = { id: 'dummies.one' }
+
+beforeEach(async () => {
+  mock.timers.enable()
+
+  warn = mock.method(console, 'warn', () => undefined)
+  lookup = new Lookup()
+  discovery = new Discovery(async () => lookup)
+
+  await discovery.connect()
+})
+
+afterEach(() => {
+  warn.mock.restore()
+  mock.timers.reset()
+})
+
+it('should not warn if a lookup is answered', async () => {
+  await discovery.lookup(locator)
+
+  mock.timers.tick(60_000)
+
+  assert.strictEqual(warn.mock.callCount(), 0)
+})
+
+it('should keep warning while a lookup is unanswered', async () => {
+  lookup.invoke.mock.mockImplementation(() => new Promise(() => undefined))
+
+  void discovery.lookup(locator)
+
+  // the interval is set after the lookup is resolved, so it has to exist
+  // before time is advanced
+  await new Promise((resolve) => process.nextTick(resolve))
+
+  // node:test moves the clock before running the callbacks it releases, so the
+  // elapsed time each warning reports is only right when time advances by steps
+  mock.timers.tick(5_000)
+  mock.timers.tick(5_000)
+
+  assert.strictEqual(warn.mock.callCount(), 2)
+
+  assert.ok(((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], 'Waiting for lookup response') && isDeepStrictEqual(call.arguments[1], { component: locator.id, waiting: 10 }))(warn.mock.calls.at(-1) ?? { arguments: [] }))
+})

package/test/emission.fixtures.js

@@ -1,17 +1,13 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
 // noinspection JSCheckFunctionSignatures
-const events = [0, 1, 2].map((index) => ({
-  emit: jest.fn(async (state) => ({ ...state, event: index }))
+export const events = [0, 1, 2].map((index) => ({
+  emit: mock.fn(async (state) => ({ ...state, event: index }))
 }))
 
-const event = {
+export const event = {
   origin: { [generate()]: generate() },
-  state: { [generate()]: generate() },
-  changeset: { [generate()]: generate() }
+  state: { [generate()]: generate() }
 }
-
-exports.events = events
-exports.event = event

package/test/emission.test.js

@@ -1,17 +1,25 @@
-'use strict'
+import { it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-jest.mock('../src/connector')
+import clone from 'clone-deep'
 
-const clone = require('clone-deep')
+import { Connector } from '../src/connector.js'
 
-const { Connector } = require('../src/connector')
-const { Emission } = require('../src/emission')
-const fixtures = require('./emission.fixtures')
+// 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 { Emission } from '../src/emission.js'
+import * as fixtures from './emission.fixtures.js'
 
 let emission, event
 
 beforeEach(async () => {
-  jest.clearAllMocks()
+  resetCalls()
+  depends.mock.resetCalls()
 
   emission = new Emission(fixtures.events)
   event = clone(fixtures.event)
@@ -20,16 +28,25 @@ beforeEach(async () => {
 })
 
 it('should depend on events', () => {
-  expect(emission).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.events)
+  assert.ok(emission instanceof Connector)
+  assert.ok(dependencies(emission).some((one) => isDeepStrictEqual(one, fixtures.events)))
 })
 
 it('should emit events', async () => {
-  expect.assertions(fixtures.events.length)
-
+  
   await emission.emit(event)
 
   for (const evt of fixtures.events) {
-    expect(evt.emit).toHaveBeenCalledWith(event)
+    assert.ok(evt.emit.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], event)))
   }
 })
+
+function resetCalls (target = [assert, clone, depends, dependencies, 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/entities/entity.fixtures.js

@@ -1,16 +1,16 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
 // noinspection JSCheckFunctionSignatures
-const schema = {
-  fit: jest.fn((object) =>
+export const schema = {
+  fit: mock.fn((object) =>
     (object.fail ? { [generate()]: generate() } : null)),
 
-  defaults: jest.fn(() => ({ [generate()]: generate() }))
+  defaults: mock.fn(() => ({ [generate()]: generate() }))
 }
 
-const state = () => ({
+export const state = () => ({
   id: generate(),
   foo: generate(),
   _created: generate(),
@@ -19,11 +19,7 @@ const state = () => ({
   _version: 0
 })
 
-const failed = () => ({
+export const failed = () => ({
   ...state(),
   fail: true
 })
-
-exports.schema = schema
-exports.state = state
-exports.failed = failed

package/test/entities/entity.test.js

@@ -1,46 +1,78 @@
-'use strict'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
 
-const { Entity } = require('../../src/entities/entity')
-const fixtures = require('./entity.fixtures')
+import { Entity } from '../../src/entities/entity.js'
+import * as fixtures from './entity.fixtures.js'
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 })
 
-describe('new', () => {
-  it('should throw on schema error', () => {
-    const entity = new Entity(fixtures.schema)
+describe('argument', () => {
+  it('should set state', () => {
+    const state = fixtures.state()
+    const entity = new Entity(fixtures.schema, state)
 
-    expect(() => entity.set(fixtures.failed())).toThrow()
+    assert.deepStrictEqual(entity.get(), state)
   })
 
-  it('should provide state', () => {
-    const entity = new Entity(fixtures.schema)
-    const state = fixtures.state()
+  it('should snapshot the record it may commit', () => {
+    const record = fixtures.state()
+    const entity = new Entity(fixtures.schema, record)
 
-    entity.set(state)
+    assert.notStrictEqual(entity.get(), record)
+    assert.strictEqual(entity.event().origin, record)
+  })
+})
+
+describe('read-only', () => {
+  it('should take the record as it came', () => {
+    const record = fixtures.state()
+    const entity = new Entity(fixtures.schema, record, undefined, false)
 
-    expect(entity.get()).toEqual(state)
+    // no pre-image to diff against, hence no copy of it
+    assert.strictEqual(entity.get(), record)
+  })
+
+  it('should still report a tombstone', () => {
+    const record = { ...fixtures.state(), _deleted: Date.now() }
+    const entity = new Entity(fixtures.schema, record, undefined, false)
+
+    assert.strictEqual(entity.deleted, true)
+  })
+
+  it('should refuse to be modified', () => {
+    const entity = new Entity(fixtures.schema, fixtures.state(), undefined, false)
+
+    assert.throws(() => entity.set(entity.get()), (error) => /read-only/.test(error.message))
   })
 })
 
-describe('argument', () => {
-  it('should provide initial state if no argument passed', () => {
-    const entity = new Entity(fixtures.schema)
-    const defaults = fixtures.schema.defaults.mock.results[0].value
-    const expected = {
-      ...defaults,
-      _version: 0
-    }
-
-    expect(entity.get()).toStrictEqual(expect.objectContaining(expected))
+describe('tombstone', () => {
+  it('should lift tombstone when transition leaves _deleted untouched', () => {
+    const origin = fixtures.state()
+    const entity = new Entity(fixtures.schema, origin)
+    const state = entity.get()
+
+    state.foo = 'revived'
+    entity.set(state)
+
+    assert.strictEqual(entity.get()._deleted, null)
+    assert.strictEqual(entity.deleted, false)
+    assert.strictEqual(entity.event().state._deleted, null)
   })
 
-  it('should set state', () => {
-    const state = fixtures.state()
-    const entity = new Entity(fixtures.schema, state)
+  it('should keep tombstone written by transition', () => {
+    const origin = { ...fixtures.state(), _deleted: null }
+    const entity = new Entity(fixtures.schema, origin)
+    const state = entity.get()
+    const timestamp = Date.now()
+
+    state._deleted = timestamp
+    entity.set(state)
 
-    expect(entity.get()).toEqual(state)
+    assert.strictEqual(entity.get()._deleted, timestamp)
+    assert.strictEqual(entity.deleted, true)
   })
 })
 
@@ -54,29 +86,18 @@ it('should provide event', () => {
 
   const event = entity.event()
 
-  expect(event).toEqual(expect.objectContaining({
-    state,
-    origin,
-    changeset: expect.objectContaining({
-      foo: 'new value',
-      _version: 1
-    })
-  }))
+  assert.partialDeepStrictEqual(event, { state, origin })
+  assert.strictEqual(event.state.foo, 'new value')
+  assert.strictEqual(event.state._version, 1)
+  assert.notStrictEqual(event.origin.foo, 'new value')
 })
 
-it('should define `id` as readonly', async () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
-  const state = entity.get()
-
-  expect(() => (state.id = 1)).toThrow('assign to read only property')
-})
+function resetCalls (target = [assert, fixtures], seen = new Set()) {
+  if (target === null || typeof target !== 'object' || seen.has(target)) return
 
-it('should seal id', async () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
-  const state = entity.get()
-  const redefine = () => Object.defineProperty(state, 'id', { writable: true })
+  seen.add(target)
 
-  expect(redefine).toThrow('redefine property')
-})
+  for (const value of Object.values(target))
+    if (typeof value === 'function' && value.mock !== undefined) value.mock.resetCalls()
+    else resetCalls(value, seen)
+}

package/test/entities/factory.fixtures.js

@@ -1,18 +1,30 @@
-'use strict'
+import { mock } from 'node:test'
 
-const randomstring = require('randomstring')
+import randomstring from 'randomstring'
 
 const schema = { [randomstring.generate()]: randomstring.generate() }
-const storage = { id: jest.fn(() => randomstring.generate()) }
+const storage = { id: mock.fn(() => randomstring.generate()) }
 const entity = { [randomstring.generate()]: randomstring.generate() }
 const set = Array.from(Array(5))
   .map((_, index) => ({ id: index, [randomstring.generate()]: randomstring.generate() }))
 
-const Entity = jest.fn().mockImplementation(function () { this.id = randomstring.generate() })
-const EntitySet = jest.fn().mockImplementation(function () {})
+// node:test records a mock's calls but not the instances it constructed
+const entities = []
 
-exports.schema = schema
-exports.storage = storage
-exports.entity = entity
-exports.set = set
-exports.mock = { Entity, EntitySet }
+const Entity = mock.fn(function () {
+  this.id = randomstring.generate()
+  entities.push(this)
+})
+
+const EntitySet = mock.fn(function () {})
+
+
+
+
+
+
+
+// named `mock` for its consumers, which is what node:test calls its own tracker
+const mocks = { Entity, EntitySet }
+
+export { schema, storage, entity, set, entities, mocks as mock }

package/test/entities/factory.test.js

@@ -1,19 +1,23 @@
-'use strict'
+import { it, beforeEach, mock as mocking } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const fixtures = require('./factory.fixtures')
+import * as fixtures from './factory.fixtures.js'
 const mock = fixtures.mock
 
-jest.mock('../../src/entities/entity', () => ({ Entity: mock.Entity }))
-jest.mock('../../src/entities/set', () => ({ EntitySet: mock.EntitySet }))
+mocking.module('../../src/entities/entity', { namedExports: ({ Entity: mock.Entity }) })
+mocking.module('../../src/entities/set', { namedExports: ({ EntitySet: mock.EntitySet }) })
+
+const { Factory } = await import('../../src/entities/factory.js')
 
-const { Factory } = require('../../src/entities/factory')
 
 let factory
 
 beforeEach(async () => {
-  jest.clearAllMocks()
+  resetCalls()
+  fixtures.entities.length = 0
 
   factory = new Factory(fixtures.schema, () => fixtures.storage.id())
 })
@@ -22,27 +26,37 @@ it('should create initial', () => {
   const id = generate()
   const initial = factory.init(id)
 
-  expect(initial).toBeInstanceOf(mock.Entity)
-  expect(initial.constructor).toHaveBeenCalledWith(fixtures.schema, id)
+  assert.ok(initial instanceof mock.Entity)
+  assert.ok(mock.Entity.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], fixtures.schema) && isDeepStrictEqual(call.arguments[1], id) && typeof call.arguments[2] === 'function'))
 })
 
 it('should create instance', () => {
   const object = factory.object(fixtures.entity)
 
-  expect(object).toBeInstanceOf(mock.Entity)
-  expect(object.constructor).toHaveBeenCalledWith(fixtures.schema, fixtures.entity)
+  assert.ok(object instanceof mock.Entity)
+  assert.ok(mock.Entity.mock.calls.some((call) => call.arguments.length === 4 && isDeepStrictEqual(call.arguments[0], fixtures.schema) && isDeepStrictEqual(call.arguments[1], fixtures.entity) && typeof call.arguments[2] === 'function' && isDeepStrictEqual(call.arguments[3], true)))
 })
 
 it('should create set', () => {
   const objects = factory.objects(fixtures.set)
 
-  expect(objects).toBeInstanceOf(mock.EntitySet)
+  assert.ok(objects instanceof mock.EntitySet)
 
   const instances = fixtures.set.map((entity, index) => {
-    expect(mock.Entity).toHaveBeenNthCalledWith(index + 1, fixtures.schema, entity)
+    assert.ok(((call) => call.arguments.length === 4 && isDeepStrictEqual(call.arguments[0], fixtures.schema) && isDeepStrictEqual(call.arguments[1], entity) && typeof call.arguments[2] === 'function' && isDeepStrictEqual(call.arguments[3], true))(mock.Entity.mock.calls[index + 1 - 1] ?? { arguments: [] }))
 
-    return mock.Entity.mock.instances[index]
+    return fixtures.entities[index]
   })
 
-  expect(objects.constructor).toHaveBeenCalledWith(instances)
+  assert.ok(mock.EntitySet.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], instances)))
 })
+
+function resetCalls (target = [assert, fixtures, mock], 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)
+}