@toa.io/bindings.amqp 0.20.0-dev.9 → 0.20.1-alpha.0

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@toa.io/bindings.amqp",
-  "version": "0.20.0-dev.9",
+  "version": "0.20.1-alpha.0",
   "description": "Toa AMQP Binding",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
-  "main": "source/index.js",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/toa-io/toa.git"
@@ -15,15 +14,21 @@
   "publishConfig": {
     "access": "public"
   },
+  "main": "transpiled/index.js",
+  "types": "transpiled/index.d.ts",
+  "dependencies": {
+    "@toa.io/console": "0.20.1-alpha.0",
+    "@toa.io/core": "0.21.0-alpha.0",
+    "@toa.io/generic": "0.20.1-alpha.0",
+    "@toa.io/pointer": "0.20.1-alpha.0",
+    "comq": "0.10.1"
+  },
   "scripts": {
-    "test": "echo \"Error: run tests from root\" && exit 1"
+    "transpile": "tsc"
   },
-  "dependencies": {
-    "@toa.io/console": "0.20.0-dev.9",
-    "@toa.io/core": "0.20.0-dev.9",
-    "@toa.io/generic": "0.20.0-dev.9",
-    "@toa.io/generics.amqp": "0.20.0-dev.9",
-    "@toa.io/pointer": "0.20.0-dev.9"
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "node"
   },
-  "gitHead": "4e503ffe4fe6dfab1165e795832d3d4fba711582"
+  "gitHead": "ed28dc0d2823022fbb1188bb28b994bc827a4432"
 }

package/readme.md

@@ -1,54 +1,19 @@
-# Toa AMQP Binding
+# Toa AMQP binding
 
 AMQP asynchronous binding on top of [ComQ](/libraries/comq).
 
-## Deployment
-
-AMQP deployment must be declared with
-the [Pointer annotation](/libraries/pointer/readme.md#annotation). Either `system` or `default`
-pointers must be defined.
-
-Well-known annotation shortcut `amqp` is available.
-
-```yaml
-# context.toa.yaml
-annotations:
-  "@toa.io/bindings.amqp":
-    system: url0          # the runtime 
-    default: url1         # all undeclared
-    dummies: url2         # namespace-wide
-    dummies.dummy1: url  # component exclusive
-```
-
-### Concise Declaration
-
-Well-known shortcut `amqp` is available. The next two declarations are equivalent:
+## Annotation
 
 ```yaml
-# context.toa.yaml
-annotations:
-  "@toa.io/bindings.amqp":
-    system: url0
-    dummies: url1
-```
-
-```yaml
-# context.toa.yaml
 amqp:
-  system: url0
-  dummies: url1
+  context:
+    .: amqp://com.example.com
+    dummies.dummy: amqp://dummmy.example.com
+  sources:
+    somewhere: amqp://queues.somewhere.com
 ```
 
-`string` annotation value is considered as `default`. The next two declarations are equivalent:
+Context annotaition is a [Pointer](/libraries/pointer) with `amqp-context` ID.
 
-```yaml
-# context.toa.yaml
-annotations:
-  "@toa.io/bindings.amqp":
-    default: url1
-``` 
-
-```yaml
-# context.toa.yaml
-amqp: url1
-``` 
+Sources annotation is a set of Pointers, declared by components consuming foreign events.
+Each Pointer ID is as follows: `amqp-sources-{source}`.

package/schemas/annotation.cos.yaml

@@ -0,0 +1,2 @@
+context*: <string>
+sources: <string>

package/source/broadcast.js

@@ -17,11 +17,6 @@ class Broadcast extends Connector {
   /** @type {string} */
   #group
 
-  /**
-   * @param {toa.amqp.Communication} comm
-   * @param {toa.core.Locator} locator
-   * @param {string} [group]
-   */
   constructor (comm, locator, group) {
     super()
 

package/source/communication.js

@@ -0,0 +1,49 @@
+'use strict'
+
+const { assert } = require('comq')
+const { Connector } = require('@toa.io/core')
+
+class Communication extends Connector {
+  #resolve
+
+  /** @type {comq.IO} */
+  #io
+
+  constructor (resolve) {
+    super()
+
+    this.#resolve = resolve
+  }
+
+  async open () {
+    const references = await this.#resolve()
+
+    this.#io = await assert(...references)
+  }
+
+  async close () {
+    await this.#io?.seal()
+  }
+
+  async dispose () {
+    await this.#io?.close()
+  }
+
+  async reply (queue, process) {
+    await this.#io.reply(queue, process)
+  }
+
+  async request (queue, request) {
+    return this.#io.request(queue, request)
+  }
+
+  async emit (exchange, message, properties) {
+    await this.#io.emit(exchange, message, properties)
+  }
+
+  async consume (exchange, group, consumer) {
+    await this.#io.consume(exchange, group, consumer)
+  }
+}
+
+exports.Communication = Communication

package/source/constants.js

@@ -1,4 +1,3 @@
 'use strict'
 
-exports.PREFIX = 'bindings-amqp'
 exports.SYSTEM = 'system'

package/source/consumer.js

@@ -13,11 +13,6 @@ class Consumer extends Connector {
   /** @type {toa.amqp.Communication} */
   #comm
 
-  /**
-   * @param {toa.amqp.Communication} comm
-   * @param {toa.core.Locator} locator
-   * @param {string} endpoint
-   */
   constructor (comm, locator, endpoint) {
     super()
 

package/source/deployment/annotation.test.ts

@@ -0,0 +1,40 @@
+import { generate } from 'randomstring'
+import { normalize } from './annotation'
+
+it('should expand string', async () => {
+  const declaration = uri()
+  const annotation = normalize(declaration)
+
+  expect(annotation).toMatchObject({
+    context: {
+      '.': [declaration]
+    }
+  })
+})
+
+it('should expand context default', async () => {
+  const declaration = { context: uri() }
+  const annotation = normalize(declaration)
+
+  expect(annotation).toMatchObject({
+    context: {
+      '.': [declaration.context]
+    }
+  })
+})
+
+it('should expand context with sources', async () => {
+  const declaration = { context: uri(), sources: { foo: [uri()] } }
+  const annotation = normalize(declaration)
+
+  expect(annotation).toMatchObject({
+    context: {
+      '.': [declaration.context]
+    },
+    sources: declaration.sources
+  })
+})
+
+function uri (): string {
+  return 'http://host-' + generate()
+}

package/source/deployment/annotation.ts

@@ -0,0 +1,26 @@
+import * as pointer from '@toa.io/pointer'
+import { type URIMap } from '@toa.io/pointer'
+
+export function normalize (declaration: string | Declaration): Annotation {
+  const annotation = expand(declaration)
+  const context = pointer.normalize(annotation.context)
+  const sources = pointer.normalize(annotation.sources)
+
+  return { context, sources }
+}
+
+function expand (declaration: string | Declaration): Declaration {
+  if (typeof declaration === 'string') return { context: { '.': [declaration] } }
+  else if (Array.isArray(declaration)) return { context: { '.': declaration } }
+  else return declaration
+}
+
+export interface Annotation {
+  context: URIMap
+  sources?: URIMap
+}
+
+export interface Declaration {
+  context: string | Record<string, string | string[]>
+  sources?: Record<string, string | string[]>
+}

package/source/deployment/context.ts

@@ -0,0 +1,112 @@
+import { type Dependency, type Variable } from '@toa.io/operations'
+import { encode, decode } from '@toa.io/generic'
+import { resolveRecord, naming } from '@toa.io/pointer'
+import { type Locator } from '@toa.io/core'
+import { type AnnotationRecord } from '@toa.io/pointer/transpiled/Deployment'
+import { dedupe } from '@toa.io/dns'
+import { type Annotation } from './annotation'
+
+export function createDependency (context: Context): Dependency {
+  const global: Variable[] = []
+  const variables = { global }
+
+  const contextVariables = createVariables(context)
+
+  global.push(...contextVariables)
+
+  return { variables }
+}
+
+export async function resolveURIs (locator: Locator): Promise<string[]> {
+  if (process.env.TOA_DEV === '1') return ['amqp://developer:secret@localhost']
+
+  const value = process.env[VARIABLE]
+
+  if (value === undefined) throw new Error(`Environment variable ${VARIABLE} is not specified`)
+
+  const map = decode(value)
+  const record = resolveRecord(map, locator.id)
+
+  return await parseRecord(record)
+}
+
+function createVariables (context: Context): Variable[] {
+  const variables: Variable[] = []
+  const uris = encode(context)
+
+  const contextVariable: Variable = {
+    name: VARIABLE,
+    value: uris
+  }
+
+  const secrets = createSecrets(context)
+
+  variables.push(contextVariable, ...secrets)
+
+  return variables
+}
+
+function createSecrets (context: Context): Variable[] {
+  const secrets: Variable[] = []
+
+  for (const key of Object.keys(context)) {
+    const keySecrets = createKeySecrets(key)
+
+    secrets.push(...keySecrets)
+  }
+
+  return secrets
+}
+
+function createKeySecrets (key: string): Variable[] {
+  const username = createSecretVariable(key, 'username')
+  const password = createSecretVariable(key, 'password')
+
+  return [username, password]
+}
+
+function createSecretVariable (key: string, secretKey: string): Variable {
+  const varKey = key === '.' ? '' : key
+  const varName = naming.nameVariable(ID, varKey, secretKey.toUpperCase())
+  const secName = naming.nameSecret(ID, key)
+
+  return {
+    name: varName,
+    secret: {
+      name: secName,
+      key: secretKey
+    }
+  }
+}
+
+async function parseRecord (record: AnnotationRecord): Promise<string[]> {
+  const unique = await dedupe(record.references)
+  const urls = new Array(unique.length)
+  const key = record.key === '.' ? '' : record.key
+  const username = readEnv(key, 'USERNAME')
+  const password = readEnv(key, 'PASSWORD')
+
+  for (let i = 0; i < record.references.length; i++) {
+    const url = new URL(record.references[i])
+
+    url.username = username
+    url.password = password
+
+    urls[i] = url.href
+  }
+
+  return urls
+}
+
+function readEnv (key: string, name: string): string {
+  const variable = naming.nameVariable(ID, key, name)
+  const value = process.env[variable]
+
+  if (value === undefined) throw new Error(variable + ' is not set')
+  else return value
+}
+
+const ID = 'amqp-context'
+const VARIABLE = 'TOA_AMQP_CONTEXT'
+
+type Context = Annotation['context']

package/source/deployment/index.ts

@@ -0,0 +1,10 @@
+import { type Dependency } from '@toa.io/operations'
+import { type Declaration, normalize } from './annotation'
+import * as sources from './sources'
+import { type Instance } from './instance'
+
+export function deployment (instances: Instance[], declaration: Declaration): Dependency {
+  const annotation = normalize(declaration)
+
+  return sources.createDependency(annotation.sources, instances)
+}

package/source/deployment/instance.ts

@@ -0,0 +1,3 @@
+import { type context } from '@toa.io/norm'
+
+export type Instance = context.Dependency

package/source/deployment/sources.ts

@@ -0,0 +1,44 @@
+import { createVariables, resolve, type Request } from '@toa.io/pointer'
+import { type Manifest } from '@toa.io/norm'
+import { type Dependency } from '@toa.io/operations'
+import { type Locator } from '@toa.io/core'
+import { type Instance } from './instance'
+import { type Annotation } from './annotation'
+
+export function createDependency (sources: Sources, instances: Instance[]): Dependency {
+  const requests = []
+
+  for (const instance of instances) {
+    const request = createRequest(instance)
+
+    if (request !== null) requests.push(request)
+  }
+
+  const variables = createVariables(ID, sources, requests)
+
+  return { variables }
+}
+
+export async function resolveURIs (locator: Locator): Promise<string[]> {
+  return await resolve(ID, locator.id)
+}
+
+function createRequest (instance: Instance): Request | null {
+  const group = instance.locator.label
+  const selectors = createSelectors(instance.component)
+
+  if (selectors === null) return null
+  else return { group, selectors }
+}
+
+function createSelectors (component: Manifest): string[] | null {
+  if (component.receivers === undefined) return null
+
+  const sources = Object.values(component.receivers).map((receiver) => receiver.source)
+
+  return sources.filter((source) => source !== undefined) as string[]
+}
+
+const ID = 'amqp-sources'
+
+type Sources = Annotation['sources']

package/source/deployment.ts

@@ -0,0 +1,14 @@
+import { type Dependency } from '@toa.io/operations'
+import { merge } from '@toa.io/generic'
+import { type Declaration, normalize } from './deployment/annotation'
+import * as sources from './deployment/sources'
+import * as context from './deployment/context'
+import { type Instance } from './deployment/instance'
+
+export function deployment (instances: Instance[], declaration: Declaration): Dependency {
+  const annotation = normalize(declaration)
+  const contextDependency = context.createDependency(annotation.context)
+  const sourcesDependency = sources.createDependency(annotation.sources, instances)
+
+  return merge(contextDependency, sourcesDependency)
+}

package/source/emitter.js

@@ -14,11 +14,6 @@ class Emitter extends Connector {
   /** @type {toa.amqp.Communication} */
   #comm
 
-  /**
-   * @param {toa.amqp.Communication} comm
-   * @param {toa.core.Locator} locator
-   * @param {string} label
-   */
   constructor (comm, locator, label) {
     super()
 

package/source/factory.js

@@ -1,70 +1,62 @@
 'use strict'
 
 const { Locator } = require('@toa.io/core')
-const { connector } = require('@toa.io/generics.amqp')
 
 const { Producer } = require('./producer')
 const { Consumer } = require('./consumer')
 const { Emitter } = require('./emitter')
 const { Receiver } = require('./receiver')
 const { Broadcast } = require('./broadcast')
+const context = require('./deployment/context')
+const sources = require('./deployment/sources')
 
-const { SYSTEM, PREFIX } = require('./constants')
+const { SYSTEM } = require('./constants')
+const { Communication } = require('./communication')
 
-/**
- * @implements {toa.core.bindings.Factory}
- */
 class Factory {
   producer (locator, endpoints, component) {
-    const comm = this.#getCommunication(locator)
+    const comm = this.#getContext(locator)
 
     return new Producer(comm, locator, endpoints, component)
   }
 
   consumer (locator, endpoint) {
-    const comm = this.#getCommunication(locator)
+    const comm = this.#getContext(locator)
 
     return new Consumer(comm, locator, endpoint)
   }
 
-  /**
-   * @param {toa.core.Locator} locator
-   * @param {string} label
-   * @return {Emitter}
-   */
   emitter (locator, label) {
-    const comm = this.#getCommunication(locator)
+    const comm = this.#getContext(locator)
 
     return new Emitter(comm, locator, label)
   }
 
-  /**
-   * @param {toa.core.Locator} source
-   * @param {string} label
-   * @param {string} group
-   * @param {toa.core.Receiver} receiver
-   * @return {Receiver}
-   */
-  receiver (source, label, group, receiver) {
-    const comm = this.#getCommunication(source)
+  receiver (locator, label, group, receiver) {
+    const comm = this.#getSource(locator)
 
     return new Receiver(comm, label, group, receiver)
   }
 
   broadcast (name, group) {
     const locator = new Locator(name, SYSTEM)
-    const comm = this.#getCommunication(locator)
+    const comm = this.#getContext(locator)
 
     return new Broadcast(comm, locator, group)
   }
 
-  /**
-   *
-   * @param {toa.core.Locator} source
-   * @return {toa.amqp.Communication}
-   */
-  #getCommunication (source) {
-    return connector(PREFIX, source)
+  #getContext (locator) {
+    const resolve = async () => context.resolveURIs(locator)
+
+    return new Communication(resolve)
+  }
+
+  #getSource (locator) {
+    const resolve = (locator.namespace === undefined)
+      ? async () => sources.resolveURIs(locator)
+      : async () => context.resolveURIs(locator)
+
+    return new Communication(resolve)
   }
 }
 

package/source/index.js

@@ -1,13 +1,11 @@
 'use strict'
 
 const { deployment } = require('./deployment')
-const { annotation } = require('./annotation')
 const { Factory } = require('./factory')
 
 /** @type {toa.core.bindings.Properties} */
 const properties = { async: true }
 
 exports.properties = properties
-exports.annotation = annotation
 exports.deployment = deployment
 exports.Factory = Factory

package/source/producer.js

@@ -17,12 +17,6 @@ class Producer extends Connector {
   /** @type {toa.core.Component} */
   #component
 
-  /**
-   * @param {toa.amqp.Communication} comm
-   * @param {toa.core.Locator} locator
-   * @param {string[]} endpoints
-   * @param {toa.core.Component} component
-   */
   constructor (comm, locator, endpoints, component) {
     super()
 

package/source/receiver.js

@@ -15,12 +15,6 @@ class Receiver extends Connector {
   /** @type {toa.core.Receiver} */
   #receiver
 
-  /**
-   * @param {toa.amqp.Communication} comm
-   * @param {string} exchange
-   * @param {string} group
-   * @param {toa.core.Receiver} receiver
-   */
   constructor (comm, exchange, group, receiver) {
     super()
 

package/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./transpiled"
+  },
+  "include": [
+    "source"
+  ],
+  "exclude": [
+    "**/*.test.ts"
+  ]
+}

package/source/annotation.js

@@ -1,5 +0,0 @@
-'use strict'
-
-const { uris } = require('@toa.io/pointer')
-
-exports.annotation = uris.construct

package/source/deployment.js

@@ -1,32 +0,0 @@
-'use strict'
-
-const pointer = require('@toa.io/pointer')
-
-const { PREFIX } = require('./constants')
-
-/**
- * @type {toa.deployment.dependency.Constructor}
- */
-const deployment = (instances, annotation) => {
-  validate(annotation)
-
-  /** @type {toa.pointer.deployment.Options} */
-  const options = { prefix: PREFIX }
-
-  return pointer.deployment(instances, annotation, options)
-}
-
-/**
- * @param {toa.pointer.URIs} annotation
- */
-const validate = (annotation) => {
-  const defined = annotation !== undefined
-  const defaults = defined && (typeof annotation === 'string' || annotation.default !== undefined)
-  const correct = defined && (defaults || 'system' in annotation)
-
-  if (!correct) {
-    throw new Error('AMQP deployment requires either \'system\' or \'default\' pointer annotation')
-  }
-}
-
-exports.deployment = deployment

package/source/pointer.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const { Pointer: Base } = require('@toa.io/pointer')
-const { PREFIX } = require('./constants')
-
-class Pointer extends Base {
-  /**
-   * @param {toa.core.Locator} locator
-   */
-  constructor (locator) {
-    super(PREFIX, locator, OPTIONS)
-  }
-}
-
-/** @type {toa.pointer.Options} */
-const OPTIONS = { protocol: 'amqp:' }
-
-exports.Pointer = Pointer

package/test/annotations.test.js

@@ -1,16 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const mock = { uris: { construct: () => generate() }, Pointer: class {} }
-
-jest.mock('@toa.io/pointer', () => mock)
-
-const { annotation } = require('../')
-
-it('should export annotations', () => {
-  expect(annotation).toBeDefined()
-})
-
-it('should export connectors.uris construct', () => {
-  expect(annotation).toStrictEqual(mock.uris.construct)
-})

package/test/deployment.test.js

@@ -1,36 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { random } = require('@toa.io/generic')
-const mock = require('@toa.io/mock')
-
-const { deployment } = require('../')
-
-/** @type {toa.norm.context.dependencies.Instance[]} */
-let instances
-
-/** @returns {URL} */
-const gen = () => new URL('amqp://host-' + generate() + ':' + (random(1000) + 1000))
-
-beforeEach(() => {
-  instances = mock.dependencies.instances()
-})
-
-it('should exist', () => {
-  expect(deployment).toBeDefined()
-})
-
-it('should throw if annotation is not defined', () => {
-  expect(() => deployment(instances, undefined))
-    .toThrow('AMQP deployment requires either \'system\' or \'default\' pointer annotation')
-})
-
-it('should throw if \'system\' is not defined', () => {
-  const url = gen()
-  const annotation = {}
-
-  for (const instance of instances) annotation[instance.locator.id] = url.href
-
-  expect(() => deployment(instances, annotation))
-    .toThrow('AMQP deployment requires either \'system\' or \'default\' pointer annotation')
-})

package/test/factory.test.js

@@ -1,190 +0,0 @@
-'use strict'
-
-// region setup
-
-const { generate } = require('randomstring')
-const { Locator } = require('@toa.io/core')
-
-jest.mock('@toa.io/generics.amqp')
-jest.mock('../source/producer')
-jest.mock('../source/consumer')
-jest.mock('../source/emitter')
-jest.mock('../source/receiver')
-jest.mock('../source/broadcast')
-
-const {
-  /** @type {jest.MockedFunction<connector>} */
-  connector
-} = require('@toa.io/generics.amqp')
-
-const {
-  /** @type {jest.MockedClass<Producer>} */
-  Producer
-} = require('../source/producer')
-
-const {
-  /** @type {jest.MockedClass<Consumer>} */
-  Consumer
-} = require('../source/consumer')
-
-const {
-  /** @type {jest.MockedClass<Emitter>} */
-  Emitter
-} = require('../source/emitter')
-
-const {
-  /** @type {jest.MockedClass<Receiver>} */
-  Receiver
-} = require('../source/receiver')
-
-const {
-  /** @type {jest.MockedClass<Broadcast>} */
-  Broadcast
-} = require('../source/broadcast')
-
-const { Factory } = require('../')
-
-it('should be', async () => {
-  expect(Factory).toBeDefined()
-})
-
-/** @type {toa.core.bindings.Factory} */
-let factory
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  factory = new Factory()
-})
-
-const locator = /** @type {toa.core.Locator} */ { name: generate(), namespace: generate() }
-const endpoints = [generate(), generate()]
-const endpoint = generate()
-const label = locator.id + '.' + endpoint
-const name = generate()
-const group = generate()
-const component = /** @type {toa.core.Component} */ {}
-const processor = /** @type {toa.core.Receiver} */ {}
-
-/** @type {jest.MockedObject<toa.amqp.Communication>} */
-let comm
-
-/** @type {toa.core.Connector} */
-let producer
-
-/** @type {toa.core.bindings.Consumer} */
-let consumer
-
-/** @type {toa.core.Connector} */
-let receiver
-
-/** @type {toa.core.bindings.Emitter} */
-let emitter
-
-/** @type {toa.core.bindings.Broadcast} */
-let broadcast
-
-// endregion
-
-describe.each(['Producer', 'Consumer', 'Emitter', 'Receiver', 'Broadcast'])('%s assets', (classname) => {
-  const method = classname.toLowerCase()
-
-  it('should be', async () => {
-    expect(factory[method]).toBeDefined()
-  })
-
-  beforeEach(() => {
-    jest.clearAllMocks()
-
-    switch (method) {
-      case 'producer':
-        factory.producer(locator, endpoints, component)
-        break
-      case 'consumer':
-        factory.consumer(locator, endpoint)
-        break
-      case 'emitter':
-        factory.emitter(locator, endpoint)
-        break
-      case 'receiver':
-        factory.receiver(locator, endpoint, group, processor)
-        break
-      case 'broadcast':
-        factory.broadcast(name, group)
-        break
-    }
-  })
-
-  if (method !== 'broadcast') {
-    it('should create Communication', async () => {
-      expect(connector).toHaveBeenCalledWith('bindings-amqp', locator)
-    })
-  }
-})
-
-describe('Producer', () => {
-  beforeEach(() => {
-    producer = factory.producer(locator, endpoints, component)
-    comm = connector.mock.results[0].value
-  })
-
-  it('should create instance', async () => {
-    expect(Producer).toHaveBeenCalledWith(comm, locator, endpoints, component)
-    expect(producer).toStrictEqual(Producer.mock.instances[0])
-  })
-})
-
-describe('Consumer', () => {
-  beforeEach(() => {
-    consumer = factory.consumer(locator, endpoint)
-    comm = connector.mock.results[0].value
-  })
-
-  it('should create instance', async () => {
-    expect(Consumer).toHaveBeenCalledWith(comm, locator, endpoint)
-    expect(consumer).toStrictEqual(Consumer.mock.instances[0])
-  })
-})
-
-describe('Emitter', () => {
-  beforeEach(() => {
-    emitter = factory.emitter(locator, endpoint)
-    comm = connector.mock.results[0].value
-  })
-
-  it('should create instance', async () => {
-    expect(Emitter).toHaveBeenCalledWith(comm, locator, endpoint)
-    expect(emitter).toStrictEqual(Emitter.mock.instances[0])
-  })
-})
-
-describe('Receiver', () => {
-  beforeEach(() => {
-    receiver = factory.receiver(locator, label, group, processor)
-    comm = connector.mock.results[0].value
-  })
-
-  it('should create instance', async () => {
-    expect(Receiver).toHaveBeenCalledWith(comm, label, group, processor)
-    expect(receiver).toStrictEqual(Receiver.mock.instances[0])
-  })
-})
-
-describe('Broadcast', () => {
-  beforeEach(() => {
-    broadcast = factory.broadcast(name, group)
-    comm = connector.mock.results[0].value
-  })
-
-  it('should create Locator', async () => {
-    const locator = Broadcast.mock.calls[0][1]
-
-    expect(locator.namespace).toStrictEqual('system')
-    expect(locator.name).toStrictEqual(name)
-  })
-
-  it('should create instance', async () => {
-    expect(Broadcast).toHaveBeenCalledWith(comm, expect.any(Locator), group)
-    expect(broadcast).toStrictEqual(Broadcast.mock.instances[0])
-  })
-})

package/test/pointer.test.js

@@ -1,59 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { Locator } = require('@toa.io/core')
-const { encode } = require('@toa.io/generic')
-
-const { Pointer } = require('../source/pointer')
-
-/** @type {toa.core.Locator} */
-let locator
-
-/** @type {Pointer} */
-let pointer
-
-const protocol = 'amqp:'
-
-let url
-
-beforeAll(() => {
-  const username = generate()
-  const password = generate()
-
-  url = new URL('amqps://whatever:5672')
-
-  url.username = username
-  url.password = password
-
-  process.env.TOA_BINDINGS_AMQP_DEFAULT_USERNAME = username
-  process.env.TOA_BINDINGS_AMQP_DEFAULT_PASSWORD = password
-})
-
-beforeEach(() => {
-  const name = generate()
-  const namespace = generate()
-  const uris = { default: url.href }
-  const value = encode(uris)
-  const key = 'TOA_BINDINGS_AMQP_POINTER'
-
-  process.env[key] = value
-
-  locator = new Locator(name, namespace)
-  pointer = new Pointer(locator)
-})
-
-it('should be', () => undefined)
-
-it('should expose reference', () => {
-  expect(pointer.reference).toStrictEqual(url.href)
-})
-
-it('should set amqp: protocol on localhost', () => {
-  process.env.TOA_DEV = '1'
-
-  pointer = new Pointer(locator)
-
-  expect(pointer.protocol).toStrictEqual(protocol)
-
-  delete process.env.TOA_DEV
-})