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

package/test/connector.test.js

@@ -1,266 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { timeout } from '@toa.io/generic'
-
-import * as fixtures from './connector.fixtures.js'
-
-let sequence
-
-beforeEach(() => {
-  sequence = []
-})
-
-describe('callbacks', () => {
-  let a
-
-  beforeEach(() => {
-    a = new fixtures.TestConnector('a', sequence)
-  })
-
-  it('should call connection', async () => {
-    await a.connect()
-    assert.deepStrictEqual(sequence, ['+a'])
-  })
-
-  it('should call disconnection', async () => {
-    await a.connect()
-    await a.disconnect()
-
-    assert.ok(sequence.indexOf('+a') < sequence.indexOf('-a'))
-  })
-
-  it('should reconnect', async () => {
-    await a.connect()
-    await a.reconnect()
-    await a.reconnect()
-
-    assert.deepStrictEqual(sequence, ['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
-  })
-})
-
-describe('dependencies', () => {
-  let a
-  let b
-  let c
-  let d
-
-  beforeEach(() => {
-    a = new fixtures.TestConnector('a', sequence)
-    b = new fixtures.TestConnector('b', sequence)
-    c = new fixtures.TestConnector('c', sequence)
-    d = new fixtures.TestConnector('d', sequence)
-  })
-
-  it('should wait dependencies on connection', async () => {
-    a.depends(b).depends(c)
-    a.depends(d)
-
-    await a.connect()
-
-    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+b'))
-    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
-    assert.ok(sequence.indexOf('+d') < sequence.indexOf('+a'))
-  })
-
-  it('should wait array of connectors', async () => {
-    a.depends([b, d])
-    b.depends(c)
-    d.depends(c)
-
-    await a.connect()
-
-    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+b'))
-    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+d'))
-    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
-    assert.ok(sequence.indexOf('+d') < sequence.indexOf('+a'))
-  })
-
-  it('should wait array(1) of connectors', async () => {
-    a.depends([b])
-    b.depends(c)
-
-    await a.connect()
-
-    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+b'))
-    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
-  })
-
-  it('should throw on empty array', async () => {
-    assert.throws(
-      () => a.depends([]),
-      (error) => /must not be empty/.test(error.message)
-    )
-  })
-
-  it('should await 2-way dependencies', async () => {
-    a.depends([b, c, d])
-    d.depends([b, c])
-
-    await a.connect()
-
-    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
-    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+a'))
-    assert.ok(sequence.indexOf('+d') < sequence.indexOf('+a'))
-
-    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+d'))
-    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+d'))
-  })
-
-  it('should disconnect before dependencies', async () => {
-    a.depends(b).depends(c)
-    b.depends(d)
-
-    await a.connect()
-    await a.disconnect()
-
-    assert.ok(sequence.indexOf('-a') < sequence.indexOf('-b'))
-    assert.ok(sequence.indexOf('-b') < sequence.indexOf('-c'))
-    assert.ok(sequence.indexOf('-b') < sequence.indexOf('-d'))
-  })
-
-  it('should call disconnected', async () => {
-    a.depends(b).depends(c)
-    b.depends(d)
-
-    await a.disconnect()
-
-    assert.ok(sequence.indexOf('*c') < sequence.indexOf('*b'))
-    assert.ok(sequence.indexOf('*b') < sequence.indexOf('*a'))
-    assert.ok(sequence.indexOf('*d') < sequence.indexOf('*b'))
-    assert.strictEqual(sequence.indexOf('*a'), sequence.length - 1)
-  })
-
-  it('should disconnect if no parents left', async () => {
-    a.depends(c)
-    b.depends(c)
-
-    await a.connect()
-    await b.connect()
-
-    assert.deepStrictEqual(sequence, ['+c', '+a', '+b'])
-
-    await a.disconnect()
-
-    assert.deepStrictEqual(sequence, ['+c', '+a', '+b', '-a', '*a'])
-
-    await b.disconnect()
-
-    assert.deepStrictEqual(sequence, [
-      '+c',
-      '+a',
-      '+b',
-      '-a',
-      '*a',
-      '-b',
-      '-c',
-      '*c',
-      '*b'
-    ])
-  })
-
-  it('should throw if depends not on Connector', async () => {
-    assert.throws(() => a.depends({}))
-  })
-
-  it('should disconnect while still connecting', async () => {
-    const stuck = new fixtures.StuckConnector()
-
-    a.depends(stuck).depends(b)
-
-    void a.connect()
-
-    while (b.connected !== true) await timeout(1)
-
-    // `a` never connects, and disconnecting must not wait for it to
-    assert.deepStrictEqual(a.connected, false)
-
-    await a.disconnect()
-
-    assert.deepStrictEqual(sequence, ['+b', '-b', '*b', '*a'])
-  })
-
-  it('should disconnect a dependency taken on after disconnection', async () => {
-    a.depends(b)
-
-    await a.connect()
-    await a.disconnect()
-
-    // what a lookup that returns once the teardown walk has gone by amounts to
-    a.depends(c)
-
-    await c.connect()
-
-    assert.strictEqual(c.connected, false)
-    assert.ok(sequence.indexOf('*c') > sequence.indexOf('*a'))
-  })
-
-  it('should disconnect a connected dependency taken on after disconnection', async () => {
-    a.depends(b)
-
-    await a.connect()
-    await a.disconnect()
-    await c.connect()
-
-    a.depends(c)
-
-    // the discarding is not something the caller waits for
-    for (let i = 0; c.connected && i < 100; i++) await timeout(1)
-
-    assert.strictEqual(c.connected, false)
-    assert.ok(sequence.includes('*c'))
-  })
-
-  it('should not connect what was disconnected while connecting', async () => {
-    const late = new fixtures.LateConnector()
-
-    late.depends(c)
-    b.depends(c)
-
-    await b.connect()
-
-    const connecting = late.connect()
-
-    await late.disconnect()
-
-    late.arrive()
-
-    await connecting
-
-    // the connection landed after the disconnection, and nothing is left to say it again
-    assert.strictEqual(late.connected, false)
-
-    await b.disconnect()
-
-    assert.strictEqual(c.connected, false)
-    assert.ok(sequence.includes('*c'))
-  })
-
-  describe('errors', () => {
-    let f
-
-    beforeEach(() => {
-      f = new fixtures.FailingConnector()
-    })
-
-    it('should disconnect on fail', async () => {
-      f.depends(b).depends(c)
-
-      await assert.rejects(f.connect(), (error) => /FailingConnector/.test(error.message))
-      assert.deepStrictEqual(sequence, ['+c', '+b', '-b', '-c', '*c', '*b'])
-    })
-
-    it('should interrupt connection chain', async () => {
-      a.depends(f).depends(c)
-      f.depends(d)
-
-      await assert.rejects(a.connect(), (error) => /FailingConnector/.test(error.message))
-
-      assert.ok(sequence.indexOf('+c') < sequence.indexOf('-c'))
-      assert.ok(sequence.indexOf('+d') < sequence.indexOf('-d'))
-
-      assert.strictEqual(sequence.indexOf('+a'), -1)
-      assert.strictEqual(sequence.indexOf('-a'), -1)
-    })
-  })
-})

package/test/context.fixtures.js

@@ -1,14 +0,0 @@
-import { mock } from 'node:test'
-
-import { Connector } from '../source/connector.js'
-
-export const local = {
-  link: mock.fn()
-}
-
-export const discover = mock.fn(() => ({
-  invoke: mock.fn(),
-  link: mock.fn()
-}))
-
-export const aspects = [new Connector(), new Connector()]

package/test/context.test.js

@@ -1,40 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import * as fixtures from './context.fixtures.js'
-import { Context } from '../source/context.js'
-
-/** @type {import('@toa.io/core').Context} */
-let context
-
-beforeEach(() => {
-  resetCalls()
-
-  context = new Context(fixtures.local, fixtures.discover, fixtures.aspects)
-})
-
-it('should expose aspects', () => {
-  assert.notStrictEqual(context.aspects, undefined)
-  assert.deepStrictEqual(context.aspects, fixtures.aspects)
-})
-
-describe('call', () => {
-  it('should discover once', async () => {
-    const request = {}
-
-    await context.call('a', 'b', 'c', request)
-    await context.call('a', 'b', 'c', request)
-
-    assert.strictEqual(fixtures.discover.mock.callCount(), 1)
-  })
-})
-
-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/contract/conditions.test.js

@@ -1,32 +0,0 @@
-import { it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-import { isDeepStrictEqual } from 'node:util'
-
-import { generate } from 'randomstring'
-
-import { Contract } from '../../source/contract/contract.js'
-import * as fixtures from './contract.fixtures.js'
-
-let contract
-
-beforeEach(() => {
-  contract = new Contract(fixtures.schema)
-})
-
-it('should fit value', () => {
-  const value = { foo: generate() }
-
-  contract.fit(value)
-
-  assert.ok(
-    fixtures.schema.fit.mock.calls.some(
-      (call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], value)
-    )
-  )
-})
-
-it('should throw on invalid value', () => {
-  const value = { invalid: true }
-
-  assert.throws(() => contract.fit(value))
-})

package/test/contract/contract.fixtures.js

@@ -1,28 +0,0 @@
-import { mock } from 'node:test'
-
-import { generate } from 'randomstring'
-
-import { query as querySchema } from '../../source/contract/schemas.js'
-
-// noinspection JSCheckFunctionSignatures
-export const schema = {
-  fit: mock.fn((input) => (input.invalid ? { message: generate() } : null))
-}
-
-export const query = {
-  parse: mock.fn(() => ({ [generate()]: generate() }))
-}
-
-export const declaration = {}
-
-export const schemas = {
-  request: {
-    type: 'object',
-    properties: {
-      input: { type: 'null' },
-      query: querySchema,
-      authentic: { type: 'boolean' }
-    },
-    additionalProperties: true
-  }
-}

package/test/contract/request.test.js

@@ -1,196 +0,0 @@
-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'
-
-import clone from 'clone-deep'
-import { generate } from 'randomstring'
-
-import { Request } from '../../source/contract/request.js'
-import { Contract } from '../../source/contract/contract.js'
-import * as fixtures from './contract.fixtures.js'
-
-// 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(() => {
-  resetCalls()
-  fit.mock.resetCalls()
-
-  contract = new Request(fixtures.schema, {})
-})
-
-const dummy = { properties: {} }
-
-it('should extend Conditions', () => {
-  assert.ok(contract instanceof Contract)
-  assert.strictEqual(contract.schema, fixtures.schema)
-})
-
-it('should fit request', () => {
-  const request = { [generate()]: generate() }
-
-  contract.fit(request)
-
-  assert.ok(
-    fit.mock.calls.some(
-      (call) => call.this === contract && isDeepStrictEqual(call.arguments[0], request)
-    )
-  )
-})
-
-describe('schema', () => {
-  let schema
-
-  beforeEach(() => {
-    schema = clone(fixtures.schemas.request)
-  })
-
-  it('should provide schema', () => {
-    assert.notStrictEqual(Request.schema({}, dummy), undefined)
-  })
-
-  it('should add required input if defined', () => {
-    const input = { type: 'number' }
-
-    assert.deepStrictEqual(Request.schema({ input }, dummy).properties.input, input)
-  })
-
-  it('should set input as null if undefined', async () => {
-    assert.deepStrictEqual(Request.schema({}, dummy).properties.input, { type: 'null' })
-  })
-
-  it('should contain query if declaration.query is not defined', () => {
-    assert.notStrictEqual(Request.schema({}, dummy).properties.query, undefined)
-  })
-
-  it('should not contain query if declaration.query is false', () => {
-    schema.properties.query = { type: 'null' }
-    assert.partialDeepStrictEqual(Request.schema({ query: false }, dummy), schema)
-  })
-
-  it('should require query if declaration.query is true', () => {
-    schema.required = ['query']
-    assert.ok(
-      ['query'].every((item) =>
-        Request.schema({ query: true }, dummy).required.some((candidate) =>
-          isDeepStrictEqual(candidate, item)
-        )
-      )
-    )
-  })
-
-  it('should forbid projection for non observations', () => {
-    assert.strictEqual(
-      Request.schema({ type: 'transition' }, dummy).properties.query.properties
-        .projection,
-      undefined
-    )
-
-    assert.strictEqual(
-      Request.schema({ type: 'assignment' }, dummy).properties.query.properties
-        .projection,
-      undefined
-    )
-
-    assert.notStrictEqual(
-      Request.schema({ type: 'observation' }, dummy).properties.query.properties
-        .projection,
-      undefined
-    )
-  })
-
-  it('should forbid version for observations', () => {
-    assert.notStrictEqual(
-      Request.schema({ type: 'transition' }, dummy).properties.query.properties.version,
-      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
-
-    assert.strictEqual(transition.omit, undefined)
-    assert.strictEqual(transition.limit, undefined)
-
-    const object = Request.schema(
-      {
-        type: 'observation',
-        scope: 'object'
-      },
-      dummy
-    ).properties.query.properties
-
-    assert.strictEqual(object.omit, undefined)
-    assert.strictEqual(object.limit, undefined)
-
-    const objects = Request.schema(
-      {
-        type: 'observation',
-        scope: 'objects'
-      },
-      dummy
-    ).properties.query.properties
-
-    assert.notStrictEqual(objects.omit, undefined)
-    assert.notStrictEqual(objects.limit, undefined)
-  })
-})
-
-describe('source', () => {
-  const compile = (definition, entity) =>
-    schemas.schema(Request.schema(definition, entity))
-
-  it('should not hold source to a schema', () => {
-    const schema = Request.schema({}, dummy)
-
-    assert.strictEqual(schema.properties.source, undefined)
-  })
-
-  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)
-    }
-  })
-
-  // whatever a peer puts beside the keys this release knows travels through: what reads
-  // `source` takes the keys it knows, and the contract does not fail a call over the rest
-  it('should pass a source a peer added to', () => {
-    const schema = compile({}, undefined)
-    const request = {
-      input: null,
-      query: null,
-      source: { service: 'exposition', mystery: 'x' }
-    }
-
-    assert.deepStrictEqual(schema.fit(request), null)
-    assert.deepStrictEqual(request.source, { service: 'exposition', mystery: 'x' })
-  })
-})
-
-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

@@ -1,71 +0,0 @@
-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 '../source/connector.js'
-import { Discovery } from '../source/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,13 +0,0 @@
-import { mock } from 'node:test'
-
-import { generate } from 'randomstring'
-
-// noinspection JSCheckFunctionSignatures
-export const events = [0, 1, 2].map((index) => ({
-  emit: mock.fn(async (state) => ({ ...state, event: index }))
-}))
-
-export const event = {
-  origin: { [generate()]: generate() },
-  state: { [generate()]: generate() }
-}