test: add libp2p-websocket-star tests

gulpfile.js

@@ -7,7 +7,9 @@ const PeerId = require('peer-id')
 const pull = require('pull-stream')
 
 const sigServer = require('libp2p-webrtc-star/src/sig-server')
+const WSsigServer = require('libp2p-websocket-star-signal')
 let server
+let server2
 
 let node
 const rawPeer = require('./test/browser-bundle/peer.json')
@@ -16,14 +18,28 @@ gulp.task('libnode:start', (done) => {
   let count = 0
   const ready = () => ++count === 2 ? done() : null
 
-  sigServer.start({ port: 15555 }, (err, _server) => {
+  sigServer.start({
+    port: 15555
+  }, (err, _server) => {
     if (err) {
       throw err
     }
     server = _server
     ready()
   })
 
+  WSsigServer.start({
+    port: 14444,
+    refreshPeerListIntervalMS: 1000,
+    strictMultiaddr: false
+  }, (err, _server) => {
+    if (err) {
+      throw err
+    }
+    server2 = _server
+    ready()
+  })
+
   PeerId.createFromJSON(rawPeer, (err, peerId) => {
     if (err) {
       return done(err)
@@ -39,12 +55,7 @@ gulp.task('libnode:start', (done) => {
 })
 
 gulp.task('libnode:stop', (done) => {
-  setTimeout(() => node.stop((err) => {
-    if (err) {
-      return done(err)
-    }
-    server.stop(done)
-  }), 2000)
+  setTimeout(() => require('async/each')([node, server, server2], (s, n) => s.stop(n), done), 2000)
 })
 
 gulp.task('test:browser:before', ['libnode:start'])

package.json

@@ -60,6 +60,8 @@
     "libp2p-tcp": "~0.11.0",
     "libp2p-webrtc-star": "~0.13.0",
     "libp2p-websockets": "~0.10.1",
+    "libp2p-websocket-star": "0.3.0-rc4",
+    "libp2p-websocket-star-signal": "0.3.0-rc4",
     "lodash.times": "^4.3.2",
     "pre-commit": "^1.2.2",
     "pull-goodbye": "0.0.2",
@@ -80,4 +82,4 @@
     "greenkeeperio-bot <support@greenkeeper.io>",
     "mayerwin <mayerwin@users.noreply.github.com>"
   ]
-}
+}

test/browser-bundle/browser-bundle.js

@@ -2,6 +2,7 @@
 
 const WS = require('libp2p-websockets')
 const WebRTCStar = require('libp2p-webrtc-star')
+const WebSocketStar = require('libp2p-websocket-star')
 const spdy = require('libp2p-spdy')
 const multiplex = require('libp2p-multiplex')
 const secio = require('libp2p-secio')
@@ -36,11 +37,13 @@ class Node extends libp2p {
   constructor (peerInfo, peerBook, options) {
     options = options || {}
     const webRTCStar = new WebRTCStar()
+    const wsStar = new WebSocketStar({ id: peerInfo.id })
 
     const modules = {
       transport: [
         new WS(),
-        webRTCStar
+        webRTCStar,
+        wsStar
       ],
       connection: {
         muxer: getMuxers(options.muxer),
@@ -55,6 +58,10 @@ class Node extends libp2p {
       modules.discovery.push(webRTCStar.discovery)
     }
 
+    if (options.wsStar) {
+      modules.discovery.push(wsStar.discovery)
+    }
+
     if (options.bootstrap) {
       const r = new Railing(options.bootstrap)
       modules.discovery.push(r)

test/browser-bundle/websocket-star-only.js

@@ -0,0 +1,121 @@
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const expect = chai.expect
+const PeerInfo = require('peer-info')
+const PeerId = require('peer-id')
+const parallel = require('async/parallel')
+const pull = require('pull-stream')
+
+const Node = require('./browser-bundle')
+
+describe('libp2p-ipfs-browser (websocket-star only)', () => {
+  let peer1
+  let peer2
+  let node1
+  let node2
+
+  it('create two peerInfo with websocket-star addrs', (done) => {
+    parallel([
+      (cb) => PeerId.create({ bits: 1024 }, cb),
+      (cb) => PeerId.create({ bits: 1024 }, cb)
+    ], (err, ids) => {
+      expect(err).to.not.exist()
+
+      peer1 = new PeerInfo(ids[0])
+      const ma1 = '/ip4/127.0.0.1/tcp/14444/ws/p2p-websocket-star/'
+      peer1.multiaddrs.add(ma1)
+
+      peer2 = new PeerInfo(ids[1])
+      const ma2 = '/ip4/127.0.0.1/tcp/14444/ws/p2p-websocket-star/'
+      peer2.multiaddrs.add(ma2)
+
+      done()
+    })
+  })
+
+  it('create two libp2p nodes with those peers', (done) => {
+    node1 = new Node(peer1, null, { wsStar: true })
+    node2 = new Node(peer2, null, { wsStar: true })
+    done()
+  })
+
+  it('listen on the two libp2p nodes', (done) => {
+    parallel([
+      (cb) => node1.start(cb),
+      (cb) => node2.start(cb)
+    ], done)
+  })
+
+  it('handle a protocol on the first node', () => {
+    node2.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn))
+  })
+
+  it('dial from the second node to the first node', (done) => {
+    node1.dial(peer2, '/echo/1.0.0', (err, conn) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        const text = 'hello'
+        const peers1 = node1.peerBook.getAll()
+        expect(Object.keys(peers1)).to.have.length(1)
+
+        const peers2 = node2.peerBook.getAll()
+        expect(Object.keys(peers2)).to.have.length(1)
+
+        pull(
+          pull.values([Buffer.from(text)]),
+          conn,
+          pull.collect((err, data) => {
+            expect(err).to.not.exist()
+            expect(data[0].toString()).to.equal(text)
+            done()
+          })
+        )
+      }
+    })
+  })
+
+  it('node1 hangUp node2', (done) => {
+    node1.hangUp(peer2, (err) => {
+      expect(err).to.not.exist()
+      setTimeout(check, 500)
+
+      function check () {
+        const peers = node1.peerBook.getAll()
+        expect(Object.keys(peers)).to.have.length(1)
+        expect(Object.keys(node1.swarm.muxedConns)).to.have.length(0)
+        done()
+      }
+    })
+  })
+
+  it('create a third node and check that discovery works', (done) => {
+    let counter = 0
+
+    function check () {
+      if (++counter === 3) {
+        expect(Object.keys(node1.swarm.muxedConns).length).to.equal(1)
+        expect(Object.keys(node2.swarm.muxedConns).length).to.equal(1)
+        done()
+      }
+    }
+
+    PeerId.create((err, id3) => {
+      expect(err).to.not.exist()
+
+      const peer3 = new PeerInfo(id3)
+      const ma3 = '/ip4/127.0.0.1/tcp/14444/ws/p2p-websocket-star/ipfs/' + id3.toB58String()
+      peer3.multiaddrs.add(ma3)
+
+      node1.on('peer:discovery', (peerInfo) => node1.dial(peerInfo, check))
+      node2.on('peer:discovery', (peerInfo) => node2.dial(peerInfo, check))
+
+      const node3 = new Node(peer3, null, { wsStar: true })
+      node3.start(check)
+    })
+  })
+})

test/browser.js

@@ -5,3 +5,4 @@ const w = require('webrtcsupport')
 require('./base')
 require('./browser-bundle/websockets-only')
 if (w.support) { require('./browser-bundle/webrtc-star-only') }
+require('./browser-bundle/websocket-star-only')

test/node.js

@@ -4,6 +4,7 @@ require('./base')
 require('./nodejs-bundle/tcp')
 require('./nodejs-bundle/tcp+websockets')
 require('./nodejs-bundle/tcp+websockets+webrtc-star')
+require('./nodejs-bundle/tcp+websockets+websocket-star')
 require('./nodejs-bundle/stream-muxing')
 require('./nodejs-bundle/discovery')
 require('./nodejs-bundle/peer-routing')