chore: release version v0.10.3

Use dignified.js

.gitignore

@@ -29,5 +29,6 @@ node_modules
 
 
 coverage
-.jshintrc
-.jshintignore
+
+dist
+lib

.npmignore

@@ -0,0 +1,35 @@
+test
+
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directory
+node_modules
+
+# Optional npm cache directory
+.npm
+
+# Optional REPL history
+.node_repl_history

.travis.yml

@@ -1,7 +1,8 @@
 sudo: false
 language: node_js
 node_js:
-  - "4.0"
+  - 4
+  - 5
 
 # Make sure we have new NPM.
 before_install:
@@ -10,3 +11,10 @@ before_install:
 script:
   - npm run lint
   - npm test
+
+addons:
+  firefox: 'latest'
+
+before_script:
+  - export DISPLAY=:99.0
+  - sh -e /etc/init.d/xvfb start

README.md

@@ -5,6 +5,9 @@ libp2p-swarm JavaScript implementation
 [![](https://img.shields.io/badge/project-IPFS-blue.svg?style=flat-square)](http://ipfs.io/) 
 [![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
 [![Build Status](https://img.shields.io/travis/diasdavid/js-libp2p-swarm/master.svg?style=flat-square)](https://travis-ci.org/diasdavid/js-libp2p-swarm)
+![](https://img.shields.io/badge/coverage-%3F-yellow.svg?style=flat-square)
+[![Dependency Status](https://david-dm.org/diasdavid/js-libp2p-swarm.svg?style=flat-square)](https://david-dm.org/ipfs/js-libp2p-swarm)
+[![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
 
 > libp2p swarm implementation in JavaScript
 

gulpfile.js

@@ -0,0 +1,58 @@
+'use strict'
+
+const gulp = require('gulp')
+const Peer = require('peer-info')
+const Id = require('peer-id')
+const WebSockets = require('libp2p-websockets')
+
+const Swarm = require('./src')
+const multiaddr = require('multiaddr')
+
+let swarmA
+let swarmB
+
+gulp.task('test:browser:before', (done) => {
+  function createListenerA (cb) {
+    const b58IdA = 'QmWg2L4Fucx1x4KXJTfKHGixBJvveubzcd7DdhB2Mqwfh1'
+    const peerA = new Peer(Id.createFromB58String(b58IdA))
+    const maA = multiaddr('/ip4/127.0.0.1/tcp/9100/websockets')
+
+    peerA.multiaddr.add(maA)
+    swarmA = new Swarm(peerA)
+    swarmA.transport.add('ws', new WebSockets())
+    swarmA.transport.listen('ws', {}, echo, cb)
+  }
+
+  function createListenerB (cb) {
+    const b58IdB = 'QmRy1iU6BHmG5Hd8rnPhPL98cy1W1przUSTAMcGDq9yAAV'
+    const maB = multiaddr('/ip4/127.0.0.1/tcp/9200/websockets')
+    const peerB = new Peer(Id.createFromB58String(b58IdB))
+    peerB.multiaddr.add(maB)
+    swarmB = new Swarm(peerB)
+
+    swarmB.transport.add('ws', new WebSockets())
+    swarmB.transport.listen('ws', {}, null, cb)
+
+    swarmB.handle('/echo/1.0.0', echo)
+  }
+
+  let count = 0
+  const ready = () => ++count === 2 ? done() : null
+
+  createListenerA(ready)
+  createListenerB(ready)
+
+  function echo (conn) {
+    conn.pipe(conn)
+  }
+})
+
+gulp.task('test:browser:after', (done) => {
+  let count = 0
+  const ready = () => ++count === 2 ? done() : null
+
+  swarmA.transport.close('ws', ready)
+  swarmB.transport.close('ws', ready)
+})
+
+require('aegir/gulp')(gulp)

package.json

@@ -1,12 +1,19 @@
 {
   "name": "libp2p-swarm",
-  "version": "0.8.1",
-  "description": "libp2p swarm implementation in Node.js",
-  "main": "src/index.js",
+  "version": "0.10.3",
+  "description": "libp2p swarm implementation in JavaScript",
+  "main": "lib/index.js",
+  "jsnext:main": "src/index.js",
   "scripts": {
-    "test": "mocha tests/*-test.js",
-    "coverage": "istanbul cover --print both -- _mocha tests/*-test.js",
-    "lint": "standard"
+    "lint": "gulp lint",
+    "build": "gulp build",
+    "test": "gulp test",
+    "test:node": "gulp test:node",
+    "test:browser": "gulp test:browser",
+    "release": "gulp release",
+    "release-minor": "gulp release --minor",
+    "release-major": "gulp release --major",
+    "coverage": "gulp coverage"
   },
   "repository": {
     "type": "git",
@@ -30,23 +37,35 @@
   },
   "devDependencies": {
     "bl": "^1.1.2",
+    "buffer-loader": "0.0.1",
     "chai": "^3.5.0",
+    "aegir": "^2.0.0",
+    "gulp": "^3.9.1",
     "istanbul": "^0.4.2",
+    "libp2p-multiplex": "^0.2.1",
     "libp2p-spdy": "^0.2.3",
     "libp2p-tcp": "^0.4.0",
-    "libp2p-websockets": "^0.2.0",
-    "mocha": "^2.4.5",
+    "libp2p-websockets": "^0.3.1",
     "multiaddr": "^1.3.0",
     "peer-id": "^0.6.0",
     "peer-info": "^0.6.0",
     "pre-commit": "^1.1.2",
-    "standard": "^6.0.7",
     "stream-pair": "^1.0.3"
   },
   "dependencies": {
+    "babel-runtime": "^6.6.1",
     "duplex-passthrough": "github:diasdavid/duplex-passthrough",
     "ip-address": "^5.0.2",
     "multistream-select": "^0.6.1",
     "protocol-buffers-stream": "^1.2.0"
+  },
+  "aegir": {
+    "webpack": {
+      "resolve": {
+        "alias": {
+          "node-forge": "../vendor/forge.bundle.js"
+        }
+      }
+    }
   }
 }

src/identify.js

@@ -5,15 +5,23 @@
  * established, so a conn can be reused
  */
 
+'use strict'
+
 const multistream = require('multistream-select')
 const fs = require('fs')
 const path = require('path')
-const pbStream = require('protocol-buffers-stream')(
-    fs.readFileSync(path.join(__dirname, 'identify.proto')))
 const Info = require('peer-info')
 const Id = require('peer-id')
 const multiaddr = require('multiaddr')
 
+const isNode = !global.window
+
+const identity = isNode
+  ? fs.readFileSync(path.join(__dirname, 'identify.proto'))
+  : require('buffer!./identify.proto')
+
+const pbStream = require('protocol-buffers-stream')(identity)
+
 exports = module.exports
 exports.multicodec = '/ipfs/identify/1.0.0'
 
@@ -36,7 +44,9 @@ exports.exec = (rawConn, muxer, peerInfo, callback) => {
       var pbs = pbStream()
 
       pbs.on('identify', (msg) => {
-        peerInfo.multiaddr.addSafe(msg.observedAddr)
+        if (msg.observedAddr.length > 0) {
+          peerInfo.multiaddr.addSafe(msg.observedAddr)
+        }
 
         const peerId = Id.createFromPubKey(msg.publicKey)
         const otherPeerInfo = new Info(peerId)
@@ -54,7 +64,7 @@ exports.exec = (rawConn, muxer, peerInfo, callback) => {
         agentVersion: 'na',
         publicKey: peerInfo.id.pubKey,
         listenAddrs: peerInfo.multiaddrs.map((mh) => { return mh.buffer }),
-        observedAddr: obsMultiaddr ? obsMultiaddr.buffer : null
+        observedAddr: obsMultiaddr ? obsMultiaddr.buffer : new Buffer('')
       })
 
       pbs.pipe(ds).pipe(pbs)
@@ -71,7 +81,9 @@ exports.handler = (peerInfo, swarm) => {
     var pbs = pbStream()
 
     pbs.on('identify', function (msg) {
-      peerInfo.multiaddr.addSafe(msg.observedAddr)
+      if (msg.observedAddr.length > 0) {
+        peerInfo.multiaddr.addSafe(msg.observedAddr)
+      }
 
       const peerId = Id.createFromPubKey(msg.publicKey)
       const conn = swarm.muxedConns[peerId.toB58String()].conn
@@ -84,7 +96,7 @@ exports.handler = (peerInfo, swarm) => {
         listenAddrs: peerInfo.multiaddrs.map(function (ma) {
           return ma.buffer
         }),
-        observedAddr: obsMultiaddr ? obsMultiaddr.buffer : null
+        observedAddr: obsMultiaddr ? obsMultiaddr.buffer : new Buffer('')
       })
       pbs.finalize()
     })

src/index.js

@@ -1,3 +1,5 @@
+'use strict'
+
 const multistream = require('multistream-select')
 const identify = require('./identify')
 const DuplexPassThrough = require('duplex-passthrough')
@@ -85,11 +87,7 @@ function Swarm (peerInfo) {
     // if no callback is passed, we pass conns to connHandler
     if (!handler) { handler = connHandler }
 
-    const multiaddrs = peerInfo.multiaddrs.filter((m) => {
-      if (m.toString().indexOf('tcp') !== -1) {
-        return m
-      }
-    })
+    const multiaddrs = this.transports[key].filter(peerInfo.multiaddrs)
 
     this.transports[key].createListener(multiaddrs, handler, (err, maUpdate) => {
       if (err) {
@@ -201,6 +199,8 @@ function Swarm (peerInfo) {
       gotMuxer(this.muxedConns[b58Id].muxer)
     }
 
+    return pt
+
     function gotWarmedUpConn (conn) {
       attemptMuxerUpgrade(conn, (err, muxer) => {
         if (!protocol) {

test/00-basic.node.js

@@ -0,0 +1,13 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const Swarm = require('../src')
+
+describe('basics', () => {
+  it('throws on missing peerInfo', (done) => {
+    expect(Swarm).to.throw(Error)
+    done()
+  })
+})

test/01-transport-tcp.node.js

@@ -0,0 +1,166 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+const bl = require('bl')
+
+describe('transport - tcp', function () {
+  this.timeout(10000)
+
+  var swarmA
+  var swarmB
+  var peerA = new Peer()
+  var peerB = new Peer()
+
+  before((done) => {
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999'))
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    done()
+  })
+
+  it('add', (done) => {
+    swarmA.transport.add('tcp', new TCP())
+    expect(Object.keys(swarmA.transports).length).to.equal(1)
+    swarmB.transport.add('tcp', new TCP(), () => {
+      expect(Object.keys(swarmB.transports).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('listen', (done) => {
+    var count = 0
+    swarmA.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+    swarmB.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      if (++count === 2) {
+        expect(peerA.multiaddrs.length).to.equal(1)
+        expect(peerA.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9888'))
+        expect(peerB.multiaddrs.length).to.equal(1)
+        expect(peerB.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9999'))
+        done()
+      }
+    }
+  })
+
+  it('dial to a multiaddr', (done) => {
+    const conn = swarmA.transport.dial('tcp', multiaddr('/ip4/127.0.0.1/tcp/9999'), (err, conn) => {
+      expect(err).to.not.exist
+    })
+    conn.pipe(bl((err, data) => {
+      expect(err).to.not.exist
+      done()
+    }))
+    conn.write('hey')
+    conn.end()
+  })
+
+  it('dial to set of multiaddr, only one is available', (done) => {
+    const conn = swarmA.transport.dial('tcp', [
+      multiaddr('/ip4/127.0.0.1/tcp/9910/websockets'), // not valid on purpose
+      multiaddr('/ip4/127.0.0.1/tcp/9910'),
+      multiaddr('/ip4/127.0.0.1/tcp/9999'),
+      multiaddr('/ip4/127.0.0.1/tcp/9309')
+    ], (err, conn) => {
+      expect(err).to.not.exist
+    })
+    conn.pipe(bl((err, data) => {
+      expect(err).to.not.exist
+      done()
+    }))
+    conn.write('hey')
+    conn.end()
+  })
+
+  it('close', (done) => {
+    var count = 0
+    swarmA.transport.close('tcp', closed)
+    swarmB.transport.close('tcp', closed)
+
+    function closed () {
+      if (++count === 2) {
+        done()
+      }
+    }
+  })
+
+  it('support port 0', (done) => {
+    var swarm
+    var peer = new Peer()
+    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
+    swarm = new Swarm(peer)
+    swarm.transport.add('tcp', new TCP())
+    swarm.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      expect(peer.multiaddrs.length).to.equal(1)
+      expect(peer.multiaddrs[0]).to.not.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/0'))
+      swarm.close(done)
+    }
+  })
+
+  it('support addr /ip4/0.0.0.0/tcp/9050', (done) => {
+    var swarm
+    var peer = new Peer()
+    peer.multiaddr.add(multiaddr('/ip4/0.0.0.0/tcp/9050'))
+    swarm = new Swarm(peer)
+    swarm.transport.add('tcp', new TCP())
+    swarm.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      expect(peer.multiaddrs.length).to.equal(1)
+      expect(peer.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/0.0.0.0/tcp/9050'))
+      swarm.close(done)
+    }
+  })
+
+  it('support addr /ip4/0.0.0.0/tcp/0', (done) => {
+    var swarm
+    var peer = new Peer()
+    peer.multiaddr.add(multiaddr('/ip4/0.0.0.0/tcp/0'))
+    swarm = new Swarm(peer)
+    swarm.transport.add('tcp', new TCP())
+    swarm.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      expect(peer.multiaddrs.length).to.equal(1)
+      expect(peer.multiaddrs[0]).to.not.deep.equal(multiaddr('/ip4/0.0.0.0/tcp/0'))
+      swarm.close(done)
+    }
+  })
+
+  it('listen in several addrs', (done) => {
+    var swarm
+    var peer = new Peer()
+    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
+    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
+    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
+    swarm = new Swarm(peer)
+    swarm.transport.add('tcp', new TCP())
+    swarm.transport.listen('tcp', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      expect(peer.multiaddrs.length).to.equal(3)
+      swarm.close(done)
+    }
+  })
+})

test/02-transport-utp.node.js

@@ -0,0 +1,13 @@
+/* eslint-env mocha */
+'use strict'
+
+describe('transport - utp', function () {
+  this.timeout(10000)
+
+  before((done) => { done() })
+
+  it.skip('add', (done) => {})
+  it.skip('listen', (done) => {})
+  it.skip('dial', (done) => {})
+  it.skip('close', (done) => {})
+})

test/03-transport-websockets.node.js

@@ -0,0 +1,93 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const WebSockets = require('libp2p-websockets')
+const bl = require('bl')
+
+describe('transport - websockets', function () {
+  this.timeout(10000)
+
+  var swarmA
+  var swarmB
+  var peerA = new Peer()
+  var peerB = new Peer()
+
+  before((done) => {
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'))
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    done()
+  })
+
+  it('add', (done) => {
+    swarmA.transport.add('ws', new WebSockets())
+    expect(Object.keys(swarmA.transports).length).to.equal(1)
+    swarmB.transport.add('ws', new WebSockets(), () => {
+      expect(Object.keys(swarmB.transports).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('listen', (done) => {
+    var count = 0
+    swarmA.transport.listen('ws', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+    swarmB.transport.listen('ws', {}, (conn) => {
+      conn.pipe(conn)
+    }, ready)
+
+    function ready () {
+      if (++count === 2) {
+        expect(peerA.multiaddrs.length).to.equal(1)
+        expect(peerA.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
+        expect(peerB.multiaddrs.length).to.equal(1)
+        expect(peerB.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'))
+        done()
+      }
+    }
+  })
+
+  it('dial', (done) => {
+    const conn = swarmA.transport.dial('ws', multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'), (err, conn) => {
+      expect(err).to.not.exist
+    })
+    conn.pipe(bl((err, data) => {
+      expect(err).to.not.exist
+      done()
+    }))
+    conn.write('hey')
+    conn.end()
+  })
+
+  it('dial (conn from callback)', (done) => {
+    swarmA.transport.dial('ws', multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'), (err, conn) => {
+      expect(err).to.not.exist
+
+      conn.pipe(bl((err, data) => {
+        expect(err).to.not.exist
+        done()
+      }))
+      conn.write('hey')
+      conn.end()
+    })
+  })
+
+  it('close', (done) => {
+    var count = 0
+    swarmA.transport.close('ws', closed)
+    swarmB.transport.close('ws', closed)
+
+    function closed () {
+      if (++count === 2) {
+        done()
+      }
+    }
+  })
+})

test/04-muxing-multiplex.node.js

@@ -0,0 +1,131 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+const multiplex = require('libp2p-spdy')
+
+describe('stream muxing with multiplex (on TCP)', function () {
+  this.timeout(20000)
+
+  var swarmA
+  var peerA
+  var swarmB
+  var peerB
+  var swarmC
+  var peerC
+
+  before((done) => {
+    peerA = new Peer()
+    peerB = new Peer()
+    peerC = new Peer()
+
+    // console.log('peer A', peerA.id.toB58String())
+    // console.log('peer B', peerB.id.toB58String())
+    // console.log('peer C', peerC.id.toB58String())
+
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
+    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
+
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    swarmC = new Swarm(peerC)
+
+    swarmA.transport.add('tcp', new TCP())
+    swarmA.transport.listen('tcp', {}, null, ready)
+
+    swarmB.transport.add('tcp', new TCP())
+    swarmB.transport.listen('tcp', {}, null, ready)
+
+    swarmC.transport.add('tcp', new TCP())
+    swarmC.transport.listen('tcp', {}, null, ready)
+
+    var counter = 0
+
+    function ready () {
+      if (++counter === 3) {
+        done()
+      }
+    }
+  })
+
+  after((done) => {
+    var counter = 0
+
+    swarmA.close(closed)
+    swarmB.close(closed)
+    swarmC.close(closed)
+
+    function closed () {
+      if (++counter === 3) {
+        done()
+      }
+    }
+  })
+
+  it('add', (done) => {
+    swarmA.connection.addStreamMuxer(multiplex)
+    swarmB.connection.addStreamMuxer(multiplex)
+    swarmC.connection.addStreamMuxer(multiplex)
+    done()
+  })
+
+  it('handle + dial on protocol', (done) => {
+    swarmB.handle('/abacaxi/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerB, '/abacaxi/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('dial to warm conn', (done) => {
+    swarmB.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmB.conns).length).to.equal(0)
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial on protocol, reuse warmed conn', (done) => {
+    swarmA.handle('/papaia/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmB.dial(peerA, '/papaia/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmB.conns).length).to.equal(0)
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('enable identify to reuse incomming muxed conn', (done) => {
+    swarmA.connection.reuse()
+    swarmC.connection.reuse()
+
+    swarmC.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      setTimeout(() => {
+        expect(Object.keys(swarmC.muxedConns).length).to.equal(1)
+        expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
+        done()
+      }, 500)
+    })
+  })
+})

test/05-muxing-spdy.node.js

@@ -0,0 +1,131 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+const spdy = require('libp2p-spdy')
+
+describe('stream muxing with spdy (on TCP)', function () {
+  this.timeout(20000)
+
+  var swarmA
+  var peerA
+  var swarmB
+  var peerB
+  var swarmC
+  var peerC
+
+  before((done) => {
+    peerA = new Peer()
+    peerB = new Peer()
+    peerC = new Peer()
+
+    // console.log('peer A', peerA.id.toB58String())
+    // console.log('peer B', peerB.id.toB58String())
+    // console.log('peer C', peerC.id.toB58String())
+
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
+    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
+
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    swarmC = new Swarm(peerC)
+
+    swarmA.transport.add('tcp', new TCP())
+    swarmA.transport.listen('tcp', {}, null, ready)
+
+    swarmB.transport.add('tcp', new TCP())
+    swarmB.transport.listen('tcp', {}, null, ready)
+
+    swarmC.transport.add('tcp', new TCP())
+    swarmC.transport.listen('tcp', {}, null, ready)
+
+    var counter = 0
+
+    function ready () {
+      if (++counter === 3) {
+        done()
+      }
+    }
+  })
+
+  after((done) => {
+    var counter = 0
+
+    swarmA.close(closed)
+    swarmB.close(closed)
+    swarmC.close(closed)
+
+    function closed () {
+      if (++counter === 3) {
+        done()
+      }
+    }
+  })
+
+  it('add', (done) => {
+    swarmA.connection.addStreamMuxer(spdy)
+    swarmB.connection.addStreamMuxer(spdy)
+    swarmC.connection.addStreamMuxer(spdy)
+    done()
+  })
+
+  it('handle + dial on protocol', (done) => {
+    swarmB.handle('/abacaxi/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerB, '/abacaxi/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('dial to warm conn', (done) => {
+    swarmB.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmB.conns).length).to.equal(0)
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial on protocol, reuse warmed conn', (done) => {
+    swarmA.handle('/papaia/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmB.dial(peerA, '/papaia/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmB.conns).length).to.equal(0)
+      expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('enable identify to reuse incomming muxed conn', (done) => {
+    swarmA.connection.reuse()
+    swarmC.connection.reuse()
+
+    swarmC.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      setTimeout(() => {
+        expect(Object.keys(swarmC.muxedConns).length).to.equal(1)
+        expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
+        done()
+      }, 500)
+    })
+  })
+})

test/06-conn-upgrade-secio.node.js

@@ -0,0 +1,13 @@
+/* eslint-env mocha */
+'use strict'
+
+describe('secio conn upgrade (on TCP)', function () {
+  this.timeout(20000)
+
+  before((done) => { done() })
+  after((done) => { done() })
+
+  it.skip('add', (done) => {})
+  it.skip('dial', (done) => {})
+  it.skip('tls on a muxed stream (not the full conn)', (done) => {})
+})

test/07-conn-upgrade-tls.node.js

@@ -0,0 +1,11 @@
+/* eslint-env mocha */
+'use strict'
+
+describe('tls conn upgrade (on TCP)', function () {
+  before((done) => { done() })
+  after((done) => { done() })
+
+  it.skip('add', (done) => {})
+  it.skip('dial', (done) => {})
+  it.skip('tls on a muxed stream (not the full conn)', (done) => {})
+})

test/08-swarm-without-muxing.node.js

@@ -0,0 +1,106 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+
+describe('high level API - 1st without stream multiplexing (on TCP)', function () {
+  this.timeout(20000)
+
+  var swarmA
+  var peerA
+  var swarmB
+  var peerB
+
+  before((done) => {
+    peerA = new Peer()
+    peerB = new Peer()
+
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
+
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+
+    swarmA.transport.add('tcp', new TCP())
+    swarmA.transport.listen('tcp', {}, null, ready)
+
+    swarmB.transport.add('tcp', new TCP())
+    swarmB.transport.listen('tcp', {}, null, ready)
+
+    var counter = 0
+
+    function ready () {
+      if (++counter === 2) {
+        done()
+      }
+    }
+  })
+
+  after((done) => {
+    var counter = 0
+
+    swarmA.close(closed)
+    swarmB.close(closed)
+
+    function closed () {
+      if (++counter === 2) {
+        done()
+      }
+    }
+  })
+
+  it('handle a protocol', (done) => {
+    swarmB.handle('/bananas/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+    expect(Object.keys(swarmB.protocols).length).to.equal(1)
+    done()
+  })
+
+  it('dial on protocol', (done) => {
+    swarmB.handle('/pineapple/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerB, '/pineapple/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      conn.end()
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('dial on protocol (returned conn)', (done) => {
+    swarmB.handle('/apples/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    const conn = swarmA.dial(peerB, '/apples/1.0.0', (err) => {
+      expect(err).to.not.exist
+    })
+    conn.end()
+    conn.on('data', () => {}) // let it flow.. let it flooooow
+    conn.on('end', done)
+  })
+
+  it('dial to warm a conn', (done) => {
+    swarmA.dial(peerB, (err) => {
+      expect(err).to.not.exist
+      done()
+    })
+  })
+
+  it('dial on protocol, reuse warmed conn', (done) => {
+    swarmA.dial(peerB, '/bananas/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      conn.end()
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+})

test/09-swarm-with-muxing.node.js

@@ -0,0 +1,197 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+
+const multiaddr = require('multiaddr')
+const Peer = require('peer-info')
+const Swarm = require('../src')
+const TCP = require('libp2p-tcp')
+const WebSockets = require('libp2p-websockets')
+const spdy = require('libp2p-spdy')
+
+describe('high level API - with everything mixed all together!', function () {
+  this.timeout(20000)
+
+  var swarmA // tcp
+  var peerA
+  var swarmB // tcp+ws
+  var peerB
+  var swarmC // tcp+ws
+  var peerC
+  var swarmD // ws
+  var peerD
+  var swarmE // ws
+  var peerE
+
+  before((done) => {
+    peerA = new Peer()
+    peerB = new Peer()
+    peerC = new Peer()
+    peerD = new Peer()
+    peerE = new Peer()
+
+    // console.log('peer A', peerA.id.toB58String())
+    // console.log('peer B', peerB.id.toB58String())
+    // console.log('peer C', peerC.id.toB58String())
+
+    swarmA = new Swarm(peerA)
+    swarmB = new Swarm(peerB)
+    swarmC = new Swarm(peerC)
+    swarmD = new Swarm(peerD)
+    swarmE = new Swarm(peerE)
+
+    done()
+  })
+
+  after((done) => {
+    var counter = 0
+
+    swarmA.close(closed)
+    swarmB.close(closed)
+    swarmC.close(closed)
+    swarmD.close(closed)
+    swarmE.close(closed)
+
+    function closed () {
+      if (++counter === 4) {
+        done()
+      }
+    }
+  })
+
+  it('add tcp', (done) => {
+    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
+    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
+
+    swarmA.transport.add('tcp', new TCP())
+    swarmA.transport.listen('tcp', {}, null, ready)
+
+    swarmB.transport.add('tcp', new TCP())
+    swarmB.transport.listen('tcp', {}, null, ready)
+
+    swarmC.transport.add('tcp', new TCP())
+    swarmC.transport.listen('tcp', {}, null, ready)
+
+    var counter = 0
+
+    function ready () {
+      if (++counter === 3) {
+        done()
+      }
+    }
+  })
+
+  it.skip('add utp', (done) => {})
+
+  it('add websockets', (done) => {
+    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9012/websockets'))
+    peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9022/websockets'))
+    peerD.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9032/websockets'))
+    peerE.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9042/websockets'))
+
+    swarmB.transport.add('ws', new WebSockets())
+    swarmB.transport.listen('ws', {}, null, ready)
+
+    swarmC.transport.add('ws', new WebSockets())
+    swarmC.transport.listen('ws', {}, null, ready)
+
+    swarmD.transport.add('ws', new WebSockets())
+    swarmD.transport.listen('ws', {}, null, ready)
+
+    swarmE.transport.add('ws', new WebSockets())
+    swarmE.transport.listen('ws', {}, null, ready)
+
+    var counter = 0
+
+    function ready () {
+      if (++counter === 4) {
+        done()
+      }
+    }
+  })
+
+  it('add spdy', (done) => {
+    swarmA.connection.addStreamMuxer(spdy)
+    swarmB.connection.addStreamMuxer(spdy)
+    swarmC.connection.addStreamMuxer(spdy)
+    swarmD.connection.addStreamMuxer(spdy)
+    swarmE.connection.addStreamMuxer(spdy)
+
+    swarmA.connection.reuse()
+    swarmB.connection.reuse()
+    swarmC.connection.reuse()
+    swarmD.connection.reuse()
+    swarmE.connection.reuse()
+
+    done()
+  })
+
+  it.skip('add multiplex', (done) => {})
+
+  it('dial from tcp to tcp+ws', (done) => {
+    swarmB.handle('/anona/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerB, '/anona/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+
+  it('dial from ws to ws', (done) => {
+    swarmE.handle('/abacaxi/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmD.dial(peerE, '/abacaxi/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmD.muxedConns).length).to.equal(1)
+
+      conn.end()
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', () => {
+        setTimeout(() => {
+          expect(Object.keys(swarmE.muxedConns).length).to.equal(1)
+          done()
+        }, 1000)
+      })
+    })
+  })
+
+  it('dial from tcp to tcp+ws (returned conn)', (done) => {
+    swarmB.handle('/grapes/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    const conn = swarmA.dial(peerB, '/grapes/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+    })
+    conn.end()
+
+    conn.on('data', () => {}) // let it flow.. let it flooooow
+    conn.on('end', done)
+  })
+
+  it('dial from tcp+ws to tcp+ws', (done) => {
+    swarmC.handle('/mamao/1.0.0', (conn) => {
+      conn.pipe(conn)
+    })
+
+    swarmA.dial(peerC, '/mamao/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
+      conn.end()
+
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+})

test/browser.js

@@ -0,0 +1,125 @@
+/* eslint-env mocha */
+'use strict'
+
+const expect = require('chai').expect
+const multiaddr = require('multiaddr')
+const Id = require('peer-id')
+const Peer = require('peer-info')
+const WebSockets = require('libp2p-websockets')
+const bl = require('bl')
+
+const Swarm = require('../src')
+
+describe('basics', () => {
+  it('throws on missing peerInfo', (done) => {
+    expect(Swarm).to.throw(Error)
+    done()
+  })
+})
+
+describe('transport - websockets', function () {
+  this.timeout(10000)
+
+  var swarm
+
+  before((done) => {
+    const b58IdSrc = 'QmYzgdesgjdvD3okTPGZT9NPmh1BuH5FfTVNKjsvaAprhb'
+    // use a pre generated Id to save time
+    const idSrc = Id.createFromB58String(b58IdSrc)
+    const peerSrc = new Peer(idSrc)
+    swarm = new Swarm(peerSrc)
+
+    done()
+  })
+
+  it('add', (done) => {
+    swarm.transport.add('ws', new WebSockets(), () => {
+      expect(Object.keys(swarm.transports).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial', (done) => {
+    const ma = multiaddr('/ip4/127.0.0.1/tcp/9100/websockets')
+
+    const conn = swarm.transport.dial('ws', ma, (err, conn) => {
+      expect(err).to.not.exist
+    })
+
+    conn.pipe(bl((err, data) => {
+      expect(err).to.not.exist
+      expect(data.toString()).to.equal('hey')
+      done()
+    }))
+    conn.write('hey')
+    conn.end()
+  })
+})
+
+describe('high level API - 1st without stream multiplexing (on websockets)', function () {
+  this.timeout(10000)
+
+  var swarm
+  var peerDst
+
+  before((done) => {
+    const b58IdSrc = 'QmYzgdesgjdvD3okTPGZT9NPmh1BuH5FfTVNKjsvaAprhb'
+    // use a pre generated Id to save time
+    const idSrc = Id.createFromB58String(b58IdSrc)
+    const peerSrc = new Peer(idSrc)
+    swarm = new Swarm(peerSrc)
+
+    done()
+  })
+
+  after((done) => {
+    done()
+    // swarm.close(done)
+  })
+
+  it('add ws', (done) => {
+    swarm.transport.add('ws', new WebSockets())
+    expect(Object.keys(swarm.transports).length).to.equal(1)
+    done()
+  })
+
+  it('create Dst peer info', (done) => {
+    const b58IdDst = 'QmYzgdesgjdvD3okTPGZT9NPmh1BuH5FfTVNKjsvaAprhb'
+    // use a pre generated Id to save time
+    const idDst = Id.createFromB58String(b58IdDst)
+    peerDst = new Peer(idDst)
+
+    const ma = multiaddr('/ip4/127.0.0.1/tcp/9200/websockets')
+    peerDst.multiaddr.add(ma)
+    done()
+  })
+
+  it('dial on protocol', (done) => {
+    swarm.dial(peerDst, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      conn.pipe(bl((err, data) => {
+        expect(err).to.not.exist
+        expect(data.toString()).to.equal('hey')
+        done()
+      }))
+      conn.write('hey')
+      conn.end()
+    })
+  })
+
+  it('dial to warm a conn', (done) => {
+    swarm.dial(peerDst, (err) => {
+      expect(err).to.not.exist
+      done()
+    })
+  })
+
+  it('dial on protocol, reuse warmed conn', (done) => {
+    swarm.dial(peerDst, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist
+      conn.end()
+      conn.on('data', () => {}) // let it flow.. let it flooooow
+      conn.on('end', done)
+    })
+  })
+})

test/node.js

@@ -0,0 +1,12 @@
+/* eslint-env mocha */
+'use strict'
+
+const fs = require('fs')
+
+describe('libp2p-swarm', () => {
+  fs.readdirSync(__dirname)
+    .filter((file) => file.match(/\.node\.js$/))
+    .forEach((file) => {
+      require(`./${file}`)
+    })
+})

tests/swarm-test.js

@@ -1,507 +0,0 @@
-/* eslint-env mocha */
-
-const expect = require('chai').expect
-// const async = require('async')
-
-const multiaddr = require('multiaddr')
-// const Id = require('peer-id')
-const Peer = require('peer-info')
-const Swarm = require('../src')
-const TCP = require('libp2p-tcp')
-const WebSockets = require('libp2p-websockets')
-const bl = require('bl')
-const spdy = require('libp2p-spdy')
-
-describe('basics', () => {
-  it('throws on missing peerInfo', (done) => {
-    expect(Swarm).to.throw(Error)
-    done()
-  })
-})
-
-describe('transport - tcp', function () {
-  this.timeout(10000)
-
-  var swarmA
-  var swarmB
-  var peerA = new Peer()
-  var peerB = new Peer()
-
-  before((done) => {
-    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888'))
-    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999'))
-    swarmA = new Swarm(peerA)
-    swarmB = new Swarm(peerB)
-    done()
-  })
-
-  it('add', (done) => {
-    swarmA.transport.add('tcp', new TCP())
-    expect(Object.keys(swarmA.transports).length).to.equal(1)
-    swarmB.transport.add('tcp', new TCP(), () => {
-      expect(Object.keys(swarmB.transports).length).to.equal(1)
-      done()
-    })
-  })
-
-  it('listen', (done) => {
-    var count = 0
-    swarmA.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-    swarmB.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      if (++count === 2) {
-        expect(peerA.multiaddrs.length).to.equal(1)
-        expect(peerA.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9888'))
-        expect(peerB.multiaddrs.length).to.equal(1)
-        expect(peerB.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9999'))
-        done()
-      }
-    }
-  })
-
-  it('dial to a multiaddr', (done) => {
-    const conn = swarmA.transport.dial('tcp', multiaddr('/ip4/127.0.0.1/tcp/9999'), (err, conn) => {
-      expect(err).to.not.exist
-    })
-    conn.pipe(bl((err, data) => {
-      expect(err).to.not.exist
-      done()
-    }))
-    conn.write('hey')
-    conn.end()
-  })
-
-  it('dial to set of multiaddr, only one is available', (done) => {
-    const conn = swarmA.transport.dial('tcp', [
-      multiaddr('/ip4/127.0.0.1/tcp/9910/websockets'), // not valid on purpose
-      multiaddr('/ip4/127.0.0.1/tcp/9910'),
-      multiaddr('/ip4/127.0.0.1/tcp/9999'),
-      multiaddr('/ip4/127.0.0.1/tcp/9309')
-    ], (err, conn) => {
-      expect(err).to.not.exist
-    })
-    conn.pipe(bl((err, data) => {
-      expect(err).to.not.exist
-      done()
-    }))
-    conn.write('hey')
-    conn.end()
-  })
-
-  it('close', (done) => {
-    var count = 0
-    swarmA.transport.close('tcp', closed)
-    swarmB.transport.close('tcp', closed)
-
-    function closed () {
-      if (++count === 2) {
-        done()
-      }
-    }
-  })
-
-  it('support port 0', (done) => {
-    var swarm
-    var peer = new Peer()
-    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/0'))
-    swarm = new Swarm(peer)
-    swarm.transport.add('tcp', new TCP())
-    swarm.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      expect(peer.multiaddrs.length).to.equal(1)
-      expect(peer.multiaddrs[0]).to.not.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/0'))
-      swarm.close(done)
-    }
-  })
-
-  it('support addr /ip4/0.0.0.0/tcp/9050', (done) => {
-    var swarm
-    var peer = new Peer()
-    peer.multiaddr.add(multiaddr('/ip4/0.0.0.0/tcp/9050'))
-    swarm = new Swarm(peer)
-    swarm.transport.add('tcp', new TCP())
-    swarm.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      expect(peer.multiaddrs.length).to.equal(1)
-      expect(peer.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/0.0.0.0/tcp/9050'))
-      swarm.close(done)
-    }
-  })
-
-  it('support addr /ip4/0.0.0.0/tcp/0', (done) => {
-    var swarm
-    var peer = new Peer()
-    peer.multiaddr.add(multiaddr('/ip4/0.0.0.0/tcp/0'))
-    swarm = new Swarm(peer)
-    swarm.transport.add('tcp', new TCP())
-    swarm.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      expect(peer.multiaddrs.length).to.equal(1)
-      expect(peer.multiaddrs[0]).to.not.deep.equal(multiaddr('/ip4/0.0.0.0/tcp/0'))
-      swarm.close(done)
-    }
-  })
-
-  it('listen in several addrs', (done) => {
-    var swarm
-    var peer = new Peer()
-    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
-    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
-    peer.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
-    swarm = new Swarm(peer)
-    swarm.transport.add('tcp', new TCP())
-    swarm.transport.listen('tcp', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      expect(peer.multiaddrs.length).to.equal(3)
-      swarm.close(done)
-    }
-  })
-})
-
-describe('transport - websockets', function () {
-  this.timeout(10000)
-
-  var swarmA
-  var swarmB
-  var peerA = new Peer()
-  var peerB = new Peer()
-
-  before((done) => {
-    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
-    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'))
-    swarmA = new Swarm(peerA)
-    swarmB = new Swarm(peerB)
-    done()
-  })
-
-  it('add', (done) => {
-    swarmA.transport.add('ws', new WebSockets())
-    expect(Object.keys(swarmA.transports).length).to.equal(1)
-    swarmB.transport.add('ws', new WebSockets(), () => {
-      expect(Object.keys(swarmB.transports).length).to.equal(1)
-      done()
-    })
-  })
-
-  it('listen', (done) => {
-    var count = 0
-    swarmA.transport.listen('ws', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-    swarmB.transport.listen('ws', {}, (conn) => {
-      conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      if (++count === 2) {
-        expect(peerA.multiaddrs.length).to.equal(1)
-        expect(peerA.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
-        expect(peerB.multiaddrs.length).to.equal(1)
-        expect(peerB.multiaddrs[0]).to.deep.equal(multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'))
-        done()
-      }
-    }
-  })
-
-  it('dial', (done) => {
-    const conn = swarmA.transport.dial('ws', multiaddr('/ip4/127.0.0.1/tcp/9999/websockets'), (err, conn) => {
-      expect(err).to.not.exist
-    })
-    conn.pipe(bl((err, data) => {
-      expect(err).to.not.exist
-      done()
-    }))
-    conn.write('hey')
-    conn.end()
-  })
-
-  it('close', (done) => {
-    var count = 0
-    swarmA.transport.close('ws', closed)
-    swarmB.transport.close('ws', closed)
-
-    function closed () {
-      if (++count === 2) {
-        done()
-      }
-    }
-  })
-})
-
-describe('transport - utp', function () {
-  this.timeout(10000)
-
-  before((done) => { done() })
-
-  it.skip('add', (done) => {})
-  it.skip('listen', (done) => {})
-  it.skip('dial', (done) => {})
-  it.skip('close', (done) => {})
-})
-
-describe('high level API - 1st without stream multiplexing (on TCP)', function () {
-  this.timeout(20000)
-
-  var swarmA
-  var peerA
-  var swarmB
-  var peerB
-
-  before((done) => {
-    peerA = new Peer()
-    peerB = new Peer()
-
-    peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
-    peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
-
-    swarmA = new Swarm(peerA)
-    swarmB = new Swarm(peerB)
-
-    swarmA.transport.add('tcp', new TCP())
-    swarmA.transport.listen('tcp', {}, null, ready)
-
-    swarmB.transport.add('tcp', new TCP())
-    swarmB.transport.listen('tcp', {}, null, ready)
-
-    var counter = 0
-
-    function ready () {
-      if (++counter === 2) {
-        done()
-      }
-    }
-  })
-
-  after((done) => {
-    var counter = 0
-
-    swarmA.close(closed)
-    swarmB.close(closed)
-
-    function closed () {
-      if (++counter === 2) {
-        done()
-      }
-    }
-  })
-
-  it('handle a protocol', (done) => {
-    swarmB.handle('/bananas/1.0.0', (conn) => {
-      conn.pipe(conn)
-    })
-    expect(Object.keys(swarmB.protocols).length).to.equal(1)
-    done()
-  })
-
-  it('dial on protocol', (done) => {
-    swarmB.handle('/pineapple/1.0.0', (conn) => {
-      conn.pipe(conn)
-    })
-
-    swarmA.dial(peerB, '/pineapple/1.0.0', (err, conn) => {
-      expect(err).to.not.exist
-      conn.end()
-      conn.on('data', () => {}) // let it flow.. let it flooooow
-      conn.on('end', done)
-    })
-  })
-
-  it('dial to warm a conn', (done) => {
-    swarmA.dial(peerB, (err) => {
-      expect(err).to.not.exist
-      done()
-    })
-  })
-
-  it('dial on protocol, reuse warmed conn', (done) => {
-    swarmA.dial(peerB, '/bananas/1.0.0', (err, conn) => {
-      expect(err).to.not.exist
-      conn.end()
-      conn.on('data', () => {}) // let it flow.. let it flooooow
-      conn.on('end', done)
-    })
-  })
-})
-
-describe('stream muxing (on TCP)', function () {
-  this.timeout(20000)
-
-  describe('multiplex', () => {
-    before((done) => { done() })
-    after((done) => { done() })
-
-    it.skip('add', (done) => {})
-    it.skip('handle + dial on protocol', (done) => {})
-    it.skip('dial to warm conn', (done) => {})
-    it.skip('dial on protocol, reuse warmed conn', (done) => {})
-    it.skip('enable identify to reuse incomming muxed conn', (done) => {})
-  })
-  describe('spdy', () => {
-    var swarmA
-    var peerA
-    var swarmB
-    var peerB
-    var swarmC
-    var peerC
-
-    before((done) => {
-      peerA = new Peer()
-      peerB = new Peer()
-      peerC = new Peer()
-
-      // console.log('peer A', peerA.id.toB58String())
-      // console.log('peer B', peerB.id.toB58String())
-      // console.log('peer C', peerC.id.toB58String())
-
-      peerA.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9001'))
-      peerB.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9002'))
-      peerC.multiaddr.add(multiaddr('/ip4/127.0.0.1/tcp/9003'))
-
-      swarmA = new Swarm(peerA)
-      swarmB = new Swarm(peerB)
-      swarmC = new Swarm(peerC)
-
-      swarmA.transport.add('tcp', new TCP())
-      swarmA.transport.listen('tcp', {}, null, ready)
-
-      swarmB.transport.add('tcp', new TCP())
-      swarmB.transport.listen('tcp', {}, null, ready)
-
-      swarmC.transport.add('tcp', new TCP())
-      swarmC.transport.listen('tcp', {}, null, ready)
-
-      var counter = 0
-
-      function ready () {
-        if (++counter === 3) {
-          done()
-        }
-      }
-    })
-
-    after((done) => {
-      var counter = 0
-
-      swarmA.close(closed)
-      swarmB.close(closed)
-      swarmC.close(closed)
-
-      function closed () {
-        if (++counter === 3) {
-          done()
-        }
-      }
-    })
-
-    it('add', (done) => {
-      swarmA.connection.addStreamMuxer(spdy)
-      swarmB.connection.addStreamMuxer(spdy)
-      swarmC.connection.addStreamMuxer(spdy)
-      done()
-    })
-
-    it('handle + dial on protocol', (done) => {
-      swarmB.handle('/abacaxi/1.0.0', (conn) => {
-        conn.pipe(conn)
-      })
-
-      swarmA.dial(peerB, '/abacaxi/1.0.0', (err, conn) => {
-        expect(err).to.not.exist
-        expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
-        conn.end()
-
-        conn.on('data', () => {}) // let it flow.. let it flooooow
-        conn.on('end', done)
-      })
-    })
-
-    it('dial to warm conn', (done) => {
-      swarmB.dial(peerA, (err) => {
-        expect(err).to.not.exist
-        expect(Object.keys(swarmB.conns).length).to.equal(0)
-        expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
-        done()
-      })
-    })
-
-    it('dial on protocol, reuse warmed conn', (done) => {
-      swarmA.handle('/papaia/1.0.0', (conn) => {
-        conn.pipe(conn)
-      })
-
-      swarmB.dial(peerA, '/papaia/1.0.0', (err, conn) => {
-        expect(err).to.not.exist
-        expect(Object.keys(swarmB.conns).length).to.equal(0)
-        expect(Object.keys(swarmB.muxedConns).length).to.equal(1)
-        conn.end()
-
-        conn.on('data', () => {}) // let it flow.. let it flooooow
-        conn.on('end', done)
-      })
-    })
-
-    it('enable identify to reuse incomming muxed conn', (done) => {
-      swarmA.connection.reuse()
-      swarmC.connection.reuse()
-
-      swarmC.dial(peerA, (err) => {
-        expect(err).to.not.exist
-        setTimeout(() => {
-          expect(Object.keys(swarmC.muxedConns).length).to.equal(1)
-          expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
-          done()
-        }, 500)
-      })
-    })
-  })
-})
-
-describe('conn upgrades', function () {
-  this.timeout(20000)
-
-  describe('secio on tcp', () => {
-    // before((done) => { done() })
-    // after((done) => { done() })
-
-    it.skip('add', (done) => {})
-    it.skip('dial', (done) => {})
-    it.skip('tls on a muxed stream (not the full conn)', (done) => {})
-  })
-  describe('tls on tcp', () => {
-    // before((done) => { done() })
-    // after((done) => { done() })
-
-    it.skip('add', (done) => {})
-    it.skip('dial', (done) => {})
-    it.skip('tls on a muxed stream (not the full conn)', (done) => {})
-  })
-})
-
-describe('high level API - with everything mixed all together!', function () {
-  this.timeout(20000)
-
-  // before((done) => { done() })
-  // after((done) => { done() })
-
-  it.skip('add tcp', (done) => {})
-  it.skip('add utp', (done) => {})
-  it.skip('add websockets', (done) => {})
-  it.skip('dial', (done) => {})
-})