@toa.io/storages.mongodb 0.2.0-dev.1 → 0.2.1-dev.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toa.io/storages.mongodb",
-  "version": "0.2.0-dev.1",
+  "version": "0.2.1-dev.4",
   "description": "Toa MongoDB Storage Connector",
   "author": "temich <tema.gurtovoy@gmail.com>",
   "homepage": "https://github.com/toa-io/toa#readme",
@@ -19,7 +19,11 @@
     "test": "echo \"Error: run tests from root\" && exit 1"
   },
   "dependencies": {
-    "mongodb": "4.1.4"
+    "@toa.io/console": "*",
+    "@toa.io/core": "*",
+    "@toa.io/generic": "*",
+    "@toa.io/pointer": "*",
+    "mongodb": "4.13.0"
   },
-  "gitHead": "a0df6f203bca3e26e3a4a791a213e418d2b65764"
+  "gitHead": "2be07592325b2e4dc823e81d882a4e50bf50de24"
 }

package/src/annotation.js

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

package/src/connection.js

@@ -0,0 +1,90 @@
+// noinspection JSCheckFunctionSignatures
+
+'use strict'
+
+const { MongoClient } = require('mongodb')
+const { Connector } = require('@toa.io/core')
+const { console } = require('@toa.io/console')
+
+/**
+ * @implements {toa.mongodb.Connection}
+ */
+class Connection extends Connector {
+  /** @type {toa.mongodb.Pointer} */
+  #pointer
+  /** @type {import('mongodb').MongoClient} */
+  #client
+  /** @type {import('mongodb').Collection<toa.mongodb.Record>} */
+  #collection
+
+  /**
+   * @param {toa.mongodb.Pointer} pointer
+   */
+  constructor (pointer) {
+    super()
+
+    this.#pointer = pointer
+    this.#client = new MongoClient(pointer.reference, OPTIONS)
+  }
+
+  async open () {
+    await this.#client.connect()
+
+    this.#collection = this.#client.db(this.#pointer.db).collection(this.#pointer.collection)
+
+    console.info(`Storage Mongo connected to ${this.#pointer.label}/${this.#pointer.db}/${this.#pointer.collection}`)
+  }
+
+  async close () {
+    await this.#client.close()
+
+    console.info(`Storage Mongo disconnected from ${this.#pointer.label}/${this.#pointer.db}/${this.#pointer.collection}`)
+  }
+
+  /** @hot */
+  async get (query, options) {
+    return /** @type {toa.mongodb.Record} */ this.#collection.findOne(query, options)
+  }
+
+  /** @hot */
+  async find (query, options) {
+    const cursor = await this.#collection.find(query, options)
+
+    return cursor.toArray()
+  }
+
+  /** @hot */
+  async add (record) {
+    /** @type {boolean} */
+    let result
+
+    try {
+      const response = await this.#collection.insertOne(record)
+
+      result = response.acknowledged
+    } catch (e) {
+      if (e.code === 11000) result = false // duplicate id
+      else throw e
+    }
+
+    return result
+  }
+
+  /** @hot */
+  async replace (query, record, options) {
+    return await this.#collection.findOneAndReplace(query, record, options)
+  }
+
+  /** @hot */
+  async update (query, update, options) {
+    return this.#collection.findOneAndUpdate(query, update, options)
+  }
+}
+
+const OPTIONS = {
+  useNewUrlParser: true,
+  useUnifiedTopology: true,
+  ignoreUndefined: true
+}
+
+exports.Connection = Connection

package/src/deployment.js

@@ -0,0 +1,15 @@
+'use strict'
+
+const pointer = require('@toa.io/pointer')
+
+/** @type {toa.deployment.dependency.Constructor} */
+const deployment = (instances, annotation) => {
+  if (annotation === undefined) throw new Error('MongoDB pointer annotation is required')
+
+  return pointer.deployment(instances, annotation, OPTIONS)
+}
+
+/** @type {toa.pointer.deployment.Options} */
+const OPTIONS = { prefix: 'storages-mongodb' }
+
+exports.deployment = deployment

package/src/factory.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const { Pointer } = require('./pointer')
+const { Connection } = require('./connection')
+const { Storage } = require('./storage')
+
+/**
+ * @implements {toa.core.storages.Factory}
+ */
+class Factory {
+  storage (locator) {
+    const pointer = new Pointer(locator)
+    const connection = new Connection(pointer)
+
+    return new Storage(connection)
+  }
+}
+
+exports.Factory = Factory

package/src/index.js

@@ -1,5 +1,9 @@
-const { Storage } = require('./storage')
-const { deployments } = require('./deployments')
+'use strict'
 
-exports.Storage = Storage
-exports.deployments = deployments
+const { annotation } = require('./annotation')
+const { deployment } = require('./deployment')
+const { Factory } = require('./factory')
+
+exports.annotation = annotation
+exports.deployment = deployment
+exports.Factory = Factory

package/src/pointer.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const { Pointer: Base } = require('@toa.io/pointer')
+
+// noinspection JSClosureCompilerSyntax
+/**
+ * @implements {toa.mongodb.Pointer}
+ */
+class Pointer extends Base {
+  db
+  collection
+
+  /**
+   * @param {toa.core.Locator} locator
+   */
+  constructor (locator) {
+    super(PREFIX, locator, OPTIONS)
+
+    this.db = locator.namespace
+    this.collection = locator.name
+  }
+}
+
+/** @type {toa.pointer.Options} */
+const OPTIONS = { protocol: 'mongodb:' }
+const PREFIX = 'storages-mongodb'
+
+exports.Pointer = Pointer

package/src/record.js

@@ -1,11 +1,19 @@
 'use strict'
 
+/**
+ * @param {toa.core.storages.Record} entity
+ * @returns {toa.mongodb.Record}
+ */
 const to = (entity) => {
   const { id, _version, ...rest } = entity
 
-  return { _id: id, _version: _version === undefined ? 1 : _version + 1, ...rest }
+  return /** @type {toa.mongodb.Record} */ { _id: id, _version: _version + 1, ...rest }
 }
 
+/**
+ * @param {toa.mongodb.Record} record
+ * @returns {toa.core.storages.Record}
+ */
 const from = (record) => {
   if (record === undefined || record === null) return null
 

package/src/storage.js

@@ -2,53 +2,58 @@
 
 const { Connector } = require('@toa.io/core')
 
-const { Client } = require('./client')
 const { translate } = require('./translate')
 const { to, from } = require('./record')
 
+/**
+ * @implements {toa.core.Storage}
+ */
 class Storage extends Connector {
-  #client
+  /** @type {toa.mongodb.Connection} */
+  #connection
 
-  constructor (locator) {
+  /**
+   * @param {toa.mongodb.Connection} connection
+   */
+  constructor (connection) {
     super()
 
-    const host = locator.host('mongodb')
+    this.#connection = connection
 
-    // TODO: create Factory, add test for host
-    this.#client = new Client(host, locator.domain, locator.name)
-    this.depends(this.#client)
+    this.depends(connection)
   }
 
   async get (query) {
     const { criteria, options } = translate(query)
 
-    const record = await this.#client.get(criteria, options)
+    const record = await this.#connection.get(criteria, options)
 
     return from(record)
   }
 
-  async add (entity) {
-    let result
+  async find (query) {
+    const { criteria, options } = translate(query)
+    const recordset = await this.#connection.find(criteria, options)
 
-    try {
-      result = await this.#client.add(to(entity))
-    } catch (e) {
-      if (e.code === 11000) result = false // duplicate id
-      else throw e
-    }
+    return recordset.map((item) => from(item))
+  }
+
+  async add (entity) {
+    const record = to(entity)
 
-    return result
+    return await this.#connection.add(record)
   }
 
   async set (entity) {
     const criteria = { _id: entity.id, _version: entity._version }
-    const result = await this.#client.replace(criteria, to(entity))
+    const result = await this.#connection.replace(criteria, to(entity))
 
     return result.value !== null
   }
 
   async store (entity) {
-    return entity._version === 0 ? this.add(entity) : this.set(entity)
+    if (entity._version === 0) return this.add(entity)
+    else return this.set(entity)
   }
 
   async upsert (query, changeset, insert) {
@@ -68,17 +73,10 @@ class Storage extends Connector {
 
     options.returnDocument = 'after'
 
-    const result = await this.#client.update(criteria, update, options)
+    const result = await this.#connection.update(criteria, update, options)
 
     return from(result.value)
   }
-
-  async find (query) {
-    const { criteria, options } = translate(query)
-    const recordset = await this.#client.find(criteria, options)
-
-    return recordset.map(from)
-  }
 }
 
 exports.Storage = Storage

package/src/translate/criteria.js

@@ -1,8 +1,13 @@
 'use strict'
 
 const { rename } = require('./rename')
+
+/**
+ * @param {toa.core.storages.ast.Node} node
+ * @returns {import('mongodb').Filter}
+ */
 const criteria = (node) => {
-  if (!TYPES[node.type]) { throw new Error('Query criteria AST parse error') }
+  if (TYPES[node.type] === undefined) throw new Error(`AST parse error: unknown node type '${node.type}'`)
 
   return TYPES[node.type](node)
 }
@@ -38,8 +43,11 @@ TYPES.LOGIC = (expression) => {
 TYPES.COMPARISON = (expression) => {
   const left = criteria(expression.left)
   const right = criteria(expression.right)
+  const operator = OPERATORS.COMPARISON[expression.operator]
+
+  if (operator === undefined) throw new Error(`AST parse error: unknown operator '${expression.operator}'`)
 
-  return { [left]: { [OPERATORS.COMPARISON[expression.operator]]: right } }
+  return { [left]: { [operator]: right } }
 }
 
 TYPES.SELECTOR = (expression) => rename(expression.selector)

package/src/translate.js

@@ -2,13 +2,17 @@
 
 const parse = { ...require('./translate/criteria'), ...require('./translate/options') }
 
+/**
+ * @param {toa.core.storages.Query} query
+ * @returns {{criteria: Object, options: Object}}
+ */
 const translate = (query) => {
   const result = { criteria: {}, options: {} }
 
-  if (query.criteria) result.criteria = parse.criteria(query.criteria)
-  if (query.options) result.options = parse.options(query.options)
-  if (query.id) result.criteria._id = query.id
-  if (query.version) result.criteria._version = query.version
+  if (query.criteria !== undefined) result.criteria = parse.criteria(query.criteria)
+  if (query.options !== undefined) result.options = parse.options(query.options)
+  if (query.id !== undefined) result.criteria._id = query.id
+  if (query.version !== undefined) result.criteria._version = query.version
 
   return result
 }

package/test/annotations.test.js

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

@@ -0,0 +1,13 @@
+'use strict'
+
+const { deployment } = require('../')
+
+it('should be', () => {
+  expect(deployment).toBeDefined()
+})
+
+it('should throw if annotation is not defined', () => {
+  const instances = []
+
+  expect(() => deployment(instances, undefined)).toThrow('is required')
+})

package/test/factory.fixtures.js

@@ -0,0 +1,18 @@
+'use strict'
+
+const { generate } = require('randomstring')
+
+const Connection = jest.fn().mockImplementation(function () {})
+const Storage = jest.fn().mockImplementation(function () {})
+
+/** @type {toa.core.Locator} */ const locator = {
+  name: generate(),
+  namespace: generate(),
+  id: generate(),
+  label: generate(),
+  uppercase: generate().toUpperCase(),
+  hostname: jest.fn(() => generate())
+}
+
+exports.mock = { Connection, Storage }
+exports.locator = locator

package/test/factory.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const { encode } = require('@toa.io/generic')
+
+const fixtures = require('./factory.fixtures')
+const mock = fixtures.mock
+
+jest.mock('../src/storage', () => ({ Storage: mock.Storage }))
+jest.mock('../src/connection', () => ({ Connection: mock.Connection }))
+
+const { Factory } = require('../src/')
+
+/** @type {toa.core.storages.Factory} */
+let factory
+
+const uris = { default: 'mongodb://whatever' }
+const value = encode(uris)
+
+process.env.TOA_STORAGES_MONGODB_POINTER = value
+
+beforeEach(() => {
+  factory = new Factory()
+})
+
+it('should create url', () => {
+  factory.storage(fixtures.locator)
+
+  expect(mock.Connection).toHaveBeenCalled()
+
+  const instance = mock.Connection.mock.instances[0]
+  /** @type {toa.mongodb.Pointer} */
+  const pointer = mock.Connection.mock.calls[0][0]
+
+  expect(mock.Storage).toHaveBeenLastCalledWith(instance)
+
+  expect(pointer).toBeDefined()
+})

package/test/pointer.test.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const { generate } = require('randomstring')
+const { Locator } = require('@toa.io/core')
+const { encode } = require('@toa.io/generic')
+
+const { Pointer } = require('../src/pointer')
+
+it('should be', () => undefined)
+
+/** @type {toa.core.Locator} */
+let locator
+
+/** @type {toa..Pointer} */
+let pointer
+
+const uris = { default: 'mongodb://whatever' }
+const value = encode(uris)
+
+process.env.TOA_STORAGES_MONGODB_POINTER = value
+
+beforeEach(() => {
+  const name = generate()
+  const namespace = generate()
+
+  locator = new Locator(name, namespace)
+  pointer = new Pointer(locator)
+})
+
+it('should define schema', () => {
+  expect(pointer.protocol).toStrictEqual('mongodb:')
+})
+
+it('should expose db', () => {
+  expect(pointer.db).toStrictEqual(locator.namespace)
+})
+
+it('should expose collection', () => {
+  expect(pointer.collection).toStrictEqual(locator.name)
+})
+
+it('should define schema on local environment', () => {
+  process.env.TOA_ENV = 'local'
+
+  expect(() => (pointer = new Pointer(locator))).not.toThrow()
+
+  expect(pointer.protocol).toStrictEqual('mongodb:')
+
+  delete process.env.TOA_ENV
+})

package/test/record.test.js

@@ -0,0 +1,50 @@
+'use strict'
+
+const { to, from } = require('../src/record')
+const { random } = require('@toa.io/generic')
+
+describe('to', () => {
+  it('should rename id to _id', () => {
+    /** @type {toa.core.storages.Record} */
+    const entity = { id: '1', _version: 0 }
+    const record = to(entity)
+
+    expect(record).toMatchObject({ _id: '1' })
+  })
+
+  it('should not modify argument', () => {
+    /** @type {toa.core.storages.Record} */
+    const entity = { id: '1', _version: 0 }
+
+    to(entity)
+
+    expect(entity).toStrictEqual({ id: '1', _version: 0 })
+  })
+
+  it('should increment _version', () => {
+    /** @type {toa.core.storages.Record} */
+    const entity = { id: '1', _version: random() }
+    const record = to(entity)
+
+    expect(record).toMatchObject({ _version: entity._version + 1 })
+  })
+})
+
+describe('from', () => {
+  it('should rename _id to id', () => {
+    /** @type {toa.mongodb.Record} */
+    const record = { _id: '1', _version: 0 }
+    const entity = from(record)
+
+    expect(entity).toStrictEqual({ id: '1', _version: 0 })
+  })
+
+  it('should not modify argument', () => {
+    /** @type {toa.mongodb.Record} */
+    const record = { _id: '1', _version: 0 }
+
+    from(record)
+
+    expect(record).toStrictEqual({ _id: '1', _version: 0 })
+  })
+})

package/types/connection.d.ts

@@ -0,0 +1,29 @@
+// noinspection ES6UnusedImports
+
+import type {
+    Document,
+    Filter,
+    FindOneAndReplaceOptions,
+    FindOneAndUpdateOptions,
+    FindOptions,
+    UpdateFilter
+} from 'mongodb'
+
+import type { Connector } from '@toa.io/core'
+import type { Record } from './record'
+
+declare namespace toa.mongodb {
+
+    interface Connection extends Connector {
+        get(query: Filter<Record>, options?: FindOptions<Record>): Promise<Record>
+
+        find(query: Filter<Record>, options?: FindOptions<Record>): Promise<Record[]>
+
+        add(record: Record): Promise<boolean>
+
+        replace(query: Filter<Record>, record: UpdateFilter<Record>, options?: FindOneAndReplaceOptions): Promise<any>
+
+        update(query: Filter<Record>, update: UpdateFilter<Record>, options?: FindOneAndUpdateOptions): Promise<any>
+    }
+
+}

package/types/pointer.d.ts

@@ -0,0 +1,10 @@
+import type { Pointer as Base } from '@toa.io/pointer/types'
+
+declare namespace toa.mongodb {
+
+    interface Pointer extends Base {
+        db: string
+        collection: string
+    }
+
+}

package/types/record.d.ts

@@ -0,0 +1,12 @@
+declare namespace toa.mongodb {
+
+    interface Record {
+        _id: string
+        _version: number
+
+        [key: string]: any
+    }
+
+}
+
+export type Record = toa.mongodb.Record

package/LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2020-present Artem Gurtovoi
-
-MIT License
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/deploy/service.yaml

@@ -1,21 +0,0 @@
-apiVersion: v1
-kind: Service
-metadata:
-  name: messages-mongodb
-spec:
-  selector:
-    app.kubernetes.io/name: rabbitmq
-  ports:
-    - port: 27017
-      targetPort: 27017
----
-apiVersion: v1
-kind: Service
-metadata:
-  name: credits-mongodb
-spec:
-  selector:
-    app.kubernetes.io/name: rabbitmq
-  ports:
-    - port: 27017
-      targetPort: 27017

package/src/client.js

@@ -1,76 +0,0 @@
-'use strict'
-
-const { MongoClient } = require('mongodb')
-const { Connector } = require('@toa.io/core')
-const { console } = require('@toa.io/gears')
-
-class Client extends Connector {
-  #connection
-
-  #client
-  #collection
-
-  constructor (host, db, collection) {
-    super()
-
-    this.#connection = { host, db, collection }
-
-    const url = this.#url()
-    this.#client = new MongoClient(url, OPTIONS)
-  }
-
-  async connection () {
-    await this.#client.connect()
-
-    this.#collection = this.#client.db(this.#connection.db).collection(this.#connection.collection)
-
-    console.info(`Storage MongoDB connected to ${this.#url()}`)
-  }
-
-  async disconnection () {
-    await this.#client.close()
-
-    console.info('Storage MongoDB disconnected from ' +
-      `${this.#url}/${this.#connection.db}/${this.#connection.collection}`)
-  }
-
-  async add (record) {
-    const { acknowledged } = await this.#collection.insertOne(record)
-
-    return acknowledged
-  }
-
-  async get (query, options) {
-    return await this.#collection.findOne(query, options)
-  }
-
-  async replace (query, record, options) {
-    return this.#collection.findOneAndReplace(query, record, options)
-  }
-
-  async update (query, update, options) {
-    return this.#collection.findOneAndUpdate(query, update, options)
-  }
-
-  async find (query, options) {
-    const cursor = await this.#collection.find(query, options)
-
-    return cursor.toArray()
-  }
-
-  #url () {
-    // TODO: see ./deployment.js
-    const user = 'user'
-    const password = 'password'
-
-    return `mongodb://${user}:${password}@${this.#connection.host}:27017/?authSource=${this.#connection.db}&readPreference=primary&appname=svc&ssl=false`
-  }
-}
-
-const OPTIONS = {
-  useNewUrlParser: true,
-  useUnifiedTopology: true,
-  ignoreUndefined: true
-}
-
-exports.Client = Client

package/src/deployments.js

@@ -1,36 +0,0 @@
-'use strict'
-
-const deployments = (values) => {
-  const domains = new Set(values.map((value) => value.domain))
-
-  return [...domains].map(deployment)
-}
-
-const deployment = (domain) => {
-  const alias = domain + '-mongodb'
-
-  // TODO: credentials management
-  const usernames = ['user']
-  const passwords = ['password']
-  const databases = [domain]
-
-  return {
-    chart: {
-      name: 'mongodb',
-      version: '10.29.2',
-      repository: 'https://charts.bitnami.com/bitnami',
-      alias
-    },
-    values: {
-      architecture: 'standalone',
-      fullnameOverride: alias,
-      auth: {
-        usernames,
-        passwords,
-        databases
-      }
-    }
-  }
-}
-
-exports.deployments = deployments

package/test/client.fixtures.js

@@ -1,46 +0,0 @@
-'use strict'
-
-const MongoClient = jest.fn().mockImplementation(function () {
-  this.db = jest.fn(() => new DB())
-
-  this.connect = jest.fn()
-  this.close = jest.fn()
-})
-
-const DB = jest.fn().mockImplementation(function () {
-  this.collection = jest.fn(() => new Collection())
-})
-
-const results = {
-  insertOne: { acknowledged: 1 }
-}
-
-const Collection = jest.fn().mockImplementation(function () {
-  this.find = jest.fn(() => ({
-    toArray: jest.fn(() => ({ id: 1, foo: 'bar' }))
-  }))
-  this.findOne = jest.fn(() => ({ id: 1, foo: 'bar' }))
-  this.insertOne = jest.fn(() => results.insertOne)
-  this.findOneAndReplace = jest.fn(() => ({ ok: 1 }))
-})
-
-const OPTIONS = {
-  useNewUrlParser: true,
-  useUnifiedTopology: true,
-  ignoreUndefined: true
-}
-
-const query = {
-  criteria: {
-    id: 1
-  },
-  options: {
-    limit: 1
-  }
-}
-
-exports.mock = { MongoClient }
-exports.OPTIONS = OPTIONS
-exports.locator = { host: 'bar.foo', db: 'foo', collection: 'bar' }
-exports.object = { id: '1', foo: 'bar' }
-exports.query = query

package/test/client.test.js

@@ -1,75 +0,0 @@
-'use strict'
-
-const fixtures = require('./client.fixtures')
-const mock = fixtures.mock
-
-jest.mock('mongodb', () => ({ MongoClient: mock.MongoClient }))
-
-const { Client } = require('../src/client')
-
-let instance, client, collection
-
-beforeEach(async () => {
-  jest.clearAllMocks()
-
-  instance = new Client(fixtures.locator.host, fixtures.locator.db, fixtures.locator.collection)
-  await instance.connect()
-
-  client = fixtures.mock.MongoClient.mock.instances[0]
-
-  collection = fixtures.mock.MongoClient.mock.instances[0]
-    .db.mock.results[0].value
-    .collection.mock.results[0].value
-})
-
-it('should create client', () => {
-  expect(client).toBeDefined()
-  expect(fixtures.mock.MongoClient).toHaveBeenCalledWith(
-    expect.any(String),
-    fixtures.OPTIONS
-  )
-})
-
-it('should connect', async () => {
-  expect(client.connect).toHaveBeenCalled()
-  expect(client.db).toHaveBeenCalledWith(fixtures.locator.db)
-
-  const db = client.db.mock.results[0].value
-
-  expect(db.collection).toHaveBeenCalledWith(fixtures.locator.collection)
-})
-
-it('should disconnect', async () => {
-  await instance.disconnect()
-
-  expect(client.connect).toHaveBeenCalled()
-  expect(client.close).toHaveBeenCalled()
-})
-
-it('should add', async () => {
-  const ok = await instance.add(fixtures.object)
-
-  expect(collection.insertOne).toHaveBeenCalledWith(fixtures.object)
-  expect(ok).toBe(collection.insertOne.mock.results[0].value.acknowledged)
-})
-
-it('should get', async () => {
-  const entity = await instance.get(fixtures.query.criteria, fixtures.query.options)
-
-  expect(entity).toBe(collection.findOne.mock.results[0].value)
-  expect(collection.findOne).toHaveBeenCalledWith(fixtures.query.criteria, fixtures.query.options)
-})
-
-it('should replace', async () => {
-  const update = { ...fixtures.object, foo: 'foo' }
-  await instance.replace(fixtures.query.criteria, update, fixtures.query.options)
-
-  expect(collection.findOneAndReplace).toHaveBeenCalledWith(fixtures.query.criteria, update, fixtures.query.options)
-})
-
-it('should find', async () => {
-  const set = await instance.find(fixtures.query.criteria, fixtures.query.options)
-
-  expect(set).toStrictEqual(collection.find.mock.results[0].value.toArray.mock.results[0].value)
-  expect(collection.find).toHaveBeenCalledWith(fixtures.query.criteria, fixtures.query.options)
-})

package/test/entry.test.js

@@ -1,45 +0,0 @@
-'use strict'
-
-const { to, from } = require('../src/record')
-const { random } = require('@toa.io/gears')
-
-describe('to', () => {
-  it('should rename id to _id', () => {
-    const entity = { id: 1 }
-    const record = to(entity)
-
-    expect(record).toMatchObject({ _id: 1 })
-  })
-
-  it('should not modify argument', () => {
-    const entity = { id: 1 }
-
-    to(entity)
-
-    expect(entity).toStrictEqual({ id: 1 })
-  })
-
-  it('should increment _version', () => {
-    const entity = { _version: random() }
-    const record = to(entity)
-
-    expect(record).toMatchObject({ _version: entity._version + 1 })
-  })
-})
-
-describe('from', () => {
-  it('should rename _id to id', () => {
-    const record = { _id: 1 }
-    const entity = from(record)
-
-    expect(entity).toStrictEqual({ id: 1 })
-  })
-
-  it('should not modify argument', () => {
-    const record = { _id: 1 }
-
-    from(record)
-
-    expect(record).toStrictEqual({ _id: 1 })
-  })
-})

package/test/storage.fixtures.js

@@ -1,25 +0,0 @@
-'use strict'
-
-const Client = jest.fn().mockImplementation(function () {
-  this.connect = jest.fn()
-  this.disconnect = jest.fn()
-  this.add = jest.fn(() => true)
-  this.get = jest.fn(() => ({ foo: 'bar' }))
-  this.replace = jest.fn(() => ({ ok: 1 }))
-  this.find = jest.fn(() => [{ foo: 'bar' }, { bar: 'foo' }])
-})
-
-const query = {
-  criteria: {},
-  options: {}
-}
-
-const translate = jest.fn(() => ({ criteria: 'foo', options: 'bar' }))
-
-const to = jest.fn((entity) => entity)
-const from = jest.fn((record) => record)
-
-exports.mock = { Client, translate, to, from }
-exports.locator = { host: jest.fn(() => 'bar.foo.local'), domain: 'foo', name: 'bar' }
-exports.entity = { id: '1', foo: 'bar' }
-exports.query = query

package/test/storage.test.js

@@ -1,73 +0,0 @@
-'use strict'
-
-const fixtures = require('./storage.fixtures')
-const mock = fixtures.mock
-
-jest.mock('../src/client', () => ({ Client: mock.Client }))
-jest.mock('../src/translate', () => ({ translate: mock.translate }))
-jest.mock('../src/record', () => ({ to: mock.to, from: mock.from }))
-
-const { Storage } = require('../src/storage')
-
-let connector, client
-
-beforeAll(() => {
-  connector = new Storage(fixtures.locator)
-
-  client = fixtures.mock.Client.mock.instances[0]
-
-  expect(client).toBeDefined()
-
-  expect(fixtures.mock.Client).toHaveBeenCalledWith(
-    fixtures.locator.host.mock.results[0].value,
-    fixtures.locator.domain,
-    fixtures.locator.name
-  )
-
-  expect(fixtures.locator.host.mock.calls[0][0].toLowerCase()).toBe('mongodb')
-})
-
-beforeEach(() => {
-  jest.clearAllMocks()
-})
-
-it('should add', async () => {
-  const result = await connector.add(fixtures.entity)
-
-  expect(client.add).toHaveBeenCalledWith(mock.to.mock.results[0].value)
-  expect(mock.to).toHaveBeenCalledWith(fixtures.entity)
-  expect(result).toBe(client.add.mock.results[0].value)
-})
-
-it('should get', async () => {
-  const entity = await connector.get(fixtures.query)
-
-  expect(entity).toBe(mock.from.mock.results[0].value)
-  expect(mock.from).toHaveBeenCalledWith(client.get.mock.results[0].value)
-
-  const { criteria, options } = mock.translate.mock.results[0].value
-
-  expect(client.get).toHaveBeenCalledWith(criteria, options)
-  expect(mock.translate).toHaveBeenCalledWith(fixtures.query)
-})
-
-it('should set', async () => {
-  await connector.set(fixtures.entity)
-  const criteria = { _id: fixtures.entity.id }
-
-  expect(client.replace).toHaveBeenCalledWith(criteria, mock.to.mock.results[0].value)
-  expect(mock.to).toHaveBeenCalledWith(fixtures.entity)
-})
-
-it('should find', async () => {
-  const set = await connector.find(fixtures.query)
-  const found = client.find.mock.results[0].value
-
-  const expected = found.map((result, index) => {
-    expect(mock.from).toHaveBeenNthCalledWith(index + 1, result, index, found)
-
-    return mock.from.mock.results[index].value
-  })
-
-  expect(set).toStrictEqual(expected)
-})