refactor: move stream-muxer

new-src/stream-muxer/base-test.js

@@ -0,0 +1,153 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('chai-checkmark'))
+const { expect } = chai
+const pair = require('it-pair/duplex')
+const pipe = require('it-pipe')
+const { collect, map, consume } = require('streaming-iterables')
+
+function close (stream) {
+  return pipe([], stream, consume)
+}
+
+async function closeAndWait (stream) {
+  await close(stream)
+  expect(true).to.be.true.mark()
+}
+
+/**
+ * A tick is considered valid if it happened between now
+ * and `ms` milliseconds ago
+ * @param {number} date Time in ticks
+ * @param {number} ms max milliseconds that should have expired
+ * @returns {boolean}
+ */
+function isValidTick (date, ms = 5000) {
+  const now = Date.now()
+  if (date > now - ms && date <= now) return true
+  return false
+}
+
+module.exports = (common) => {
+  describe('base', () => {
+    let Muxer
+
+    beforeEach(async () => {
+      Muxer = await common.setup()
+    })
+
+    it('Open a stream from the dialer', (done) => {
+      const p = pair()
+      const dialer = new Muxer()
+
+      const listener = new Muxer({
+        onStream: stream => {
+          expect(stream).to.exist.mark() // 1st check
+          expect(isValidTick(stream.timeline.open)).to.equal(true)
+          // Make sure the stream is being tracked
+          expect(listener.streams).to.include(stream)
+          close(stream)
+        },
+        onStreamEnd: stream => {
+          expect(stream).to.exist.mark() // 2nd check
+          expect(listener.streams).to.not.include(stream)
+          // Make sure the stream is removed from tracking
+          expect(isValidTick(stream.timeline.close)).to.equal(true)
+        }
+      })
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      expect(3).checks(() => {
+        // ensure we have no streams left
+        expect(dialer.streams).to.have.length(0)
+        expect(listener.streams).to.have.length(0)
+        done()
+      })
+
+      const conn = dialer.newStream()
+      expect(dialer.streams).to.include(conn)
+      expect(isValidTick(conn.timeline.open)).to.equal(true)
+
+      closeAndWait(conn) // 3rd check
+    })
+
+    it('Open a stream from the listener', (done) => {
+      const p = pair()
+      const dialer = new Muxer(stream => {
+        expect(stream).to.exist.mark()
+        expect(isValidTick(stream.timeline.open)).to.equal(true)
+        closeAndWait(stream)
+      })
+      const listener = new Muxer()
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      expect(3).check(done)
+
+      const conn = listener.newStream()
+      expect(listener.streams).to.include(conn)
+      expect(isValidTick(conn.timeline.open)).to.equal(true)
+
+      closeAndWait(conn)
+    })
+
+    it('Open a stream on both sides', (done) => {
+      const p = pair()
+      const dialer = new Muxer(stream => {
+        expect(stream).to.exist.mark()
+        closeAndWait(stream)
+      })
+      const listener = new Muxer(stream => {
+        expect(stream).to.exist.mark()
+        closeAndWait(stream)
+      })
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      expect(6).check(done)
+
+      const listenerConn = listener.newStream()
+      const dialerConn = dialer.newStream()
+
+      closeAndWait(dialerConn)
+      closeAndWait(listenerConn)
+    })
+
+    it('Open a stream on one side, write, open a stream on the other side', (done) => {
+      const toString = map(c => c.slice().toString())
+      const p = pair()
+      const dialer = new Muxer()
+      const listener = new Muxer(stream => {
+        pipe(stream, toString, collect).then(chunks => {
+          expect(chunks).to.be.eql(['hey']).mark()
+        })
+
+        dialer.onStream = onDialerStream
+
+        const listenerConn = listener.newStream()
+
+        pipe(['hello'], listenerConn)
+
+        async function onDialerStream (stream) {
+          const chunks = await pipe(stream, toString, collect)
+          expect(chunks).to.be.eql(['hello']).mark()
+        }
+      })
+
+      pipe(p[0], dialer, p[0])
+      pipe(p[1], listener, p[1])
+
+      expect(2).check(done)
+
+      const dialerConn = dialer.newStream()
+
+      pipe(['hey'], dialerConn)
+    })
+  })
+}