WIP - feat: convergence (#94)

* feat: convergence

* structure examples

test/nodejs-bundle/content-routing.js

@@ -0,0 +1,90 @@
+/* eslint-env mocha */
+/* eslint max-nested-callbacks: ["error", 8] */
+
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const utils = require('./utils')
+const createNode = utils.createNode
+const _times = require('lodash.times')
+const CID = require('cids')
+
+describe('.contentRouting', () => {
+  let nodeA
+  let nodeB
+  let nodeC
+  let nodeD
+  let nodeE
+
+  before((done) => {
+    const tasks = _times(5, () => (cb) => {
+      createNode('/ip4/0.0.0.0/tcp/0', {
+        mdns: false,
+        dht: true
+      }, (err, node) => {
+        expect(err).to.not.exist()
+        node.start((err) => cb(err, node))
+      })
+    })
+
+    parallel(tasks, (err, nodes) => {
+      expect(err).to.not.exist()
+      nodeA = nodes[0]
+      nodeB = nodes[1]
+      nodeC = nodes[2]
+      nodeD = nodes[3]
+      nodeE = nodes[4]
+
+      parallel([
+        (cb) => nodeA.dial(nodeB.peerInfo, cb),
+        (cb) => nodeB.dial(nodeC.peerInfo, cb),
+        (cb) => nodeC.dial(nodeD.peerInfo, cb),
+        (cb) => nodeD.dial(nodeE.peerInfo, cb),
+        (cb) => nodeE.dial(nodeA.peerInfo, cb)
+      ], done)
+    })
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeA.stop(cb),
+      (cb) => nodeB.stop(cb),
+      (cb) => nodeC.stop(cb),
+      (cb) => nodeD.stop(cb),
+      (cb) => nodeE.stop(cb)
+    ], done)
+  })
+
+  describe('le ring', () => {
+    const cid = new CID('QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSySnL')
+
+    it('let kbucket get filled', (done) => {
+      setTimeout(() => done(), 250)
+    })
+
+    it('nodeA.contentRouting.provide', (done) => {
+      nodeA.contentRouting.provide(cid, done)
+    })
+
+    it('nodeE.contentRouting.findProviders for existing record', (done) => {
+      nodeE.contentRouting.findProviders(cid, 5000, (err, providers) => {
+        expect(err).to.not.exist()
+        expect(providers).to.have.length.above(0)
+        done()
+      })
+    })
+
+    it('nodeC.contentRouting.findProviders for non existing record (timeout)', (done) => {
+      const cid = new CID('QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSnnnn')
+
+      nodeE.contentRouting.findProviders(cid, 5000, (err, providers) => {
+        expect(err).to.not.exist()
+        expect(providers).to.have.length(0)
+        done()
+      })
+    })
+  })
+})

test/nodejs-bundle/discovery.js

@@ -0,0 +1,99 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const signalling = require('libp2p-webrtc-star/src/sig-server')
+const parallel = require('async/parallel')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('discovery', () => {
+  let nodeA
+  let nodeB
+  let port = 24642
+  let ss
+
+  function setup (options) {
+    before((done) => {
+      port++
+      parallel([
+        (cb) => {
+          signalling.start({ port: port }, (err, server) => {
+            expect(err).to.not.exist()
+            ss = server
+            cb()
+          })
+        },
+        (cb) => createNode([
+          '/ip4/0.0.0.0/tcp/0',
+          `/libp2p-webrtc-star/ip4/127.0.0.1/tcp/${port}/ws`
+        ], options, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode([
+          '/ip4/0.0.0.0/tcp/0',
+          `/libp2p-webrtc-star/ip4/127.0.0.1/tcp/${port}/ws`
+        ], options, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], done)
+    })
+
+    after((done) => {
+      parallel([
+        (cb) => nodeA.stop(cb),
+        (cb) => nodeB.stop(cb),
+        (cb) => ss.stop(done)
+      ], done)
+    })
+  }
+
+  describe('MulticastDNS', () => {
+    setup({ mdns: true })
+
+    it('find a peer', (done) => {
+      nodeA.once('peer:discovery', (peerInfo) => {
+        expect(nodeB.peerInfo.id.toB58String())
+          .to.eql(peerInfo.id.toB58String())
+        done()
+      })
+    })
+  })
+
+  // TODO needs a delay (this test is already long)
+  describe.skip('WebRTCStar', () => {
+    setup({ webRTCStar: true })
+
+    it('find a peer', (done) => {
+      nodeA.once('peer:discovery', (peerInfo) => {
+        expect(nodeB.peerInfo.id.toB58String())
+          .to.eql(peerInfo.id.toB58String())
+        done()
+      })
+    })
+  })
+
+  describe('MulticastDNS + WebRTCStar', () => {
+    setup({
+      webRTCStar: true,
+      mdns: true
+    })
+
+    it('find a peer', (done) => {
+      nodeA.once('peer:discovery', (peerInfo) => {
+        expect(nodeB.peerInfo.id.toB58String())
+          .to.eql(peerInfo.id.toB58String())
+        done()
+      })
+    })
+  })
+})

test/nodejs-bundle/nodejs-bundle.js

@@ -0,0 +1,80 @@
+'use strict'
+
+const TCP = require('libp2p-tcp')
+const MulticastDNS = require('libp2p-mdns')
+const WS = require('libp2p-websockets')
+const Railing = require('libp2p-railing')
+const spdy = require('libp2p-spdy')
+const KadDHT = require('libp2p-kad-dht')
+const multiplex = require('libp2p-multiplex')
+const secio = require('libp2p-secio')
+const libp2p = require('../..')
+
+function mapMuxers (list) {
+  return list.map((pref) => {
+    if (typeof pref !== 'string') {
+      return pref
+    }
+    switch (pref.trim().toLowerCase()) {
+      case 'spdy': return spdy
+      case 'multiplex': return multiplex
+      default:
+        throw new Error(pref + ' muxer not available')
+    }
+  })
+}
+
+function getMuxers (muxers) {
+  const muxerPrefs = process.env.LIBP2P_MUXER
+  if (muxerPrefs && !muxers) {
+    return mapMuxers(muxerPrefs.split(','))
+  } else if (muxers) {
+    return mapMuxers(muxers)
+  } else {
+    return [multiplex, spdy]
+  }
+}
+
+class Node extends libp2p {
+  constructor (peerInfo, peerBook, options) {
+    options = options || {}
+
+    const modules = {
+      transport: [
+        new TCP(),
+        new WS()
+      ],
+      connection: {
+        muxer: getMuxers(options.muxer),
+        crypto: [ secio ]
+      },
+      discovery: []
+    }
+
+    if (options.dht) {
+      modules.DHT = KadDHT
+    }
+
+    if (options.mdns) {
+      const mdns = new MulticastDNS(peerInfo, 'ipfs.local')
+      modules.discovery.push(mdns)
+    }
+
+    if (options.bootstrap) {
+      const r = new Railing(options.bootstrap)
+      modules.discovery.push(r)
+    }
+
+    if (options.modules && options.modules.transport) {
+      options.modules.transport.forEach((t) => modules.transport.push(t))
+    }
+
+    if (options.modules && options.modules.discovery) {
+      options.modules.discovery.forEach((d) => modules.discovery.push(d))
+    }
+
+    super(modules, peerInfo, peerBook, options)
+  }
+}
+
+module.exports = Node

test/nodejs-bundle/peer-routing.js

@@ -0,0 +1,94 @@
+/* eslint-env mocha */
+/* eslint max-nested-callbacks: ["error", 8] */
+
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const utils = require('./utils')
+const createNode = utils.createNode
+const _times = require('lodash.times')
+
+describe('.peerRouting', () => {
+  let nodeA
+  let nodeB
+  let nodeC
+  let nodeD
+  let nodeE
+
+  before((done) => {
+    const tasks = _times(5, () => (cb) => {
+      createNode('/ip4/0.0.0.0/tcp/0', {
+        mdns: false,
+        dht: true
+      }, (err, node) => {
+        expect(err).to.not.exist()
+        node.start((err) => cb(err, node))
+      })
+    })
+
+    parallel(tasks, (err, nodes) => {
+      expect(err).to.not.exist()
+      nodeA = nodes[0]
+      nodeB = nodes[1]
+      nodeC = nodes[2]
+      nodeD = nodes[3]
+      nodeE = nodes[4]
+
+      parallel([
+        (cb) => nodeA.dial(nodeB.peerInfo, cb),
+        (cb) => nodeB.dial(nodeC.peerInfo, cb),
+        (cb) => nodeC.dial(nodeD.peerInfo, cb),
+        (cb) => nodeD.dial(nodeE.peerInfo, cb),
+        (cb) => nodeE.dial(nodeA.peerInfo, cb)
+      ], done)
+    })
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeA.stop(cb),
+      (cb) => nodeB.stop(cb),
+      (cb) => nodeC.stop(cb),
+      (cb) => nodeD.stop(cb),
+      (cb) => nodeE.stop(cb)
+    ], done)
+  })
+
+  describe('el ring', () => {
+    it('let kbucket get filled', (done) => {
+      setTimeout(() => done(), 250)
+    })
+
+    it('nodeA.dial by Id to node C', (done) => {
+      nodeA.dial(nodeC.peerInfo.id, (err) => {
+        expect(err).to.not.exist()
+        done()
+      })
+    })
+
+    it('nodeB.dial by Id to node D', (done) => {
+      nodeB.dial(nodeD.peerInfo.id, (err) => {
+        expect(err).to.not.exist()
+        done()
+      })
+    })
+
+    it('nodeC.dial by Id to node E', (done) => {
+      nodeC.dial(nodeE.peerInfo.id, (err) => {
+        expect(err).to.not.exist()
+        done()
+      })
+    })
+
+    it('nodeB.peerRouting.findPeer(nodeE.peerInfo.id)', (done) => {
+      nodeB.peerRouting.findPeer(nodeE.peerInfo.id, (err, peerInfo) => {
+        expect(err).to.not.exist()
+        expect(nodeE.peerInfo.id.toB58String()).to.equal(peerInfo.id.toB58String())
+        done()
+      })
+    })
+  })
+})

test/nodejs-bundle/spawn-libp2p-node.js

@@ -0,0 +1,30 @@
+#! /usr/bin/env node
+
+'use strict'
+
+const Node = require('./nodejs-bundle')
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const pull = require('pull-stream')
+
+const idBak = require('./test-data/test-id.json')
+
+PeerId.createFromJSON(idBak, (err, peerId) => {
+  if (err) {
+    throw err
+  }
+
+  const peerInfo = new PeerInfo(peerId)
+
+  peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/12345')
+
+  const node = new Node(peerInfo)
+
+  node.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn))
+
+  node.start((err) => {
+    if (err) { throw err }
+
+    console.log('Spawned node started, env:', process.env.LIBP2P_MUXER)
+  })
+})

test/nodejs-bundle/stream-muxing.js

@@ -0,0 +1,207 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const series = require('async/series')
+const pull = require('pull-stream')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+function test (nodeA, nodeB, callback) {
+  nodeA.dial(nodeB.peerInfo, '/echo/1.0.0', (err, conn) => {
+    expect(err).to.not.exist()
+
+    pull(
+      pull.values([new Buffer('hey')]),
+      conn,
+      pull.collect((err, data) => {
+        expect(err).to.not.exist()
+        expect(data).to.be.eql([new Buffer('hey')])
+        callback()
+      })
+    )
+  })
+}
+
+function teardown (nodeA, nodeB, callback) {
+  parallel([
+    (cb) => nodeA.stop(cb),
+    (cb) => nodeB.stop(cb)
+  ], callback)
+}
+
+describe('stream muxing', (done) => {
+  it('spdy only', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => test(nodeA, nodeB, cb),
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+
+  it('multiplex only', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => test(nodeA, nodeB, cb),
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+
+  it('spdy + multiplex', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy', 'multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy', 'multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => test(nodeA, nodeB, cb),
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+
+  it('spdy + multiplex switched order', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy', 'multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['multiplex', 'spdy']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => test(nodeA, nodeB, cb),
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+
+  it('one without the other fails to establish a muxedConn', (done) => {
+    let nodeA
+    let nodeB
+
+    function setup (callback) {
+      parallel([
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['spdy']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeA = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        }),
+        (cb) => createNode('/ip4/0.0.0.0/tcp/0', {
+          muxer: ['multiplex']
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeB = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      ], callback)
+    }
+
+    series([
+      (cb) => setup(cb),
+      (cb) => {
+        // it will just 'warm up a conn'
+        expect(Object.keys(nodeA.swarm.muxers)).to.have.length(1)
+        expect(Object.keys(nodeB.swarm.muxers)).to.have.length(1)
+
+        nodeA.dial(nodeB.peerInfo, (err) => {
+          expect(err).to.not.exist()
+          expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+          cb()
+        })
+      },
+      (cb) => teardown(nodeA, nodeB, cb)
+    ], done)
+  })
+})

test/nodejs-bundle/tcp+websockets+webrtc-star.js

@@ -0,0 +1,246 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const signalling = require('libp2p-webrtc-star/src/sig-server')
+const WStar = require('libp2p-webrtc-star')
+const wrtc = require('wrtc')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('TCP + WebSockets + WebRTCStar', () => {
+  let nodeAll
+  let nodeTCP
+  let nodeWS
+  let nodeWStar
+
+  let ss
+
+  before((done) => {
+    parallel([
+      (cb) => {
+        signalling.start({ port: 24642 }, (err, server) => {
+          expect(err).to.not.exist()
+          ss = server
+          cb()
+        })
+      },
+      (cb) => {
+        const wstar = new WStar({wrtc: wrtc})
+        createNode([
+          '/ip4/0.0.0.0/tcp/0',
+          '/ip4/127.0.0.1/tcp/25011/ws',
+          '/libp2p-webrtc-star/ip4/127.0.0.1/tcp/24642/ws'
+        ], {
+          modules: {
+            transport: [wstar],
+            discovery: [wstar.discovery]
+          }
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeAll = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      },
+      (cb) => createNode([
+        '/ip4/0.0.0.0/tcp/0'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeTCP = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+      (cb) => createNode([
+        '/ip4/127.0.0.1/tcp/25022/ws'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeWS = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+
+      (cb) => {
+        const wstar = new WStar({wrtc: wrtc})
+
+        createNode([
+          '/libp2p-webrtc-star/ip4/127.0.0.1/tcp/24642/ws'
+        ], {
+          modules: {
+            transport: [wstar],
+            discovery: [wstar.discovery]
+          }
+        }, (err, node) => {
+          expect(err).to.not.exist()
+          nodeWStar = node
+          node.handle('/echo/1.0.0', echo)
+          node.start(cb)
+        })
+      }
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeAll.stop(cb),
+      (cb) => nodeTCP.stop(cb),
+      (cb) => nodeWS.stop(cb),
+      (cb) => nodeWStar.stop(cb),
+      (cb) => ss.stop(done)
+    ], done)
+  })
+
+  it('nodeAll.dial nodeTCP using PeerInfo', (done) => {
+    nodeAll.dial(nodeTCP.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeTCP.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCP.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.hangUp nodeTCP using PeerInfo', (done) => {
+    nodeAll.hangUp(nodeTCP.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeTCP.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCP.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.dial nodeWS using PeerInfo', (done) => {
+    nodeAll.dial(nodeWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(2)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWS.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.hangUp nodeWS using PeerInfo', (done) => {
+    nodeAll.hangUp(nodeWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(2)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWS.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.dial nodeWStar using PeerInfo', (done) => {
+    nodeAll.dial(nodeWStar.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(3)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWStar.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeAll.hangUp nodeWStar using PeerInfo', (done) => {
+    nodeAll.hangUp(nodeWStar.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeAll.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(3)
+            expect(Object.keys(nodeAll.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWStar.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWStar.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+})

test/nodejs-bundle/tcp+websockets.js

@@ -0,0 +1,167 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+// const multiaddr = require('multiaddr')
+// const pull = require('pull-stream')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('TCP + WebSockets', () => {
+  let nodeTCP
+  let nodeTCPnWS
+  let nodeWS
+
+  before((done) => {
+    parallel([
+      (cb) => createNode([
+        '/ip4/0.0.0.0/tcp/0'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeTCP = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+      (cb) => createNode([
+        '/ip4/0.0.0.0/tcp/0',
+        '/ip4/127.0.0.1/tcp/25011/ws'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeTCPnWS = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+      (cb) => createNode([
+        '/ip4/127.0.0.1/tcp/25022/ws'
+      ], (err, node) => {
+        expect(err).to.not.exist()
+        nodeWS = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      })
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeTCP.stop(cb),
+      (cb) => nodeTCPnWS.stop(cb),
+      (cb) => nodeWS.stop(cb)
+    ], done)
+  })
+
+  it('nodeTCP.dial nodeTCPnWS using PeerInfo', (done) => {
+    nodeTCP.dial(nodeTCPnWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeTCP.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCP.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeTCPnWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCPnWS.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeTCP.hangUp nodeTCPnWS using PeerInfo', (done) => {
+    nodeTCP.hangUp(nodeTCPnWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeTCP.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCP.swarm.muxedConns)).to.have.length(0)
+
+            cb()
+          },
+          (cb) => {
+            const peers = nodeTCPnWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeTCPnWS.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeTCPnWS.dial nodeWS using PeerInfo', (done) => {
+    nodeTCPnWS.dial(nodeWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeTCPnWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(2)
+            expect(Object.keys(nodeTCPnWS.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWS.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeTCPnWS.hangUp nodeWS using PeerInfo', (done) => {
+    nodeTCPnWS.hangUp(nodeWS.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeTCPnWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(2)
+            expect(Object.keys(nodeTCPnWS.swarm.muxedConns)).to.have.length(0)
+
+            cb()
+          },
+          (cb) => {
+            const peers = nodeWS.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeWS.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  // Until https://github.com/libp2p/js-libp2p/issues/46 is resolved
+  // Everynode will be able to dial in WebSockets
+  it.skip('nodeTCP.dial nodeWS using PeerInfo is unsuccesful', (done) => {
+    nodeTCP.dial(nodeWS.peerInfo, (err) => {
+      expect(err).to.exist()
+      done()
+    })
+  })
+})

test/nodejs-bundle/tcp.js

@@ -0,0 +1,234 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const parallel = require('async/parallel')
+const series = require('async/series')
+const pull = require('pull-stream')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('TCP only', () => {
+  let nodeA
+  let nodeB
+
+  before((done) => {
+    parallel([
+      (cb) => createNode('/ip4/0.0.0.0/tcp/0', (err, node) => {
+        expect(err).to.not.exist()
+        nodeA = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      }),
+      (cb) => createNode('/ip4/0.0.0.0/tcp/0', (err, node) => {
+        expect(err).to.not.exist()
+        nodeB = node
+        node.handle('/echo/1.0.0', echo)
+        node.start(cb)
+      })
+    ], done)
+  })
+
+  after((done) => {
+    parallel([
+      (cb) => nodeA.stop(cb),
+      (cb) => nodeB.stop(cb)
+    ], done)
+  })
+
+  it('nodeA.dial nodeB using PeerInfo without proto (warmup)', (done) => {
+    nodeA.dial(nodeB.peerInfo, (err) => {
+      expect(err).to.not.exist()
+
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(err).to.not.exist()
+            expect(Object.keys(peers)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(err).to.not.exist()
+            expect(Object.keys(peers)).to.have.length(1)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeA.dial nodeB using PeerInfo', (done) => {
+    nodeA.dial(nodeB.peerInfo, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist()
+
+      pull(
+        pull.values([new Buffer('hey')]),
+        conn,
+        pull.collect((err, data) => {
+          expect(err).to.not.exist()
+          expect(data).to.be.eql([new Buffer('hey')])
+          done()
+        })
+      )
+    })
+  })
+
+  it('nodeA.hangUp nodeB using PeerInfo (first)', (done) => {
+    nodeA.hangUp(nodeB.peerInfo, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeB.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeA.dial nodeB using multiaddr', (done) => {
+    nodeA.dial(nodeB.peerInfo.multiaddrs.toArray()[0], '/echo/1.0.0', (err, conn) => {
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        expect(err).to.not.exist()
+        series([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], () => {
+          pull(
+            pull.values([new Buffer('hey')]),
+            conn,
+            pull.collect((err, data) => {
+              expect(err).to.not.exist()
+              expect(data).to.be.eql([new Buffer('hey')])
+              done()
+            })
+          )
+        })
+      }
+    })
+  })
+
+  it('nodeA.hangUp nodeB using multiaddr (second)', (done) => {
+    nodeA.hangUp(nodeB.peerInfo.multiaddrs.toArray()[0], (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeB.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+
+  it('nodeA.dial nodeB using PeerId', (done) => {
+    nodeA.dial(nodeB.peerInfo.id, '/echo/1.0.0', (err, conn) => {
+      // Some time for Identify to finish
+      setTimeout(check, 500)
+
+      function check () {
+        expect(err).to.not.exist()
+        series([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(1)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(1)
+            cb()
+          }
+        ], () => {
+          pull(
+            pull.values([new Buffer('hey')]),
+            conn,
+            pull.collect((err, data) => {
+              expect(err).to.not.exist()
+              expect(data).to.be.eql([new Buffer('hey')])
+              done()
+            })
+          )
+        })
+      }
+    })
+  })
+
+  it('nodeA.hangUp nodeB using PeerId (third)', (done) => {
+    nodeA.hangUp(nodeB.peerInfo.multiaddrs.toArray()[0], (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        parallel([
+          (cb) => {
+            const peers = nodeA.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+            cb()
+          },
+          (cb) => {
+            const peers = nodeB.peerBook.getAll()
+            expect(Object.keys(peers)).to.have.length(1)
+
+            expect(Object.keys(nodeB.swarm.muxedConns)).to.have.length(0)
+            cb()
+          }
+        ], done)
+      }
+    })
+  })
+})

test/nodejs-bundle/test-data/test-id.json

@@ -0,0 +1,5 @@
+{
+  "id": "QmaG17D4kfTB2RNUCr16bSfVvUVt2Xn3rPYeqQDvnVcXFr",
+  "privKey": "CAASqAkwggSkAgEAAoIBAQDBpXRrSLoVhP8C4YI0nm+YTb7UIe+xT9dwaMzKcGsH2zzz1lfxl54e1XNO+6Ut+If5jswpydgHhn9nGPod53sUIR2m+BiHOAH/Blgfa1nUKUkspts1MH3z5ZaO6Xo336Y0Uaw7UqfeIzKliTM6bpev2XIHyu0v/VJ2mylzfbDLMWqZs/shE3xwCJCD/PxoVpTlr/SzzF7MdgDMxkyiC3iLZ5Zkm+baPbi3mpKM0ue25Thedcc0KFjhQrjBfy5FPamrsMn5fnnoHwnQl9u7UWigzeC+7X+38EML1sVrV37ExxHPtM6882Ivjc7VN6zFHOHD2c9eVfbShkIf8YkVQUcFAgMBAAECggEAVE1mgGo58LJknml0WNn8tS5rfEiF5AhhPyOwvBTy04nDYFgZEykxgjTkrSbqgzfmYmOjSDICJUyNXGHISYqDz4CXOyBY9U0RuWeWp58BjVan75N4bRB+VNbHk9HbDkYEQlSoCW9ze0aRfvVa4v5QdRLSDMhwN+stokrsYcX/WIWYTM2e2jW+qQOzS8SJl7wYsgtd3WikrxwXkRL3sCMHEcgcPhoKacoD5Yr9cB0IC5vzhu4t/WMa+N2UEndcKGAbXsh8kA7BPFM6lqnEpOHpWEVEAYasAwFGUvUN9GwhtqpaNNS2sG6Nrz95cC99Nqx58uIXcTAJm3Fh/WfKJ6I1xQKBgQD+g7A5OSWw+i/zhTKVPJg93/eohViL0dGZT9Tf0/VslsFl00FwnZmBKA6BJ6ZL3hD00OcqIL3m6EzZ4q38U97XZxf2OUsPPJtl+Avqtlk16AHRHB9I17LGXJ30xZRkxL665oLms0D2T4NIZZX/uVMoS18lRvCZj1aEYQFCrZYgowKBgQDCxtA695S0vl6E3Q4G6MrDZK+2JqjaGL0XTnpHWiAjnk2lnV2CCZnWpEHT+ebF2fWx5nYQo5sugc6bS+4k9jRNUgxf2sQieZYCBjbnjCEVrPTm/dPTkaw1CQ/ox5/R1/Elbw8vteF9uUAvR0FL8Ss1Dqw6B2SxdTowxMy6qQ7sNwKBgG2N3eMj2DeP2egm45kdliK8L2yYyX6V+HTXyjf2kuQFGIZuIvMIw7S2u1eY65ooon/fFEIsCdJFGB+J1X6R05BAzi2sh8StP+7qkKadi1UK4w1R352JS2jbIRrlmXSuw7LL2njXnBTqMQaOw7xp14O2vePb32EaNBGTd+ltsvulAoGBALGIc4370oA4MIDb2Ag2MXKNmJbnf+piuB/BOTVGEZtFlDKLUArR43W/+/xRgKX/97FyhVS/OxfV21Kzj9oCy0NasMrB5RojRraLoYnFsPZH0mWlIGlsEtG4c9bR9XtYX4WmR+pN1r04mCc/xGWK6b4PpK2zxXT2i9ad2pmctGxbAoGBAIcp0UML5QCqvLmcob2/6PCRaYAxJBb9lDqOHredMgQih2hGnHFCyKk9eBAbFf/KN0guJTBDaAJRclcxsLLn7rV6grMNt+0EUepm7tWT0z5j8gNGbGGhuGDdqcmfJTc2EMdQrfhzYDN3rL1v3l+Ujwla2khL2ozE7SQ/KVeA1saY",
+  "pubKey": "CAASpgIwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDBpXRrSLoVhP8C4YI0nm+YTb7UIe+xT9dwaMzKcGsH2zzz1lfxl54e1XNO+6Ut+If5jswpydgHhn9nGPod53sUIR2m+BiHOAH/Blgfa1nUKUkspts1MH3z5ZaO6Xo336Y0Uaw7UqfeIzKliTM6bpev2XIHyu0v/VJ2mylzfbDLMWqZs/shE3xwCJCD/PxoVpTlr/SzzF7MdgDMxkyiC3iLZ5Zkm+baPbi3mpKM0ue25Thedcc0KFjhQrjBfy5FPamrsMn5fnnoHwnQl9u7UWigzeC+7X+38EML1sVrV37ExxHPtM6882Ivjc7VN6zFHOHD2c9eVfbShkIf8YkVQUcFAgMBAAE="
+}

test/nodejs-bundle/turbolence.js

@@ -0,0 +1,84 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const multiaddr = require('multiaddr')
+const spawn = require('child_process').spawn
+const path = require('path')
+// const map = require('async/map')
+const pull = require('pull-stream')
+const utils = require('./utils')
+const createNode = utils.createNode
+const echo = utils.echo
+
+describe('Turbolence tests', () => {
+  let nodeA
+  let nodeSpawn
+
+  before((done) => {
+    createNode('/ip4/0.0.0.0/tcp/0', (err, node) => {
+      expect(err).to.not.exist()
+      nodeA = node
+      node.handle('/echo/1.0.0', echo)
+      node.start(done)
+    })
+  })
+
+  after((done) => nodeA.stop(done))
+
+  it('spawn a node in a different process', (done) => {
+    const filePath = path.join(__dirname, './spawn-libp2p-node.js')
+
+    nodeSpawn = spawn(filePath, { env: process.env })
+
+    let spawned = false
+
+    nodeSpawn.stdout.on('data', (data) => {
+      // console.log(data.toString())
+      if (!spawned) {
+        spawned = true
+        done()
+      }
+    })
+
+    nodeSpawn.stderr.on('data', (data) => console.log(data.toString()))
+  })
+
+  it('connect nodeA to that node', (done) => {
+    const spawnedId = require('./test-data/test-id.json')
+    const maddr = multiaddr('/ip4/127.0.0.1/tcp/12345/ipfs/' + spawnedId.id)
+
+    nodeA.dial(maddr, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist()
+      const peers = nodeA.peerBook.getAll()
+
+      expect(Object.keys(peers)).to.have.length(1)
+
+      pull(
+        pull.values([new Buffer('hey')]),
+        conn,
+        pull.collect((err, data) => {
+          expect(err).to.not.exist()
+          expect(data).to.eql([new Buffer('hey')])
+          done()
+        })
+      )
+    })
+  })
+
+  it('crash that node, ensure nodeA continues going steady', (done) => {
+    // TODO investigate why CI crashes
+    setTimeout(() => nodeSpawn.kill('SIGKILL'), 1000)
+    // nodeSpawn.kill('SIGKILL')
+    setTimeout(check, 5000)
+
+    function check () {
+      const peers = nodeA.peerBook.getAll()
+      expect(Object.keys(peers)).to.have.length(1)
+      expect(Object.keys(nodeA.swarm.muxedConns)).to.have.length(0)
+      done()
+    }
+  })
+})

test/nodejs-bundle/utils.js

@@ -0,0 +1,43 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const Node = require('./nodejs-bundle')
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const waterfall = require('async/waterfall')
+const pull = require('pull-stream')
+
+function createNode (multiaddrs, options, callback) {
+  if (typeof options === 'function') {
+    callback = options
+    options = {}
+  }
+
+  if (!Array.isArray(multiaddrs)) {
+    multiaddrs = [multiaddrs]
+  }
+
+  waterfall([
+    (cb) => PeerId.create({ bits: 1024 }, cb),
+    (peerId, cb) => PeerInfo.create(peerId, cb),
+    (peerInfo, cb) => {
+      multiaddrs.map((ma) => peerInfo.multiaddrs.add(ma))
+      cb(null, peerInfo)
+    },
+    (peerInfo, cb) => {
+      const node = new Node(peerInfo, undefined, options)
+      cb(null, node)
+    }
+  ], callback)
+}
+
+function echo (protocol, conn) {
+  pull(conn, conn)
+}
+
+module.exports = {
+  createNode: createNode,
+  echo: echo
+}