grenache-nodejs-http 1.0.2 → 2.0.1

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "grenache-nodejs-http",
-  "version": "1.0.2",
+  "version": "2.0.1",
   "private": false,
-  "description": "Granache Node.js HTTP implementation",
+  "description": "Grenache Node.js HTTP implementation",
   "author": "prdn <paolo@bitfinex.com> (https://bitfinex.com/)",
   "keywords": [
     "grenache",
@@ -11,27 +11,27 @@
     "micro-services"
   ],
   "engines": {
-    "node": ">=16.0"
+    "node": ">=22.0"
   },
   "dependencies": {
     "async": "3.2.6",
     "duplexify": "4.1.3",
-    "grenache-nodejs-base": "1.1.0",
-    "grenache-nodejs-link": "1.0.2",
+    "grenache-nodejs-base": "2.0.1",
+    "grenache-nodejs-link": "2.0.1",
     "node-fetch": "2.7.0",
     "pump": "3.0.2"
   },
   "main": "index.js",
   "devDependencies": {
-    "grenache-grape": "1.0.0",
-    "mocha": "11.1.0",
-    "standard": "17.1.2"
+    "@bitfinex/lint-js": "^1.1.0",
+    "brittle": "^4.5.0",
+    "grenache-grape": "^2.0.0"
   },
   "scripts": {
     "test": "npm run lint && npm run unit",
-    "unit": "mocha",
-    "lint": "standard",
-    "lint:fix": "standard --fix"
+    "unit": "brittle-node test/*.js",
+    "lint": "bfx-lint-js",
+    "lint:fix": "bfx-lint-js --fix"
   },
   "license": "Apache-2.0",
   "repository": {

package/test/before-after.js

@@ -1,28 +1,69 @@
-/* eslint-env mocha */
-
 'use strict'
 
 const { startGrapes, stopGrapes } = require('./helper')
+const Link = require('grenache-nodejs-link')
+const { PeerRPCClient, PeerRPCServer } = require('../index')
+const fs = require('fs')
+const path = require('path')
 
-let grapes
-function setupHooks (cb) {
-  beforeEach(async function () {
-    this.timeout(20000)
+const SERVICE_PORT = 1337
 
+const rpcTestCase = ({ transport, isSecure, disableBuffered }) => (testBlock) => async (t) => {
+  let grapes, peer, link, service
+  try {
     grapes = await startGrapes()
-    cb()
 
-    await new Promise((resolve) => {
+    const announceTask = new Promise((resolve) => {
       grapes[0].once('announce', () => resolve())
     })
-  })
+    link = new Link({
+      grape: 'http://127.0.0.1:30001'
+    })
+    link.start()
+
+    const peerOpts = {}
+    if (isSecure) {
+      peerOpts.secure = {
+        key: fs.readFileSync(path.join(__dirname, './certs/client1-key.pem')),
+        cert: fs.readFileSync(path.join(__dirname, './certs/client1-crt.pem')),
+        ca: fs.readFileSync(path.join(__dirname, './certs/ca-crt.pem')),
+        rejectUnauthorized: false // take care, can be dangerous in production!
+      }
+    }
+    peer = new PeerRPCClient(link, peerOpts)
+    peer.init()
 
-  afterEach(async function () {
-    this.timeout(5000)
-    await stopGrapes(grapes)
-  })
+    const peerSrvOpts = {
+      timeout: 300000
+    }
+    if (isSecure) {
+      peerSrvOpts.secure = {
+        key: fs.readFileSync(path.join(__dirname, './certs/server-key.pem')),
+        cert: fs.readFileSync(path.join(__dirname, './certs/server-crt.pem')),
+        ca: fs.readFileSync(path.join(__dirname, './certs/ca-crt.pem')),
+        requestCert: true,
+        rejectUnauthorized: false // take care, can be dangerous in production!
+      }
+    }
+    if (disableBuffered) { peerSrvOpts.disableBuffered = true }
+    const peerSrv = new PeerRPCServer(link, peerSrvOpts)
+
+    peerSrv.init()
+    service = peerSrv.transport(transport)
+    service.listen(SERVICE_PORT)
+
+    link.announce('rpc_test', service.port, {}, (err) => {
+      if (err) throw Error('error in announce, setup')
+    })
+    await announceTask
 
-  return grapes
+    await testBlock({ t, service, peer })
+  } finally {
+    if (peer) peer.stop()
+    if (link) link.stop()
+    if (service) service.stop()
+    if (grapes) await stopGrapes(grapes)
+  }
 }
 
-module.exports = setupHooks
+module.exports = { rpcTestCase }

package/test/peer-rpc-server-buffered.js

@@ -1,221 +1,195 @@
-/* eslint-env mocha */
+'use strict'
 
-const assert = require('assert')
+const test = require('brittle')
 const { PassThrough } = require('stream')
 const fs = require('fs')
 const path = require('path')
-const { PeerRPCClient, PeerRPCServer } = require('../')
-const Link = require('grenache-nodejs-link')
-const setupHooks = require('./before-after.js')
+const { rpcTestCase } = require('./before-after')
 
-const PORT = 1337
-let link, peer, peerSrvBuf, serviceBuf, stop
-describe('RPC integration', () => {
-  setupHooks((grapes) => {
-    link = new Link({
-      grape: 'http://127.0.0.1:30001'
-    })
-    link.start()
-
-    peer = new PeerRPCClient(link, {})
-    peer.init()
-
-    peerSrvBuf = new PeerRPCServer(link, {
-      timeout: 300000
-    })
-
-    peerSrvBuf.init()
-    serviceBuf = peerSrvBuf.transport('buffered')
-    serviceBuf.listen(PORT)
-
-    link.announce('rpc_buf', serviceBuf.port, {}, (err, res) => {
-      if (err) throw Error('error in announce, setup')
-    })
-
-    stop = () => {
-      peer.stop()
-      link.stop()
-      serviceBuf.stop()
-    }
-  })
+const rpcTest = rpcTestCase({ transport: 'buffered' })
 
-  it('buffered parsing works, objects', (done) => {
-    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_buf')
-      assert.deepStrictEqual(payload, { hello: 'world' })
+test('RPC integration', async (t) => {
+  await t.test('buffered parsing works, objects', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('request', (rid, key, payload, handler, cert, meta) => {
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
+      t.alike(payload, { hello: 'world' })
 
-      assert.strictEqual(meta.isStream, false)
+      t.is(meta.isStream, false)
 
       handler.reply(null, { hello: 'helloworld' })
     })
 
     const opts = { timeout: 100000 }
-    peer.request('rpc_buf', { hello: 'world' }, opts, (err, result) => {
-      if (err) throw err
-
-      assert.deepStrictEqual(result, { hello: 'helloworld' })
-
-      stop()
-      done()
+    await new Promise(resolve => {
+      peer.request('rpc_test', { hello: 'world' }, opts, (err, result) => {
+        if (err) throw err
+        t.alike(result, { hello: 'helloworld' })
+        resolve()
+      })
     })
-  }).timeout(7000)
+  }))
 
-  it('buffered parsing works, strings', (done) => {
-    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_buf')
-      assert.strictEqual(payload, 'hello')
+  await t.test('buffered parsing works, strings', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('request', (rid, key, payload, handler, cert, meta) => {
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
+      t.is(payload, 'hello')
 
-      assert.strictEqual(meta.isStream, false)
+      t.is(meta.isStream, false)
 
       handler.reply(null, 'world')
     })
 
     const opts = { timeout: 100000 }
-    peer.request('rpc_buf', 'hello', opts, (err, result) => {
-      if (err) throw err
-
-      assert.strictEqual(result, 'world')
-
-      stop()
-      done()
+    await new Promise(resolve => {
+      peer.request('rpc_test', 'hello', opts, (err, result) => {
+        if (err) throw err
+        t.is(result, 'world')
+        resolve()
+      })
     })
-  }).timeout(7000)
+  }))
 
-  it('buffered parsing works, compressed strings', (done) => {
-    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_buf')
-      assert.strictEqual(payload, 'hello')
+  await t.test('buffered parsing works, compressed strings', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('request', (rid, key, payload, handler, cert, meta) => {
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
+      t.is(payload, 'hello')
 
-      assert.strictEqual(meta.isStream, false)
-      assert.strictEqual(meta.compress, true)
+      t.is(meta.isStream, false)
+      t.is(meta.compress, true)
 
       handler.reply(null, 'world')
     })
 
     const opts = { timeout: 100000, compress: true }
-    peer.request('rpc_buf', 'hello', opts, (err, result) => {
-      if (err) throw err
-
-      assert.strictEqual(result, 'world')
-
-      stop()
-      done()
+    await new Promise(resolve => {
+      peer.request('rpc_test', 'hello', opts, (err, result) => {
+        if (err) throw err
+        t.is(result, 'world')
+        resolve()
+      })
     })
-  }).timeout(7000)
-
-  it('buffered parsing works, strings from streaming client', (done) => {
-    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_buf')
-      assert.strictEqual(payload, 'hello')
-
-      assert.strictEqual(meta.isStream, true)
+  }))
 
+  await t.test('buffered parsing works, strings from streaming client', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('request', (rid, key, payload, handler, cert, meta) => {
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
+      t.is(payload, 'hello')
+      t.is(meta.isStream, true)
       handler.reply(null, 'world')
     })
 
-    const req = peer.stream('rpc_buf', {
+    const req = peer.stream('rpc_test', {
       timeout: 10000
     })
 
-    req
-      .on('data', (data) => {
-        const d = JSON.parse(data.toString())
-        // ["65c5737f-bbce-40f9-b48a-af8bd8869d66",null,"world"]
-        assert.strictEqual(d[1], null)
-        assert.strictEqual(d[2], 'world')
-        stop()
-        done()
-      })
-      .on('end', () => {})
-      .on('error', (e) => { console.error(e) })
+    const p = new Promise(resolve => {
+      req
+        .on('data', (data) => {
+          const d = JSON.parse(data.toString())
+          // ["65c5737f-bbce-40f9-b48a-af8bd8869d66",null,"world"]
+          t.is(d[1], null)
+          t.is(d[2], 'world')
+          resolve()
+        })
+        .on('end', () => {})
+        .on('error', (e) => { console.error(e) })
+    })
 
     const writable = new PassThrough()
-    writable.write('["UUID", "rpc_buf", "hello"]')
+    writable.write('["UUID", "rpc_test", "hello"]')
     writable.end()
     writable.pipe(req)
-  }).timeout(7000)
 
-  it('buffered parsing works, objects from streaming client', (done) => {
-    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_buf')
-      assert.deepStrictEqual(payload, { hello: 'world' })
+    await p
+  }))
 
-      assert.strictEqual(meta.isStream, true)
+  await t.test('buffered parsing works, objects from streaming client', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('request', (rid, key, payload, handler, cert, meta) => {
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
+      t.alike(payload, { hello: 'world' })
+
+      t.is(meta.isStream, true)
 
       handler.reply(null, { hello: 'helloworld' })
     })
 
-    const req = peer.stream('rpc_buf', {
+    const req = peer.stream('rpc_test', {
       timeout: 10000
     })
 
-    req
-      .on('data', (data) => {
-        const d = JSON.parse(data.toString())
-        assert.strictEqual(d[1], null)
-        assert.deepStrictEqual(d[2], { hello: 'helloworld' })
-        stop()
-        done()
-      })
-      .on('end', () => {})
-      .on('error', (e) => { console.error(e) })
+    const p = new Promise(resolve => {
+      req
+        .on('data', (data) => {
+          const d = JSON.parse(data.toString())
+          t.is(d[1], null)
+          t.alike(d[2], { hello: 'helloworld' })
+          resolve()
+        })
+        .on('end', () => {})
+        .on('error', (e) => { console.error(e) })
+    })
 
     const writable = new PassThrough()
-    writable.write('["UUID", "rpc_buf", { "hello": "world" }]')
+    writable.write('["UUID", "rpc_test", { "hello": "world" }]')
     writable.end()
     writable.pipe(req)
-  }).timeout(7000)
 
-  it('buffered parsing works, extra headers', (done) => {
-    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_buf')
-      assert.deepStrictEqual(payload, { hello: 'world' })
+    await p
+  }))
+
+  await t.test('buffered parsing works, extra headers', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('request', (rid, key, payload, handler, cert, meta) => {
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
+      t.alike(payload, { hello: 'world' })
 
-      assert.strictEqual(meta.action, 'uploadPublic')
-      assert.deepStrictEqual(meta.args, { foo: 'bar' })
-      assert.strictEqual(meta.isStream, true)
+      t.is(meta.action, 'uploadPublic')
+      t.alike(meta.args, { foo: 'bar' })
+      t.is(meta.isStream, true)
 
       handler.reply(null, { hello: 'helloworld' })
     })
 
-    const req = peer.stream('rpc_buf', {
+    const req = peer.stream('rpc_test', {
       timeout: 10000,
       headers: { _a: 'uploadPublic', _ar: { foo: 'bar' } }
     })
 
-    req
-      .on('data', (data) => {
-        const d = JSON.parse(data.toString())
-        assert.strictEqual(d[1], null)
-        assert.deepStrictEqual(d[2], { hello: 'helloworld' })
-        stop()
-        done()
-      })
-      .on('end', () => {})
-      .on('error', (e) => { console.error(e) })
+    const p = new Promise(resolve => {
+      req
+        .on('data', (data) => {
+          const d = JSON.parse(data.toString())
+          t.is(d[1], null)
+          t.alike(d[2], { hello: 'helloworld' })
+          resolve()
+        })
+        .on('end', () => {})
+        .on('error', (e) => { console.error(e) })
+    })
 
     const writable = new PassThrough()
-    writable.write('["UUID", "rpc_buf", { "hello": "world" }]')
+    writable.write('["UUID", "rpc_test", { "hello": "world" }]')
     writable.end()
     writable.pipe(req)
-  }).timeout(7000)
 
-  it('buf/buf: serialized files work', (done) => {
-    serviceBuf.on('request', (rid, key, payload, handler, cert, meta) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_buf')
+    await p
+  }))
 
-      assert.strictEqual(payload.action, 'uploadPublic')
-      assert.strictEqual(payload.args[1].key, 'example-amazon-dynamo-sosp2007-4.pdf')
-      assert.strictEqual(typeof payload.args[0], 'string')
+  await t.test('buf/buf: serialized files work', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('request', (rid, key, payload, handler, cert, meta) => {
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
 
-      assert.strictEqual(meta.isStream, false)
+      t.is(payload.action, 'uploadPublic')
+      t.is(payload.args[1].key, 'example-amazon-dynamo-sosp2007-4.pdf')
+      t.is(typeof payload.args[0], 'string')
+
+      t.is(meta.isStream, false)
 
       handler.reply(null, 'ok')
     })
@@ -236,13 +210,12 @@ describe('RPC integration', () => {
       action: 'uploadPublic',
       args: [buf.toString('hex'), optsPdf]
     }
-    peer.request('rpc_buf', queryUploadPublicPdf, opts, (err, result) => {
-      if (err) throw err
-
-      assert.deepStrictEqual(result, 'ok')
-
-      stop()
-      done()
+    await new Promise(resolve => {
+      peer.request('rpc_test', queryUploadPublicPdf, opts, (err, result) => {
+        if (err) throw err
+        t.alike(result, 'ok')
+        resolve()
+      })
     })
-  }).timeout(7000)
+  }))
 })