@toa.io/userland 0.2.1-dev.3

package/samples/test/context/components/ok/samples/dummies.dummy.do.yaml

@@ -0,0 +1,11 @@
+title: Third case
+input:
+  foo: bar
+output:
+  baz: true
+---
+title: Fourth case
+input:
+  foo: qux
+output:
+  baz: false

package/samples/test/context/components/ok/samples/dummies.dummy.undo.yaml

@@ -0,0 +1,7 @@
+title: Should undo
+input: 1
+output: true
+---
+title: Should not undo
+input: 0
+output: false

package/samples/test/context/components/ok/samples/messages/somewhere.something.happened.yaml

@@ -0,0 +1,6 @@
+title: Foobar
+payload:
+  foo: bar
+input: foo
+query:
+  id: bar

package/samples/test/context/context.toa.yaml

@@ -0,0 +1,3 @@
+name: test
+packages: components/*
+registry: whatever.none

package/samples/test/context/samples/dummies.dummy.observe.yaml

@@ -0,0 +1,6 @@
+title: Should observe
+query:
+  id: 57022f11306149d8b246c9ea4a164079
+output:
+  id: 57022f11306149d8b246c9ea4a164079
+  bar: 2

package/samples/test/context/samples/dummies.dummy.transit.yaml

@@ -0,0 +1,10 @@
+title: First sample
+input:
+  foo: 1
+output:
+  bar: 2
+---
+input:
+  foo: 2
+output:
+  bar: 3

package/samples/test/context/samples/messages/somewhere.something.happened.yaml

@@ -0,0 +1,6 @@
+title: First sample
+component: dummies.dummy
+payload:
+  foo: 1
+input:
+  bar: 2

package/samples/test/context.fixtures.js

@@ -0,0 +1,8 @@
+'use strict'
+
+const { flip } = require('@toa.io/generic')
+
+const components = jest.fn(async () => flip())
+const mock = { components: { components } }
+
+exports.mock = mock

package/samples/test/context.test.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const { resolve } = require('node:path')
+const { directory: { glob } } = require('@toa.io/filesystem')
+
+const fixtures = require('./context.fixtures')
+const { suite } = require('./suite.mock')
+const { replay } = require('./replay.mock')
+
+const mock = { suite, replay, ...fixtures.mock }
+
+jest.mock('../src/suite', () => mock.suite)
+jest.mock('../src/replay', () => mock.replay)
+jest.mock('../src/components', () => mock.components)
+
+const { context } = require('../src/context')
+
+it('should be', async () => {
+  expect(context).toBeDefined()
+})
+
+const CONTEXT = resolve(__dirname, './context')
+const COMPONENTS = resolve(CONTEXT, 'components/*')
+
+/** @type {string[]} */
+let paths
+
+/** @type {boolean} */
+let ok
+
+beforeAll(async () => {
+  paths = await glob(COMPONENTS)
+})
+
+beforeEach(async () => {
+  jest.clearAllMocks()
+
+  mock.components.components.mockImplementation(async () => true)
+
+  ok = await context(CONTEXT)
+})
+
+it('should replay context components sample sets', async () => {
+  expect(mock.components.components).toHaveBeenCalledWith(paths)
+})
+
+it('should load integration suite', async () => {
+  expect(mock.suite.context).toHaveBeenCalledWith(CONTEXT)
+})
+
+it('should replay integration suite', async () => {
+  const suite = await mock.suite.context.mock.results[0].value
+
+  expect(replay.replay).toHaveBeenCalledWith(suite, paths)
+})
+
+it('should return false if components replay failed', async () => {
+  jest.clearAllMocks()
+
+  mock.components.components.mockImplementation(async () => false)
+
+  ok = await context(CONTEXT)
+
+  expect(ok).toStrictEqual(false)
+  expect(replay.replay).not.toHaveBeenCalled()
+})
+
+it('should return replay result if components replay ok', async () => {
+  jest.clearAllMocks()
+
+  mock.components.components.mockImplementation(async () => true)
+
+  ok = await context(CONTEXT)
+
+  const mocked = await mock.replay.replay.mock.results[0].value
+
+  expect(ok).toStrictEqual(mocked)
+})

package/samples/test/replay.fixtures.js

@@ -0,0 +1,72 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { random } = require('@toa.io/generic')
+
+/** @type {toa.samples.Suite} */
+const suite = { autonomous: true, operations: {} }
+
+/**
+ * @returns {toa.samples.Operation[]}
+ */
+const ops = () => {
+  const samples = []
+
+  for (let i = 0; i < random(3) + 1; i++) {
+    const sample = {
+      input: generate(),
+      output: generate(),
+      local: generate(),
+      current: generate(),
+      next: generate()
+    }
+
+    samples.push(sample)
+  }
+
+  return samples
+}
+
+/**
+ * @returns {toa.samples.Message[]}
+ */
+const msgs = () => {
+  /** @type {toa.samples.Message[]} */
+  const samples = []
+
+  for (let i = 0; i < random(3) + 1; i++) {
+    const sample = /** @type {toa.samples.Message} */ {
+      component: generate(),
+      payload: generate(),
+      input: generate()
+    }
+
+    samples.push(sample)
+  }
+
+  return samples
+}
+
+// components
+for (let i = 0; i < random(3) + 1; i++) {
+  const id = generate() + '.' + generate()
+  const operations = {}
+  const messages = {}
+
+  for (let j = 0; j < random(3) + 1; j++) {
+    const endpoint = generate()
+    const label = generate()
+
+    operations[endpoint] = ops()
+    messages[label] = msgs()
+  }
+
+  suite.operations[id] = operations
+}
+
+/** @type {string} */
+const label = generate()
+
+suite.messages = { [label]: msgs() }
+
+exports.suite = suite

package/samples/test/replay.mock.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const replay = jest.fn(async () => generate())
+
+exports.replay = { replay }

package/samples/test/replay.test.js

@@ -0,0 +1,116 @@
+'use strict'
+
+const { resolve } = require('node:path')
+const clone = require('clone-deep')
+
+const { stage } = require('./stage.mock')
+const { translate } = require('./replay.translate.mock')
+const mock = { stage, translate }
+
+jest.mock('@toa.io/userland/stage', () => mock.stage)
+jest.mock('../src/.replay/.suite/translate', () => mock.translate)
+
+const fixtures = require('./replay.fixtures')
+const { replay } = require('../src')
+
+it('should be', () => {
+  expect(replay).toBeDefined()
+})
+
+let ok
+
+/** @type {toa.samples.Suite} */
+let suite
+
+const path = resolve(__dirname, '../../example/components/math/calculations')
+const paths = [path]
+
+beforeEach(async () => {
+  jest.clearAllMocks()
+
+  suite = clone(fixtures.suite)
+  ok = await replay(suite, paths)
+})
+
+it('should boot composition', () => {
+  expect(stage.composition).toHaveBeenCalled()
+  expect(stage.composition).toHaveBeenCalledWith(paths)
+})
+
+it('should invoke operations with translated samples', async () => {
+  const translation = (declaration) => {
+    const find = (call) => call[0].input === declaration.input
+    const index = mock.translate.operation.mock.calls.findIndex(find)
+
+    return mock.translate.operation.mock.results[index].value
+  }
+
+  /**
+   * @param {string} component
+   * @return {Promise<jest.MockedObject<toa.core.Component>>}
+   */
+  const find = async (component) => {
+    for (let n = 0; n < stage.remote.mock.calls.length; n++) {
+      const call = stage.remote.mock.calls[n]
+
+      if (call[0] === component) return stage.remote.mock.results[n].value
+    }
+
+    throw new Error(`Remote ${component} hasn't been connected`)
+  }
+
+  for (const [id, set] of Object.entries(fixtures.suite.operations)) {
+    const remote = await find(id)
+
+    for (const [endpoint, samples] of Object.entries(set)) {
+      for (const sample of samples) {
+        const request = translation(sample)
+
+        expect(remote.invoke).toHaveBeenCalledWith(endpoint, request)
+      }
+    }
+  }
+})
+
+it('should emit translated messages', async () => {
+  /**
+   * @param {toa.samples.Message} declaration
+   * @param {string} id
+   * @returns {{index: number, message: toa.sampling.Message}}
+   */
+  const translation = (declaration) => {
+    const find = (call) => call[0].payload === declaration.payload
+    const index = mock.translate.message.mock.calls.findIndex(find)
+    const message = mock.translate.message.mock.results[index].value
+    const call = mock.translate.message.mock.calls[index]
+
+    expect(call[1]).toStrictEqual(fixtures.suite.autonomous)
+
+    return { index, message }
+  }
+
+  for (const [label, samples] of Object.entries(fixtures.suite.messages)) {
+    for (const sample of samples) {
+      const { index, message } = translation(sample)
+
+      expect(stage.binding.binding.emit)
+        .toHaveBeenNthCalledWith(index + 1, label, message)
+    }
+  }
+})
+
+it('should shutdown stage', () => {
+  expect(stage.shutdown).toHaveBeenCalled()
+})
+
+it('should return results', () => {
+  expect(ok).toStrictEqual(true)
+})
+
+it.each(['messages', 'operations'])('should not throw if no %s defined', async (key) => {
+  delete suite[key]
+
+  ok = await replay(suite, paths)
+
+  expect(ok).toStrictEqual(true)
+})

package/samples/test/replay.translate.message.fixtures.js

@@ -0,0 +1,24 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { flip } = require('@toa.io/generic')
+
+/** @type {toa.samples.Message} */
+const message = {
+  title: generate(),
+  payload: { [generate()]: generate() },
+  input: generate(),
+  query: { id: generate() },
+  request: {
+    current: {
+      id: generate()
+    }
+  }
+}
+
+const autonomous = flip()
+const component = generate()
+
+exports.message = message
+exports.autonomous = autonomous
+exports.component = component

package/samples/test/replay.translate.message.test.js

@@ -0,0 +1,123 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+const fixtures = require('./replay.translate.message.fixtures')
+const { message: translate } = require('../src/.replay/.suite/translate')
+const { generate } = require('randomstring')
+
+it('should be', async () => {
+  expect(translate).toBeDefined()
+})
+
+/** @type {toa.samples.Message} */
+let declaration
+
+/** @type {toa.sampling.Message} */
+let message
+
+/** @type {toa.sampling.messages.Sample} */
+let sample
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  declaration = clone(fixtures.message)
+  message = translate(declaration, fixtures.autonomous, fixtures.component)
+  sample = message.sample
+})
+
+it('should copy payload', async () => {
+  expect(message.payload).toStrictEqual(declaration.payload)
+})
+
+it('should copy title', async () => {
+  expect(sample.request.title).toStrictEqual(declaration.title)
+})
+
+it('should copy autonomous', async () => {
+  expect(sample.request.autonomous).toStrictEqual(fixtures.autonomous)
+})
+
+it('should copy component', async () => {
+  expect(sample.component).toStrictEqual(fixtures.component)
+})
+
+it.each(['input', 'query'])('should copy %s to request', async (key) => {
+  const value = declaration[key]
+
+  expect(sample.request.request[key]).toStrictEqual(value)
+})
+
+it.each(['input', 'query'])('should create request with %s', async (key) => {
+  const value = declaration[key]
+
+  delete declaration.request
+
+  const { sample } = translate(declaration, fixtures.autonomous, fixtures.component)
+
+  expect(sample.request.request[key]).toStrictEqual(value)
+})
+
+it('should keep request properties', async () => {
+  expect(sample.request.storage.current).toMatchObject(fixtures.message.request.current)
+})
+
+it('should add `terminate: true` if request is not defined (and sample is autonomous)',
+  async () => {
+    delete declaration.request
+
+    message = translate(declaration, fixtures.autonomous, fixtures.component)
+
+    expect(message.sample.request.terminate).toStrictEqual(true)
+  })
+
+it('should not create undefined keys in request', async () => {
+  delete declaration.input
+
+  message = translate(declaration, fixtures.autonomous, fixtures.component)
+
+  expect('input' in message.sample.request.request).toStrictEqual(false)
+})
+
+it('should declare sample as authentic', async () => {
+  expect(sample.authentic).toStrictEqual(true)
+})
+
+describe('validation', () => {
+  /** @type {toa.samples.Message} */
+  let declaration
+
+  const check = () => translate(declaration, fixtures.autonomous, fixtures.component)
+
+  beforeEach(() => {
+    declaration = clone(fixtures.message)
+  })
+
+  it('should throw on schema mismatch', async () => {
+    // noinspection JSValidateTypes
+    declaration.title = { foo: 1 }
+
+    expect(check).toThrow('must be string')
+  })
+
+  it('should throw on request schema mismatch', async () => {
+    // noinspection JSValidateTypes
+    declaration.request = { title: { foo: 1 } }
+
+    expect(check).toThrow('must be string')
+  })
+
+  it.each(['input', 'query'])('should throw if request.%s is defined', async (key) => {
+    expect.assertions(1)
+
+    declaration[key] = { id: generate() }
+    declaration.request = /** @type {toa.samples.Operation} */ { [key]: { id: generate() } }
+
+    try {
+      check()
+    } catch (exception) {
+      expect(exception).toMatchObject({ path: '/request' })
+    }
+  })
+})

package/samples/test/replay.translate.mock.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+// noinspection JSCheckFunctionSignatures
+const operation = jest.fn((declaration) => {
+  const { input, ...sample } = declaration
+
+  return { input, sample }
+})
+
+// noinspection JSCheckFunctionSignatures
+const message = jest.fn((declaration) => generate())
+
+const translate = { operation, message }
+
+exports.translate = translate

package/samples/test/replay.translate.operation.fixtures.js

@@ -0,0 +1,107 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { flip } = require('@toa.io/generic')
+
+const title = generate()
+const input = generate()
+const output = generate()
+const reply = { output }
+
+const context = {}
+
+context.declaration = {
+  local: {
+    do: {
+      input: generate(),
+      output: generate()
+    },
+    undo: [
+      {
+        input: generate()
+      },
+      {
+        output: generate()
+      }
+    ]
+  }
+}
+
+context.sample = {
+  local: {
+    do: [
+      {
+        request: {
+          input: context.declaration.local.do.input
+        },
+        reply: {
+          output: context.declaration.local.do.output
+        }
+      }
+    ],
+    undo: [
+      {
+        request: {
+          input: context.declaration.local.undo[0].input
+        }
+      },
+      {
+        reply: {
+          output: context.declaration.local.undo[1].output
+        }
+      }
+    ]
+  }
+}
+
+const storage = {}
+
+storage.declaration = {
+  current: flip() ? { foo: generate() } : [{ foo: generate() }], // object or array
+  next: { foo: generate() }
+}
+
+storage.sample = {
+  current: storage.declaration.current,
+  next: storage.declaration.next
+}
+
+const events = { declaration: {}, sample: {} }
+const label = generate()
+
+events.declaration[label] = { [generate()]: generate() }
+events.sample[label] = { payload: events.declaration[label] }
+
+const extension = () => ([{ permanent: flip() }])
+
+/** @type {toa.samples.Extensions} */
+const extensions = { [generate()]: extension() }
+
+/** @type {toa.samples.Operation} */
+const declaration = {
+  title,
+  input,
+  output,
+  ...context.declaration,
+  ...storage.declaration,
+  events: events.declaration,
+  extensions
+}
+
+/** @type {toa.sampling.Request} */
+const expected = {
+  input,
+  sample: {
+    authentic: true,
+    autonomous: true,
+    title,
+    reply,
+    context: context.sample,
+    storage: storage.sample,
+    events: events.sample,
+    extensions
+  }
+}
+
+exports.declaration = declaration
+exports.expected = expected

package/samples/test/replay.translate.operation.test.js

@@ -0,0 +1,68 @@
+'use strict'
+
+const clone = require('clone-deep')
+const { generate } = require('randomstring')
+
+const fixtures = require('./replay.translate.operation.fixtures')
+const { operation: translate } = require('../src/.replay/.suite/translate')
+
+it('should be', () => {
+  expect(translate).toBeDefined()
+})
+
+/** @type {toa.samples.Operation} */
+let declaration
+
+/** @type {toa.sampling.Request} */
+let request
+
+/** @type {toa.sampling.request.Sample} */
+let expected
+
+const autonomous = true
+
+beforeEach(() => {
+  declaration = clone(fixtures.declaration)
+  expected = clone(fixtures.expected)
+  request = translate(declaration, autonomous)
+})
+
+it('should translate input', () => {
+  expect(request).toStrictEqual(expected)
+})
+
+describe('validation', () => {
+  it('should not allow additional properties', () => {
+    declaration.foo = generate()
+
+    expect(() => translate(declaration, true)).toThrow('must NOT have additional properties')
+  })
+})
+
+describe('specials', () => {
+  it('should transform configuration object to permanent sample', async () => {
+    const configuration = { foo: generate() }
+    const declaration = /** @type {toa.samples.Operation} */ { configuration }
+    const request = translate(declaration, true)
+
+    expect(request.sample.extensions.configuration).toStrictEqual([{
+      result: configuration,
+      permanent: true
+    }])
+  })
+
+  it('should throw if configuration is provided twice', async () => {
+    const configuration = { foo: generate() }
+
+    const declaration = {
+      configuration,
+      extensions: {
+        configuration: [{
+          result: configuration
+        }]
+      }
+    }
+
+    expect(() => translate(declaration, true)).toThrow('ambiguous')
+  })
+})