@toa.io/userland 1.0.0-alpha.7 → 1.0.0-alpha.9

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

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

@@ -1,68 +0,0 @@
-'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('not expected')
-  })
-})
-
-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')
-  })
-})

package/samples/test/stage.mock.js

@@ -1,30 +0,0 @@
-// noinspection JSCheckFunctionSignatures
-
-'use strict'
-
-const { Locator } = require('@toa.io/core')
-const stage = jest.requireActual('@toa.io/userland/stage')
-
-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 (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 } }
-
-exports.stage = { manifest, composition, component, remote, shutdown, binding }

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

@@ -1,122 +0,0 @@
-'use strict'
-
-const { resolve } = require('node:path')
-const yaml = require('@toa.io/yaml')
-
-const { components } = require('../src/suite')
-
-it('should be', () => {
-  expect(components).toBeDefined()
-})
-
-const dummy = resolve(__dirname, 'context/components/dummy')
-const pot = resolve(__dirname, 'context/components/pot')
-const component = 'dummies.dummy'
-
-/** @type {toa.samples.Suite} */
-let suite
-
-beforeAll(async () => {
-  const paths = [dummy]
-
-  suite = await components(paths)
-})
-
-it('should return object', () => {
-  expect(typeof suite).toStrictEqual('object')
-})
-
-it('should set title', async () => {
-  expect(suite.title).toStrictEqual('Component samples')
-})
-
-it('should define suite as autonomous', async () => {
-  expect(suite.autonomous).toStrictEqual(true)
-})
-
-it('should load operation samples', async () => {
-  const expected = await operations()
-
-  expect(Object.keys(suite.operations)).toStrictEqual([component])
-
-  const set = suite.operations[component]
-
-  expect(Object.keys(set)).toStrictEqual(['do', 'undo'])
-
-  expect(set.do).toStrictEqual(expected.do)
-  expect(set.undo).toStrictEqual(expected.undo)
-})
-
-describe('options', () => {
-  const paths = [dummy, pot]
-
-  it('should filter samples by component id', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { component: 'dummies.dummy' }
-
-    suite = await components(paths, options)
-
-    expect(suite.operations['dummies.pot']).toBeUndefined()
-  })
-
-  it('should filter samples by operation name', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { operation: 'do' }
-
-    suite = await components(paths, options)
-
-    expect('undo' in suite.operations['dummies.dummy']).toStrictEqual(false)
-  })
-
-  it('should filter operation samples by title', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { title: 'Should not undo' }
-
-    suite = await components(paths, options)
-
-    expect('do' in suite.operations['dummies.dummy']).toStrictEqual(false)
-    expect(suite.operations['dummies.dummy'].undo.length).toStrictEqual(1)
-    expect(suite.operations['dummies.dummy'].undo[0].title).toStrictEqual(options.title)
-  })
-
-  it('should filter operation samples by title as regexp', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { title: 'Should [a-z]{2}t undo' }
-
-    suite = await components(paths, options)
-
-    expect(suite.operations['dummies.dummy']?.do).toBeUndefined()
-    expect(suite.operations['dummies.dummy'].undo.length).toStrictEqual(1)
-    expect(suite.operations['dummies.dummy'].undo[0].title).toStrictEqual('Should not undo')
-  })
-
-  it('should filter operation samples by title', async () => {
-    /** @type {toa.samples.suite.Options} */
-    const options = { title: 'Should not undo' }
-
-    suite = await components(paths, options)
-
-    expect(Object.keys(suite.operations['dummies.dummy']).length).toStrictEqual(1)
-    expect(suite.operations['dummies.dummy'].undo[0].title).toStrictEqual(options.title)
-  })
-})
-
-/**
- * @returns {Promise<toa.samples.operations.Set>}
- */
-const operations = async () => {
-  const path = resolve(dummy, 'samples')
-
-  /** @type {toa.samples.Operation[]} */
-  const do1 = (await yaml.load.all(resolve(path, 'do.yaml')))
-
-  /** @type {toa.samples.Operation[]} */
-  const do2 = (await yaml.load.all(resolve(path, 'dummies.dummy.do.yaml')))
-
-  /** @type {toa.samples.Operation[]} */
-  const undo = (await yaml.load.all(resolve(path, 'dummies.dummy.undo.yaml')))
-
-  return {
-    do: [...do1, ...do2], undo
-  }
-}

package/samples/test/suite.context.test.js

@@ -1,79 +0,0 @@
-'use strict'
-
-const { join } = require('node:path')
-const yaml = require('@toa.io/yaml')
-
-const { context } = require('../src/suite')
-
-it('should be', async () => {
-  expect(context).toBeDefined()
-})
-
-const root = join(__dirname, 'context')
-
-/** @type {toa.samples.Suite} */
-let suite
-
-beforeAll(async () => {
-  suite = await context(root)
-})
-
-it('should return object', async () => {
-  expect(typeof suite).toStrictEqual('object')
-})
-
-it('should set title', async () => {
-  expect(suite.title).toStrictEqual('Integration samples')
-})
-
-it('should define suite as non-autonomous', async () => {
-  expect(suite.autonomous).toStrictEqual(false)
-})
-
-it('should load operation samples', async () => {
-  const expected = await operations()
-
-  expect(suite.operations).toStrictEqual(expected)
-})
-
-it('should load message samples', async () => {
-  const expected = await messages()
-
-  expect(suite.messages).toStrictEqual(expected)
-})
-
-/**
- * @returns {Promise<toa.samples.suite.Operations>}
- */
-const operations = async () => {
-  const path = join(root, 'samples')
-  const component = 'dummies.dummy'
-  const endpoints = ['transit', 'observe']
-
-  /** @type {toa.samples.suite.Operations} */
-  const operations = {}
-
-  /** @type {toa.samples.operations.Set} */
-  const set = operations[component] = {}
-
-  for (const endpoint of endpoints) {
-    const filename = component + '.' + endpoint + '.yaml'
-    const filepath = join(path, filename)
-
-    set[endpoint] = /** @type {toa.samples.Operation[]} */ await yaml.load.all(filepath)
-  }
-
-  return operations
-}
-
-/**
- * @returns {Promise<toa.samples.messages.Set>}
- */
-const messages = async () => {
-  const label = 'somewhere.something.happened'
-  const file = label + '.yaml'
-  const path = join(root, 'samples/messages', file)
-  const samples = /** @type {toa.samples.Message[]} */ await yaml.load.all(path)
-
-  return { [label]: samples }
-}

package/samples/test/suite.mock.js

@@ -1,10 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const suite = {
-  components: jest.fn(async () => generate()),
-  context: jest.fn(async () => generate())
-}
-
-exports.suite = suite

package/samples/types/index.d.ts

@@ -1,8 +0,0 @@
-import * as _replay from './replay'
-
-export { Operation } from './operation'
-export { Message } from './message'
-
-export const context: _replay.context
-export const components: _replay.components
-export const replay: _replay.replay

package/samples/types/message.d.ts

@@ -1,24 +0,0 @@
-import type * as _core from '@toa.io/core'
-import type * as _operation from './operation'
-
-declare namespace toa.samples{
-
-  namespace messages{
-
-    type Set = Record<string, Message[]>
-
-  }
-
-  type Message = {
-    title?: string
-    component: string
-    payload: Object
-    input?: any
-    query?: _core.Query
-    request?: _operation.Operation | null
-  }
-
-}
-
-export type Message = toa.samples.Message
-export type Set = toa.samples.messages.Set

package/samples/types/operation.d.ts

@@ -1,36 +0,0 @@
-import * as _core from '@toa.io/core'
-import * as _sampling from '@toa.io/extensions.sampling/types/request'
-
-declare namespace toa.samples{
-
-  namespace operations{
-
-    type Call = {
-      input?: any
-      output?: any
-    }
-
-    type Calls = Record<string, Call[]>
-
-    type Events = Record<string, Object>
-
-    type Set = Record<string, Operation[]>
-
-  }
-
-  type Operation = {
-    title?: string
-    input?: any
-    output?: any
-    current?: _core.storages.Record
-    next?: _core.storages.Record
-    remote?: operations.Calls
-    local?: operations.Calls
-    events?: operations.Events
-    extensions?: _sampling.Extensions
-  }
-
-}
-
-export type Operation = toa.samples.Operation
-export type Set = toa.samples.operations.Set

package/samples/types/replay.d.ts

@@ -1,13 +0,0 @@
-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[], options?: object) => Promise<boolean>
-
-}
-
-export type context = toa.samples.replay.context
-export type components = toa.samples.replay.components
-export type replay = toa.samples.replay.replay

package/samples/types/suite.d.ts

@@ -1,31 +0,0 @@
-import * as _core from '@toa.io/core'
-import * as _operations from './operation'
-import * as _messages from './message'
-
-declare namespace toa.samples{
-
-  namespace suite{
-    type Operations = Record<string, _operations.Set>
-
-    type Options = {
-      id?: string
-      component?: string
-      autonomous?: boolean
-      integration?: boolean
-      operation?: string
-      title?: string
-      runner?: object
-    }
-  }
-
-  type Suite = {
-    title?: string
-    autonomous: boolean
-    operations?: suite.Operations
-    messages?: _messages.Set
-  }
-
-}
-
-export type Suite = toa.samples.Suite
-export type Options = toa.samples.suite.Options