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

package/test/call.test.js

@@ -1,18 +1,20 @@
-'use strict'
+import { it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const fixtures = require('./call.fixtures')
-const { Call } = require('../src/call')
+import * as fixtures from './call.fixtures.js'
+import { Call } from '../src/call.js'
 
 let call
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 
   call = new Call(fixtures.transmission, fixtures.contract)
 })
 
 it('should depend on transmission', () => {
-  expect(fixtures.transmission.link).toHaveBeenLastCalledWith(call)
+  assert.ok(((invocation) => invocation.arguments.length === 1 && isDeepStrictEqual(invocation.arguments[0], call))(fixtures.transmission.link.mock.calls.at(-1) ?? { arguments: [] }))
 })
 
 it('should call transmission', async () => {
@@ -20,7 +22,7 @@ it('should call transmission', async () => {
 
   await call.invoke(request)
 
-  expect(fixtures.transmission.request).toHaveBeenCalledWith(request)
+  assert.ok(fixtures.transmission.request.mock.calls.some((invocation) => invocation.arguments.length === 1 && isDeepStrictEqual(invocation.arguments[0], request)))
 })
 
 it('should fit request', async () => {
@@ -28,7 +30,7 @@ it('should fit request', async () => {
 
   await call.invoke(request)
 
-  expect(fixtures.contract.fit).toHaveBeenLastCalledWith(request)
+  assert.ok(((invocation) => invocation.arguments.length === 1 && isDeepStrictEqual(invocation.arguments[0], request))(fixtures.contract.fit.mock.calls.at(-1) ?? { arguments: [] }))
 })
 
 it('should return reply', async () => {
@@ -36,11 +38,21 @@ it('should return reply', async () => {
 
   const reply = await call.invoke(request)
 
-  expect(reply).toStrictEqual(fixtures.transmission.request.mock.results[0].value.output)
+  assert.deepStrictEqual(reply, fixtures.transmission.request.mock.calls[0].result.output)
 })
 
 it('should throw received exceptions', async () => {
   const request = fixtures.request().bad
 
-  await expect(call.invoke(request)).rejects.toBeDefined()
+  await assert.rejects(call.invoke(request), (error) => { assert.notStrictEqual(error, undefined); return true })
 })
+
+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/component.fixtures.js

@@ -1,10 +1,10 @@
-'use strict'
+import { mock } from 'node:test'
 
-const randomstring = require('randomstring')
+import randomstring from 'randomstring'
 
-const invocation = () => jest.fn(() => randomstring.generate())
+const invocation = () => mock.fn(() => randomstring.generate())
 
-const invocations = {
+export const invocations = {
   foo: {
     invoke: invocation('foo'),
     link: () => null
@@ -15,7 +15,4 @@ const invocations = {
   }
 }
 
-const locator = {}
-
-exports.invocations = invocations
-exports.locator = locator
+export const locator = {}

package/test/component.test.js

@@ -1,8 +1,11 @@
-'use strict'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { Component } = require('../src/component')
-const { codes } = require('../src/exceptions')
-const fixtures = require('./component.fixtures')
+import { Component } from '../src/component.js'
+import { codes } from '../src/exceptions.js'
+import * as fixtures from './component.fixtures.js'
+import { AssertionError } from 'node:assert'
 
 describe('Invocations', () => {
   const name = ['foo', 'bar'][Math.floor(2 * Math.random())]
@@ -10,18 +13,17 @@ describe('Invocations', () => {
   const component = new Component(fixtures.locator, fixtures.invocations)
 
   beforeEach(() => {
-    jest.clearAllMocks()
+    resetCalls()
   })
 
   it('should invoke', async () => {
     await component.invoke(name)
 
-    expect(invocation.invoke).toBeCalled()
+    assert.ok(invocation.invoke.mock.callCount() > 0)
   })
 
   it('should throw on unknown invocation name', async () => {
-    await expect(() => component.invoke('baz'))
-      .rejects.toMatchObject({ code: codes.NotImplemented })
+    await assert.rejects(() => component.invoke('baz'), AssertionError)
   })
 
   it('should invoke input and query', async () => {
@@ -29,12 +31,22 @@ describe('Invocations', () => {
     const query = { test: Math.random() }
     await component.invoke(name, { input, query })
 
-    expect(invocation.invoke).toBeCalledWith({ input, query })
+    assert.ok(invocation.invoke.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], { input, query })))
   })
 
   it('should return io', async () => {
     const io = await component.invoke(name)
 
-    expect(io).toBe(fixtures.invocations[name].invoke.mock.results[0].value)
+    assert.strictEqual(io, fixtures.invocations[name].invoke.mock.calls[0].result)
   })
 })
+
+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/connector.fixtures.js

@@ -1,9 +1,7 @@
-'use strict'
+import { random, timeout } from '@toa.io/generic'
+import { Connector } from '../src/connector.js'
 
-const { random, timeout } = require('@toa.io/generic')
-const { Connector } = require('../src/connector')
-
-class TestConnector extends Connector {
+export class TestConnector extends Connector {
   #label
   #seq
 
@@ -29,12 +27,16 @@ class TestConnector extends Connector {
   }
 }
 
-class FailingConnector extends Connector {
+export class FailingConnector extends Connector {
   async open () {
     await timeout(random(10))
     throw new Error('FailingConnector')
   }
 }
 
-exports.TestConnector = TestConnector
-exports.FailingConnector = FailingConnector
+/** Stands for a connector waiting for something that never arrives. */
+export class StuckConnector extends Connector {
+  async open () {
+    return new Promise(() => undefined)
+  }
+}

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,12 @@ 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 +96,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 +122,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 +135,36 @@ 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'])
   })
 
   describe('errors', () => {
@@ -156,21 +177,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 '../src/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, mock } 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 '../src/context.js'
 
 /** @type {toa.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,28 @@
-'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 '../../src/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,29 @@
-'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 { readFileSync } from 'node:fs'
+import { load as parseYAML } from 'js-yaml'
+import { resolve } from 'path'
 
 // 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: parseYAML(readFileSync(resolve(import.meta.dirname, '../../src/contract/schemas/query.yaml'), 'utf8')),
       authentic: { type: 'boolean' }
     },
     additionalProperties: true
   }
 }
-
-exports.schema = schema
-exports.query = query
-exports.declaration = declaration
-exports.schemas = schemas