Improving test coverage

.travis.yml

@@ -2,6 +2,15 @@ language: node_js
 node_js:
   - "4"
   - "5"
+env:
+  - CXX=g++-4.8 #need that for the buffertools dependency
+addons:
+  apt:
+    sources:
+      - ubuntu-toolchain-r-test
+    packages:
+      - g++-4.8
+
 
 branches:
   only:

src/lib/interactive.js

@@ -48,6 +48,7 @@ function Interactive () {
       if (msgBuffer.toString().slice(0, -1) === 'na') {
         return callback(new Error(protocol + ' not supported'))
       }
+    // todo: function doesn't bark if response has not been recognized effectively locking socket
     })
   }
 }

src/lib/silent.js

@@ -23,7 +23,7 @@ function Silent () {
         callback()
       } else {
         duplexStream.end()
-        callback(new Error('Received non supported MultiStream version' + msg))
+        callback(new Error('Received non supported MultiStream version ' + msg))
       }
     })
   }
@@ -34,7 +34,6 @@ function Silent () {
       if (msg === protocol) {
         return callback(null, self.duplexStream)
       } else {
-        self.duplexStream.end()
         callback(new Error('Received non supported Protocol or Version: ' + msg))
       }
     })

tests/impl/interactive-test.js

@@ -10,6 +10,8 @@ var expect = Code.expect
 
 var tcp = require('net')
 var MultiStream = require('../../src/')
+var PROTOCOLID = require('../../src/lib/protocol-id')
+var lpm = require('length-prefixed-message')
 
 experiment('Node.js Implementation: ', function () {
   var msS
@@ -30,12 +32,40 @@ experiment('Node.js Implementation: ', function () {
     done()
   })
 
+  test('create a Select MultiStream via function', function (done) {
+    expect(MultiStream.Select.createSelect()).to.be.an.instanceof(MultiStream.Select)
+    done()
+  })
+
+  test('throw an error if Select function is misused', function (done) {
+    try {
+      MultiStream.Select()
+    } catch (e) {
+      expect(e.message).to.equal('Select must be called with new, or used with createSelect')
+      done()
+    }
+  })
+
   test('create a Interactive MultiStream()', function (done) {
     msI = new MultiStream.Interactive()
     expect(msI).to.be.an.instanceof(MultiStream.Interactive)
     done()
   })
 
+  test('create a Interactive MultiStream() via utility function', function (done) {
+    expect(MultiStream.Interactive.createInteractive()).to.be.an.instanceof(MultiStream.Interactive)
+    done()
+  })
+
+  test('throw an error if Interactive function is misused', function (done) {
+    try {
+      MultiStream.Interactive()
+    } catch (e) {
+      expect(e.message).to.equal('MultiStream must be called with new, or used with createMultiStream')
+      done()
+    }
+  })
+
   test('attach a duplex stream to Select MultiStream (tcp server)', function (done) {
     tcp.createServer(function (socket) {
       msS.handle(socket)
@@ -91,4 +121,56 @@ experiment('Node.js Implementation: ', function () {
       })
     })
   })
+
+  test('Select closes connection for non supported protocol', function (done) {
+    var select = new MultiStream.Select()
+    tcp.createServer(function (socket) {
+      select.handle(socket)
+      socket.on('end', function () {
+        done()
+      })
+    }).listen(8011)
+
+    var socket = tcp.connect({port: 8011}, function tcpConnectionOpen () {
+      lpm.write(socket, PROTOCOLID + '\n')
+      lpm.write(socket, 'na\n')
+    })
+  })
+
+  test('Interactive responds with `na` for wrong protocol', function (done) {
+    var interactive = new MultiStream.Interactive()
+    var server = tcp.createServer(function (socket) {
+      interactive.handle(socket)
+    })
+    server.listen(8012)
+
+    var socket = tcp.connect({port: 8012}, function tcpConnectionOpen () {
+      lpm.write(socket, '/garbage/1.2.3\n')
+    })
+    socket.on('data', function (data) {
+      if (data.toString().indexOf('na\n') >= 0) {
+        done()
+      }
+    })
+  })
+
+  test('Interactive handles `na` handler response', function (done) {
+    var interactive = new MultiStream.Interactive()
+    tcp.createServer(function (socket) {
+      interactive.handle(socket, function () {
+        interactive.select('skipping')
+        interactive.select('whatever', function (err) {
+          expect(err.message).to.equal('whatever not supported')
+          done()
+        })
+      })
+    }).listen(8013)
+
+    var socket = tcp.connect({port: 8013}, function tcpConnectionOpen () {
+      lpm.write(socket, PROTOCOLID + '\n')
+      lpm.write(socket, 'nan\n')
+      lpm.write(socket, 'na\n')
+    })
+  })
+
 })

tests/impl/one-way-test.js

@@ -1,6 +1,7 @@
 var Lab = require('lab')
 var Code = require('code')
 var lab = exports.lab = Lab.script()
+var lpm = require('length-prefixed-message')
 
 var experiment = lab.experiment
 var test = lab.test
@@ -29,12 +30,40 @@ experiment('Node.js Implementation: ', function () {
     done()
   })
 
+  test('create a Broadcast MultiStream via utility function', function (done) {
+    expect(MultiStream.Broadcast.createBroadcast()).to.be.an.instanceof(MultiStream.Broadcast)
+    done()
+  })
+
+  test('throw an error if Broadcast function is misused', function (done) {
+    try {
+      MultiStream.Broadcast()
+    } catch (e) {
+      expect(e.message).to.equal('Broadcast must be called with new, or used with Broadcast')
+      done()
+    }
+  })
+
   test('create a Silent MultiStream()', function (done) {
     msS = new MultiStream.Silent()
     expect(msS).to.be.an.instanceof(MultiStream.Silent)
     done()
   })
 
+  test('create a Silent MultiStream via utility function', function (done) {
+    expect(MultiStream.Silent.createSilent()).to.be.an.instanceof(MultiStream.Silent)
+    done()
+  })
+
+  test('throw an error if Silent function is misused', function (done) {
+    try {
+      MultiStream.Silent()
+    } catch (e) {
+      expect(e.message).to.equal('Silent must be called with new, or used with Silent')
+      done()
+    }
+  })
+
   test('attach a stream to Broadcast MultiStream (tcp server)', function (done) {
     tcp.createServer(function (socket) {
       msB.handle(socket)
@@ -68,4 +97,19 @@ experiment('Node.js Implementation: ', function () {
 
   })
 
+  test('closing socket for unsupported protocol', function (done) {
+    var acc = new MultiStream.Silent()
+    tcp.createServer(function (socket) {
+      acc.handle(socket, function (err) {
+        expect(err.message).to.equal('Received non supported MultiStream version /garbage/1.0.0')
+        socket.on('end', done)
+
+      })
+    }).listen(8021)
+
+    var socket = tcp.connect({port: 8021}, function tcpConnectionOpen () {
+      lpm.write(socket, '/garbage/1.0.0\n')
+    })
+  })
+
 })