@toa.io/core 1.0.0-alpha.32 → 1.0.0-alpha.321

package/test/connector.test.js

@@ -1,176 +0,0 @@
-'use strict'
-
-const fixtures = require('./connector.fixtures')
-
-let sequence
-
-beforeEach(() => {
-  sequence = []
-})
-
-describe('callbacks', () => {
-  let a
-
-  beforeEach(() => {
-    a = new fixtures.TestConnector('a', sequence)
-  })
-
-  it('should call connection', async () => {
-    await a.connect()
-    expect(sequence).toEqual(['+a'])
-  })
-
-  it('should call disconnection', async () => {
-    await a.connect()
-    await a.disconnect()
-
-    expect(sequence.indexOf('+a')).toBeLessThan(sequence.indexOf('-a'))
-  })
-
-  it('should reconnect', async () => {
-    await a.connect()
-    await a.reconnect()
-    await a.reconnect()
-
-    expect(sequence).toEqual(['+a', '-a', '*a', '+a', '-a', '*a', '+a'])
-  })
-})
-
-describe('dependencies', () => {
-  let a
-  let b
-  let c
-  let d
-
-  beforeEach(() => {
-    a = new fixtures.TestConnector('a', sequence)
-    b = new fixtures.TestConnector('b', sequence)
-    c = new fixtures.TestConnector('c', sequence)
-    d = new fixtures.TestConnector('d', sequence)
-  })
-
-  it('should wait dependencies on connection', async () => {
-    a.depends(b).depends(c)
-    a.depends(d)
-
-    await a.connect()
-
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
-  })
-
-  it('should wait array of connectors', async () => {
-    a.depends([b, d])
-    b.depends(c)
-    d.depends(c)
-
-    await a.connect()
-
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
-  })
-
-  it('should wait array(1) of connectors', async () => {
-    a.depends([b])
-    b.depends(c)
-
-    await a.connect()
-
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+b'))
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-  })
-
-  it('should throw on empty array', async () => {
-    expect(() => a.depends([])).toThrow(/must not be empty/)
-  })
-
-  it('should await 2-way dependencies', async () => {
-    a.depends([b, c, d])
-    d.depends([b, c])
-
-    await a.connect()
-
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+a'))
-    expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('+a'))
-
-    expect(sequence.indexOf('+b')).toBeLessThan(sequence.indexOf('+d'))
-    expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('+d'))
-  })
-
-  it('should disconnect before dependencies', async () => {
-    a.depends(b).depends(c)
-    b.depends(d)
-
-    await a.disconnect()
-
-    expect(sequence.indexOf('-a')).toBeLessThan(sequence.indexOf('-b'))
-    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-c'))
-    expect(sequence.indexOf('-b')).toBeLessThan(sequence.indexOf('-d'))
-  })
-
-  it('should call disconnected', async () => {
-    a.depends(b).depends(c)
-    b.depends(d)
-
-    await a.disconnect()
-
-    expect(sequence.indexOf('*c')).toBeLessThan(sequence.indexOf('*b'))
-    expect(sequence.indexOf('*b')).toBeLessThan(sequence.indexOf('*a'))
-    expect(sequence.indexOf('*d')).toBeLessThan(sequence.indexOf('*b'))
-    expect(sequence.indexOf('*a')).toBe(sequence.length - 1)
-  })
-
-  it('should disconnect if no parents left', async () => {
-    a.depends(c)
-    b.depends(c)
-
-    await a.connect()
-    await b.connect()
-
-    expect(sequence).toEqual(['+c', '+a', '+b'])
-
-    await a.disconnect()
-
-    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a'])
-
-    await b.disconnect()
-
-    expect(sequence).toEqual(['+c', '+a', '+b', '-a', '*a', '-b', '-c', '*c', '*b'])
-  })
-
-  it('should throw if depends not on Connector', async () => {
-    expect(() => a.depends({})).toThrow()
-  })
-
-  describe('errors', () => {
-    let f
-
-    beforeEach(() => {
-      f = new fixtures.FailingConnector()
-    })
-
-    it('should disconnect on fail', async () => {
-      f.depends(b).depends(c)
-
-      await expect(f.connect()).rejects.toThrow('FailingConnector')
-      expect(sequence).toEqual(['+c', '+b', '-b', '-c', '*c', '*b'])
-    })
-
-    it('should interrupt connection chain', async () => {
-      a.depends(f).depends(c)
-      f.depends(d)
-
-      await expect(a.connect()).rejects.toThrow('FailingConnector')
-
-      expect(sequence.indexOf('+c')).toBeLessThan(sequence.indexOf('-c'))
-      expect(sequence.indexOf('+d')).toBeLessThan(sequence.indexOf('-d'))
-
-      expect(sequence.indexOf('+a')).toBe(-1)
-      expect(sequence.indexOf('-a')).toBe(-1)
-    })
-  })
-})

package/test/context.fixtures.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const { Connector } = require('../src/connector')
-
-const local = {
-  link: jest.fn()
-}
-
-const discover = jest.fn(() => ({
-  invoke: jest.fn(),
-  link: jest.fn()
-}))
-
-const aspects = [new Connector(), new Connector()]
-
-exports.local = local
-exports.discover = discover
-exports.aspects = aspects

package/test/context.test.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const fixtures = require('./context.fixtures')
-const { Context } = require('../src/context')
-
-/** @type {toa.core.Context} */
-let context
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  context = new Context(fixtures.local, fixtures.discover, fixtures.aspects)
-})
-
-it('should expose aspects', () => {
-  expect(context.aspects).toBeDefined()
-  expect(context.aspects).toStrictEqual(fixtures.aspects)
-})
-
-describe('call', () => {
-  it('should discover once', async () => {
-    const request = {}
-
-    await context.call('a', 'b', 'c', request)
-    await context.call('a', 'b', 'c', request)
-
-    expect(fixtures.discover).toHaveBeenCalledTimes(1)
-  })
-})

package/test/contract/conditions.test.js

@@ -1,26 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const { Conditions } = require('../../src/contract/conditions')
-const fixtures = require('./contract.fixtures')
-
-let conditions
-
-beforeEach(() => {
-  conditions = new Conditions(fixtures.schema)
-})
-
-it('should fit value', () => {
-  const value = { foo: generate() }
-
-  conditions.fit(value)
-
-  expect(fixtures.schema.fit).toHaveBeenCalledWith(value)
-})
-
-it('should throw on invalid value', () => {
-  const value = { invalid: true }
-
-  expect(() => conditions.fit(value)).toThrow()
-})

package/test/contract/contract.fixtures.js

@@ -1,33 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-const { load } = require('@toa.io/yaml')
-const { resolve } = require('path')
-
-// noinspection JSCheckFunctionSignatures
-const schema = {
-  fit: jest.fn((input) => (input.invalid ? { message: generate() } : null))
-}
-
-const query = {
-  parse: jest.fn(() => ({ [generate()]: generate() }))
-}
-
-const declaration = {}
-
-const schemas = {
-  request: {
-    type: 'object',
-    properties: {
-      input: { type: 'null' },
-      query: load.sync(resolve(__dirname, '../../src/contract/schemas/query.yaml')),
-      authentic: { type: 'boolean' }
-    },
-    additionalProperties: true
-  }
-}
-
-exports.schema = schema
-exports.query = query
-exports.declaration = declaration
-exports.schemas = schemas

package/test/contract/request.test.js

@@ -1,112 +0,0 @@
-'use strict'
-
-const clone = require('clone-deep')
-const { generate } = require('randomstring')
-
-jest.mock('../../src/contract/conditions')
-
-const { Request } = require('../../src/contract/request')
-const { Conditions } = require('../../src/contract/conditions')
-const fixtures = require('./contract.fixtures')
-
-let contract
-
-beforeEach(() => {
-  jest.clearAllMocks()
-
-  contract = new Request(fixtures.schema)
-})
-
-const dummy = { schema: { properties: {} } }
-
-it('should extend Conditions', () => {
-  expect(contract).toBeInstanceOf(Conditions)
-  expect(Conditions).toHaveBeenCalledWith(fixtures.schema)
-})
-
-it('should fit request', () => {
-  const request = { [generate()]: generate() }
-
-  contract.fit(request)
-
-  expect(Conditions.mock.instances[0].fit).toHaveBeenCalledWith(request)
-})
-
-describe('schema', () => {
-  let schema
-
-  beforeEach(() => {
-    schema = clone(fixtures.schemas.request)
-  })
-
-  it('should provide schema', () => {
-    expect(Request.schema({}, dummy)).toBeDefined()
-  })
-
-  it('should add required input if defined', () => {
-    const input = { type: 'number' }
-
-    expect(Request.schema({ input }, dummy).properties.input).toStrictEqual(input)
-  })
-
-  it('should set input as null if undefined', async () => {
-    expect(Request.schema({}, dummy).properties.input).toStrictEqual({ type: 'null' })
-  })
-
-  it('should contain query if declaration.query is not defined', () => {
-    expect(Request.schema({}, dummy).properties.query).toBeDefined()
-  })
-
-  it('should not contain query if declaration.query is false', () => {
-    schema.properties.query = { type: 'null' }
-    expect(Request.schema({ query: false }, dummy)).toStrictEqual(schema)
-  })
-
-  it('should require query if declaration.query is true', () => {
-    schema.required = ['query']
-    expect(Request.schema({ query: true }, dummy).required).toStrictEqual(expect.arrayContaining(['query']))
-  })
-
-  it('should forbid projection for non observations', () => {
-    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.projection)
-      .toBe(undefined)
-
-    expect(Request.schema({ type: 'assignment' }, dummy).properties.query.properties.projection)
-      .toBe(undefined)
-
-    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.projection)
-      .toBeDefined()
-  })
-
-  it('should forbid version for observations', () => {
-    expect(Request.schema({ type: 'transition' }, dummy).properties.query.properties.version)
-      .toBeDefined()
-
-    expect(Request.schema({ type: 'observation' }, dummy).properties.query.properties.version)
-      .toBe(undefined)
-  })
-
-  it('should allow omit, limit only for set observations', () => {
-    const schema = Request.schema({ type: 'transition' }, dummy)
-    const transition = schema.properties.query.properties
-
-    expect(transition.omit).toBeUndefined()
-    expect(transition.limit).toBeUndefined()
-
-    const object = Request.schema({
-      type: 'observation',
-      scope: 'object'
-    }, dummy).properties.query.properties
-
-    expect(object.omit).toBeUndefined()
-    expect(object.limit).toBeUndefined()
-
-    const objects = Request.schema({
-      type: 'observation',
-      scope: 'objects'
-    }, dummy).properties.query.properties
-
-    expect(objects.omit).toBeDefined()
-    expect(objects.limit).toBeDefined()
-  })
-})

package/test/emission.fixtures.js

@@ -1,17 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-// noinspection JSCheckFunctionSignatures
-const events = [0, 1, 2].map((index) => ({
-  emit: jest.fn(async (state) => ({ ...state, event: index }))
-}))
-
-const event = {
-  origin: { [generate()]: generate() },
-  state: { [generate()]: generate() },
-  changeset: { [generate()]: generate() }
-}
-
-exports.events = events
-exports.event = event

package/test/emission.test.js

@@ -1,35 +0,0 @@
-'use strict'
-
-jest.mock('../src/connector')
-
-const clone = require('clone-deep')
-
-const { Connector } = require('../src/connector')
-const { Emission } = require('../src/emission')
-const fixtures = require('./emission.fixtures')
-
-let emission, event
-
-beforeEach(async () => {
-  jest.clearAllMocks()
-
-  emission = new Emission(fixtures.events)
-  event = clone(fixtures.event)
-
-  await emission.open()
-})
-
-it('should depend on events', () => {
-  expect(emission).toBeInstanceOf(Connector)
-  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.events)
-})
-
-it('should emit events', async () => {
-  expect.assertions(fixtures.events.length)
-
-  await emission.emit(event)
-
-  for (const evt of fixtures.events) {
-    expect(evt.emit).toHaveBeenCalledWith(event)
-  }
-})

package/test/entities/entity.fixtures.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-// noinspection JSCheckFunctionSignatures
-const schema = {
-  fit: jest.fn((object) =>
-    (object.fail ? { [generate()]: generate() } : null)),
-
-  defaults: jest.fn(() => ({ [generate()]: generate() }))
-}
-
-const state = () => ({
-  id: generate(),
-  foo: generate(),
-  _created: generate(),
-  _updated: generate(),
-  _deleted: generate(),
-  _version: 0
-})
-
-const failed = () => ({
-  ...state(),
-  fail: true
-})
-
-exports.schema = schema
-exports.state = state
-exports.failed = failed

package/test/entities/entity.test.js

@@ -1,65 +0,0 @@
-'use strict'
-
-const { Entity } = require('../../src/entities/entity')
-const fixtures = require('./entity.fixtures')
-
-beforeEach(() => {
-  jest.clearAllMocks()
-})
-
-describe('new', () => {
-  it('should throw on schema error', () => {
-    const entity = new Entity(fixtures.schema)
-
-    expect(() => entity.set(fixtures.failed())).toThrow()
-  })
-
-  it('should provide state', () => {
-    const entity = new Entity(fixtures.schema)
-    const state = fixtures.state()
-
-    entity.set(state)
-
-    expect(entity.get()).toEqual(state)
-  })
-})
-
-describe('argument', () => {
-  it('should provide initial state if no argument passed', () => {
-    const entity = new Entity(fixtures.schema)
-    const defaults = fixtures.schema.defaults.mock.results[0].value
-    const expected = {
-      ...defaults,
-      _version: 0
-    }
-
-    expect(entity.get()).toStrictEqual(expect.objectContaining(expected))
-  })
-
-  it('should set state', () => {
-    const state = fixtures.state()
-    const entity = new Entity(fixtures.schema, state)
-
-    expect(entity.get()).toEqual(state)
-  })
-})
-
-it('should provide event', () => {
-  const origin = fixtures.state()
-  const entity = new Entity(fixtures.schema, origin)
-  const state = entity.get()
-
-  state.foo = 'new value'
-  entity.set(state)
-
-  const event = entity.event()
-
-  expect(event).toEqual(expect.objectContaining({
-    state,
-    origin,
-    changeset: expect.objectContaining({
-      foo: 'new value',
-      _version: 1
-    })
-  }))
-})

package/test/entities/factory.fixtures.js

@@ -1,18 +0,0 @@
-'use strict'
-
-const randomstring = require('randomstring')
-
-const schema = { [randomstring.generate()]: randomstring.generate() }
-const storage = { id: jest.fn(() => randomstring.generate()) }
-const entity = { [randomstring.generate()]: randomstring.generate() }
-const set = Array.from(Array(5))
-  .map((_, index) => ({ id: index, [randomstring.generate()]: randomstring.generate() }))
-
-const Entity = jest.fn().mockImplementation(function () { this.id = randomstring.generate() })
-const EntitySet = jest.fn().mockImplementation(function () {})
-
-exports.schema = schema
-exports.storage = storage
-exports.entity = entity
-exports.set = set
-exports.mock = { Entity, EntitySet }

package/test/entities/factory.test.js

@@ -1,48 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const fixtures = require('./factory.fixtures')
-const mock = fixtures.mock
-
-jest.mock('../../src/entities/entity', () => ({ Entity: mock.Entity }))
-jest.mock('../../src/entities/set', () => ({ EntitySet: mock.EntitySet }))
-
-const { Factory } = require('../../src/entities/factory')
-
-let factory
-
-beforeEach(async () => {
-  jest.clearAllMocks()
-
-  factory = new Factory(fixtures.schema, () => fixtures.storage.id())
-})
-
-it('should create initial', () => {
-  const id = generate()
-  const initial = factory.init(id)
-
-  expect(initial).toBeInstanceOf(mock.Entity)
-  expect(initial.constructor).toHaveBeenCalledWith(fixtures.schema, id)
-})
-
-it('should create instance', () => {
-  const object = factory.object(fixtures.entity)
-
-  expect(object).toBeInstanceOf(mock.Entity)
-  expect(object.constructor).toHaveBeenCalledWith(fixtures.schema, fixtures.entity)
-})
-
-it('should create set', () => {
-  const objects = factory.objects(fixtures.set)
-
-  expect(objects).toBeInstanceOf(mock.EntitySet)
-
-  const instances = fixtures.set.map((entity, index) => {
-    expect(mock.Entity).toHaveBeenNthCalledWith(index + 1, fixtures.schema, entity)
-
-    return mock.Entity.mock.instances[index]
-  })
-
-  expect(objects.constructor).toHaveBeenCalledWith(instances)
-})

package/test/entities/set.fixtures.js

@@ -1,11 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const set = [
-  { get: jest.fn(() => ({ [generate()]: generate() })) },
-  { get: jest.fn(() => ({ [generate()]: generate() })) },
-  { get: jest.fn(() => ({ [generate()]: generate() })) }
-]
-
-exports.set = set

package/test/entities/set.test.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const { EntitySet } = require('../../src/entities/set')
-const fixtures = require('./set.fixtures')
-
-it('should provide state', () => {
-  const set = new EntitySet(fixtures.set)
-  const state = set.get()
-  const expected = fixtures.set.map((entity) => entity.get.mock.results[0].value)
-
-  expect(state).toStrictEqual(expected)
-})

package/test/event.fixtures.js

@@ -1,29 +0,0 @@
-'use strict'
-
-const { generate } = require('randomstring')
-
-const definition = {
-  conditioned: true,
-  subjective: true
-}
-
-// noinspection JSCheckFunctionSignatures
-const bridge = {
-  condition: jest.fn(async (origin) => !origin.falsy),
-  payload: jest.fn(async () => ({ [generate()]: generate() }))
-}
-
-const binding = {
-  emit: jest.fn()
-}
-
-const event = {
-  origin: { [generate()]: generate() },
-  state: { [generate()]: generate() },
-  changeset: { [generate()]: generate() }
-}
-
-exports.bridge = bridge
-exports.binding = binding
-exports.definition = definition
-exports.event = event