@toa.io/userland 0.10.1-dev.0 → 0.20.0-alpha.0

package/samples/src/.replay/.suite/translate/.operation/.prepare/shortcuts/configuration.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { aspect } = require('./.aspect')
+
+exports.configuration = aspect('configuration')

package/samples/src/.replay/.suite/translate/.operation/.prepare/shortcuts/http.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { aspect } = require('./.aspect')
+
+exports.http = aspect('http')

package/samples/src/.replay/.suite/translate/.operation/.prepare/shortcuts/index.js

@@ -0,0 +1,9 @@
+'use strict'
+
+const { configuration } = require('./configuration')
+const { state } = require('./state')
+const { http } = require('./http')
+
+exports.configuration = configuration
+exports.state = state
+exports.http = http

package/samples/src/.replay/.suite/translate/.operation/.prepare/shortcuts/state.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { aspect } = require('./.aspect')
+
+exports.state = aspect('state')

package/samples/src/.replay/.suite/translate/.operation/.prepare/types/async.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = (value) => async () => value

package/samples/src/.replay/.suite/translate/.operation/.prepare/types/cast.js

@@ -0,0 +1,26 @@
+'use strict'
+
+const { map } = require('@toa.io/generic')
+
+const types = {
+  Map: require('./map'),
+  Set: require('./set'),
+  sync: require('./sync'),
+  async: require('./async')
+}
+
+function cast (value) {
+  return map(value, replace)
+}
+
+function replace (key, value) {
+  const [name, type] = key.split(':')
+
+  if (!(type in types)) return
+
+  const typed = types[type](value)
+
+  return [name, typed]
+}
+
+exports.cast = cast

package/samples/src/.replay/.suite/translate/.operation/.prepare/types/index.js

@@ -0,0 +1,5 @@
+'use strict'
+
+const { cast } = require('./cast')
+
+exports.cast = cast

package/samples/src/.replay/.suite/translate/.operation/.prepare/types/map.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = (value) => new Map(Object.entries(value))

package/samples/src/.replay/.suite/translate/.operation/.prepare/types/set.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = (value) => new Set(value)

package/samples/src/.replay/.suite/translate/.operation/.prepare/types/sync.js

@@ -0,0 +1,3 @@
+'use strict'
+
+module.exports = (value) => () => value

package/samples/src/.replay/.suite/translate/.operation/prepare.js

@@ -1,14 +1,14 @@
 'use strict'
 
-const specials = require('./specials')
+const { cast, expand } = require('./.prepare')
 
 /**
  * @param {toa.samples.Operation & Object} declaration
  */
 const prepare = (declaration) => {
-  for (const [keyword, prepare] of Object.entries(specials)) {
-    if (keyword in declaration) prepare(declaration)
-  }
+  expand(declaration)
+
+  if ('extensions' in declaration) cast(declaration.extensions)
 }
 
 exports.prepare = prepare

package/samples/src/.replay/index.js

@@ -1,5 +1,7 @@
 'use strict'
 
 const { test } = require('./test')
+const stage = require('./stage')
 
 exports.test = test
+exports.stage = stage

package/samples/src/.replay/stage.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const stage = require('@toa.io/userland/stage')
+const storage = require.resolve('@toa.io/storages.null')
+
+/**
+ * @param {string[]} paths
+ * @param {boolean} autonomous
+ * @return {Promise<Record<string, toa.core.Component>>}
+ */
+async function setup (paths, autonomous) {
+  if (!autonomous) return remotes(paths)
+  else return components(paths)
+}
+
+async function remotes (paths) {
+  await stage.composition(paths)
+
+  const remotes = {}
+
+  for (const path of paths) {
+    const id = await getId(path)
+
+    remotes[id] = await stage.remote(id)
+  }
+
+  return remotes
+}
+
+async function components (paths) {
+  const components = {}
+
+  process.env.TOA_SAMPLING_AUTONOMOUS = '1'
+
+  for (const path of paths) {
+    const id = await getId(path)
+
+    components[id] = await stage.component(path, { storage })
+  }
+
+  delete process.env.TOA_SAMPLING_AUTONOMOUS
+
+  return components
+}
+
+async function getId (path) {
+  const manifest = await stage.manifest(path)
+
+  return manifest.locator.id
+}
+
+/**
+ * @return {Promise<void>}
+ */
+async function shutdown () {
+  await stage.shutdown()
+}
+
+exports.setup = setup
+exports.shutdown = shutdown

package/samples/src/.replay/suite.js

@@ -4,12 +4,13 @@ const replay = require('./.suite')
 
 /**
  * @param {toa.samples.Suite} suite
+ * @param {Record<string, toa.core.Component>} components
  * @returns {Function}
  */
-const suite = (suite) =>
+const suite = (suite, components) =>
   async (test) => {
     if ('operations' in suite) {
-      await test.test('Operations', replay.operations(suite.operations, suite.autonomous))
+      await test.test('Operations', replay.operations(suite.operations, components, suite.autonomous))
     }
 
     if ('messages' in suite) {

package/samples/src/.replay/test.js

@@ -6,12 +6,14 @@ const replay = require('./suite')
 
 /**
  * @param {toa.samples.Suite} suite
+ * @param {Record<string, toa.core.Component>} components
+ * @param {object} options
  * @return {Promise<boolean>}
  */
-const test = async (suite) => {
-  const { ok } = await tap.test(suite.title, replay.suite(suite))
+const test = async (suite, components, options) => {
+  const result = await tap.test(suite.title, options, replay.suite(suite, components))
 
-  return ok
+  return result === null ? false : result.ok
 }
 
 exports.test = test

package/samples/src/components.js

@@ -7,7 +7,7 @@ const { replay } = require('./replay')
 const components = async (paths, options = {}) => {
   const suite = await load(paths, options)
 
-  return await replay(suite, paths)
+  return await replay(suite, paths, options.runner)
 }
 
 exports.components = components

package/samples/src/context.js

@@ -9,13 +9,13 @@ const { replay } = require('./replay')
 /** @type {toa.samples.replay.context} */
 const context = async (path, options = {}) => {
   const context = await norm.context(path)
-  const paths = context.components.map((component) => component.path)
   const suite = await load(path, options)
+  const paths = context.components.map((component) => component.path)
 
   let ok = true
 
   if (options.integration !== true) ok = await test.components(paths, options)
-  if (ok) ok = await replay(suite, paths)
+  if (ok && options.autonomous !== true) ok = await replay(suite, paths, options.runner)
 
   return ok
 }

package/samples/src/replay.js

@@ -1,13 +1,12 @@
 'use strict'
 
-const stage = require('@toa.io/userland/stage')
-const { test } = require('./.replay')
+const { test, stage } = require('./.replay')
 
 /** @type {toa.samples.replay.replay} */
-const replay = async (suite, paths) => {
-  await stage.composition(paths)
+const replay = async (suite, paths, options = undefined) => {
+  const components = await stage.setup(paths, suite.autonomous)
 
-  const ok = await test(suite)
+  const ok = await test(suite, components, options)
 
   await stage.shutdown()
 

package/samples/src/suite/components.js

@@ -12,7 +12,7 @@ const read = require('./.read')
  */
 const components = async (paths, options = {}) => {
   /** @type {toa.samples.Suite} */
-  const suite = { title: 'Component samples', autonomous: true, operations: {}, messages: {} }
+  const suite = { title: 'Component samples', autonomous: true, operations: {} }
 
   for (const path of paths) {
     const manifest = await norm.component(path)
@@ -20,9 +20,9 @@ const components = async (paths, options = {}) => {
     options.id = manifest.locator.id
 
     const operations = await read.operations(path, options)
-    const messages = await read.messages(path, options)
+    // const messages = await read.messages(path, options)
 
-    merge(suite, { operations, messages })
+    merge(suite, { operations })
   }
 
   return suite

package/samples/test/components.test.js

@@ -18,7 +18,7 @@ it('should be', () => {
 const paths = [generate()]
 
 /** @type {toa.samples.suite.Options} */
-const options = { component: generate() }
+const options = { component: generate(), runner: { [generate()]: generate() } }
 
 /** @type {boolean} */
 let result
@@ -34,7 +34,7 @@ it('should load suite', async () => {
 it('should replay suite', async () => {
   const suite = await mock.suite.components.mock.results[0].value
 
-  expect(mock.replay.replay).toHaveBeenCalledWith(suite, paths)
+  expect(mock.replay.replay).toHaveBeenCalledWith(suite, paths, options.runner)
 })
 
 it('should return result', async () => {

package/samples/test/context.test.js

@@ -27,7 +27,7 @@ const COMPONENTS = resolve(CONTEXT, 'components/*')
 let paths
 
 /** @type {toa.samples.suite.Options} */
-const options = { component: generate() }
+const options = { component: generate(), runner: { [generate()]: generate() } }
 
 /** @type {boolean} */
 let ok
@@ -55,7 +55,7 @@ it('should load integration suite', async () => {
 it('should replay integration suite', async () => {
   const suite = await mock.suite.context.mock.results[0].value
 
-  expect(replay.replay).toHaveBeenCalledWith(suite, paths)
+  expect(replay.replay).toHaveBeenCalledWith(suite, paths, options.runner)
 })
 
 it('should return false if components replay failed', async () => {

package/samples/test/replay.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { resolve } = require('node:path')
-const clone = require('clone-deep')
+const { directory } = require('@toa.io/filesystem')
 
 const { stage } = require('./stage.mock')
 const { translate } = require('./replay.translate.mock')
@@ -10,7 +10,8 @@ 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 load = require('../src/suite')
+
 const { replay } = require('../src')
 
 it('should be', () => {
@@ -22,95 +23,130 @@ let ok
 /** @type {toa.samples.Suite} */
 let suite
 
-const path = resolve(__dirname, '../../example/components/math/calculations')
-const paths = [path]
-
-beforeEach(async () => {
+beforeEach(() => {
   jest.clearAllMocks()
-
-  suite = clone(fixtures.suite)
-  ok = await replay(suite, paths)
 })
 
-it('should boot composition', () => {
-  expect(stage.composition).toHaveBeenCalled()
-  expect(stage.composition).toHaveBeenCalledWith(paths)
-})
+describe('autonomous', () => {
+  let 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)
+  beforeEach(async () => {
+    const path = resolve(__dirname, '../../example/components/tea.pots')
 
-    return mock.translate.operation.mock.results[index].value
-  }
+    paths = [path]
+    suite = await load.components(paths)
+    ok = await replay(suite, paths)
+  })
 
-  /**
-   * @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]
+  it('should not boot composition for autonomous suite', async () => {
+    expect(stage.composition).not.toHaveBeenCalled()
+  })
 
-      if (call[0] === component) return stage.remote.mock.results[n].value
+  it('should invoke operations with translated samples', async () => {
+    const component = await stage.component.mock.results[0].value
+
+    for (const set of Object.values(suite.operations)) {
+      for (const [endpoint, samples] of Object.entries(set)) {
+        for (const sample of samples) {
+          const request = translation(sample)
+
+          expect(component.invoke).toHaveBeenCalledWith(endpoint, request)
+        }
+      }
     }
+  })
+})
 
-    throw new Error(`Remote ${component} hasn't been connected`)
-  }
+describe('integration', () => {
+  let paths
 
-  for (const [id, set] of Object.entries(fixtures.suite.operations)) {
-    const remote = await find(id)
+  beforeEach(async () => {
+    const path = resolve(__dirname, '../../example')
 
-    for (const [endpoint, samples] of Object.entries(set)) {
-      for (const sample of samples) {
-        const request = translation(sample)
+    paths = await directory.directories(resolve(path, 'components'))
+    suite = await load.context(path)
+    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 () => {
+    /**
+     * @param {string} component
+     * @return {jest.MockedObject<toa.core.Component>}
+     */
+    const getRemote = (component) => {
+      for (let n = 0; n < stage.remote.mock.calls.length; n++) {
+        const call = stage.remote.mock.calls[n]
 
-        expect(remote.invoke).toHaveBeenCalledWith(endpoint, request)
+        if (call[0] === component) return stage.remote.mock.results[n].value
       }
+
+      throw new Error(`Remote ${component} hasn't been connected`)
     }
-  }
-})
 
-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)
+    for (const [id, set] of Object.entries(suite.operations)) {
+      const remote = await getRemote(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
+     * @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(suite.autonomous)
+
+      return { index, message }
     }
-  }
-})
 
-it('should shutdown stage', () => {
-  expect(stage.shutdown).toHaveBeenCalled()
-})
+    for (const [label, samples] of Object.entries(suite.messages)) {
+      for (const sample of samples) {
+        const { index, message } = translation(sample)
 
-it('should return results', () => {
-  expect(ok).toStrictEqual(true)
-})
+        expect(stage.binding.binding.emit)
+          .toHaveBeenNthCalledWith(index + 1, label, message)
+      }
+    }
+  })
+
+  it('should shutdown stage', () => {
+    expect(stage.shutdown).toHaveBeenCalled()
+  })
 
-it.each(['messages', 'operations'])('should not throw if no %s defined', async (key) => {
-  delete suite[key]
+  it('should return results', () => {
+    expect(ok).toStrictEqual(true)
+  })
 
-  ok = await replay(suite, paths)
+  it.each(['messages', 'operations'])('should not throw if no %s defined', async (key) => {
+    delete suite[key]
 
-  expect(ok).toStrictEqual(true)
+    ok = await replay(suite, paths)
+
+    expect(ok).toStrictEqual(true)
+  })
 })
+
+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
+}

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

@@ -108,16 +108,12 @@ describe('validation', () => {
     expect(check).toThrow('must be string')
   })
 
-  it.each(['input', 'query'])('should throw if request.%s is defined', async (key) => {
+  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' })
-    }
+    expect(() => check()).toThrow('/request')
   })
 })

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

@@ -35,7 +35,7 @@ describe('validation', () => {
   it('should not allow additional properties', () => {
     declaration.foo = generate()
 
-    expect(() => translate(declaration, true)).toThrow('must NOT have additional properties')
+    expect(() => translate(declaration, true)).toThrow('not expected')
   })
 })
 

package/samples/test/stage.mock.js

@@ -2,33 +2,29 @@
 
 'use strict'
 
-const { generate } = require('randomstring')
 const { Locator } = require('@toa.io/core')
+const stage = jest.requireActual('@toa.io/userland/stage')
 
-const locator = () => {
-  const name = generate()
-  const namespace = generate()
-
-  return new Locator(name, namespace)
-}
-
-// stage
-const manifest = jest.fn(async (path) => ({ path, locator: locator() }))
+const manifest = jest.fn(async (path) => stage.manifest(path))
 const composition = jest.fn()
 const shutdown = jest.fn()
 
 const remote = jest.fn(async (id) => {
   const [namespace, name] = id.split('.')
   const locator = new Locator(name, namespace)
-  const invoke = jest.fn(async (operation, request) => request.reply)
+  const invoke = jest.fn(async (endpoint, request) => request.reply)
   const disconnect = jest.fn(async () => undefined)
 
   return { locator, invoke, disconnect }
 })
 
+const component = jest.fn(async () => {
+  const invoke = jest.fn(async (endpoint, request) => request.reply)
+
+  return { invoke }
+})
+
 const emit = jest.fn()
 const binding = { binding: { emit } }
 
-const stage = { manifest, composition, remote, shutdown, binding }
-
-exports.stage = stage
+exports.stage = { manifest, composition, component, remote, shutdown, binding }