@toa.io/core 1.0.0-alpha.273 → 1.0.0-alpha.277

package/test/state.fixtures.js

@@ -1,50 +1,42 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
-const storage = {
+export const storage = {
   name: 'dummy',
-  get: jest.fn(() => ({ id: generate() })),
-  find: jest.fn(() => ([{ id: generate() }])),
-  add: jest.fn(() => true),
-  set: jest.fn(() => true),
-  store: jest.fn(() => true),
-  massStore: jest.fn(() => true),
-  upsert: jest.fn(() => ({ id: generate() })),
-  ensure: jest.fn((query, properties, state) => state)
+  get: mock.fn(() => ({ id: generate() })),
+  find: mock.fn(() => ([{ id: generate() }])),
+  add: mock.fn(() => true),
+  set: mock.fn(() => true),
+  store: mock.fn(() => true),
+  massStore: mock.fn(() => true),
+  upsert: mock.fn(() => ({ id: generate() })),
+  ensure: mock.fn((query, properties, state) => state)
 }
 
-const factory = {
-  object: jest.fn(() => ({ [generate()]: generate() })),
-  objects: jest.fn(() => ({ [generate()]: generate() }))
+export const factory = {
+  object: mock.fn(() => ({ [generate()]: generate() })),
+  objects: mock.fn(() => ({ [generate()]: generate() }))
 }
 
-const query = generate()
+export const query = generate()
 
-const entity = {
-  get: jest.fn(() => ({ [generate()]: generate() })),
-  event: jest.fn(() => ({ state: { [generate()]: generate() } }))
+export const entity = {
+  get: mock.fn(() => ({ [generate()]: generate() })),
+  event: mock.fn(() => ({ state: { [generate()]: generate() } }))
 }
 
-const initial = {
+export const initial = {
   initial: true, ...entity
 }
 
-const unchanged = {
+export const unchanged = {
   ...entity,
-  event: jest.fn(() => ({ state: { [generate()]: generate() } }))
+  event: mock.fn(() => ({ state: { [generate()]: generate() } }))
 }
 
 // a legacy outbox: no storage capability, so `publish` emits inline
-const outbox = {
-  row: jest.fn((event) => ({ id: generate(), lane: 0, published: false, pending: 0, event })),
-  publish: jest.fn()
+export const outbox = {
+  row: mock.fn((event) => ({ id: generate(), lane: 0, published: false, pending: 0, event })),
+  publish: mock.fn()
 }
-
-exports.storage = storage
-exports.factory = factory
-exports.outbox = outbox
-exports.query = query
-exports.entity = entity
-exports.initial = initial
-exports.unchanged = unchanged

package/test/state.test.js

@@ -1,12 +1,14 @@
-'use strict'
+import { describe, it, beforeEach, mock } from 'node:test'
+import assert from 'node:assert/strict'
+import { isDeepStrictEqual } from 'node:util'
 
-const { State } = require('../src/state')
-const fixtures = require('./state.fixtures')
+import { State } from '../src/state.js'
+import * as fixtures from './state.fixtures.js'
 
 let state
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
 
   state = new State(fixtures.storage, fixtures.factory, fixtures.outbox)
 })
@@ -14,59 +16,53 @@ beforeEach(() => {
 it('should provide object', async () => {
   const entity = await state.object(fixtures.query)
 
-  expect(fixtures.storage.get).toHaveBeenCalledWith(fixtures.query)
-  expect(entity).toStrictEqual(fixtures.factory.object.mock.results[0].value)
-  expect(fixtures.factory.object)
-    .toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value, true)
+  assert.ok(fixtures.storage.get.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.query)))
+  assert.deepStrictEqual(entity, fixtures.factory.object.mock.calls[0].result)
+  assert.ok(fixtures.factory.object.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.storage.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], true)))
 })
 
 it('should provide read-only object', async () => {
   await state.object(fixtures.query, false)
 
-  expect(fixtures.factory.object)
-    .toHaveBeenCalledWith(fixtures.storage.get.mock.results[0].value, false)
+  assert.ok(fixtures.factory.object.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.storage.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], false)))
 })
 
 it('should provide read-only objects', async () => {
   await state.objects(fixtures.query, false)
 
-  expect(fixtures.factory.objects)
-    .toHaveBeenCalledWith(fixtures.storage.find.mock.results[0].value, undefined, false)
+  assert.ok(fixtures.factory.objects.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], fixtures.storage.find.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], undefined) && isDeepStrictEqual(call.arguments[2], false)))
 })
 
 it('should store entity', async () => {
   await state.commit(fixtures.initial)
 
-  expect(fixtures.storage.store).toHaveBeenCalledWith(
-    fixtures.initial.get.mock.results[0].value,
-    fixtures.outbox.row.mock.results[0].value)
+  assert.ok(fixtures.storage.store.mock.calls.some((call) => call.arguments.length === 2 && isDeepStrictEqual(call.arguments[0], fixtures.initial.get.mock.calls[0].result) && isDeepStrictEqual(call.arguments[1], fixtures.outbox.row.mock.calls[0].result)))
 })
 
 it('should publish the row', async () => {
   await state.commit(fixtures.entity)
 
-  expect(fixtures.outbox.row).toHaveBeenCalledWith(fixtures.entity.event.mock.results[0].value)
-  expect(fixtures.outbox.publish).toHaveBeenCalledWith(fixtures.outbox.row.mock.results[0].value)
+  assert.ok(fixtures.outbox.row.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.entity.event.mock.calls[0].result)))
+  assert.ok(fixtures.outbox.publish.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.outbox.row.mock.calls[0].result)))
 })
 
 it('should not publish if the write did not happen', async () => {
-  fixtures.storage.store.mockImplementationOnce(() => false)
+  fixtures.storage.store.mock.mockImplementationOnce(() => false)
 
   await state.commit(fixtures.entity)
 
-  expect(fixtures.outbox.publish).not.toHaveBeenCalled()
+  assert.strictEqual(fixtures.outbox.publish.mock.callCount(), 0)
 })
 
 it('should build the row before the write', async () => {
   // the storage commits the row in the same transaction, so it must already exist
-  fixtures.storage.store.mockImplementationOnce((_, row) => {
-    expect(row).toBeDefined()
+  fixtures.storage.store.mock.mockImplementationOnce((_, row) => {
+    assert.notStrictEqual(row, undefined)
 
     return true
   })
 
-  expect.assertions(1)
-
+  
   await state.commit(fixtures.entity)
 })
 
@@ -76,19 +72,28 @@ describe('assignment', () => {
   it('should pass the row to upsert and publish it', async () => {
     const result = await state.apply(changeset, { foo: 1 })
 
-    expect(fixtures.storage.upsert).toHaveBeenCalledWith(
-      changeset.query, { foo: 1 }, fixtures.outbox.row.mock.results[0].value)
+    assert.ok(fixtures.storage.upsert.mock.calls.some((call) => call.arguments.length === 3 && isDeepStrictEqual(call.arguments[0], changeset.query) && isDeepStrictEqual(call.arguments[1], { foo: 1 }) && isDeepStrictEqual(call.arguments[2], fixtures.outbox.row.mock.calls[0].result)))
 
-    expect(fixtures.outbox.publish).toHaveBeenCalledWith(fixtures.outbox.row.mock.results[0].value)
-    expect(result).toStrictEqual(fixtures.storage.upsert.mock.results[0].value)
+    assert.ok(fixtures.outbox.publish.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], fixtures.outbox.row.mock.calls[0].result)))
+    assert.deepStrictEqual(result, fixtures.storage.upsert.mock.calls[0].result)
   })
 
   it('should fill the state a storage without the outbox left alone', async () => {
     await state.apply(changeset, { foo: 1 })
 
-    const row = fixtures.outbox.row.mock.results[0].value
+    const row = fixtures.outbox.row.mock.calls[0].result
 
-    expect(row.event.state).toStrictEqual(fixtures.storage.upsert.mock.results[0].value)
-    expect(row.event.input).toStrictEqual({ foo: 1 })
+    assert.deepStrictEqual(row.event.state, fixtures.storage.upsert.mock.calls[0].result)
+    assert.deepStrictEqual(row.event.input, { foo: 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/transmission.fixtures.js

@@ -1,15 +1,13 @@
-'use strict'
+import { mock } from 'node:test'
 
-const { generate } = require('randomstring')
+import { generate } from 'randomstring'
 
 const binding = (index) => ({
-  request: jest.fn(async (request) => {
+  request: mock.fn(async (request) => {
     if (request?.pick !== undefined && request.pick !== index) return false
 
     return { output: generate() }
   })
 })
 
-const bindings = [0, 1, 2, 3, 4].map(binding)
-
-exports.bindings = bindings
+export const bindings = [0, 1, 2, 3, 4].map(binding)

package/test/transmission.test.js

@@ -1,16 +1,24 @@
-'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 { Connector } from '../src/connector.js'
 
-const { Connector } = require('../src/connector')
-const { Transmission } = require('../src/transmission')
-const { codes } = require('../src/exceptions')
-const fixtures = require('./transmission.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 { Transmission } from '../src/transmission.js'
+import { codes } from '../src/exceptions.js'
+import * as fixtures from './transmission.fixtures.js'
 
 let transmission
 
 beforeEach(() => {
-  jest.clearAllMocks()
+  resetCalls()
+  depends.mock.resetCalls()
 })
 
 beforeEach(() => {
@@ -18,29 +26,39 @@ beforeEach(() => {
 })
 
 it('should be instance of Connector depending on bindings', () => {
-  expect(transmission).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bindings)
+  assert.ok(transmission instanceof Connector)
+  assert.ok(dependencies(transmission).some((one) => isDeepStrictEqual(one, fixtures.bindings)))
 })
 
 it('should pass arguments and return value', async () => {
   const request = { foo: 'bar' }
   const result = await transmission.request(request)
 
-  expect(fixtures.bindings[0].request).toHaveBeenCalledWith(request)
-  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
+  assert.ok(fixtures.bindings[0].request.mock.calls.some((call) => call.arguments.length === 1 && isDeepStrictEqual(call.arguments[0], request)))
+  assert.strictEqual(result, await fixtures.bindings[0].request.mock.calls[0].result)
 })
 
 it('should pick bindings sequentially', async () => {
   let result = await transmission.request()
-  expect(result).toBe(await fixtures.bindings[0].request.mock.results[0].value)
+  assert.strictEqual(result, await fixtures.bindings[0].request.mock.calls[0].result)
 
   result = await transmission.request({ pick: 1 })
-  expect(result).toBe(await fixtures.bindings[1].request.mock.results[0]?.value)
+  assert.strictEqual(result, await fixtures.bindings[1].request.mock.calls[0]?.result)
 })
 
 it('should throw exception if none succeeded', async () => {
-  await expect(transmission.request({ pick: 5 })).rejects.toMatchObject({ code: codes.Transmission })
+  await assert.rejects(transmission.request({ pick: 5 }), (error) => { assert.partialDeepStrictEqual(error, { code: codes.Transmission }); return true })
 
   fixtures.bindings.forEach((binding) =>
-    expect(binding.request).toHaveBeenCalled())
+    assert.ok(binding.request.mock.callCount() > 0))
 })
+
+function resetCalls (target = [assert, 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/types/atomicity.d.ts

@@ -1,6 +1,6 @@
 // noinspection ES6UnusedImports
 
-import { Connector } from './connector'
+import { Connector } from './connector.js'
 
 declare namespace toa.core {
 

package/types/bindings.d.ts

@@ -1,4 +1,4 @@
-import * as _core from './index'
+import * as _core from './index.js'
 
 declare namespace toa.core.bindings {
 

package/types/bridges.ts

@@ -1,6 +1,6 @@
-import type { Request, Reply } from './request'
-import type { Context } from './context'
-import type { Connector } from './connector'
+import type { Request, Reply } from './request.js'
+import type { Context } from './context.js'
+import type { Connector } from './connector.js'
 
 export interface Algorithm {
   mount: (context?: Context) => Promise<void>

package/types/component.d.ts

@@ -1,7 +1,7 @@
-import { Connector } from './connector'
-import { Locator } from './locator'
-import { Request } from './request'
-import { Operation } from './operations'
+import { Connector } from './connector.js'
+import { Locator } from './locator.js'
+import { Request } from './request.js'
+import { Operation } from './operations.js'
 
 export class Component extends Connector {
   locator: Locator

package/types/context.d.ts

@@ -1,8 +1,8 @@
-import * as _request from './request'
-import { Locator } from './locator'
+import * as _request from './request.js'
+import { Locator } from './locator.js'
 import * as _reply from './reply'
-import * as _extensions from './extensions'
-import * as _connector from './connector'
+import * as _extensions from './extensions.js'
+import * as _connector from './connector.js'
 
 export interface Context extends _connector.Connector{
   aspects: _extensions.Aspect[]

package/types/entity.d.ts

@@ -1,5 +1,5 @@
-import * as _event from './event'
-import * as _storages from './storages'
+import * as _event from './event.js'
+import * as _storages from './storages.js'
 
 declare namespace toa.core {
 

package/types/event.d.ts

@@ -1,4 +1,4 @@
-import * as _state from './state'
+import * as _state from './state.js'
 
 declare namespace toa.core {
 

package/types/extensions.d.ts

@@ -1,16 +1,17 @@
-import * as _core from './index'
-import * as _component from './component'
-import * as _context from './context'
-import * as _storages from './storages'
-import * as _bindings from './bindings'
+import * as _core from './index.js'
+import * as _component from './component.js'
+import * as _context from './context.js'
+import * as _storages from './storages.js'
+import * as _bindings from './bindings.js'
 import { Manifest } from '@toa.io/norm'
 
 export interface Factory {
-  tenant? (locator: _core.Locator, manifest: object, component: Manifest): _core.Connector
+  tenant? (locator: _core.Locator, manifest: object, component: Manifest):
+  _core.Connector | Promise<_core.Connector>
 
   aspect? (locator: _core.Locator, manifest: object | null): Aspect | Aspect[]
 
-  service? (name?: string): _core.Connector | null
+  service? (name?: string): _core.Connector | null | Promise<_core.Connector | null>
 
   component? (component: _component.Component): _component.Component
 

package/types/index.ts

@@ -1,17 +1,17 @@
-export * as bindings from './bindings'
-export * as extensions from './extensions'
-export * as storages from './storages'
-export * as outbox from './outbox'
-export * as atomicity from './atomicity'
-export * as bridges from './bridges'
-export * as operations from './operations'
+export * as bindings from './bindings.js'
+export * as extensions from './extensions.js'
+export * as storages from './storages.js'
+export * as outbox from './outbox.js'
+export * as atomicity from './atomicity.js'
+export * as bridges from './bridges.js'
+export * as operations from './operations.js'
 
-export type { Component } from './component'
-export type { Remote } from './remote'
-export { Connector } from './connector'
-export type { Context } from './context'
-export type { Exception } from './exception'
-export { Locator } from './locator'
-export type { Receiver } from './receiver'
-export type { Message } from './message'
-export type { Request, Query, Reply, Source } from './request'
+export type { Component } from './component.js'
+export type { Remote } from './remote.js'
+export { Connector } from './connector.js'
+export type { Context } from './context.js'
+export type { Exception } from './exception.js'
+export { Locator } from './locator.js'
+export type { Receiver } from './receiver.js'
+export type { Message } from './message.js'
+export type { Request, Query, Reply, Source } from './request.js'

package/types/operations.d.ts

@@ -1,4 +1,4 @@
-import { Request } from './request'
+import { Request } from './request.js'
 
 export type type = 'transition' | 'observation' | 'assignment' | 'computation' | 'effect'
 export type scope = 'object' | 'objects' | 'changeset'

package/types/outbox.d.ts

@@ -1,5 +1,5 @@
-import * as _state from './state'
-import * as _atomicity from './atomicity'
+import * as _state from './state.js'
+import * as _atomicity from './atomicity.js'
 
 declare namespace toa.core {
 

package/types/receiver.d.ts

@@ -1,5 +1,5 @@
-import * as _message from './message'
-import * as _connector from './connector'
+import * as _message from './message.js'
+import * as _connector from './connector.js'
 
 declare namespace toa.core {
 

package/types/reflection.d.ts

@@ -1,4 +1,4 @@
-import * as _core from './connector'
+import * as _core from './connector.js'
 
 declare namespace toa.core {
 

package/types/remote.d.ts

@@ -1,4 +1,4 @@
-import { Component } from './component'
+import { Component } from './component.js'
 
 export class Remote extends Component {
   explain (endpoint: string): Promise<Explanation>

package/types/request.d.ts

@@ -1,4 +1,4 @@
-import { Exception } from './exception'
+import { Exception } from './exception.js'
 
 export interface Query {
   id?: string

package/types/state.d.ts

@@ -1,5 +1,5 @@
-import * as _entity from './entity'
-import * as _storages from './storages'
+import * as _entity from './entity.js'
+import * as _storages from './storages.js'
 
 declare namespace toa.core {
 

package/types/storages.d.ts

@@ -1,8 +1,8 @@
 // noinspection ES6UnusedImports
 
-import { Locator } from './locator'
-import { Connector } from './connector'
-import * as outbox from './outbox'
+import { Locator } from './locator.js'
+import { Connector } from './connector.js'
+import * as outbox from './outbox.js'
 
 declare namespace toa.core {