@toa.io/core 0.1.0-alpha.12

package/test/entities/entity.test.js

@@ -0,0 +1,64 @@
+'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)
+
+    expect(entity.get()).toStrictEqual(fixtures.schema.defaults.mock.results[0].value)
+  })
+
+  it('should set provide origin state', () => {
+    const state = fixtures.state()
+    const entity = new Entity(fixtures.schema, state)
+
+    expect(entity.get()).toStrictEqual(state)
+  })
+
+  it('should not validate origin state', () => {
+    const state = fixtures.failed()
+    const entity = new Entity(fixtures.schema, state)
+
+    expect(entity.get()).toStrictEqual(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).toStrictEqual({
+    state,
+    origin: origin,
+    changeset: { foo: 'new value' }
+  })
+})

package/test/entities/factory.fixtures.js

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

@@ -0,0 +1,48 @@
+'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 entity = factory.entity(fixtures.entity)
+
+  expect(entity).toBeInstanceOf(mock.Entity)
+  expect(entity.constructor).toHaveBeenCalledWith(fixtures.schema, fixtures.entity)
+})
+
+it('should create set', () => {
+  const set = factory.set(fixtures.set)
+
+  expect(set).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(set.constructor).toHaveBeenCalledWith(instances)
+})

package/test/entities/set.fixtures.js

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

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

@@ -0,0 +1,28 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const definition = {
+  conditioned: true,
+  subjective: true
+}
+
+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

package/test/event.test.js

@@ -0,0 +1,106 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+jest.mock('../src/connector')
+
+const { Connector } = require('../src/connector')
+const { Event } = require('../src/event')
+const fixtures = require('./event.fixtures')
+
+let event, emit
+
+beforeEach(() => {
+  jest.clearAllMocks()
+
+  event = new Event(fixtures.definition, fixtures.binding, fixtures.bridge)
+  emit = () => event.emit(fixtures.event)
+})
+
+it('should depend on binding', () => {
+  expect(event).toBeInstanceOf(Connector)
+  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.binding)
+})
+
+it('should depend on bridge if provided', () => {
+  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridge)
+
+  event = new Event(fixtures.definition, fixtures.binding)
+  expect(Connector.mock.instances[1].depends).not.toHaveBeenCalledWith(fixtures.bridge)
+})
+
+describe('condition', () => {
+  describe('conditioned', () => {
+    it('should call condition', async () => {
+      await emit()
+
+      expect(fixtures.bridge.condition).toHaveBeenCalledWith(fixtures.event)
+    })
+
+    it('should emit if condition returns true', async () => {
+      await emit()
+
+      expect(fixtures.binding.emit).toHaveBeenCalledWith(await fixtures.bridge.payload.mock.results[0].value)
+    })
+
+    it('should not emit if condition returns false', async () => {
+      const origin = clone(fixtures.event.origin)
+
+      origin.falsy = true
+
+      await event.emit(origin, fixtures.event.changeset, fixtures.event.state)
+
+      expect(fixtures.binding.emit).not.toHaveBeenCalled()
+    })
+  })
+
+  describe('unconditioned', () => {
+    beforeEach(() => {
+      const definition = clone(fixtures.definition)
+
+      definition.conditioned = false
+
+      event = new Event(definition, fixtures.binding, fixtures.bridge)
+    })
+
+    it('should not call condition', async () => {
+      await event.emit(fixtures.event.origin, fixtures.event.changeset, fixtures.event.state)
+
+      expect(fixtures.bridge.condition).not.toHaveBeenCalledWith()
+      expect(fixtures.binding.emit).toHaveBeenCalledWith(await fixtures.bridge.payload.mock.results[0].value)
+    })
+  })
+})
+
+describe('payload', () => {
+  describe('subjective', () => {
+    it('should emit payload', async () => {
+      await emit()
+
+      expect(fixtures.binding.emit).toHaveBeenCalledWith(await fixtures.bridge.payload.mock.results[0].value)
+    })
+  })
+
+  describe('objective', () => {
+    beforeEach(() => {
+      const definition = clone(fixtures.definition)
+
+      definition.subjective = false
+
+      event = new Event(definition, fixtures.binding, fixtures.bridge)
+      emit = () => event.emit(fixtures.event)
+    })
+
+    it('should not call payload', async () => {
+      await emit()
+
+      expect(fixtures.bridge.payload).not.toHaveBeenCalled()
+    })
+
+    it('should return state as payload', async () => {
+      await emit()
+
+      expect(fixtures.binding.emit).toHaveBeenCalledWith(fixtures.event.state)
+    })
+  })
+})

package/test/locator.test.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const { Locator } = require('../src/locator')
+
+const manifest = {
+  domain: 'foo',
+  name: 'bar',
+  entity: { schema: { foo: 'bar' } },
+  operations: { add: { query: false }, get: { output: null } }
+}
+
+const nameless = {
+  domain: 'foo',
+  entity: { schema: { foo: 'bar' } },
+  operations: [{ name: 'add' }, { name: 'get' }]
+}
+
+const env = process.env.TOA_ENV
+
+beforeAll(() => {
+  delete process.env.TOA_ENV
+})
+
+afterAll(() => {
+  process.env.TOA_ENV = env
+})
+
+it('should provide host', () => {
+  expect(new Locator(manifest).host('db')).toBe('foo-db')
+  expect(new Locator(nameless).host('db')).toBe('foo-db')
+  expect(new Locator(nameless).host('DB')).toBe('foo-db')
+  expect(new Locator(manifest).host('db', 1)).toBe('foo-bar-db')
+  expect(new Locator(nameless).host('db', 1)).toBe('foo-db')
+})

package/test/query.fixtures.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const samples = {
+  simple: {
+    query: {
+      criteria: 'name==Eddie'
+    },
+    parsed: {
+      criteria: {
+        type: 'COMPARISON',
+        left: { type: 'SELECTOR', selector: 'name' },
+        operator: '==',
+        right: { type: 'VALUE', value: 'Eddie' }
+      }
+    },
+    properties: {
+      name: {
+        type: 'string'
+      }
+    }
+  },
+
+  extended: {
+    query: {
+      criteria: 'flag==true;volume>2.1'
+    },
+    parsed: {
+      criteria: {
+        type: 'LOGIC',
+        left: {
+          type: 'COMPARISON',
+          left: { type: 'SELECTOR', selector: 'flag' },
+          operator: '==',
+          right: { type: 'VALUE', value: true }
+        },
+        operator: ';',
+        right: {
+          type: 'COMPARISON',
+          left: { type: 'SELECTOR', selector: 'volume' },
+          operator: '>',
+          right: { type: 'VALUE', value: 2.1 }
+        }
+      }
+    },
+    properties: {
+      flag: {
+        type: 'boolean'
+      },
+      volume: {
+        type: 'number'
+      }
+    }
+  },
+
+  abc: {
+    properties: {
+      a: {
+        type: 'string'
+      },
+      b: {
+        type: 'string'
+      },
+      c: {
+        type: 'string'
+      }
+    }
+  },
+
+  id: {
+    properties: {
+      id: {
+        type: 'string'
+      },
+      name: {
+        type: 'string'
+      }
+    },
+    query: {
+      id: '123',
+      criteria: 'name==Eddie'
+    },
+    parsed: {
+      id: '123',
+      criteria: {
+        type: 'COMPARISON',
+        left: {
+          type: 'SELECTOR',
+          selector: 'name'
+        },
+        operator: '==',
+        right: {
+          type: 'VALUE',
+          value: 'Eddie'
+        }
+      }
+    }
+  }
+}
+
+exports.samples = samples

package/test/query.test.js

@@ -0,0 +1,86 @@
+'use strict'
+
+const { Query } = require('../src/query')
+const fixtures = require('./query.fixtures')
+
+beforeEach(() => {
+  jest.clearAllMocks()
+})
+
+describe('criteria', () => {
+  it('should not throw if no criteria', () => {
+    const instance = new Query(fixtures.samples.simple.properties)
+    const query = instance.parse({})
+
+    expect(query.criteria).toBeUndefined()
+  })
+
+  it('should parse criteria', () => {
+    const instance = new Query(fixtures.samples.simple.properties)
+    const query = instance.parse(fixtures.samples.simple.query)
+
+    expect(query.criteria).toEqual(fixtures.samples.simple.parsed.criteria)
+  })
+
+  it('should parse criteria with type coercion', () => {
+    const instance = new Query(fixtures.samples.extended.properties)
+    const query = instance.parse(fixtures.samples.extended.query)
+
+    expect(query.criteria).toEqual(fixtures.samples.extended.parsed.criteria)
+  })
+
+  it('should throw on unknown properties', () => {
+    const instance = new Query(fixtures.samples.simple.properties)
+
+    expect(() => instance.parse({ criteria: 'lastname==Johnson' })).toThrow(/not defined/)
+  })
+
+  it('should parse id', () => {
+    const instance = new Query(fixtures.samples.id.properties)
+    const query = instance.parse({ ...fixtures.samples.id.query })
+
+    expect(query).toStrictEqual(fixtures.samples.id.parsed)
+  })
+})
+
+describe('options', () => {
+  const instance = new Query(fixtures.samples.abc.properties)
+
+  it('should not throw if no options', () => {
+    const query = instance.parse({})
+
+    expect(query.options).toBeUndefined()
+  })
+
+  describe('omit, limit', () => {
+    it('should pass', () => {
+      const input = { omit: 1, limit: 1 }
+      const query = instance.parse(input)
+
+      expect(query.options).toStrictEqual(input)
+    })
+  })
+
+  describe('sort', () => {
+    it('should set default values', () => {
+      const sort = ['a', 'b:desc', 'c']
+      const query = instance.parse({ sort })
+
+      expect(query.options.sort).toStrictEqual([['a', 'asc'], ['b', 'desc'], ['c', 'asc']])
+    })
+
+    it('should throw on unknown properties', () => {
+      const sort = ['d:asc']
+
+      expect(() => instance.parse({ sort })).toThrow(/not defined/)
+    })
+  })
+
+  describe('projection', () => {
+    it('should throw on unknown properties', () => {
+      const projection = ['a', 'b', 'c', 'd']
+
+      expect(() => instance.parse({ projection })).toThrow(/not defined/)
+    })
+  })
+})

package/test/receiver.fixtures.js

@@ -0,0 +1,22 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const definition = {
+  transition: generate(),
+  conditioned: false,
+  adaptive: false
+}
+
+const local = {
+  invoke: jest.fn()
+}
+
+const bridge = {
+  condition: jest.fn((payload) => !(payload.reject === true)),
+  request: jest.fn(() => generate())
+}
+
+exports.definition = definition
+exports.local = local
+exports.bridge = bridge

package/test/receiver.test.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const clone = require('clone-deep')
+
+jest.mock('../src/connector')
+
+const { Connector } = require('../src/connector')
+
+const { Receiver } = require('../src/receiver')
+const fixtures = require('./receiver.fixtures')
+
+let receiver, definition
+
+beforeEach(() => {
+  definition = clone(fixtures.definition)
+  receiver = new Receiver(fixtures.definition, fixtures.local, fixtures.bridge)
+})
+
+it('should depend on local, bridge', () => {
+  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.local)
+  expect(Connector.mock.instances[0].depends).toHaveBeenCalledWith(fixtures.bridge)
+})
+
+it('should apply', async () => {
+  const payload = { foo: 'bar' }
+  await receiver.receive(payload)
+
+  expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.transition, payload)
+})
+
+describe('conditioned', () => {
+  beforeEach(() => {
+    definition.conditioned = true
+    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
+  })
+
+  it('should test condition', async () => {
+    const payload = { foo: 'bar' }
+    await receiver.receive(payload)
+
+    expect(fixtures.bridge.condition).toHaveBeenCalledWith(payload)
+    expect(fixtures.local.invoke).toHaveBeenCalledWith(definition.transition, payload)
+  })
+
+  it('should not apply if condition is false', async () => {
+    const payload = { reject: true }
+    await receiver.receive(payload)
+
+    expect(fixtures.local.invoke).not.toHaveBeenCalled()
+  })
+})
+
+describe('adaptive', () => {
+  beforeEach(() => {
+    definition.adaptive = true
+    receiver = new Receiver(definition, fixtures.local, fixtures.bridge)
+  })
+
+  it('should apply', async () => {
+    const payload = { reject: true }
+    await receiver.receive(payload)
+
+    expect(fixtures.local.invoke)
+      .toHaveBeenCalledWith(definition.transition, fixtures.bridge.request.mock.results[0].value)
+  })
+})

package/test/runtime.fixtures.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const randomstring = require('randomstring')
+
+const invocation = () => jest.fn(() => randomstring.generate())
+
+const invocations = {
+  foo: {
+    invoke: invocation('foo')
+  },
+  bar: {
+    invoke: invocation('bar')
+  }
+}
+
+const locator = {}
+
+exports.invocations = invocations
+exports.locator = locator

package/test/runtime.test.js

@@ -0,0 +1,40 @@
+'use strict'
+
+const { Runtime } = require('../src/runtime')
+const { codes } = require('../src/exceptions')
+const fixtures = require('./runtime.fixtures')
+
+describe('Invocations', () => {
+  const name = ['foo', 'bar'][Math.floor(2 * Math.random())]
+  const invocation = fixtures.invocations[name]
+  const runtime = new Runtime(fixtures.locator, fixtures.invocations)
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  it('should invoke', async () => {
+    await runtime.invoke(name)
+
+    expect(invocation.invoke).toBeCalled()
+  })
+
+  it('should throw on unknown invocation name', async () => {
+    await expect(() => runtime.invoke('baz'))
+      .rejects.toMatchObject({ code: codes.NotImplemented })
+  })
+
+  it('should invoke input and query', async () => {
+    const input = { test: Math.random() }
+    const query = { test: Math.random() }
+    await runtime.invoke(name, { input, query })
+
+    expect(invocation.invoke).toBeCalledWith({ input, query })
+  })
+
+  it('should return io', async () => {
+    const io = await runtime.invoke(name)
+
+    expect(io).toBe(fixtures.invocations[name].invoke.mock.results[0].value)
+  })
+})