A few BUGFIXES and new tests to cover those scenarios

gulpfile.js

@@ -1,9 +1,11 @@
 'use strict'
 
 const gulp = require('gulp')
+const parallel = require('async/parallel')
+
 const sigServer = require('./src/signalling')
 
-let sigS
+let sigS, sigS2
 
 gulp.task('test:node:before', boot)
 gulp.task('test:node:after', stop)
@@ -15,19 +17,47 @@ function boot (done) {
     port: 15555,
     host: '127.0.0.1'
   }
+  const options2 = {
+    port: 15556,
+    host: '127.0.0.1'
+  }
 
-  sigServer.start(options, (err, server) => {
-    if (err) {
-      throw err
-    }
-    sigS = server
-    console.log('signalling on:', server.info.uri)
-    done()
-  })
+  parallel([
+    first,
+    second
+  ], done)
+  function first () {
+    sigServer.start(options, (err, server) => {
+      if (err) {
+        throw err
+      }
+      sigS = server
+      console.log('signalling on:', server.info.uri)
+    })
+  }
+  function second () {
+    sigServer.start(options2, (err, server) => {
+      if (err) {
+        throw err
+      }
+      sigS2 = server
+      console.log('signalling 2 on:', server.info.uri)
+      done()
+    })
+  }
 }
 
 function stop (done) {
-  sigS.stop(done)
+  parallel([
+    first,
+    second
+  ], done)
+  function first (done) {
+    sigS.stop(() => done())
+  }
+  function second (done) {
+    sigS2.stop(() => done())
+  }
 }
 
 require('aegir/gulp')(gulp)

src/webrtc-star/index.js

@@ -26,7 +26,6 @@ function WebRTCStar () {
     return new WebRTCStar()
   }
 
-  let maSelf
   const listeners = {}
   this.discovery = new EE()
 
@@ -36,12 +35,14 @@ function WebRTCStar () {
       options = {}
     }
 
-    if (!callback) {
-      callback = function noop () {}
-    }
+    callback = callback || function () {}
 
     const intentId = (~~(Math.random() * 1e9)).toString(36) + Date.now()
-    const sioClient = listeners[Object.keys(listeners)[0]].io
+    const keys = Object.keys(listeners)
+                      .filter((key) => key.startsWith(ma.toString().substring(0, ma.toString().lastIndexOf('/'))))
+    const listener = listeners[keys[0]]
+    if (!listener) return callback(new Error('signalling server not connected'))
+    const sioClient = listener.io
 
     const spOptions = {
       initiator: true,
@@ -58,7 +59,7 @@ function WebRTCStar () {
     channel.on('signal', function (signal) {
       sioClient.emit('ss-handshake', {
         intentId: intentId,
-        srcMultiaddr: maSelf.toString(),
+        srcMultiaddr: listener.ma.toString(),
         dstMultiaddr: ma.toString(),
         signal: signal
       })
@@ -113,14 +114,12 @@ function WebRTCStar () {
     const listener = new EE()
 
     listener.listen = (ma, callback) => {
-      if (!callback) {
-        callback = function noop () {}
-      }
-      maSelf = ma
+      callback = callback || function () {}
 
       const sioUrl = 'http://' + ma.toString().split('/')[3] + ':' + ma.toString().split('/')[5]
 
       listener.io = io.connect(sioUrl, sioOptions)
+      listener.ma = ma
 
       listener.io.on('connect_error', callback)
       listener.io.on('error', (err) => {
@@ -135,8 +134,25 @@ function WebRTCStar () {
         listener.io.on('ws-handshake', incommingDial)
         listener.io.on('ws-peer', peerDiscovered.bind(this))
         listener.emit('listening')
+        listeners[ma.toString()] = listener
         callback()
       })
+      listener.close = (callback) => {
+        callback = callback || function () {}
+
+        listener.io.emit('ss-leave', ma.toString())
+        setTimeout(() => {
+          listener.io.disconnect()
+          delete listeners[ma.toString()]
+          listener.emit('close')
+          callback()
+        }, 100)
+      }
+      listener.getAddrs = (callback) => {
+        setImmediate(() => {
+          callback(null, [ma])
+        })
+      }
 
       function incommingDial (offer) {
         if (offer.answer || offer.err) {
@@ -172,24 +188,6 @@ function WebRTCStar () {
       }
     }
 
-    listener.close = (callback) => {
-      if (!callback) {
-        callback = function noop () {}
-      }
-      listener.io.emit('ss-leave')
-      setTimeout(() => {
-        listener.emit('close')
-        callback()
-      }, 100)
-    }
-
-    listener.getAddrs = (callback) => {
-      process.nextTick(() => {
-        callback(null, [maSelf])
-      })
-    }
-
-    listeners[multiaddr.toString()] = listener
     return listener
   }
 

test/webrtc-star/test-dial.js

@@ -75,3 +75,108 @@ describe('dial', () => {
     // TODO IPv6 not supported yet
   })
 })
+describe('complex dial scenarios', () => {
+  let ws1, ws2, ws3
+  const ma1a = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooA1')
+  const ma1b = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooA2')
+  const ma1c = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15556/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooA3')
+  const ma2 = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15555/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooB1')
+  const ma3 = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.1/tcp/15556/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSoooC1')
+  before((done) => {
+    series([
+      first,
+      second,
+      third,
+      fourth,
+      fifth
+    ], done)
+
+    function first (next) {
+      ws1 = new WebRTCStar()
+
+      const listener = ws1.createListener((conn) => {
+        pull(conn, conn)
+      })
+
+      // close immediately
+      listener.listen(ma1a, () => {
+        listener.close(next)
+      })
+    }
+
+    function second (next) {
+      const listener = ws1.createListener((conn) => {
+        pull(conn, conn)
+      })
+
+      listener.listen(ma1b, next)
+    }
+    function third (next) {
+      const listener = ws1.createListener((conn) => {
+        pull(conn, conn)
+      })
+
+      listener.listen(ma1c, next)
+    }
+
+    function fourth (next) {
+      ws2 = new WebRTCStar()
+
+      const listener = ws2.createListener((conn) => {
+        pull(conn, conn)
+      })
+      listener.listen(ma2, next)
+    }
+    function fifth (next) {
+      ws3 = new WebRTCStar()
+
+      const listener = ws3.createListener((conn) => {
+        pull(conn, conn)
+      })
+      listener.listen(ma3, next)
+    }
+  })
+
+  it('dial closed listener should error', (done) => {
+    ws2.dial(ma1a, (err, conn) => {
+      expect(err).to.exist
+      done()
+    })
+  })
+
+  it('dial after first listener is closed and its signalling connection disconnected', (done) => {
+    ws1.dial(ma2, (err, conn) => {
+      expect(err).to.not.exist
+
+      const data = new Buffer('some data')
+
+      pull(
+        pull.values([data]),
+        conn,
+        pull.collect((err, values) => {
+          expect(err).to.not.exist
+          expect(values).to.be.eql([data])
+          done()
+        })
+      )
+    })
+  })
+  it('dial a second node on a different signaling server', (done) => {
+    ws1.dial(ma3, (err, conn) => {
+      expect(err).to.not.exist
+
+      const data = new Buffer('some data')
+
+      pull(
+        pull.values([data]),
+        conn,
+        pull.collect((err, values) => {
+          expect(err).to.not.exist
+          expect(values).to.be.eql([data])
+          done()
+        })
+      )
+    })
+  })
+})
+

test/webrtc-star/test-listen.js

@@ -42,6 +42,16 @@ describe('listen', () => {
     })
   })
 
+  it('listen on offline signalling server should error', (done) => {
+    let maOfflineSigServer = multiaddr('/libp2p-webrtc-star/ip4/127.0.0.0/tcp/15555/ws/ipfs/QmcgpsyWgH8Y8ajJz1Cu72KnS5uo2Aa2LpzU7kinSooooA')
+    const listener = ws.createListener((conn) => {})
+    listener.listen(maOfflineSigServer, (err) => {
+      expect(err).to.exist
+      listener.once('close', done)
+      listener.close()
+    })
+  })
+
   it.skip('close listener with connections, through timeout', (done) => {
     // TODO ? Should this apply ?
   })