chore: release version v0.12.10

Feat/listen

README.md

@@ -102,6 +102,10 @@ dial uses the best transport (whatever works first, in the future we can have so
 - `protocol`
 - `callback`
 
+### `swarm.listen(callback)`
+
+Start listening on all added transports that are available on the current `peerInfo`.
+
 ### `swarm.handle(protocol, handler)`
 
 handle a new protocol.
@@ -109,6 +113,12 @@ handle a new protocol.
 - `protocol`
 - `handler` - function called when we receive a dial on `protocol. Signature must be `function (conn) {}`
 
+### `swarm.unhandle(protocol)`
+
+unhandle a protocol.
+
+- `protocol`
+
 ### `swarm.close(callback)`
 
 close all the listeners and muxers.

package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-swarm",
-  "version": "0.10.7",
+  "version": "0.12.10",
   "description": "libp2p swarm implementation in JavaScript",
   "main": "lib/index.js",
   "jsnext:main": "src/index.js",
@@ -11,8 +11,8 @@
     "test:node": "gulp test:node",
     "test:browser": "gulp test:browser",
     "release": "gulp release",
-    "release-minor": "gulp release --minor",
-    "release-major": "gulp release --major",
+    "release-minor": "gulp release --type minor",
+    "release-major": "gulp release --type major",
     "coverage": "gulp coverage",
     "coverage-publish": "aegir-coverage publish"
   },
@@ -40,16 +40,13 @@
     "bl": "^1.1.2",
     "buffer-loader": "0.0.1",
     "chai": "^3.5.0",
-    "aegir": "^2.1.1",
+    "aegir": "^3.0.1",
     "gulp": "^3.9.1",
     "istanbul": "^0.4.3",
     "libp2p-multiplex": "^0.2.1",
     "libp2p-spdy": "^0.3.1",
-    "libp2p-tcp": "^0.4.0",
-    "libp2p-websockets": "^0.3.2",
-    "multiaddr": "^1.4.0",
-    "peer-id": "^0.6.6",
-    "peer-info": "^0.6.2",
+    "libp2p-tcp": "^0.5.1",
+    "libp2p-websockets": "^0.4.4",
     "pre-commit": "^1.1.2",
     "stream-pair": "^1.0.3"
   },
@@ -58,8 +55,12 @@
     "duplex-passthrough": "github:diasdavid/duplex-passthrough",
     "ip-address": "^5.8.0",
     "lodash.contains": "^2.4.3",
+    "multiaddr": "^1.4.1",
     "multistream-select": "^0.6.5",
-    "protocol-buffers-stream": "^1.3.1"
+    "peer-id": "^0.6.6",
+    "peer-info": "^0.6.2",
+    "protocol-buffers-stream": "^1.3.1",
+    "run-parallel": "^1.1.6"
   },
   "aegir": {
     "webpack": {

src/index.js

@@ -4,9 +4,14 @@ const multistream = require('multistream-select')
 const identify = require('./identify')
 const DuplexPassThrough = require('duplex-passthrough')
 const contains = require('lodash.contains')
+const util = require('util')
+const EE = require('events').EventEmitter
+const parallel = require('run-parallel')
 
 exports = module.exports = Swarm
 
+util.inherits(Swarm, EE)
+
 function Swarm (peerInfo) {
   if (!(this instanceof Swarm)) {
     return new Swarm(peerInfo)
@@ -113,7 +118,13 @@ function Swarm (peerInfo) {
   }
 
   this.transport.close = (key, callback) => {
-    this.transports[key].close(callback)
+    const transport = this.transports[key]
+
+    if (!transport) {
+      return callback(new Error(`Trying to close non existing transport: ${key}`))
+    }
+
+    transport.close(callback)
   }
 
   // connections --
@@ -144,7 +155,23 @@ function Swarm (peerInfo) {
     // for listening
     this.handle(muxer.multicodec, (conn) => {
       const muxedConn = muxer(conn, true)
+
+      var peerIdForConn
+
       muxedConn.on('stream', (conn) => {
+        function gotId () {
+          if (peerIdForConn) {
+            conn.peerId = peerIdForConn
+            connHandler(conn)
+          } else {
+            setTimeout(gotId, 100)
+          }
+        }
+
+        if (this.identify) {
+          return gotId()
+        }
+
         connHandler(conn)
       })
 
@@ -154,9 +181,18 @@ function Swarm (peerInfo) {
           if (err) {
             return console.log('Identify exec failed', err)
           }
+
+          peerIdForConn = pi.id
           this.muxedConns[pi.id.toB58String()] = {}
           this.muxedConns[pi.id.toB58String()].muxer = muxedConn
           this.muxedConns[pi.id.toB58String()].conn = conn // to be able to extract addrs
+
+          self.emit('peer-mux-established', pi)
+
+          muxedConn.on('close', () => {
+            delete self.muxedConns[pi.id.toB58String()]
+            self.emit('peer-mux-closed', pi)
+          })
         })
       }
     })
@@ -181,17 +217,29 @@ function Swarm (peerInfo) {
     msS.handle(conn)
   }
 
+  function availableTransports (pi) {
+    const addrs = pi.multiaddrs
+    return Object.keys(self.transports).filter((ts) => {
+      // Only listen on transports we actually have addresses for
+      return self.transports[ts].filter(addrs).length > 0
+    })
+  }
+
   // higher level (public) API
   this.dial = (pi, protocol, callback) => {
-    var pt = null
     if (typeof protocol === 'function') {
       callback = protocol
       protocol = null
-    } else {
-      pt = new DuplexPassThrough()
     }
 
+    if (!callback) {
+      callback = function noop () {}
+    }
+
+    const pt = new DuplexPassThrough()
+
     const b58Id = pi.id.toB58String()
+
     if (!this.muxedConns[b58Id]) {
       if (!this.conns[b58Id]) {
         attemptDial(pi, (err, conn) => {
@@ -206,6 +254,9 @@ function Swarm (peerInfo) {
         gotWarmedUpConn(conn)
       }
     } else {
+      if (!protocol) {
+        return callback()
+      }
       gotMuxer(this.muxedConns[b58Id].muxer)
     }
 
@@ -236,7 +287,7 @@ function Swarm (peerInfo) {
     }
 
     function attemptDial (pi, cb) {
-      const tKeys = Object.keys(self.transports)
+      const tKeys = availableTransports(pi)
       nextTransport(tKeys.shift())
 
       function nextTransport (key) {
@@ -284,14 +335,25 @@ function Swarm (peerInfo) {
             self.muxedConns[b58Id].muxer = muxedConn
             self.muxedConns[b58Id].conn = conn
 
+            self.emit('peer-mux-established', pi)
+
+            muxedConn.on('close', () => {
+              delete self.muxedConns[pi.id.toB58String()]
+              self.emit('peer-mux-closed', pi)
+            })
+
             // in case identify is on
-            muxedConn.on('stream', connHandler)
+            muxedConn.on('stream', (conn) => {
+              conn.peerId = pi.id
+              connHandler(conn)
+            })
 
             cb(null, muxedConn)
           })
         })
       }
     }
+
     function openConnInMuxedConn (muxer, cb) {
       cb(muxer.newStream())
     }
@@ -305,30 +367,39 @@ function Swarm (peerInfo) {
           }
 
           pt.wrapStream(conn)
+          pt.peerId = pi.id
           callback(null, pt)
         })
       })
     }
   }
 
+  // Start listening on all available transports
+  this.listen = (callback) => {
+    parallel(availableTransports(peerInfo).map((ts) => (cb) => {
+      // Listen on the given transport
+      this.transport.listen(ts, {}, null, cb)
+    }), callback)
+  }
+
   this.handle = (protocol, handler) => {
     this.protocols[protocol] = handler
   }
 
-  this.close = (callback) => {
-    var count = 0
+  this.unhandle = (protocol, handler) => {
+    if (this.protocols[protocol]) {
+      delete this.protocols[protocol]
+    }
+  }
 
+  this.close = (callback) => {
     Object.keys(this.muxedConns).forEach((key) => {
       this.muxedConns[key].muxer.end()
     })
 
-    Object.keys(this.transports).forEach((key) => {
-      this.transports[key].close(() => {
-        if (++count === Object.keys(this.transports).length) {
-          callback()
-        }
-      })
-    })
+    parallel(Object.keys(this.transports).map((key) => {
+      return (cb) => this.transports[key].close(cb)
+    }), callback)
   }
 }
 

test/00-basic.node.js

@@ -6,8 +6,7 @@ const expect = require('chai').expect
 const Swarm = require('../src')
 
 describe('basics', () => {
-  it('throws on missing peerInfo', (done) => {
-    expect(Swarm).to.throw(Error)
-    done()
+  it('throws on missing peerInfo', () => {
+    expect(() => Swarm()).to.throw(Error)
   })
 })

test/01-transport-tcp.node.js

@@ -3,6 +3,7 @@
 
 const expect = require('chai').expect
 
+const parallel = require('run-parallel')
 const multiaddr = require('multiaddr')
 const Peer = require('peer-info')
 const Swarm = require('../src')
@@ -92,15 +93,10 @@ describe('transport - tcp', function () {
   })
 
   it('close', (done) => {
-    var count = 0
-    swarmA.transport.close('tcp', closed)
-    swarmB.transport.close('tcp', closed)
-
-    function closed () {
-      if (++count === 2) {
-        done()
-      }
-    }
+    parallel([
+      (cb) => swarmA.transport.close('tcp', cb),
+      (cb) => swarmB.transport.close('tcp', cb)
+    ], done)
   })
 
   it('support port 0', (done) => {

test/03-transport-websockets.node.js

@@ -3,6 +3,7 @@
 
 const expect = require('chai').expect
 
+const parallel = require('run-parallel')
 const multiaddr = require('multiaddr')
 const Peer = require('peer-info')
 const Swarm = require('../src')
@@ -17,12 +18,11 @@ describe('transport - websockets', function () {
   var peerA = new Peer()
   var peerB = new Peer()
 
-  before((done) => {
+  before(() => {
     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) => {
@@ -35,16 +35,14 @@ describe('transport - websockets', function () {
   })
 
   it('listen', (done) => {
-    var count = 0
-    swarmA.transport.listen('ws', {}, (conn) => {
+    parallel([
+      (cb) => swarmA.transport.listen('ws', {}, (conn) => {
         conn.pipe(conn)
-    }, ready)
-    swarmB.transport.listen('ws', {}, (conn) => {
+      }, cb),
+      (cb) => swarmB.transport.listen('ws', {}, (conn) => {
         conn.pipe(conn)
-    }, ready)
-
-    function ready () {
-      if (++count === 2) {
+      }, cb)
+    ], () => {
       expect(peerA.multiaddrs.length).to.equal(1)
       expect(
         peerA.multiaddrs[0].equals(multiaddr('/ip4/127.0.0.1/tcp/9888/websockets'))
@@ -58,8 +56,7 @@ describe('transport - websockets', function () {
         true
       )
       done()
-      }
-    }
+    })
   })
 
   it('dial', (done) => {
@@ -88,14 +85,9 @@ describe('transport - websockets', function () {
   })
 
   it('close', (done) => {
-    var count = 0
-    swarmA.transport.close('ws', closed)
-    swarmB.transport.close('ws', closed)
-
-    function closed () {
-      if (++count === 2) {
-        done()
-      }
-    }
+    parallel([
+      (cb) => swarmA.transport.close('ws', cb),
+      (cb) => swarmB.transport.close('ws', cb)
+    ], done)
   })
 })

test/04-muxing-multiplex.node.js

@@ -3,6 +3,7 @@
 
 const expect = require('chai').expect
 
+const parallel = require('run-parallel')
 const multiaddr = require('multiaddr')
 const Peer = require('peer-info')
 const Swarm = require('../src')
@@ -10,7 +11,7 @@ const TCP = require('libp2p-tcp')
 const multiplex = require('libp2p-spdy')
 
 describe('stream muxing with multiplex (on TCP)', function () {
-  this.timeout(20000)
+  this.timeout(60 * 1000)
 
   var swarmA
   var peerA
@@ -37,35 +38,22 @@ describe('stream muxing with multiplex (on TCP)', function () {
     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()
-      }
-    }
+    parallel([
+      (cb) => swarmA.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmB.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmC.transport.listen('tcp', {}, null, cb)
+    ], done)
   })
 
   after((done) => {
-    var counter = 0
-
-    swarmA.close(closed)
-    swarmB.close(closed)
-    swarmC.close(closed)
-
-    function closed () {
-      if (++counter === 3) {
-        done()
-      }
-    }
+    parallel([
+      (cb) => swarmA.close(cb),
+      (cb) => swarmB.close(cb),
+      (cb) => swarmC.close(cb)
+    ], done)
   })
 
   it('add', (done) => {

test/05-muxing-spdy.node.js

@@ -3,6 +3,7 @@
 
 const expect = require('chai').expect
 
+const parallel = require('run-parallel')
 const multiaddr = require('multiaddr')
 const Peer = require('peer-info')
 const Swarm = require('../src')
@@ -10,7 +11,7 @@ const TCP = require('libp2p-tcp')
 const spdy = require('libp2p-spdy')
 
 describe('stream muxing with spdy (on TCP)', function () {
-  this.timeout(20000)
+  this.timeout(60 * 1000)
 
   var swarmA
   var peerA
@@ -37,42 +38,28 @@ describe('stream muxing with spdy (on TCP)', function () {
     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()
-      }
-    }
+    parallel([
+      (cb) => swarmA.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmB.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmC.transport.listen('tcp', {}, null, cb)
+    ], done)
   })
 
   after((done) => {
-    var counter = 0
-
-    swarmA.close(closed)
-    swarmB.close(closed)
-    swarmC.close(closed)
-
-    function closed () {
-      if (++counter === 3) {
-        done()
-      }
-    }
+    parallel([
+      (cb) => swarmA.close(cb),
+      (cb) => swarmB.close(cb)
+      // (cb) => swarmC.close(cb)
+    ], done)
   })
 
-  it('add', (done) => {
+  it('add', () => {
     swarmA.connection.addStreamMuxer(spdy)
     swarmB.connection.addStreamMuxer(spdy)
     swarmC.connection.addStreamMuxer(spdy)
-    done()
   })
 
   it('handle + dial on protocol', (done) => {
@@ -128,4 +115,12 @@ describe('stream muxing with spdy (on TCP)', function () {
       }, 500)
     })
   })
+
+  it('close one end, make sure the other does not blow', (done) => {
+    swarmC.close((err) => {
+      if (err) throw err
+      // to make sure it has time to propagate
+      setTimeout(done, 1000)
+    })
+  })
 })

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

@@ -4,9 +4,6 @@
 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

@@ -2,9 +2,6 @@
 '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

@@ -3,6 +3,7 @@
 
 const expect = require('chai').expect
 
+const parallel = require('run-parallel')
 const multiaddr = require('multiaddr')
 const Peer = require('peer-info')
 const Swarm = require('../src')
@@ -27,31 +28,19 @@ describe('high level API - 1st without stream multiplexing (on TCP)', function (
     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()
-      }
-    }
+    parallel([
+      (cb) => swarmA.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmB.transport.listen('tcp', {}, null, cb)
+    ], done)
   })
 
   after((done) => {
-    var counter = 0
-
-    swarmA.close(closed)
-    swarmB.close(closed)
-
-    function closed () {
-      if (++counter === 2) {
-        done()
-      }
-    }
+    parallel([
+      (cb) => swarmA.close(cb),
+      (cb) => swarmB.close(cb)
+    ], done)
   })
 
   it('handle a protocol', (done) => {
@@ -103,4 +92,11 @@ describe('high level API - 1st without stream multiplexing (on TCP)', function (
       conn.on('end', done)
     })
   })
+
+  it('unhandle', (done) => {
+    const proto = '/bananas/1.0.0'
+    swarmA.unhandle(proto)
+    expect(swarmA.protocols[proto]).to.not.exist
+    done()
+  })
 })

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

@@ -3,6 +3,7 @@
 
 const expect = require('chai').expect
 
+const parallel = require('run-parallel')
 const multiaddr = require('multiaddr')
 const Peer = require('peer-info')
 const Swarm = require('../src')
@@ -45,19 +46,13 @@ describe('high level API - with everything mixed all together!', function () {
   })
 
   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()
-      }
-    }
+    parallel([
+      (cb) => swarmA.close(cb),
+      (cb) => swarmB.close(cb),
+      // (cb) => swarmC.close(cb),
+      (cb) => swarmD.close(cb),
+      (cb) => swarmE.close(cb)
+    ], done)
   })
 
   it('add tcp', (done) => {
@@ -66,21 +61,14 @@ describe('high level API - with everything mixed all together!', function () {
     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()
-      }
-    }
+    parallel([
+      (cb) => swarmA.transport.listen('tcp', {}, null, cb),
+      (cb) => swarmB.transport.listen('tcp', {}, null, cb)
+      // (cb) => swarmC.transport.listen('tcp', {}, null, cb)
+    ], done)
   })
 
   it.skip('add utp', (done) => {})
@@ -92,27 +80,23 @@ describe('high level API - with everything mixed all together!', function () {
     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()
-      }
-    }
+    parallel([
+      (cb) => swarmB.transport.listen('ws', {}, null, cb),
+      // (cb) => swarmC.transport.listen('ws', {}, null, cb),
+      (cb) => swarmD.transport.listen('ws', {}, null, cb),
+      (cb) => swarmE.transport.listen('ws', {}, null, cb)
+    ], done)
   })
 
-  it('add spdy', (done) => {
+  it('listen automatically', (done) => {
+    swarmC.listen(done)
+  })
+
+  it('add spdy', () => {
     swarmA.connection.addStreamMuxer(spdy)
     swarmB.connection.addStreamMuxer(spdy)
     swarmC.connection.addStreamMuxer(spdy)
@@ -124,13 +108,37 @@ describe('high level API - with everything mixed all together!', function () {
     swarmC.connection.reuse()
     swarmD.connection.reuse()
     swarmE.connection.reuse()
-
-    done()
   })
 
-  it.skip('add multiplex', (done) => {})
+  it.skip('add multiplex', () => {})
 
-  it('dial from tcp to tcp+ws', (done) => {
+  it('warm up from A to B on tcp to tcp+ws', (done) => {
+    parallel([
+      (cb) => swarmB.once('peer-mux-established', (peerInfo) => {
+        expect(peerInfo.id.toB58String()).to.equal(peerA.id.toB58String())
+        cb()
+      }),
+      (cb) => swarmA.once('peer-mux-established', (peerInfo) => {
+        expect(peerInfo.id.toB58String()).to.equal(peerB.id.toB58String())
+        cb()
+      }),
+      (cb) => swarmA.dial(peerB, (err) => {
+        expect(err).to.not.exist
+        expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+        cb()
+      })
+    ], done)
+  })
+
+  it('warm up a warmed up, from B to A', (done) => {
+    swarmB.dial(peerA, (err) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmA.muxedConns).length).to.equal(1)
+      done()
+    })
+  })
+
+  it('dial from tcp to tcp+ws, on protocol', (done) => {
     swarmB.handle('/anona/1.0.0', (conn) => {
       conn.pipe(conn)
     })
@@ -145,6 +153,14 @@ describe('high level API - with everything mixed all together!', function () {
     })
   })
 
+  it('dial from ws to ws no proto', (done) => {
+    swarmD.dial(peerE, (err) => {
+      expect(err).to.not.exist
+      expect(Object.keys(swarmD.muxedConns).length).to.equal(1)
+      done()
+    })
+  })
+
   it('dial from ws to ws', (done) => {
     swarmE.handle('/abacaxi/1.0.0', (conn) => {
       conn.pipe(conn)
@@ -182,11 +198,13 @@ describe('high level API - with everything mixed all together!', function () {
 
   it('dial from tcp+ws to tcp+ws', (done) => {
     swarmC.handle('/mamao/1.0.0', (conn) => {
+      expect(conn.peerId).to.exist
       conn.pipe(conn)
     })
 
     swarmA.dial(peerC, '/mamao/1.0.0', (err, conn) => {
       expect(err).to.not.exist
+      expect(conn.peerId).to.exist
       expect(Object.keys(swarmA.muxedConns).length).to.equal(2)
       conn.end()
 
@@ -194,4 +212,11 @@ describe('high level API - with everything mixed all together!', function () {
       conn.on('end', done)
     })
   })
+
+  it('close a muxer emits event', (done) => {
+    parallel([
+      (cb) => swarmC.close(cb),
+      (cb) => swarmA.once('peer-mux-closed', () => cb())
+    ], done)
+  })
 })

test/browser.js

@@ -22,14 +22,12 @@ describe('transport - websockets', function () {
 
   var swarm
 
-  before((done) => {
+  before(() => {
     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) => {
@@ -62,28 +60,24 @@ describe('high level API - 1st without stream multiplexing (on websockets)', fun
   var swarm
   var peerDst
 
-  before((done) => {
+  before(() => {
     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)
+    swarm.close(done)
   })
 
-  it('add ws', (done) => {
+  it('add ws', () => {
     swarm.transport.add('ws', new WebSockets())
     expect(Object.keys(swarm.transports).length).to.equal(1)
-    done()
   })
 
-  it('create Dst peer info', (done) => {
+  it('create Dst peer info', () => {
     const b58IdDst = 'QmYzgdesgjdvD3okTPGZT9NPmh1BuH5FfTVNKjsvaAprhb'
     // use a pre generated Id to save time
     const idDst = Id.createFromB58String(b58IdDst)
@@ -91,7 +85,6 @@ describe('high level API - 1st without stream multiplexing (on websockets)', fun
 
     const ma = multiaddr('/ip4/127.0.0.1/tcp/9200/websockets')
     peerDst.multiaddr.add(ma)
-    done()
   })
 
   it('dial on protocol', (done) => {