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

package/test/connector.test.js

@@ -1,6 +1,9 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const fixtures = require('./connector.fixtures')
+import { timeout } from '@toa.io/generic'
+
+import * as fixtures from './connector.fixtures.js'
 
 let sequence
 
@@ -17,14 +20,14 @@ describe('callbacks', () => {
 
   it('should call connection', async () => {
     await a.connect()
-    expect(sequence).toEqual(['+a'])
+    assert.deepStrictEqual(sequence, ['+a'])
   })
 
   it('should call disconnection', async () => {
     await a.connect()
     await a.disconnect()
 
-    expect(sequence.indexOf('+a')).toBeLessThan(sequence.indexOf('-a'))
+    assert.ok(sequence.indexOf('+a') < sequence.indexOf('-a'))
   })
 
   it('should reconnect', async () => {
@@ -32,7 +35,7 @@ describe('callbacks', () => {
     await a.reconnect()
     await a.reconnect()
 
-    expect(sequence).toEqual(['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
+    assert.deepStrictEqual(sequence, ['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
   })
 })
 
@@ -55,9 +58,9 @@ describe('dependencies', () => {
 
     await a.connect()
 
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+    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 () => {
@@ -67,10 +70,10 @@ describe('dependencies', () => {
 
     await a.connect()
 
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+    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 () => {
@@ -79,12 +82,15 @@ describe('dependencies', () => {
 
     await a.connect()
 
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+b'))
+    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
   })
 
   it('should throw on empty array', async () => {
-    expect(() => a.depends([])).toThrow(/must not be empty/)
+    assert.throws(
+      () => a.depends([]),
+      (error) => /must not be empty/.test(error.message)
+    )
   })
 
   it('should await 2-way dependencies', async () => {
@@ -93,23 +99,24 @@ describe('dependencies', () => {
 
     await a.connect()
 
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+b') < sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+c') < sequence.indexOf('+a'))
+    assert.ok(sequence.indexOf('+d') < sequence.indexOf('+a'))
 
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+d'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
+    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()
 
-    expect(sequence.indexOf('-a')).toBeLessThan(sequence.indexOf('-b'))
-    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-c'))
-    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-d'))
+    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 () => {
@@ -118,10 +125,10 @@ describe('dependencies', () => {
 
     await a.disconnect()
 
-    expect(sequence.indexOf('*c')).toBeLessThan(sequence.indexOf('*b'))
-    expect(sequence.indexOf('*b')).toBeLessThan(sequence.indexOf('*a'))
-    expect(sequence.indexOf('*d')).toBeLessThan(sequence.indexOf('*b'))
-    expect(sequence.indexOf('*a')).toBe(sequence.length - 1)
+    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 () => {
@@ -131,19 +138,102 @@ describe('dependencies', () => {
     await a.connect()
     await b.connect()
 
-    expect(sequence).toEqual(['+c', '+a', '+b'])
+    assert.deepStrictEqual(sequence, ['+c', '+a', '+b'])
 
     await a.disconnect()
 
-    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a'])
+    assert.deepStrictEqual(sequence, ['+c', '+a', '+b', '-a', '*a'])
 
     await b.disconnect()
 
-    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a', '-b', '-c', '*c', '*b'])
+    assert.deepStrictEqual(sequence, [
+      '+c',
+      '+a',
+      '+b',
+      '-a',
+      '*a',
+      '-b',
+      '-c',
+      '*c',
+      '*b'
+    ])
   })
 
   it('should throw if depends not on Connector', async () => {
-    expect(() => a.depends({})).toThrow()
+    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', () => {
@@ -156,21 +246,21 @@ describe('dependencies', () => {
     it('should disconnect on fail', async () => {
       f.depends(b).depends(c)
 
-      await expect(f.connect()).rejects.toThrow('FailingConnector')
-      expect(sequence).toEqual(['+c', '+b', '-b', '-c', '*c', '*b'])
+      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 expect(a.connect()).rejects.toThrow('FailingConnector')
+      await assert.rejects(a.connect(), (error) => /FailingConnector/.test(error.message))
 
-      expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('-c'))
-      expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('-d'))
+      assert.ok(sequence.indexOf('+c') < sequence.indexOf('-c'))
+      assert.ok(sequence.indexOf('+d') < sequence.indexOf('-d'))
 
-      expect(sequence.indexOf('+a')).toBe(-1)
-      expect(sequence.indexOf('-a')).toBe(-1)
+      assert.strictEqual(sequence.indexOf('+a'), -1)
+      assert.strictEqual(sequence.indexOf('-a'), -1)
     })
   })
 })

package/test/context.fixtures.js

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

package/test/context.test.js

@@ -1,20 +1,21 @@
-'use strict'
+import { describe, it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
 
-const fixtures = require('./context.fixtures')
-const { Context } = require('../src/context')
+import * as fixtures from './context.fixtures.js'
+import { Context } from '../source/context.js'
 
-/** @type {toa.core.Context} */
+/** @type {import('@toa.io/core').Context} */
 let context
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 
   context = new Context(fixtures.local, fixtures.discover, fixtures.aspects)
 })
 
 it('should expose aspects', () => {
-  expect(context.aspects).toBeDefined()
-  expect(context.aspects).toStrictEqual(fixtures.aspects)
+  assert.notStrictEqual(context.aspects, undefined)
+  assert.deepStrictEqual(context.aspects, fixtures.aspects)
 })
 
 describe('call', () => {
@@ -24,6 +25,16 @@ describe('call', () => {
     await context.call('a', 'b', 'c', request)
     await context.call('a', 'b', 'c', request)
 
-    expect(fixtures.discover).toHaveBeenCalledTimes(1)
+    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,26 +1,32 @@
-'use strict'
+import { it, beforeEach } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const { Conditions } = require('../../src/contract/conditions')
-const fixtures = require('./contract.fixtures')
+import { Contract } from '../../source/contract/contract.js'
+import * as fixtures from './contract.fixtures.js'
 
-let conditions
+let contract
 
 beforeEach(() => {
-  conditions = new Conditions(fixtures.schema)
+  contract = new Contract(fixtures.schema)
 })
 
 it('should fit value', () => {
   const value = { foo: generate() }
 
-  conditions.fit(value)
+  contract.fit(value)
 
-  expect(fixtures.schema.fit).toHaveBeenCalledWith(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 }
 
-  expect(() => conditions.fit(value)).toThrow()
+  assert.throws(() => contract.fit(value))
 })

package/test/contract/contract.fixtures.js

@@ -1,33 +1,28 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
-const { load } = require('@toa.io/yaml')
-const { resolve } = require('path')
+import { generate } from 'randomstring'
+
+import { query as querySchema } from '../../source/contract/schemas.js'
 
 // noinspection JSCheckFunctionSignatures
-const schema = {
-  fit: jest.fn((input) => (input.invalid ? { message: generate() } : null))
+export const schema = {
+  fit: mock.fn((input) => (input.invalid ? { message: generate() } : null))
 }
 
-const query = {
-  parse: jest.fn(() => ({ [generate()]: generate() }))
+export const query = {
+  parse: mock.fn(() => ({ [generate()]: generate() }))
 }
 
-const declaration = {}
+export const declaration = {}
 
-const schemas = {
+export const schemas = {
   request: {
     type: 'object',
     properties: {
       input: { type: 'null' },
-      query: load.sync(resolve(__dirname, '../../src/contract/schemas/query.yaml')),
+      query: querySchema,
       authentic: { type: 'boolean' }
     },
     additionalProperties: true
   }
 }
-
-exports.schema = schema
-exports.query = query
-exports.declaration = declaration
-exports.schemas = schemas

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 '../../source/contract/request.js'
+import { Contract } from '../../source/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: {} } }
+const dummy = { 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,11 @@ 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 +49,148 @@ 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)
-
-    expect(Request.schema({ type: 'assignment' }, dummy).properties.query.properties.projection)
-      .toBe(undefined)
-
-    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.projection)
-      .toBeDefined()
+    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', () => {
-    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.version)
-      .toBeDefined()
-
-    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.version)
-      .toBe(undefined)
+    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
 
-    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
+
+    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))
 
-    const object = Request.schema({
-      type: 'observation',
-      scope: 'object'
-    }, dummy).properties.query.properties
+  it('should not hold source to a schema', () => {
+    const schema = Request.schema({}, dummy)
 
-    expect(object.omit).toBeUndefined()
-    expect(object.limit).toBeUndefined()
+    assert.strictEqual(schema.properties.source, undefined)
+  })
 
-    const objects = Request.schema({
-      type: 'observation',
-      scope: 'objects'
-    }, dummy).properties.query.properties
+  it('should pass known source variants', () => {
+    const schema = compile({}, undefined)
 
-    expect(objects.omit).toBeDefined()
-    expect(objects.limit).toBeDefined()
+    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)
+}