test: actually test the parser

The assertions were not checked, because the functions are asynchronous.

Besides, the Blob tests were throwing in the browser:

> Uncaught ReferenceError: can't access lexical declaration 'BlobBuilder' before initialization

Author: darrachequesne

test/arraybuffer.js

@@ -4,17 +4,17 @@ const helpers = require('./helpers.js');
 const encoder = new Encoder();
 
 describe('parser', () => {
-  it('encodes an ArrayBuffer', () => {
+  it('encodes an ArrayBuffer', done => {
     var packet = {
       type: PacketType.BINARY_EVENT,
       data: ['a', new ArrayBuffer(2)],
       id: 0,
       nsp: '/'
     };
-    helpers.test_bin(packet);
+    helpers.test_bin(packet, done);
   });
 
-  it('encodes a TypedArray', () => {
+  it('encodes a TypedArray', done => {
     var array = new Uint8Array(5);
     for (var i = 0; i < array.length; i++) array[i] = i;
 
@@ -24,27 +24,27 @@ describe('parser', () => {
       id: 0,
       nsp: '/'
     };
-    helpers.test_bin(packet);
+    helpers.test_bin(packet, done);
   });
 
-  it('encodes ArrayBuffers deep in JSON', () => {
+  it('encodes ArrayBuffers deep in JSON', done => {
     var packet = {
       type: PacketType.BINARY_EVENT,
       data: ['a', {a: 'hi', b: {why: new ArrayBuffer(3)}, c: {a: 'bye', b: { a: new ArrayBuffer(6)}}}],
       id: 999,
       nsp: '/deep'
     };
-    helpers.test_bin(packet);
+    helpers.test_bin(packet, done);
   });
 
-  it('encodes deep binary JSON with null values', () => {
+  it('encodes deep binary JSON with null values', done => {
     var packet = {
       type: PacketType.BINARY_EVENT,
       data: ['a', {a: 'b', c: 4, e: {g: null}, h: new ArrayBuffer(9)}],
       nsp: '/',
       id: 600
     };
-    helpers.test_bin(packet);
+    helpers.test_bin(packet, done);
   });
 
   it('cleans itself up on close', () => {

test/blob.js

@@ -1,67 +1,67 @@
 const { PacketType } = require('..');
 const helpers = require('./helpers.js');
 
-const BlobBuilder = typeof BlobBuilder !== 'undefined' ? BlobBuilder :
+const BlobBuilderImpl = typeof BlobBuilder !== 'undefined' ? BlobBuilder :
                   typeof WebKitBlobBuilder !== 'undefined' ? WebKitBlobBuilder :
                   typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder :
                   typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder : false;
 
 describe('parser', () => {
-  it('encodes a Blob', () => {
-    var data;
-    if (BlobBuilder) {
-      var bb = new BlobBuilder();
+  it('encodes a Blob', (done) => {
+    let data;
+    if (BlobBuilderImpl) {
+      const bb = new BlobBuilderImpl();
       bb.append(new ArrayBuffer(2));
       data = bb.getBlob();
     } else {
       data = new Blob([new ArrayBuffer(2)]);
     }
 
-    var packet = {
+    const packet = {
       type: PacketType.BINARY_EVENT,
-      data: data,
+      data: [data],
       id: 0,
       nsp: '/'
     };
-    helpers.test_bin(packet);
+    helpers.test_bin(packet, done);
   });
 
-  it('encodes an Blob deep in JSON', () => {
-    var data;
-    if (BlobBuilder) {
-      var bb = new BlobBuilder();
+  it('encodes an Blob deep in JSON', (done) => {
+    let data;
+    if (BlobBuilderImpl) {
+      const bb = new BlobBuilderImpl();
       bb.append(new ArrayBuffer(2));
       data = bb.getBlob();
     } else {
       data = new Blob([new ArrayBuffer(2)]);
     }
 
-    var packet = {
+    const packet = {
       type: PacketType.BINARY_EVENT,
-      data: {a: 'hi', b: { why: data }, c: 'bye'},
+      data: [{a: 'hi', b: {why: data}, c: 'bye'}],
       id: 999,
       nsp: '/deep'
     };
-    helpers.test_bin(packet);
+    helpers.test_bin(packet, done);
   });
 
-  it('encodes a binary ack with a blob', () => {
-    var data;
-    if (BlobBuilder) {
-      var bb = new BlobBuilder();
+  it('encodes a binary ack with a blob', (done) => {
+    let data;
+    if (BlobBuilderImpl) {
+      const bb = new BlobBuilderImpl();
       bb.append(new ArrayBuffer(2));
       data = bb.getBlob();
     } else {
       data = new Blob([new ArrayBuffer(2)]);
     }
 
-    var packet = {
+    const packet = {
       type: PacketType.BINARY_ACK,
-      data: {a: 'hi ack', b: { why: data }, c: 'bye ack'},
+      data: [{a: 'hi ack', b: {why: data}, c: 'bye ack'}],
       id: 999,
       nsp: '/deep'
     };
-    helpers.test_bin(packet);
+    helpers.test_bin(packet, done);
   })
 
 });

test/buffer.js

@@ -2,21 +2,21 @@ const { PacketType } = require('..');
 const helpers = require('./helpers.js');
 
 describe('parser', () => {
-  it('encodes a Buffer', () => {
+  it('encodes a Buffer', done => {
       helpers.test_bin({
         type: PacketType.BINARY_EVENT,
         data: ['a', Buffer.from('abc', 'utf8')],
         id: 23,
         nsp: '/cool'
-      });
+      }, done);
   });
 
-  it('encodes a binary ack with Buffer', () => {
+  it('encodes a binary ack with Buffer', done => {
     helpers.test_bin({
       type: PacketType.BINARY_ACK,
       data: ['a', Buffer.from('xxx', 'utf8'), {}],
       id: 127,
       nsp: '/back'
-    })
+    }, done)
   });
 });

test/helpers.js

@@ -3,26 +3,28 @@ const expect = require('expect.js');
 const encoder = new parser.Encoder();
 
 // tests encoding and decoding a single packet
-module.exports.test = obj => {
+module.exports.test = (obj, done) => {
   encoder.encode(obj, encodedPackets => {
     const decoder = new parser.Decoder();
     decoder.on('decoded', packet => {
       expect(packet).to.eql(obj);
+      done();
     });
 
     decoder.add(encodedPackets[0]);
   });
 }
 
 // tests encoding of binary packets
-module.exports.test_bin = obj => {
+module.exports.test_bin = (obj, done) => {
   const originalData = obj.data;
   encoder.encode(obj, encodedPackets => {
     const decoder = new parser.Decoder();
     decoder.on('decoded', packet => {
       obj.data = originalData;
       obj.attachments = undefined;
       expect(obj).to.eql(packet);
+      done();
     });
 
     for (let i = 0; i < encodedPackets.length; i++) {

test/index.js

@@ -12,11 +12,11 @@ const blobSupported = (function () {
 /**
  * Create a blob builder even when vendor prefixes exist
  */
-const BlobBuilderRef = typeof BlobBuilder !== 'undefined' ? BlobBuilder :
+const BlobBuilderImpl = typeof BlobBuilder !== 'undefined' ? BlobBuilder :
   typeof WebKitBlobBuilder !== 'undefined' ? WebKitBlobBuilder :
     typeof MSBlobBuilder !== 'undefined' ? MSBlobBuilder :
       typeof MozBlobBuilder !== 'undefined' ? MozBlobBuilder : false;
-const blobBuilderSupported = !!BlobBuilderRef && !!BlobBuilderRef.prototype.append && !!BlobBuilderRef.prototype.getBlob;
+const blobBuilderSupported = !!BlobBuilderImpl && !!BlobBuilderImpl.prototype.append && !!BlobBuilderImpl.prototype.getBlob;
 
 require('./parser.js');
 

test/parser.js

@@ -14,49 +14,52 @@ describe('parser', () => {
     expect(PacketType.BINARY_ACK).to.be.a('number');
   });
 
-  it('encodes connection', () => {
+  it('encodes connection', done => {
     helpers.test({
       type: PacketType.CONNECT,
       nsp: '/woot'
-    });
+    }, done);
   });
 
-  it('encodes disconnection', () => {
+  it('encodes disconnection', done => {
     helpers.test({
       type: PacketType.DISCONNECT,
       nsp: '/woot'
-    });
+    }, done);
   });
 
-  it('encodes an event', () => {
+  it('encodes an event', done => {
     helpers.test({
       type: PacketType.EVENT,
       data: ['a', 1, {}],
       nsp: '/'
-    });
+    }, done);
+  });
+
+  it('encodes an event (with ack)', done => {
     helpers.test({
       type: PacketType.EVENT,
       data: ['a', 1, {}],
       id: 1,
       nsp: '/test'
-    });
+    }, done);
   });
 
-  it('encodes an ack', () => {
+  it('encodes an ack', done => {
     helpers.test({
       type: PacketType.ACK,
       data: ['a', 1, {}],
       id: 123,
       nsp: '/'
-    });
+    }, done);
   });
 
-  it('encodes an error', () => {
+  it('encodes an error', done => {
     helpers.test({
       type: PacketType.ERROR,
       data: 'Unauthorized',
       nsp: '/'
-    });
+    }, done);
   });
 
   it('throws an error when encoding circular objects', () => {