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

package/test/emission.test.js

@@ -1,60 +0,0 @@
-import { it, beforeEach, mock } from 'node:test'
-import assert from 'node:assert/strict'
-import { isDeepStrictEqual } from 'node:util'
-
-import clone from 'clone-deep'
-
-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 { Emission } from '../source/emission.js'
-import * as fixtures from './emission.fixtures.js'
-
-let emission, event
-
-beforeEach(async () => {
-  resetCalls()
-  depends.mock.resetCalls()
-
-  emission = new Emission(fixtures.events)
-  event = clone(fixtures.event)
-
-  await emission.open()
-})
-
-it('should depend on events', () => {
-  assert.ok(emission instanceof Connector)
-  assert.ok(dependencies(emission).some((one) => isDeepStrictEqual(one, fixtures.events)))
-})
-
-it('should emit events', async () => {
-  await emission.emit(event)
-
-  for (const evt of fixtures.events) {
-    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,24 +0,0 @@
-import { mock } from 'node:test'
-
-import { generate } from 'randomstring'
-
-// noinspection JSCheckFunctionSignatures
-export const schema = {
-  fit: mock.fn((object) => (object.fail ? { [generate()]: generate() } : null)),
-
-  defaults: mock.fn(() => ({ [generate()]: generate() }))
-}
-
-export const state = () => ({
-  id: generate(),
-  foo: generate(),
-  CREATED: generate(),
-  UPDATED: generate(),
-  DELETED: generate(),
-  VERSION: 0
-})
-
-export const failed = () => ({
-  ...state(),
-  fail: true
-})

package/test/entities/entity.test.js

@@ -1,137 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { Entity } from '../../source/entities/entity.js'
-import * as fixtures from './entity.fixtures.js'
-
-const BLANK = {}
-
-beforeEach(() => {
-  resetCalls()
-})
-
-describe('argument', () => {
-  it('should set state', () => {
-    const state = fixtures.state()
-    const entity = new Entity(fixtures.schema, BLANK, state)
-
-    assert.deepStrictEqual(entity.get(), state)
-  })
-
-  it('should snapshot the record it may commit', () => {
-    const record = fixtures.state()
-    const entity = new Entity(fixtures.schema, BLANK, record)
-
-    assert.notStrictEqual(entity.get(), record)
-    assert.strictEqual(entity.event().origin, record)
-  })
-})
-
-describe('blank', () => {
-  it('should write what the component declares a record starts as', () => {
-    const entity = new Entity(fixtures.schema, { foo: 'declared' })
-    const state = entity.get()
-
-    assert.strictEqual(state.foo, 'declared')
-    assert.strictEqual(state.VERSION, 0)
-    assert.strictEqual(state.DELETED, null)
-    assert.strictEqual(typeof state.id, 'string')
-    assert.strictEqual(entity.event().origin, null)
-  })
-
-  it('should not validate it', () => {
-    const entity = new Entity(fixtures.schema, { fail: true })
-
-    assert.strictEqual(entity.get().fail, true)
-    assert.strictEqual(fixtures.schema.fit.mock.callCount(), 0)
-  })
-
-  it('should give every record its own copy', () => {
-    const blank = { foo: { bar: 'nested' } }
-    const one = new Entity(fixtures.schema, blank)
-    const other = new Entity(fixtures.schema, blank)
-
-    assert.notStrictEqual(one.get().foo, other.get().foo)
-    assert.notStrictEqual(one.get().foo, blank.foo)
-  })
-})
-
-describe('read-only', () => {
-  it('should take the record as it came', () => {
-    const record = fixtures.state()
-    const entity = new Entity(fixtures.schema, BLANK, record, undefined, false)
-
-    // 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, BLANK, record, undefined, false)
-
-    assert.strictEqual(entity.deleted, true)
-  })
-
-  it('should refuse to be modified', () => {
-    const entity = new Entity(fixtures.schema, BLANK, fixtures.state(), undefined, false)
-
-    assert.throws(
-      () => entity.set(entity.get()),
-      (error) => /read-only/.test(error.message)
-    )
-  })
-})
-
-describe('tombstone', () => {
-  it('should lift tombstone when transition leaves DELETED untouched', () => {
-    const origin = fixtures.state()
-    const entity = new Entity(fixtures.schema, BLANK, 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 keep tombstone written by transition', () => {
-    const origin = { ...fixtures.state(), DELETED: null }
-    const entity = new Entity(fixtures.schema, BLANK, origin)
-    const state = entity.get()
-    const timestamp = Date.now()
-
-    state.DELETED = timestamp
-    entity.set(state)
-
-    assert.strictEqual(entity.get().DELETED, timestamp)
-    assert.strictEqual(entity.deleted, true)
-  })
-})
-
-it('should provide event', () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, BLANK, origin)
-  const state = entity.get()
-
-  state.foo = 'new value'
-  entity.set(state)
-
-  const event = entity.event()
-
-  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')
-})
-
-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/entities/factory.fixtures.js

@@ -1,31 +0,0 @@
-import { mock } from 'node:test'
-
-import randomstring from 'randomstring'
-
-const schemas = {
-  entity: { [randomstring.generate()]: randomstring.generate() },
-  changeset: { [randomstring.generate()]: randomstring.generate() }
-}
-
-const blank = { [randomstring.generate()]: 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()
-}))
-
-// node:test records a mock's calls but not the instances it constructed
-const entities = []
-
-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 { schemas, blank, storage, entity, set, entities, mocks as mock }

package/test/entities/factory.test.js

@@ -1,99 +0,0 @@
-import { it, beforeEach, mock as mocking } from 'node:test'
-import assert from 'node:assert/strict'
-import { isDeepStrictEqual } from 'node:util'
-
-import { generate } from 'randomstring'
-
-import * as fixtures from './factory.fixtures.js'
-const mock = fixtures.mock
-
-mocking.module('../../source/entities/entity.js', {
-  namedExports: { Entity: mock.Entity }
-})
-mocking.module('../../source/entities/set.js', {
-  namedExports: { EntitySet: mock.EntitySet }
-})
-
-const { Factory } = await import('../../source/entities/factory.js')
-
-let factory
-
-beforeEach(async () => {
-  resetCalls()
-  fixtures.entities.length = 0
-
-  factory = new Factory(fixtures.schemas, fixtures.blank, () => fixtures.storage.id())
-})
-
-it('should create initial', () => {
-  const id = generate()
-  const initial = factory.init(id)
-
-  assert.ok(initial instanceof mock.Entity)
-  assert.ok(
-    mock.Entity.mock.calls.some(
-      (call) =>
-        call.arguments.length === 4 &&
-        isDeepStrictEqual(call.arguments[0], fixtures.schemas.entity) &&
-        isDeepStrictEqual(call.arguments[1], fixtures.blank) &&
-        isDeepStrictEqual(call.arguments[2], id) &&
-        typeof call.arguments[3] === 'function'
-    )
-  )
-})
-
-it('should create instance', () => {
-  const object = factory.object(fixtures.entity)
-
-  assert.ok(object instanceof mock.Entity)
-  assert.ok(
-    mock.Entity.mock.calls.some(
-      (call) =>
-        call.arguments.length === 5 &&
-        isDeepStrictEqual(call.arguments[0], fixtures.schemas.entity) &&
-        isDeepStrictEqual(call.arguments[1], fixtures.blank) &&
-        isDeepStrictEqual(call.arguments[2], fixtures.entity) &&
-        typeof call.arguments[3] === 'function' &&
-        isDeepStrictEqual(call.arguments[4], true)
-    )
-  )
-})
-
-it('should create set', () => {
-  const objects = factory.objects(fixtures.set)
-
-  assert.ok(objects instanceof mock.EntitySet)
-
-  const instances = fixtures.set.map((entity, index) => {
-    assert.ok(
-      ((call) =>
-        call.arguments.length === 5 &&
-        isDeepStrictEqual(call.arguments[0], fixtures.schemas.entity) &&
-        isDeepStrictEqual(call.arguments[1], fixtures.blank) &&
-        isDeepStrictEqual(call.arguments[2], entity) &&
-        typeof call.arguments[3] === 'function' &&
-        isDeepStrictEqual(call.arguments[4], true))(
-        mock.Entity.mock.calls[index + 1 - 1] ?? { arguments: [] }
-      )
-    )
-
-    return fixtures.entities[index]
-  })
-
-  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)
-}

package/test/entities/set.fixtures.js

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

package/test/entities/set.test.js

@@ -1,13 +0,0 @@
-import { it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { EntitySet } from '../../source/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.calls[0].result)
-
-  assert.deepStrictEqual(state, expected)
-})

package/test/event.fixtures.js

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

package/test/event.test.js

@@ -1,162 +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 { 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(() => {
-  resetCalls()
-  depends.mock.resetCalls()
-
-  event = new Event(fixtures.definition, fixtures.binding, fixtures.bridge)
-  emit = () => event.emit(fixtures.event)
-})
-
-it('should depend on binding', () => {
-  assert.ok(event instanceof Connector)
-  assert.ok(dependencies(event).some((one) => isDeepStrictEqual(one, fixtures.binding)))
-})
-
-it('should depend on bridge if provided', () => {
-  assert.ok(dependencies(event).some((one) => isDeepStrictEqual(one, fixtures.bridge)))
-
-  const bridgeless = new Event(fixtures.definition, fixtures.binding)
-
-  assert.ok(
-    !dependencies(bridgeless).some((one) => isDeepStrictEqual(one, fixtures.bridge))
-  )
-})
-
-describe('condition', () => {
-  describe('conditioned', () => {
-    it('should call condition', async () => {
-      await emit()
-
-      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.calls[0].result
-      assertEmitted(payload)
-    })
-
-    it('should not emit if condition returns false', async () => {
-      const origin = clone(fixtures.event.origin)
-
-      origin.falsy = true
-
-      await event.emit(origin, fixtures.event.changeset, fixtures.event.state)
-
-      assert.strictEqual(fixtures.binding.emit.mock.callCount(), 0)
-    })
-  })
-
-  describe('unconditioned', () => {
-    beforeEach(() => {
-      const definition = clone(fixtures.definition)
-
-      definition.conditioned = false
-
-      event = new Event(definition, fixtures.binding, fixtures.bridge)
-    })
-
-    it('should not call condition', async () => {
-      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)
-    })
-  })
-})
-
-describe('payload', () => {
-  describe('subjective', () => {
-    it('should emit payload', async () => {
-      await emit()
-
-      const payload = await fixtures.bridge.payload.mock.calls[0].result
-      assertEmitted(payload)
-    })
-  })
-
-  describe('objective', () => {
-    beforeEach(() => {
-      const definition = clone(fixtures.definition)
-
-      definition.subjective = false
-
-      event = new Event(definition, fixtures.binding, fixtures.bridge)
-      emit = () => event.emit(fixtures.event)
-    })
-
-    it('should not call payload', async () => {
-      await emit()
-
-      assert.strictEqual(fixtures.bridge.payload.mock.callCount(), 0)
-    })
-
-    it('should return state as payload', async () => {
-      await emit()
-
-      const payload = fixtures.event.state
-      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,120 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { generate } from 'randomstring'
-import { Locator } from '../source/locator.js'
-
-/** @type {string} */
-let name
-
-/** @type {string} */
-let namespace
-
-/** @type {import('@toa.io/core').Locator} */
-let locator
-
-beforeEach(() => {
-  name = generate()
-  namespace = generate()
-
-  locator = new Locator(name, namespace)
-})
-
-it('should expose name and 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()
-
-  assert.deepStrictEqual(locator.id, id)
-  assert.deepStrictEqual(locator.label, label)
-})
-
-it('should expose uppercase', () => {
-  assert.deepStrictEqual(
-    locator.uppercase,
-    (locator.namespace + '_' + locator.name).toUpperCase()
-  )
-})
-
-it('should throw if name is undefined', () => {
-  assert.throws(() => new Locator(undefined, namespace), TypeError)
-
-  // noinspection JSCheckFunctionSignatures
-  assert.throws(() => new Locator(), TypeError)
-})
-
-it('should expose host', () => {
-  assert.deepStrictEqual(locator.hostname(), (namespace + '-' + name).toLowerCase())
-})
-
-it('should expose host with given prefix', () => {
-  const prefix = generate()
-
-  assert.deepStrictEqual(
-    locator.hostname(prefix),
-    (prefix + '-' + namespace + '-' + name).toLowerCase()
-  )
-})
-
-describe('global', () => {
-  beforeEach(() => {
-    locator = new Locator(name)
-  })
-
-  it('should not throw', () => undefined)
-
-  it('should expose id', () => {
-    assert.deepStrictEqual(locator.id, name)
-  })
-
-  it('should expose label', () => {
-    assert.deepStrictEqual(locator.label, name.toLowerCase())
-  })
-
-  it('should expose uppercase', () => {
-    assert.deepStrictEqual(locator.uppercase, name.toUpperCase())
-  })
-
-  it('should expose hostname', () => {
-    const type = generate()
-
-    assert.deepStrictEqual(locator.hostname(type), (type + '-' + name).toLowerCase())
-    assert.deepStrictEqual(locator.hostname(), name.toLowerCase())
-  })
-})
-
-describe('parse', () => {
-  it('should be', async () => {
-    assert.ok(Locator.parse instanceof Function)
-  })
-
-  const namespace = generate()
-  const name = generate()
-  const id = `${namespace}.${name}`
-
-  it('should parse id', async () => {
-    const locator = Locator.parse(id)
-
-    assert.deepStrictEqual(locator.namespace, namespace)
-    assert.deepStrictEqual(locator.name, name)
-  })
-
-  it('should parse endpoint', async () => {
-    const endpoint = `${id}.${generate()}`
-    const locator = Locator.parse(endpoint)
-
-    assert.deepStrictEqual(locator.namespace, namespace)
-    assert.deepStrictEqual(locator.name, name)
-  })
-
-  it('should parse token as global', async () => {
-    const locator = Locator.parse(name)
-
-    assert.strictEqual(locator.namespace, undefined)
-    assert.deepStrictEqual(locator.name, name)
-  })
-})