@toa.io/userland 1.1.0-dev.0 → 1.1.1-alpha.56

package/example/components/echo/operations/signal.js

@@ -1,7 +1,15 @@
 'use strict'
 
-async function computation (input, context) {
-  return context.configuration.signal
+class Computation {
+  #context
+
+  async mount (context) {
+    this.#context = context
+  }
+
+  async execute () {
+    return this.#context.configuration.signal
+  }
 }
 
-exports.computation = computation
+exports.Computation = Computation

package/example/components/echo/samples/signal.yaml

@@ -1,6 +1,3 @@
-title: Should echo
-output: quack
----
 title: Should substitute configuration
 output: woof
 configuration:

package/example/components/math.calculations/samples/add.yaml

@@ -1,7 +1,6 @@
 title: Should add numbers
 input:
-  a: 1
-  b: 2
+  $import: assets/ab.yaml
 output: 3
 ---
 title: Should add negative numbers

package/example/components/math.calculations/samples/assets/ab.yaml

@@ -0,0 +1,2 @@
+a: 1
+b: 2

package/example/components/math.calculations/samples/increment.yaml

@@ -1,6 +1,7 @@
 title: Should increment number
 input:
   value: 1
+  times: 1
 output: 2
 local:
   add:
@@ -9,12 +10,7 @@ local:
       b: 1
     output: 2
 ---
-title: Should increment with actual call
-input:
-  value: 2
-output: 3
----
-title: Should increment twice (with second actual call)
+title: Should increment twice
 input:
   value: 0
   times: 2
@@ -28,3 +24,4 @@ local:
     - input:
         a: 1
         b: 1
+      output: 2

package/example/components/web/operations/get.js

@@ -2,6 +2,10 @@
 
 async function computation (_, context) {
   const response = await context.http.dev.path.to.resource.get()
+  const type = response.headers.get('content-type')
+
+  if (type !== 'application/json') return { error: { code: 0, message: 'Unsupported media type ' + type } }
+
   const output = await response.json()
 
   return { output }

package/example/components/web/samples/get.yaml

@@ -1,5 +1,7 @@
 title: Should return response
 http:
+  headers:
+    get:sync: 'application/json'
   json:async:
     foo: bar
 output:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/userland",
-  "version": "1.1.0-dev.0",
+  "version": "1.1.1-alpha.56+a80d81d4",
   "description": "Toa development kit",
   "homepage": "https://toa.io",
   "author": {
@@ -24,14 +24,15 @@
   "main": "src/index.js",
   "types": "types/index.d.ts",
   "dependencies": {
-    "@toa.io/boot": "1.0.1-dev.0",
-    "@toa.io/core": "1.0.1-dev.0",
-    "@toa.io/filesystem": "1.0.1-dev.0",
-    "@toa.io/generic": "0.10.0-dev.0",
-    "@toa.io/norm": "1.0.1-dev.0",
-    "@toa.io/schemas": "0.8.3-dev.0",
-    "@toa.io/yaml": "0.7.5-dev.0",
+    "@toa.io/boot": "1.0.2-alpha.56+a80d81d4",
+    "@toa.io/core": "1.0.2-alpha.56+a80d81d4",
+    "@toa.io/filesystem": "1.0.2-alpha.56+a80d81d4",
+    "@toa.io/generic": "0.10.1-alpha.56+a80d81d4",
+    "@toa.io/norm": "1.0.2-alpha.56+a80d81d4",
+    "@toa.io/schemas": "0.8.4-alpha.56+a80d81d4",
+    "@toa.io/storages.null": "0.6.0",
+    "@toa.io/yaml": "0.7.6-alpha.56+a80d81d4",
     "tap": "16.3.4"
   },
-  "gitHead": "5e7998b39ea6111a2cf7d38fad8aeae71d742621"
+  "gitHead": "a80d81d4d9da9fec07606154c959dd6512de4c76"
 }

package/samples/readme.md

@@ -36,7 +36,7 @@ Message Sample is an object containing receiver's input (`payload`) to be substi
 outcomes (`input` and `query`) to be verified. Message sample may contain the corresponding operation
 sample. See its [schema](./src/.replay/.suite/translate/schemas/message.cos.yaml).
 
-> Message samples are always [autonomous](#autonomy).
+> Message samples are only supported at [context level](#autonomy).
 
 ### Declaration
 
@@ -92,6 +92,40 @@ context (so as required extensions). See [examples](../example/samples).
 
 ## Replay
 
-Samples may be *replayed* using [`toa replay`](/runtime/cli/readme.md#replay) command.
-
 > Replaying samples requires local deployment environment.
+
+### CLI
+
+Samples may be replayed using [`toa replay`](/runtime/cli/readme.md#replay) command.
+
+See [features](/features/cli/replay.feature).
+
+### Framework
+
+`async components(paths: string[], options?): boolean`
+
+Replay component samples.
+
+`async components(paths: string[], options?): boolean`
+
+Replay context and its components' samples.
+
+#### Options
+
+<dl>
+<dt><code><strong>id</strong>: string</code></dt>
+<dd>Replay samples for a specified component</dd>
+
+<dt><code><strong>integration</strong>: string</code></dt>
+<dd>Replay samples for a specified component only</dd>
+<dd></dd>
+
+<dt><code><strong>operation</strong>: string</code></dt>
+<dd>Replay samples for specified operation</dd>
+
+<dt><code><strong>title</strong>: string</code></dt>
+<dd>Replay samples with titles matching given regexp</dd>
+
+</dl>
+
+See [types](types/suite.d.ts).

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

@@ -5,21 +5,16 @@ const stage = require('@toa.io/userland/stage')
 const { operation } = require('./operation')
 
 /**
- *
- * @param {string} id
+ * @param {toa.core.Component} component
  * @param {toa.samples.operations.Set} set
  * @param {boolean} autonomous
  * @returns {Function}
  */
-const component = (id, set, autonomous) =>
+const component = (component, set, autonomous) =>
   async (test) => {
-    const remote = await stage.remote(id)
-
     for (const [endpoint, samples] of Object.entries(set)) {
-      await test.test(endpoint, operation(remote, endpoint, samples, autonomous))
+      await test.test(endpoint, operation(component, endpoint, samples, autonomous))
     }
-
-    await remote.disconnect()
   }
 
 exports.component = component

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

@@ -19,7 +19,7 @@ const operation = (remote, endpoint, samples, autonomous) =>
       const request = translate.operation(operation, autonomous)
       const name = operation.title ?? 'Sample #' + n
 
-      await test.test(name, async () => remote.invoke(endpoint, request))
+      await test.test(name, async () => await remote.invoke(endpoint, request))
     }
 
     test.end()

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

@@ -4,15 +4,17 @@ const { component } = require('./component')
 
 /**
  * @param {toa.samples.suite.Operations} operations
+ * @param {Record<string, toa.core.Component>} components
  * @param {boolean} autonomous
  * @return {Function}
  */
-const operations = (operations, autonomous) =>
+const operations = (operations, components, autonomous) =>
   async (test) => {
     for (const [id, set] of Object.entries(operations)) {
-      await test.test(id, component(id, set, autonomous))
-    }
+      const remote = components[id]
 
+      await test.test(id, component(remote, set, autonomous))
+    }
   }
 
 exports.operations = operations

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

@@ -92,4 +92,3 @@ it('should cast to async Function', async () => {
   expect(promise).toBeInstanceOf(Promise)
   await expect(promise).resolves.toStrictEqual('hello')
 })
-

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) 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/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 }

package/samples/test/suite.components.test.js

@@ -34,7 +34,7 @@ it('should define suite as autonomous', async () => {
   expect(suite.autonomous).toStrictEqual(true)
 })
 
-it('should load component samples', async () => {
+it('should load operation samples', async () => {
   const expected = await operations()
 
   expect(Object.keys(suite.operations)).toStrictEqual([component])
@@ -47,12 +47,6 @@ it('should load component samples', async () => {
   expect(set.undo).toStrictEqual(expected.undo)
 })
 
-it('should load message samples', async () => {
-  const expected = await messages()
-
-  expect(suite.messages).toStrictEqual(expected)
-})
-
 describe('options', () => {
   const paths = [dummy, pot]
 
@@ -63,11 +57,6 @@ describe('options', () => {
     suite = await components(paths, options)
 
     expect(suite.operations['dummies.pot']).toBeUndefined()
-
-    const messages = suite.messages['somewhere.something.happened']
-
-    expect(messages.length).toStrictEqual(1)
-    expect(messages[0].component).toStrictEqual('dummies.dummy')
   })
 
   it('should filter samples by operation name', async () => {
@@ -101,16 +90,14 @@ describe('options', () => {
     expect(suite.operations['dummies.dummy'].undo[0].title).toStrictEqual('Should not undo')
   })
 
-  it('should filter message samples by title', async () => {
+  it('should filter operation samples by title', async () => {
     /** @type {toa.samples.suite.Options} */
-    const options = { title: 'Something happened with a dummy' }
+    const options = { title: 'Should not undo' }
 
     suite = await components(paths, options)
 
-    const messages = suite.messages['somewhere.something.happened']
-
-    expect(messages.length).toStrictEqual(1)
-    expect(messages[0].title).toStrictEqual(options.title)
+    expect(Object.keys(suite.operations['dummies.dummy']).length).toStrictEqual(1)
+    expect(suite.operations['dummies.dummy'].undo[0].title).toStrictEqual(options.title)
   })
 })
 
@@ -133,16 +120,3 @@ const operations = async () => {
     do: [...do1, ...do2], undo
   }
 }
-
-/**
- *
- * @returns {Promise<toa.samples.messages.Set>}
- */
-const messages = async () => {
-  const label = 'somewhere.something.happened'
-  const file = resolve(dummy, 'samples/messages', label + '.yaml')
-  const declarations = await yaml.load.all(file)
-  const messages = declarations.map((sample) => ({ component, ...sample }))
-
-  return { [label]: messages }
-}

package/samples/types/replay.d.ts

@@ -2,9 +2,9 @@ import * as _suite from './suite'
 
 declare namespace toa.samples.replay {
 
-  type components = (paths: string[], options?: _suite.Options) => Promise<boolean>
-  type context = (path: string, options?: _suite.Options) => Promise<boolean>
-  type replay = (suite: _suite.Suite, paths: string[]) => Promise<boolean>
+    type components = (paths: string[], options?: _suite.Options) => Promise<boolean>
+    type context = (path: string, options?: _suite.Options) => Promise<boolean>
+    type replay = (suite: _suite.Suite, paths: string[], options?: object) => Promise<boolean>
 
 }
 

package/samples/types/suite.d.ts

@@ -1,3 +1,4 @@
+import * as _core from '@toa.io/core/types'
 import * as _operations from './operation'
 import * as _messages from './message'
 
@@ -12,11 +13,12 @@ declare namespace toa.samples {
       component?: string
       operation?: string
       title?: string
+      runner?: object
     }
   }
 
   type Suite = {
-    title: string
+    title?: string
     autonomous: boolean
     operations?: suite.Operations
     messages?: _messages.Set

package/stage/src/component.js

@@ -4,8 +4,10 @@ const boot = require('@toa.io/boot')
 const { state } = require('./state')
 
 /** @type {toa.stage.Component} */
-const component = async (path) => {
-  const manifest = await boot.manifest(path)
+const component = async (path, options) => {
+  options = Object.assign({}, DEFAULTS, options)
+
+  const manifest = await boot.manifest(path, options)
   const component = await boot.component(manifest)
 
   await component.connect()
@@ -15,4 +17,7 @@ const component = async (path) => {
   return component
 }
 
+const binding = require.resolve('./binding')
+const DEFAULTS = { bindings: [binding] }
+
 exports.component = component

package/stage/test/component.test.js

@@ -18,7 +18,7 @@ it('should boot component', async () => {
   const path = generate()
   const component = await stage.component(path)
 
-  expect(mock.boot.manifest).toHaveBeenCalledWith(path)
+  expect(mock.boot.manifest.mock.calls[0][0]).toStrictEqual(path)
   expect(mock.boot.component).toHaveBeenCalledWith(await mock.boot.manifest.mock.results[0].value)
   expect(component).toStrictEqual(await mock.boot.component.mock.results[0].value)
   expect(component.connect).toHaveBeenCalled()

package/stage/types/index.d.ts

@@ -1,9 +1,10 @@
 import * as _core from '@toa.io/core/types'
 import * as _norm from '@toa.io/norm/types'
+import * as _composition from '@toa.io/boot/types/composition'
 
 declare namespace toa.stage {
   type Manifest = (path: string) => Promise<_norm.Component>
-  type Component = (path: string) => Promise<_core.Component>
+  type Component = (path: string, options?: _composition.Options) => Promise<_core.Component>
   type Composition = (paths: string[]) => Promise<void>
   type Remote = (id: string) => Promise<_core.Component>
   type Shutdown = () => Promise<void>

package/example/components/tea.pots/samples/messages/store.orders.created.yaml

@@ -1,37 +0,0 @@
-title: Should book a pot
-payload:
-  pot: 1b9d7983bc204c8f8928d843a666a642
-input:
-  booked: true
-query:
-  id: 1b9d7983bc204c8f8928d843a666a642
----
-title: Should book a pot (with request sample)
-payload:
-  pot: 1b9d7983bc204c8f8928d843a666a642
-input:
-  booked: true
-query:
-  id: 1b9d7983bc204c8f8928d843a666a642
-request:
-  current:
-    id: 1b9d7983bc204c8f8928d843a666a642
-    material: glass
-    booked: false
-  next:
-    id: 1b9d7983bc204c8f8928d843a666a642
-    material: glass
-    booked: true
----
-title: Should book a pot (without receiver output verification)
-payload:
-  pot: 1b9d7983bc204c8f8928d843a666a642
-request:
-  current:
-    id: 1b9d7983bc204c8f8928d843a666a642
-    material: glass
-    booked: false
-  next:
-    id: 1b9d7983bc204c8f8928d843a666a642
-    material: glass
-    booked: true

package/samples/test/replay.fixtures.js

@@ -1,72 +0,0 @@
-'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