test: refactor browser tests too

.aegir.js

@@ -2,95 +2,87 @@
 
 const PeerInfo = require('peer-info')
 const PeerId = require('peer-id')
+const parallel = require('async/parallel')
 const WebSockets = require('libp2p-websockets')
 const pull = require('pull-stream')
 const PeerBook = require('peer-book')
 
-const Swarm = require('./src')
+const Switch = require('./src')
 const spdy = require('libp2p-spdy')
 const fs = require('fs')
 const path = require('path')
 
 const sigServer = require('libp2p-webrtc-star/src/sig-server')
 
-let swarmA
-let swarmB
+let switchA
+let switchB
 let sigS
 
-const options = { port: 15555, host: '127.0.0.1' }
+const sigOptions = { port: 15555, host: '127.0.0.1' }
 
-function before (done) {
-  function createListenerA (cb) {
-    PeerId.createFromJSON(
-      JSON.parse(
-        fs.readFileSync(path.join(__dirname, './test/test-data/id-1.json'))
-      ),
-      (err, id) => {
-        if (err) {
-          return cb(err)
-        }
+function echo (protocol, conn) { pull(conn, conn) }
 
-        const peerA = new PeerInfo(id)
-        const maA = '/ip4/127.0.0.1/tcp/9100/ws'
+function idJSON (id) {
+  const p = path.join(__dirname, `./test/test-data/id-${id}.json`)
+  return JSON.parse(fs.readFileSync(p))
+}
 
-        peerA.multiaddrs.add(maA)
-        swarmA = new Swarm(peerA, new PeerBook())
+function pre (done) {
+  function createA (cb) {
+    PeerId.createFromJSON(idJSON(1), (err, id) => {
+      if (err) { return cb(err) }
 
-        swarmA.transport.add('ws', new WebSockets())
-        swarmA.transport.listen('ws', {}, echo, cb)
-      })
-  }
+      const peerA = new PeerInfo(id)
+      const maA = '/ip4/127.0.0.1/tcp/9100/ws'
+
+      peerA.multiaddrs.add(maA)
+      switchA = new Switch(peerA, new PeerBook())
 
-  function createListenerB (cb) {
-    PeerId.createFromJSON(
-      JSON.parse(
-        fs.readFileSync(path.join(__dirname, './test/test-data/id-2.json'))
-      ),
-      (err, id) => {
-        if (err) {
-          return cb(err)
-        }
-
-        const peerB = new PeerInfo(id)
-        const maB = '/ip4/127.0.0.1/tcp/9200/ws'
-
-        peerB.multiaddrs.add(maB)
-        swarmB = new Swarm(peerB, new PeerBook())
-
-        swarmB.transport.add('ws', new WebSockets())
-        swarmB.connection.addStreamMuxer(spdy)
-        swarmB.connection.reuse()
-        swarmB.start(cb)
-        swarmB.handle('/echo/1.0.0', echo)
-      })
+      switchA.transport.add('ws', new WebSockets())
+      switchA.transport.listen('ws', {}, echo, cb)
+    })
   }
 
-  let count = 0
-  const ready = () => ++count === 3 ? done() : null
+  function createB (cb) {
+    PeerId.createFromJSON(idJSON(2), (err, id) => {
+      if (err) { return cb(err) }
 
-  createListenerA(ready)
-  createListenerB(ready)
-  sigS = sigServer.start(options, ready)
+      const peerB = new PeerInfo(id)
+      const maB = '/ip4/127.0.0.1/tcp/9200/ws'
 
-  function echo (protocol, conn) {
-    pull(conn, conn)
+      peerB.multiaddrs.add(maB)
+      switchB = new Switch(peerB, new PeerBook())
+
+      switchB.transport.add('ws', new WebSockets())
+      switchB.connection.addStreamMuxer(spdy)
+      switchB.connection.reuse()
+      switchB.handle('/echo/1.0.0', echo)
+      switchB.start(cb)
+    })
   }
-}
 
-function after (done) {
-  let count = 0
-  const ready = () => ++count === 3 ? done() : null
+  parallel([
+    (cb) => {
+      sigS = sigServer.start(sigOptions, cb)
+    },
+    (cb) => createA(cb),
+    (cb) => createB(cb)
+  ], done)
+}
 
-  swarmA.transport.close('ws', ready)
-  swarmB.stop(ready)
-  sigS.stop(ready)
+function post (done) {
+  parallel([
+    (cb) => switchA.transport.close('ws', cb),
+    (cb) => switchB.stop(cb),
+    (cb) => sigS.stop(cb)
+  ], done)
 }
 
 module.exports = {
   hooks: {
     browser: {
-      pre: before,
-      post: after
+      pre: pre,
+      post: post
     }
   }
 }

test/browser.js

@@ -1,25 +1,12 @@
 /* eslint-env mocha */
 'use strict'
 
-const chai = require('chai')
-const dirtyChai = require('dirty-chai')
-const expect = chai.expect
-chai.use(dirtyChai)
 const w = require('webrtcsupport')
 
-const Swarm = require('../src')
-
-describe('basics', () => {
-  it('throws on missing peerInfo', (done) => {
-    expect(Swarm).to.throw(/You must provide a `peerInfo`/)
-    done()
-  })
-})
-
-require('./browser-transport-websockets.js')
-require('./browser-swarm-with-muxing-plus-websockets.js')
+require('./transports.browser.js')
+require('./swarm-muxing+websockets.browser')
 
 if (w.support) {
-  require('./browser-transport-webrtc-star.js')
-  require('./browser-swarm-with-muxing-plus-webrtc-star.js')
+  require('./t-webrtc-star.browser')
+  require('./swarm-muxing+webrtc-star.browser')
 }

test/node.js

@@ -6,3 +6,4 @@ require('./secio.node')
 require('./swarm-no-muxing.node')
 require('./swarm-muxing.node')
 require('./circuit-relay.node')
+require('./limit-dialer.node')

test/swarm-muxing+webrtc-star.browser.js

@@ -14,94 +14,84 @@ const parallel = require('async/parallel')
 const series = require('async/series')
 const pull = require('pull-stream')
 const PeerBook = require('peer-book')
+const tryEcho = require('./utils').tryEcho
 
-const Swarm = require('../src')
+const Switch = require('../src')
 
-describe('high level API (swarm with spdy + webrtc-star)', () => {
-  let swarm1
+describe('Switch (webrtc-star)', () => {
+  let switch1
   let peer1
   let wstar1
 
-  let swarm2
+  let switch2
   let peer2
   let wstar2
 
-  before((done) => {
-    series([
-      (cb) => peerId.create((err, id1) => {
-        expect(err).to.not.exist()
-        peer1 = new PeerInfo(id1)
-        const mh1 = 'ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/' +
-          id1.toB58String()
-        peer1.multiaddrs.add(mh1)
-        cb()
-      }),
-      (cb) => peerId.create((err, id2) => {
-        expect(err).to.not.exist()
-        peer2 = new PeerInfo(id2)
-        const mh2 = '/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/' +
-          id2.toB58String()
-        peer2.multiaddrs.add(mh2)
-        cb()
-      })
-    ], (err) => {
+  before((done) => series([
+    (cb) => peerId.create((err, id1) => {
       expect(err).to.not.exist()
-
-      swarm1 = new Swarm(peer1, new PeerBook())
-      swarm2 = new Swarm(peer2, new PeerBook())
-      done()
+      peer1 = new PeerInfo(id1)
+      const ma1 = 'ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/' +
+        id1.toB58String()
+      peer1.multiaddrs.add(ma1)
+      cb()
+    }),
+    (cb) => peerId.create((err, id2) => {
+      expect(err).to.not.exist()
+      peer2 = new PeerInfo(id2)
+      const ma2 = '/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/' +
+        id2.toB58String()
+      peer2.multiaddrs.add(ma2)
+      cb()
     })
-  })
+  ], (err) => {
+    expect(err).to.not.exist()
 
-  it('add WebRTCStar transport to swarm 1', () => {
+    switch1 = new Switch(peer1, new PeerBook())
+    switch2 = new Switch(peer2, new PeerBook())
+    done()
+  }))
+
+  it('add WebRTCStar transport to switch 1', () => {
     wstar1 = new WebRTCStar()
-    swarm1.transport.add('wstar', wstar1)
-    expect(Object.keys(swarm1.transports).length).to.equal(1)
+    switch1.transport.add('wstar', wstar1)
+    expect(Object.keys(switch1.transports).length).to.equal(1)
   })
 
-  it('add WebRTCStar transport to swarm 2', () => {
+  it('add WebRTCStar transport to switch 2', () => {
     wstar2 = new WebRTCStar()
-    swarm2.transport.add('wstar', wstar2)
-    expect(Object.keys(swarm2.transports).length).to.equal(1)
+    switch2.transport.add('wstar', wstar2)
+    expect(Object.keys(switch2.transports).length).to.equal(1)
   })
 
-  it('listen on swarm 1', (done) => {
-    swarm1.listen(done)
+  it('listen on switch 1', (done) => {
+    switch1.start(done)
   })
 
-  it('listen on swarm 2', (done) => {
-    swarm2.listen(done)
+  it('listen on switch 2', (done) => {
+    switch2.start(done)
   })
 
   it('add spdy', () => {
-    swarm1.connection.addStreamMuxer(spdy)
-    swarm1.connection.reuse()
-    swarm2.connection.addStreamMuxer(spdy)
-    swarm2.connection.reuse()
+    switch1.connection.addStreamMuxer(spdy)
+    switch1.connection.reuse()
+    switch2.connection.addStreamMuxer(spdy)
+    switch2.connection.reuse()
   })
 
   it('handle proto', () => {
-    swarm2.handle('/echo/1.0.0', (protocol, conn) => {
-      pull(conn, conn)
-    })
+    switch2.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn))
   })
 
   it('dial on proto', (done) => {
-    swarm1.dial(peer2, '/echo/1.0.0', (err, conn) => {
+    switch1.dial(peer2, '/echo/1.0.0', (err, conn) => {
       expect(err).to.not.exist()
-      expect(Object.keys(swarm1.muxedConns).length).to.equal(1)
-
-      const text = 'Hello World'
-      pull(
-        pull.values([text]),
-        conn,
-        pull.collect((err, data) => {
-          expect(err).to.not.exist()
-          expect(data.toString()).to.equal(text)
-          expect(Object.keys(swarm2.muxedConns).length).to.equal(1)
-          done()
-        })
-      )
+      expect(Object.keys(switch1.muxedConns).length).to.equal(1)
+
+      tryEcho(conn, () => {
+        expect(Object.keys(switch2.muxedConns).length).to.equal(1)
+        done()
+      })
     })
   })
 
@@ -110,25 +100,25 @@ describe('high level API (swarm with spdy + webrtc-star)', () => {
 
     let counter = 0
 
-    let swarm3
+    let switch3
 
     function check () {
       if (++counter === 4) {
-        const s1n = Object.keys(swarm1.muxedConns).length
-        const s2n = Object.keys(swarm2.muxedConns).length
-        const s3n = Object.keys(swarm3.muxedConns).length
+        const s1n = Object.keys(switch1.muxedConns).length
+        const s2n = Object.keys(switch2.muxedConns).length
+        const s3n = Object.keys(switch3.muxedConns).length
         expect(s1n).to.equal(2)
         expect(s2n).to.equal(2)
         expect(s3n).to.equal(2)
-        swarm3.close(done)
+        switch3.stop(done)
       }
       if (counter === 3) {
         setTimeout(check, 2000)
       }
     }
 
-    wstar1.discovery.on('peer', (peerInfo) => swarm1.dial(peerInfo, check))
-    wstar2.discovery.on('peer', (peerInfo) => swarm2.dial(peerInfo, check))
+    wstar1.discovery.on('peer', (peerInfo) => switch1.dial(peerInfo, check))
+    wstar2.discovery.on('peer', (peerInfo) => switch2.dial(peerInfo, check))
 
     peerId.create((err, id3) => {
       expect(err).to.not.exist()
@@ -137,19 +127,19 @@ describe('high level API (swarm with spdy + webrtc-star)', () => {
       const mh3 = '/ip4/127.0.0.1/tcp/15555/ws/p2p-webrtc-star/ipfs/' + id3.toB58String()
       peer3.multiaddrs.add(mh3)
 
-      swarm3 = new Swarm(peer3, new PeerBook())
+      switch3 = new Switch(peer3, new PeerBook())
       const wstar3 = new WebRTCStar()
-      swarm3.transport.add('wstar', wstar3)
-      swarm3.connection.addStreamMuxer(spdy)
-      swarm3.connection.reuse()
-      swarm3.listen(check)
+      switch3.transport.add('wstar', wstar3)
+      switch3.connection.addStreamMuxer(spdy)
+      switch3.connection.reuse()
+      switch3.start(check)
     })
   })
 
-  it('close', (done) => {
+  it('stop', (done) => {
     parallel([
-      (cb) => swarm1.close(cb),
-      (cb) => swarm2.close(cb)
+      (cb) => switch1.stop(cb),
+      (cb) => switch2.stop(cb)
     ], done)
   })
 })