@bitfinex/bfx-svc-test-helper 1.1.0

package/README.md

@@ -0,0 +1,146 @@
+# bfx-svc-test-helper
+
+Test helper to help with common day to day testing tasks.
+
+## Do you see yourself copy/pasting or doing the same setup code again?
+
+Maybe it's time for a pull request or an issue! `bfx-svc-test-helper` is open
+for improvements and suggestions that make our day to day life as a team easier!
+
+## Usage in tests
+
+The API supports Promise and callback based APIs. For a common example,
+see [example.js](example.js).
+
+You can also stub/mock Grenache services. See
+[example-fauxgrenache.js](example-fauxgrenache.js) for an example.
+
+## API
+
+### `createGrapes([opts]) => Grapes`
+
+Creates an instance to manage Grapes for testing.
+
+### Arguments
+
+- `opts` is an object of additional options, there is able to pass:
+  - `ports` is an array of object, for example:
+
+  ```js
+  [{
+    dht_port: 20002,
+    dht_bootstrap: ['127.0.0.1:20001'],
+    api_port: 40001
+  }, {
+    dht_port: 20001,
+    dht_bootstrap: ['127.0.0.1:20002'],
+    api_port: 30001
+  }]
+  ```
+
+### `grapes.start([cb]) => Promise`
+
+Creates two "default Grapes" and calls the callback when the found each other.
+
+### `grapes.onAnnounce([servicename], [cb]) => Promise`
+
+Calls the callback as soon as the service is announced on the network.
+Leave blank to match any announce.
+
+### `grapes.stop([cb]) => Promise`
+
+Stops the Grapes.
+
+### `createWorker(worker, [grapes]) => Worker`
+
+Creates an svc-js worker instance.
+
+### `worker.start([cb]) => Promise`
+
+Starts the worker. If `grapes` were passed via `createWorker`, resolves as
+soon as the service name is announced on the network.
+
+### `worker.stop([cb]) => Promise`
+
+Stops the worker.
+
+### `createClient(worker) => Client`
+
+Sets up a typical PeerClient needed for most use cases.
+`worker` can be the name of the worker e.g. `rest:util:net`, or can be a
+`<Worker>` instance from `createWorker`
+
+### `client.request(args, [opts], [cb]) => Promise`
+
+Makes a request to the configured worker.
+
+### `client.stop([cb]) => Promise`
+
+Stops the client.
+
+### `createFxGrenache(mocks, grapes|url, [opts]) => FauxGrenacheServer`
+
+Spins up Grenache service mocks.
+
+  `opts.port` - the port the server will listen to, defaults to `1557`
+  `opts.link` - custom / own link, can be used for customised setups
+
+Second parameter is either a `Grapes` instance or a http url pointing
+to the Grenache Grape HTTP Server.
+
+### `fxgrenache.start([cb]) => Promise`
+
+Makes a request to the configured mockserver.
+
+### `fxgrenache.stop([cb]) => Promise`
+
+Stops the server.
+
+### `createServer(mocks, opts) => Server`
+
+Sets up a HTTP stub/mock server.
+
+  `opts.port` - the port the server will listen to.
+  `opts.debug` - print the data sent from the client via post
+
+`opts.debug` is useful when you are creating new mock definitions, especially
+if you use an external client library to send the request.
+
+`mocks` can be a mock definition or an array of mock definitions.
+
+The server can basically match, test and return anything on request/response,
+sent payloads etc. For convenience, there are shorthands that should suffice
+in most cases: [example-server-simple.js](example-server-simple.js).
+
+For advanced route matching and testing of incoming requests, see [example-server-advanced.js](example-server-advanced.js)
+
+### `server.start([cb]) => Promise`
+
+Makes a request to the configured mockserver.
+
+### `server.stop([cb]) => Promise`
+
+Stops the server.
+
+### `utils.getApi(worker) => Api`
+
+Returns the loc.api instance of the worker
+
+### `utils.getGrapeApiPort(grapesWorker) => port`
+
+Gets the HTTP port of one of the Grape workers
+
+Example:
+
+```js
+const createGrapes = require('bfx-svc-test-helper/grapes')
+const utils = require('bfx-svc-test-helper/utils')
+
+const grapes = createGrapes()
+
+;(async () => {
+  await grapes.start()
+  const port = utils.getGrapeApiPort(grapes)
+  console.log(port) // 30001
+})()
+```

package/client.js

@@ -0,0 +1,89 @@
+'use strict'
+
+const { PeerRPCClient } = require('grenache-nodejs-http')
+const Link = require('grenache-nodejs-link')
+
+class Client {
+  constructor (worker, opts = {}) {
+    this.peer = null
+    this.link = null
+
+    this.worker = worker
+    this.workerName = this.getWorkerName(worker)
+
+    const oDefault = {
+      grape: 'http://127.0.0.1:30001'
+    }
+
+    this.conf = { ...oDefault, ...opts }
+  }
+
+  getWorkerName (worker) {
+    if (typeof worker === 'string') {
+      return worker
+    }
+
+    return worker.name
+  }
+
+  connectGrape (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      if (this.link && this.peer) {
+        cb(null)
+        resolve()
+        return
+      }
+
+      this.link = new Link({
+        grape: this.conf.grape
+      })
+      this.link.start()
+
+      this.peer = new PeerRPCClient(this.link, this.conf)
+      this.peer.init()
+
+      resolve()
+      cb(null)
+    })
+  }
+
+  request (query, opts, cb) {
+    return new Promise((resolve, reject) => {
+      if (typeof opts === 'function') {
+        this.request(query, { timeout: 10000 }, opts)
+        return
+      }
+
+      this.connectGrape(() => {
+        this.peer.request(this.workerName, query, opts, (err, res) => {
+          if (err) {
+            if (cb) return cb(err)
+            reject(err)
+            return
+          }
+
+          if (cb) return cb(null, res)
+          resolve(res)
+        })
+      })
+    })
+  }
+
+  stop (cb) {
+    return new Promise((resolve, reject) => {
+      if (this.peer && this.link) {
+        this.peer.stop()
+        this.link.stop()
+      }
+
+      if (cb) return cb(null)
+      resolve()
+    })
+  }
+}
+
+function createClient (worker, opts) {
+  return new Client(worker, opts)
+}
+
+module.exports = createClient

package/example-fauxgrenache.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const createGrapes = require('./grapes')
+const createClient = require('./client')
+const createFxGrenache = require('./fauxgrenache')
+
+const grapes = createGrapes()
+
+const stubs = {
+  'rest:util:net': {
+    getIpInfo (space, ip, cb) {
+      const res = [ip, { country: 'US', region: 'CA' }]
+      return cb(null, res)
+    }
+  }
+}
+
+;(async () => {
+  await grapes.start()
+  // lets create a worker stub
+
+  // we can pass in Grape instances or an url
+  const url = 'http://localhost:30001'
+  const grape = grapes || url
+
+  const fxg = createFxGrenache(stubs, grape)
+  await fxg.start()
+  console.log('stub service started, announcing on grape')
+
+  const client = createClient('rest:util:net')
+  const res = await client.request({
+    action: 'getIpInfo',
+    args: ['8.8.8.8']
+  })
+
+  console.log('got response:', res)
+
+  await client.stop()
+  console.log('client stopped')
+  await fxg.stop()
+  console.log('grenache stub stopped')
+  await grapes.stop()
+  console.log('grapes stopped')
+})()

package/example-server-advanced.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const createServer = require('./server')
+const fetch = require('node-fetch')
+const assert = require('assert')
+
+const server = createServer({
+  reply: (reply) => {
+    reply({ fruit: 'lemon' }, 404) // default: 200
+  },
+
+  // all are optional
+  match: (payload, match) => {
+    match({
+      route: '/foo',
+      method: 'POST',
+      payload: (payload, cb) => {
+        return cb(null, payload.fruit === 'mango')
+      },
+      custom: (req, res, cb) => {
+        return cb(null, true)
+      }
+    })
+  },
+
+  // makes assertions on the _sent request_
+  test: (req, res, payload, cb) => {
+    assert.ok(payload.fruit, 'missing property')
+    cb(null)
+  }
+}, { port: 1337 });
+
+(async () => {
+  await server.start()
+
+  const res = await fetch('http://localhost:1337/foo', {
+    body: JSON.stringify({ fruit: 'mango' }),
+    method: 'POST'
+  })
+
+  console.log('response', await res.json(), res.status)
+
+  await server.stop()
+})()

package/example-server-simple.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const createServer = require('./server')
+const fetch = require('node-fetch')
+
+const server = createServer([
+  {
+    reply: { animal: 'platypus' },
+    route: '/australia'
+  },
+  {
+    reply: { animal: 'Fair Isle Wren' },
+    route: '/england'
+  }
+], { port: 1337, debug: true });
+
+(async () => {
+  await server.start()
+
+  const res = await fetch('http://localhost:1337/australia', {
+    body: JSON.stringify({ foo: 'bar' }),
+    method: 'POST'
+  })
+
+  console.log('response', await res.json(), res.status)
+
+  await server.stop()
+})()

package/example.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const path = require('path')
+
+const createGrapes = require('./grapes')
+const createWorker = require('./worker')
+const createClient = require('./client')
+
+const grapes = createGrapes()
+
+;(async () => {
+  await grapes.start()
+
+  const worker = createWorker({
+    env: 'development',
+    wtype: 'wrk-util-net-api',
+    apiPort: 8721,
+    serviceRoot: path.join(__dirname, '..', 'bfx-util-net-js')
+  }, grapes)
+
+  await worker.start()
+  console.log('worker started, announcing on grape')
+
+  // you can also pass 'rest:util:net'
+  const client = createClient(worker)
+
+  const res = await client.request({
+    action: 'getIpGeo',
+    args: ['8.8.8.8']
+  })
+
+  console.log('got response:')
+  console.log(res)
+
+  await client.stop()
+  console.log('client stopped')
+
+  await worker.stop()
+  console.log('worker stopped')
+  await grapes.stop()
+})()

package/fauxgrenache.js

@@ -0,0 +1,148 @@
+'use strict'
+
+const http = require('http')
+const Link = require('grenache-nodejs-link')
+const { getGrapeApiUrl } = require('./utils')
+
+const getRawBody = require('raw-body')
+const async = require('async')
+
+class FauxGrenache {
+  constructor (stubs, grapes, opts = {}) {
+    this.stubs = stubs
+    this.grapes = grapes
+
+    this.port = opts.port || 1557
+    this.link = opts.link || null
+  }
+
+  getLink () {
+    if (this.link) {
+      return this.link
+    }
+
+    const url = getGrapeApiUrl(this.grapes)
+    this.link = new Link({
+      grape: url
+    })
+
+    return this.link
+  }
+
+  start (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      this.link = this.getLink()
+
+      async.waterfall([
+        (next) => {
+          this.link.start()
+          next()
+        },
+
+        (next) => {
+          this.listen(this.port, next)
+        },
+
+        (next) => {
+          this.announce(this.stubs, next)
+        }
+      ], (err) => {
+        if (err) {
+          reject(err)
+          cb(err)
+          return
+        }
+
+        resolve()
+        cb(null)
+      })
+    })
+  }
+
+  stop (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      async.waterfall([
+        (next) => {
+          this.stopAnnounces(this.stubs)
+          next()
+        },
+
+        (next) => {
+          this.link.stop()
+          next()
+        },
+
+        (next) => {
+          this.server.close(next)
+        }
+      ], (err) => {
+        if (err) {
+          reject(err)
+          cb(err)
+          return
+        }
+
+        resolve()
+        cb(null)
+      })
+    })
+  }
+
+  listen (port, cb) {
+    const stubs = this.stubs
+
+    // its just tests, so lets use some async/await
+    this.server = http.createServer(async (req, res) => {
+      const buf = await getRawBody(req)
+      const parsed = JSON.parse(buf.toString())
+
+      const [id, service, data] = parsed
+      if (!stubs[service]) {
+        throw new Error('ERR_TEST_MISSING_STUB')
+      }
+
+      if (!stubs[service][data.action]) {
+        throw new Error('ERR_TEST_MISSING_STUB_ACTION')
+      }
+
+      function reply (err, data) {
+        if (err) {
+          res.end(
+            `["${id}","ERR_API_BASE: ${err.message}",null]`
+          )
+          return
+        }
+
+        const d = JSON.stringify([id, null, data])
+        res.end(d)
+      }
+
+      data.args.push(reply)
+      const args = [{}, ...data.args]
+
+      stubs[service][data.action].apply(stubs[service], args)
+    }).listen(port, cb)
+  }
+
+  stopAnnounces (stubs) {
+    Object.keys(stubs).map((el) => {
+      this.link.stopAnnouncing(el, this.port)
+    })
+  }
+
+  announce (stubs, cb) {
+    const tasks = Object.keys(stubs).map((el) => {
+      return (cb) => {
+        this.link.startAnnouncing(el, this.port, cb)
+      }
+    })
+
+    async.parallel(tasks, cb)
+  }
+}
+
+function fauxGrenache (stubs, grapes, opts) {
+  return new FauxGrenache(stubs, grapes, opts)
+}
+
+module.exports = fauxGrenache

package/grapes.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const { Grape } = require('grenache-grape')
+const waterfall = require('async/waterfall')
+const EventEmitter = require('events')
+
+class Grapes extends EventEmitter {
+  constructor (opts = {}) {
+    super()
+
+    this.opts = opts
+    this.grapes = this.addDefaultGrapes()
+  }
+
+  start (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      const tasks = this.grapes.map((grape, i) => {
+        return (cb) => {
+          if (i === 0) grape.once('ready', cb)
+          else grape.once('node', cb)
+
+          grape.start()
+        }
+      })
+
+      waterfall(tasks, (err) => {
+        if (err) {
+          this.emit('error')
+          reject(err)
+          return cb(err)
+        }
+        this.emit('ready')
+        resolve()
+        cb(null)
+      })
+    })
+  }
+
+  onAnnounce (serviceName, cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      if (typeof serviceName === 'function') {
+        this.onAnnounce(null, serviceName)
+        return
+      }
+
+      if (!this.grapes[0]) {
+        this.on('ready', () => {
+          this.onAnnounce(serviceName, cb)
+        })
+        return
+      }
+
+      if (!serviceName) {
+        cb(null)
+        resolve()
+        return
+      }
+
+      this._checkAnnounce(serviceName, () => {
+        resolve()
+        cb(null)
+      })
+    })
+  }
+
+  _checkAnnounce (serviceName, cb) {
+    this.grapes[0].once('announce', (name) => {
+      if (serviceName === name) {
+        return cb(null)
+      }
+      this._checkAnnounce(serviceName, cb)
+    })
+  }
+
+  addDefaultGrapes () {
+    const { ports } = this.opts
+    const _ports = Array.isArray(ports)
+      ? ports
+      : [{
+        dht_port: 20002,
+        dht_bootstrap: ['127.0.0.1:20001'],
+        api_port: 40001
+      }, {
+        dht_port: 20001,
+        dht_bootstrap: ['127.0.0.1:20002'],
+        api_port: 30001
+      }]
+
+    return _ports
+      .map((ports) => new Grape(ports))
+  }
+
+  stop (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      const tasks = this.grapes.map((grape) => {
+        return (cb) => {
+          grape.stop(cb)
+        }
+      })
+
+      waterfall(tasks, (err) => {
+        if (err) {
+          reject(err)
+          return cb(err)
+        }
+
+        resolve()
+        cb(null)
+      })
+    })
+  }
+}
+
+function createGrapes (opts) {
+  return new Grapes(opts)
+}
+
+module.exports = createGrapes

package/index.js

@@ -0,0 +1,8 @@
+'use strict'
+
+exports.grapes = require('./grapes')
+exports.worker = require('./worker')
+exports.client = require('./client')
+exports.server = require('./server')
+exports.utils = require('./utils')
+exports.fxgrenache = require('./fauxgrenache')

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "@bitfinex/bfx-svc-test-helper",
+  "version": "1.1.0",
+  "description": "common test functions",
+  "main": "index.js",
+  "scripts": {
+    "test": "standard"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/bitfinexcom/bfx-svc-test-helper.git"
+  },
+  "author": "Robert <robert@bitfinex.com>",
+  "license": "Apache-2.0",
+  "devDependencies": {
+    "node-fetch": "^2.6.9",
+    "standard": "^17.0.0"
+  },
+  "dependencies": {
+    "@bitfinex/bfx-svc-boot-js": "git+https://github.com/bitfinexcom/bfx-svc-boot-js.git",
+    "async": "3.2.6",
+    "grenache-grape": "1.0.0",
+    "grenache-nodejs-http": "1.0.1",
+    "grenache-nodejs-link": "1.0.2",
+    "raw-body": "2.5.2"
+  }
+}

package/server.js

@@ -0,0 +1,169 @@
+'use strict'
+
+const http = require('http')
+const async = require('async')
+
+class Mocks {
+  constructor (routes, opts) {
+    this.routes = this.parseRouting(routes)
+    this.debug = opts.debug
+  }
+
+  parseRouting (routes) {
+    if (!Array.isArray(routes)) {
+      routes = [routes]
+    }
+
+    routes = routes.map((route) => {
+      if (route.route && route.match) {
+        throw new Error(
+          'shorthand .route must be used without .match'
+        )
+      }
+
+      if (route.route) {
+        route.match = (data, match) => {
+          match({ route: route.route })
+        }
+      }
+
+      if (typeof route.reply !== 'function') {
+        const msg = route.reply
+        route.reply = (reply) => {
+          reply(msg, 200)
+        }
+      }
+
+      return route
+    })
+
+    return routes
+  }
+
+  getMock (req, res, data, cb) {
+    const match = (route, cb) => {
+      route.match(data, (filters) => {
+        if (filters.route && filters.route !== req.url) {
+          return cb(null, false)
+        }
+
+        if (filters.method && filters.method !== req.method) {
+          return cb(null, false)
+        }
+
+        if (!filters.custom) {
+          filters.custom = (req, res, cb) => {
+            return cb(null, true)
+          }
+        }
+
+        filters.custom(req, res, (err, res) => {
+          if (err) return cb(err)
+          if (res === false) return cb(null, false)
+
+          if (!filters.payload) return cb(null, res)
+
+          filters.payload(data, cb)
+        })
+      })
+    }
+
+    async.filter(this.routes, match, cb)
+  }
+
+  stubReply (req, res, mock) {
+    mock.reply((data, code) => {
+      if (code) {
+        res.statusCode = code
+      }
+
+      if (typeof data === 'object') {
+        data = JSON.stringify(data)
+      }
+
+      res.end(data)
+    })
+  }
+
+  handle (req, res) {
+    const data = []
+    req.on('data', (buf) => {
+      data.push(buf)
+    })
+
+    req.on('end', () => {
+      const str = Buffer.concat(data).toString()
+
+      this.debug && console.log('[DEBUG] bfx-svc-test-helper:', str)
+
+      let parsed
+      try {
+        parsed = JSON.parse(str)
+      } catch (e) {
+        parsed = str
+      }
+
+      this.getMock(req, res, parsed, (err, matches) => {
+        if (err) {
+          console.error('bfx-svc-test-helper: route matching error')
+          throw err
+        }
+
+        if (matches.length === 0) {
+          throw new Error(`bfx-svc-test-helper: no route matched (${req.url})`)
+        }
+
+        if (matches.length > 1) {
+          throw new Error(`bfx-svc-test-helper: multiple routes matched (${req.url})`)
+        }
+
+        const mock = matches[0]
+        if (!mock.test) mock.test = (req, res, payload, cb) => { cb(null) }
+
+        mock.test(req, res, parsed, (err) => {
+          if (err) {
+            console.error('bfx-svc-test-helper: client request test failed')
+            throw err
+          }
+
+          this.stubReply(req, res, mock)
+        })
+      })
+    })
+  }
+}
+
+class Server {
+  constructor (mocks, opts) {
+    this.opts = opts
+    this.mocks = mocks
+
+    this.server = null
+    this.port = this.opts.port
+  }
+
+  start (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      this.server = http.createServer(this.mocks.handle.bind(this.mocks)).listen(this.port, () => {
+        resolve()
+        cb(null)
+      })
+    })
+  }
+
+  stop (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      this.server.close(() => {
+        resolve()
+        cb(null)
+      })
+    })
+  }
+}
+
+function createServer (mocks, opts) {
+  const m = typeof mocks === 'function' ? mocks() : new Mocks(mocks, opts)
+  return new Server(m, opts)
+}
+
+module.exports = createServer

package/utils.js

@@ -0,0 +1,21 @@
+'use strict'
+
+exports.getApi = getApi
+function getApi (instance) {
+  return instance.worker.api_bfx.api
+}
+
+exports.getGrapeApiPort = getGrapeApiPort
+function getGrapeApiPort (grapeHelperInstance) {
+  return grapeHelperInstance.grapes[0].conf.api_port
+}
+
+exports.getGrapeApiUrl = getGrapeApiUrl
+function getGrapeApiUrl (grapes) {
+  if (typeof grapes === 'string') {
+    return grapes
+  }
+
+  const p = getGrapeApiPort(grapes)
+  return 'http://127.0.0.1:' + p
+}

package/worker.js

@@ -0,0 +1,66 @@
+'use strict'
+
+const worker = require('@bitfinex/bfx-svc-boot-js/lib/worker')
+
+class Worker {
+  constructor (conf, grapes) {
+    this.worker = null
+    this.grenacheConf = null
+
+    this.conf = conf
+    this.grapes = grapes
+    this.name = null
+  }
+
+  start (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      this.worker = worker(this.conf)
+
+      if (!this.grapes) {
+        resolve()
+        cb(null)
+        return
+      }
+
+      if (!this.worker.getGrcConf) {
+        resolve()
+        return cb(null)
+      }
+
+      this.grenacheConf = this.worker.getGrcConf()
+
+      if (!this.grenacheConf.services) {
+        resolve()
+        return cb(null)
+      }
+
+      const [service] = this.grenacheConf.services
+      this.name = service
+      this.grapes.onAnnounce(service, () => {
+        resolve()
+        cb(null)
+      })
+    })
+  }
+
+  stop (cb = () => {}) {
+    return new Promise((resolve, reject) => {
+      this.worker.stop((err) => {
+        if (err) {
+          reject(err)
+          cb(err)
+          return
+        }
+
+        cb(null)
+        resolve()
+      })
+    })
+  }
+}
+
+function createWorker (opts, grapes) {
+  return new Worker(opts, grapes)
+}
+
+module.exports = createWorker