grenache-nodejs-http 1.0.2 → 2.0.0

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

@@ -1,103 +1,72 @@
-/* eslint-env mocha */
+'use strict'
 
-const assert = require('assert')
+const test = require('brittle')
 const { PassThrough } = require('stream')
-const { PeerRPCClient, PeerRPCServer } = require('../')
-const Link = require('grenache-nodejs-link')
-const setupHooks = require('./before-after.js')
-
-const PORT = 1337
-let link, peer, peerSrvStr, serviceStr, stop
-describe('RPC integration', () => {
-  setupHooks((grapes) => {
-    link = new Link({
-      grape: 'http://127.0.0.1:30001'
-    })
-    link.start()
-
-    peer = new PeerRPCClient(link, {})
-    peer.init()
-
-    peerSrvStr = new PeerRPCServer(link, {
-      timeout: 300000,
-      disableBuffered: true
-    })
-
-    peerSrvStr.init()
-    serviceStr = peerSrvStr.transport('stream')
-    serviceStr.listen(PORT)
+const { rpcTestCase } = require('./before-after')
 
-    link.announce('rpc_stream', serviceStr.port, {}, (err, res) => {
-      if (err) throw Error('error in announce, setup')
-    })
+const rpcTest = rpcTestCase({ transport: 'stream', disableBuffered: true })
 
-    stop = () => {
-      peer.stop()
-      link.stop()
-      serviceStr.stop()
-    }
-  })
-
-  it('streaming works, objects, buffered client, reply handler', (done) => {
-    serviceStr.on('stream', (req, res, meta, handler) => {
-      assert.strictEqual(meta.isStream, false)
+test('RPC integration', async (t) => {
+  await t.test('streaming works, objects, buffered client, reply handler', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('stream', (req, res, meta, handler) => {
+      t.is(meta.isStream, false)
 
       req.on('data', (d) => {
         const [rid, key, args] = JSON.parse(d.toString())
 
-        assert.deepStrictEqual(args, { hello: 'world' })
-        assert.ok(typeof rid === 'string')
-        assert.strictEqual(key, 'rpc_stream')
+        t.alike(args, { hello: 'world' })
+        t.ok(typeof rid === 'string')
+        t.is(key, 'rpc_test')
 
         handler.reply(rid, null, { hello: 'helloworld' })
       })
     })
 
     const opts = { timeout: 100000 }
-    peer.request('rpc_stream', { 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('streaming works, string, buffered client, reply handler', (done) => {
-    serviceStr.on('stream', (req, res, meta, handler) => {
-      assert.strictEqual(meta.isStream, false)
+  await t.test('streaming works, string, buffered client, reply handler', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('stream', (req, res, meta, handler) => {
+      t.is(meta.isStream, false)
 
       req.on('data', (d) => {
         const [rid, key, args] = JSON.parse(d.toString())
 
-        assert.strictEqual(args, 'hello')
-        assert.ok(typeof rid === 'string')
-        assert.strictEqual(key, 'rpc_stream')
+        t.is(args, 'hello')
+        t.ok(typeof rid === 'string')
+        t.is(key, 'rpc_test')
 
         handler.reply(rid, null, 'world')
       })
     })
 
     const opts = { timeout: 100000 }
-    peer.request('rpc_stream', '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('streaming works, string, buffered client, stream sent back', (done) => {
-    serviceStr.on('stream', (req, res, meta, handler) => {
-      assert.strictEqual(meta.isStream, false)
+  await t.test('streaming works, string, buffered client, stream sent back', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('stream', (req, res, meta) => {
+      t.is(meta.isStream, false)
 
       req.on('data', (d) => {
         const [rid, key, args] = JSON.parse(d.toString())
 
-        assert.strictEqual(args, 'hello')
-        assert.ok(typeof rid === 'string')
-        assert.strictEqual(key, 'rpc_stream')
+        t.is(args, 'hello')
+        t.ok(typeof rid === 'string')
+        t.is(key, 'rpc_test')
 
         const writable = new PassThrough()
         const payload = JSON.stringify([rid, null, 'world2'])
@@ -108,29 +77,29 @@ describe('RPC integration', () => {
     })
 
     const opts = { timeout: 100000 }
-    peer.request('rpc_stream', 'hello', opts, (err, result) => {
-      if (err) throw err
-      assert.strictEqual(result, 'world2')
-
-      stop()
-      done()
+    await new Promise(resolve => {
+      peer.request('rpc_test', 'hello', opts, (err, result) => {
+        if (err) throw err
+        t.is(result, 'world2')
+        resolve()
+      })
     })
-  }).timeout(7000)
+  }))
 
-  it('streaming works, buffer, stream client, stream on server', (done) => {
+  await t.test('streaming works, buffer, stream client, stream on server', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
     const reqPayload = Buffer.from('megalargefile')
     const resPayload = Buffer.from('superlargefile')
 
-    serviceStr.on('stream', (req, res, meta, handler) => {
-      assert.strictEqual(meta.isStream, true)
+    service.on('stream', (req, res, meta) => {
+      t.is(meta.isStream, true)
 
       req.on('data', (d) => {
         const [rid, key] = meta.infoHeaders
 
-        assert.ok(d.equals(reqPayload), 'received Buffer equals payload on server')
+        t.ok(d.equals(reqPayload), 'received Buffer equals payload on server')
 
-        assert.ok(typeof rid === 'string')
-        assert.strictEqual(key, 'rpc_stream')
+        t.ok(typeof rid === 'string')
+        t.is(key, 'rpc_test')
 
         const writable = new PassThrough()
         writable.pipe(res)
@@ -139,42 +108,44 @@ describe('RPC integration', () => {
       })
     })
 
-    const req = peer.stream('rpc_stream', {
+    const req = peer.stream('rpc_test', {
       timeout: 10000
     })
 
-    req
-      .on('data', (data) => {
-        assert.ok(data.equals(resPayload), 'received Buffer equals payload on client')
-
-        stop()
-        done()
-      })
-      .on('end', () => {})
-      .on('error', (e) => { console.error(e) })
+    const p = new Promise(resolve => {
+      req
+        .on('data', (data) => {
+          t.ok(data.equals(resPayload), 'received Buffer equals payload on client')
+          resolve()
+        })
+        .on('end', () => {})
+        .on('error', (e) => { console.error(e) })
+    })
 
     const writable = new PassThrough()
     writable.write(reqPayload)
     writable.pipe(req)
-  }).timeout(7000)
 
-  it('streaming works, buffer, stream client, stream on server, additional headers', (done) => {
+    await p
+  }))
+
+  await t.test('streaming works, buffer, stream client, stream on server, additional headers', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
     const reqPayload = Buffer.from('megalargefile')
     const resPayload = Buffer.from('superlargefile')
 
-    serviceStr.on('stream', (req, res, meta, handler) => {
-      assert.strictEqual(meta.isStream, true)
+    service.on('stream', (req, res, meta) => {
+      t.is(meta.isStream, true)
 
       req.on('data', (d) => {
         const [rid, key] = meta.infoHeaders
 
-        assert.ok(d.equals(reqPayload), 'received Buffer equals payload on server')
+        t.ok(d.equals(reqPayload), 'received Buffer equals payload on server')
 
-        assert.ok(typeof rid === 'string')
-        assert.strictEqual(key, 'rpc_stream')
+        t.ok(typeof rid === 'string')
+        t.is(key, 'rpc_test')
 
-        assert.strictEqual(meta.action, 'uploadPublic')
-        assert.strictEqual(meta.args.foo, 'bar')
+        t.is(meta.action, 'uploadPublic')
+        t.is(meta.args.foo, 'bar')
 
         const writable = new PassThrough()
         writable.pipe(res)
@@ -183,7 +154,7 @@ describe('RPC integration', () => {
       })
     })
 
-    const req = peer.stream('rpc_stream', {
+    const req = peer.stream('rpc_test', {
       timeout: 10000,
       headers: {
         _a: 'uploadPublic',
@@ -191,18 +162,20 @@ describe('RPC integration', () => {
       }
     })
 
-    req
-      .on('data', (data) => {
-        assert.ok(data.equals(resPayload), 'received Buffer equals payload on client')
-
-        stop()
-        done()
-      })
-      .on('end', () => {})
-      .on('error', (e) => { console.error(e) })
+    const p = new Promise(resolve => {
+      req
+        .on('data', (data) => {
+          t.ok(data.equals(resPayload), 'received Buffer equals payload on client')
+          resolve()
+        })
+        .on('end', () => {})
+        .on('error', (e) => { console.error(e) })
+    })
 
     const writable = new PassThrough()
     writable.write(reqPayload)
     writable.pipe(req)
-  }).timeout(7000)
+
+    await p
+  }))
 })

package/test/peer-rpc-server.js

@@ -1,76 +1,46 @@
-/* eslint-env mocha */
+'use strict'
 
-const assert = require('assert')
-const { PeerRPCClient, PeerRPCServer } = require('../')
-const Link = require('grenache-nodejs-link')
-const setupHooks = require('./before-after.js')
+const test = require('brittle')
+const { rpcTestCase } = require('./before-after')
 
-const PORT = 1337
-let link, peer, peerSrv, service, stop
-describe('RPC integration', () => {
-  setupHooks((grapes) => {
-    link = new Link({
-      grape: 'http://127.0.0.1:30001'
-    })
-    link.start()
-
-    peer = new PeerRPCClient(link, {})
-    peer.init()
-
-    peerSrv = new PeerRPCServer(link, { timeout: 300000 })
-
-    peerSrv.init()
-    service = peerSrv.transport('server')
-    service.listen(PORT)
-
-    link.announce('rpc_test', service.port, {}, (err, res) => {
-      if (err) throw Error('error in announce, setup')
-    })
+const rpcTest = rpcTestCase({ transport: 'server' })
 
-    stop = () => {
-      peer.stop()
-      link.stop()
-      service.stop()
-    }
-  })
-
-  it('secure request, objects', (done) => {
+test('RPC integration', { timeout: 10000 }, async (t) => {
+  await t.test('secure request, objects', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
     service.on('request', (rid, key, payload, handler) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_test')
-      assert.deepStrictEqual(payload, { hello: 'world' })
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
+      t.alike(payload, { hello: 'world' })
 
       handler.reply(null, { hello: 'helloworld' })
     })
 
     const opts = { timeout: 100000 }
-    peer.request('rpc_test', { 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('secure map, strings', (done) => {
+  await t.test('secure map, strings', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
     service.on('request', (rid, key, payload, handler) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_test')
-      assert.strictEqual(payload, 'hello')
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
+      t.is(payload, 'hello')
 
       handler.reply(null, 'world')
     })
 
     const opts = { timeout: 100000 }
-    peer.map('rpc_test', 'hello', opts, (err, result) => {
-      if (err) throw err
-
-      assert.deepStrictEqual(result, ['world'])
-
-      stop()
-      done()
+    await new Promise(resolve => {
+      peer.map('rpc_test', 'hello', opts, (err, result) => {
+        if (err) throw err
+        t.alike(result, ['world'])
+        resolve()
+      })
     })
-  }).timeout(7000)
+  }))
 })

package/test/rpc-server-manual-request-handling.js

@@ -1,44 +1,13 @@
-/* eslint-env mocha */
+'use strict'
 
-const assert = require('assert')
+const test = require('brittle')
 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, peerSrvStr, serviceStr, stop
-describe('RPC integration', () => {
-  setupHooks((grapes) => {
-    link = new Link({
-      grape: 'http://127.0.0.1:30001'
-    })
-    link.start()
-
-    peer = new PeerRPCClient(link, {})
-    peer.init()
-
-    peerSrvStr = new PeerRPCServer(link, {
-      timeout: 300000,
-      disableBuffered: true
-    })
-
-    peerSrvStr.init()
-    serviceStr = peerSrvStr.transport('stream')
-    serviceStr.listen(PORT)
-
-    link.announce('rpc_manual', serviceStr.port, {}, (err, res) => {
-      if (err) throw Error('error in announce, setup')
-    })
-
-    stop = () => {
-      peer.stop()
-      link.stop()
-      serviceStr.stop()
-    }
-  })
+const rpcTest = rpcTestCase({ transport: 'stream', disableBuffered: true })
 
+test('RPC integration', (t) => {
   const buf = fs.readFileSync(
     path.join(__dirname, './example-amazon-dynamo-sosp2007.pdf')
   )
@@ -55,35 +24,35 @@ describe('RPC integration', () => {
     args: [buf.toString('hex'), optsPdf]
   }
 
-  it('manual request handling works', (done) => {
-    serviceStr.on('stream', (req, res, meta, handler) => {
-      assert.strictEqual(meta.isStream, false)
+  t.test('manual request handling works', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('stream', (req, res, meta) => {
+      t.is(meta.isStream, false)
 
       if (meta.isStream === false) {
         // console.log('no stream content, decide to parse')
-        serviceStr.handleBufferedRequest(req, res, meta)
+        service.handleBufferedRequest(req, res, meta)
       }
     })
 
-    serviceStr.on('request', (rid, key, payload, handler, cert, meta) => {
-      assert.ok(typeof rid === 'string')
-      assert.strictEqual(key, 'rpc_manual')
+    service.on('request', (rid, key, payload, handler, cert, meta) => {
+      t.ok(typeof rid === 'string')
+      t.is(key, 'rpc_test')
       const [pdf, opts] = payload.args
-      assert.deepStrictEqual(opts, optsPdf)
+      t.alike(opts, optsPdf)
 
-      assert.deepStrictEqual([pdf[0], pdf[1], pdf[2]].join(''), '255')
+      t.alike([pdf[0], pdf[1], pdf[2]].join(''), '255')
 
-      assert.strictEqual(meta.isStream, false)
+      t.is(meta.isStream, false)
       handler.reply(null, 'ok')
     })
 
     const opts = { timeout: 100000 }
-    peer.request('rpc_manual', 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)
+  }))
 })

package/test/rpc-server-readstream-size.js

@@ -1,50 +1,19 @@
-/* eslint-env mocha */
+'use strict'
 
-const assert = require('assert')
+const test = require('brittle')
 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, peerSrvStr, serviceStr, stop
-describe('RPC integration', () => {
-  setupHooks((grapes) => {
-    link = new Link({
-      grape: 'http://127.0.0.1:30001'
-    })
-    link.start()
-
-    peer = new PeerRPCClient(link, {})
-    peer.init()
-
-    peerSrvStr = new PeerRPCServer(link, {
-      timeout: 300000,
-      disableBuffered: true
-    })
-
-    peerSrvStr.init()
-    serviceStr = peerSrvStr.transport('stream')
-    serviceStr.listen(PORT)
-
-    link.announce('rpc_manual', serviceStr.port, {}, (err, res) => {
-      if (err) throw Error('error in announce, setup')
-    })
-
-    stop = () => {
-      peer.stop()
-      link.stop()
-      serviceStr.stop()
-    }
-  })
+const rpcTest = rpcTestCase({ transport: 'stream', disableBuffered: true })
 
+test('RPC integration', (t) => {
   const pdfFile = path.join(__dirname, './example-amazon-dynamo-sosp2007.pdf')
 
-  it('manual request handling works', (done) => {
-    serviceStr.on('stream', (req, res, meta, handler) => {
-      assert.strictEqual(meta.isStream, true)
-      assert.strictEqual(req.headers['content-type'], 'application/pdf')
+  t.test('manual request handling works', { timeout: 7000 }, rpcTest(async ({ t, service, peer }) => {
+    service.on('stream', (req, res, meta, handler) => {
+      t.is(meta.isStream, true)
+      t.is(req.headers['content-type'], 'application/pdf')
 
       const rid = meta.infoHeaders[0]
       const writer = fs.createWriteStream('test.pdf')
@@ -53,7 +22,7 @@ describe('RPC integration', () => {
       writer.on('close', () => {
         const origStat = fs.statSync(pdfFile)
         const res = fs.statSync('test.pdf')
-        assert.strictEqual(res.size, origStat.size)
+        t.is(res.size, origStat.size)
 
         handler.reply(rid, null, 'ok')
       })
@@ -65,7 +34,7 @@ describe('RPC integration', () => {
       bucket: 'BUCKET',
       contentType: 'application/pdf'
     }
-    const req = peer.stream('rpc_manual', {
+    const req = peer.stream('rpc_test', {
       headers: {
         _a: 'uploadNewPublicStream',
         _ar: optsPdf,
@@ -74,15 +43,18 @@ describe('RPC integration', () => {
       timeout: 10000
     })
 
-    req.on('data', (data) => {
-      const [,, msg] = JSON.parse(data.toString())
-      assert.strictEqual(msg, 'ok')
-      stop()
-      done()
+    const p = new Promise(resolve => {
+      req.on('data', (data) => {
+        const [,, msg] = JSON.parse(data.toString())
+        t.is(msg, 'ok')
+        resolve()
+      })
     })
 
     const data = fs.createReadStream(pdfFile)
 
     data.pipe(req)
-  }).timeout(7000)
+
+    await p
+  }))
 })