ws: removes mocha as a dependency

test/parallel/test-websockets-bufferpool.js

@@ -2,31 +2,36 @@
 const BufferPool = require('../../lib/internal/websockets/BufferPool');
 const assert = require('assert');
 
-describe('BufferPool', function() {
-  describe('#ctor', function() {
-    it('allocates pool', function() {
+/*'BufferPool'*/
+{
+  /*'#ctor'*/
+  {
+    /* 'allocates pool'*/
+    {
       var db = new BufferPool(1000);
       assert.equal(db.size, 1000);
-    });
-    it('throws TypeError when called without new', function(done) {
-      // try {
-      //   var db = BufferPool(1000);
-      // } catch (e) {
-      //   assert.ifError(e)
-      //   done()
-      // }
-      done()
-    });
-  });
-  describe('#get', function() {
-    it('grows the pool if necessary', function() {
+    }
+    /*'throws TypeError when called without new'*/
+    {
+      try {
+        var db = BufferPool(1000);
+      } catch (e) {
+        assert.ok(e instanceof TypeError);
+      }
+    }
+  }
+  /*'#get'*/
+  {
+    /*'grows the pool if necessary'*/
+    {
       var db = new BufferPool(1000);
       var buf = db.get(2000);
       assert.ok(db.size > 1000);
       assert.equal(db.used, 2000);
       assert.equal(buf.length, 2000);
-    });
-    it('grows the pool after the first call, if necessary', function() {
+    }
+    /*'grows the pool after the first call, if necessary'*/
+    {
       var db = new BufferPool(1000);
       var buf = db.get(1000);
       assert.equal(db.used, 1000);
@@ -36,30 +41,35 @@ describe('BufferPool', function() {
       assert.equal(db.used, 2000);
       assert.ok(db.size > 1000);
       assert.equal(buf2.length, 1000);
-    });
-    it('grows the pool according to the growStrategy if necessary', function() {
+    }
+    /*'grows the pool according to the growStrategy if necessary'*/
+    {
       var db = new BufferPool(1000, function(db, length) {
         return db.size + 2345;
       });
       var buf = db.get(2000);
       assert.equal(db.size, 3345);
       assert.equal(buf.length, 2000);
-    });
-    it('doesnt grow the pool if theres enough room available', function() {
+    }
+    /*'doesnt grow the pool if theres enough room available'*/
+    {
       var db = new BufferPool(1000);
       var buf = db.get(1000);
       assert.equal(db.size, 1000);
       assert.equal(buf.length, 1000);
-    });
-  });
-  describe('#reset', function() {
-    it('shinks the pool', function() {
+    }
+  }
+  /*'#reset'*/
+  {
+    /*'shinks the pool'*/
+    {
       var db = new BufferPool(1000);
       var buf = db.get(2000);
       db.reset(true);
       assert.equal(db.size, 1000);
-    });
-    it('shrinks the pool according to the shrinkStrategy', function() {
+    }
+    /*'shrinks the pool according to the shrinkStrategy'*/
+    {
       var db = new BufferPool(1000, function(db, length) {
         return db.used + length;
       }, function(db) {
@@ -68,6 +78,6 @@ describe('BufferPool', function() {
       var buf = db.get(2000);
       db.reset(true);
       assert.equal(db.size, 0);
-    });
-  });
-});
+    }
+  }
+}

test/parallel/test-websockets-extensions.js

@@ -2,53 +2,63 @@
 const Extensions = require('../../lib/internal/websockets/Extensions');
 const assert = require('assert');
 
-describe('Extensions', function() {
-  describe('parse', function() {
-    it('should parse', function() {
+/*'Extensions'*/
+{
+  /*'parse'*/
+  {
+    /*'should parse'*/
+    {
       var extensions = Extensions.parse('foo');
       assert.deepEqual(extensions, { foo: [{}] });
-    });
+    }
 
-    it('should parse params', function() {
+    /*'should parse params'*/
+    {
       var extensions = Extensions.parse('foo; bar; baz=1; bar=2');
       assert.deepEqual(extensions, {
         foo: [{ bar: [true, '2'], baz: ['1'] }]
       });
-    });
+    }
 
-    it('should parse multiple extensions', function() {
+    /*'should parse multiple extensions'*/
+    {
       var extensions = Extensions.parse('foo, bar; baz, foo; baz');
       assert.deepEqual(extensions, {
         foo: [{}, { baz: [true] }],
         bar: [{ baz: [true] }]
       });
-    });
+    }
 
-    it('should parse quoted params', function() {
+    /*'should parse quoted params'*/
+    {
       var extensions = Extensions.parse('foo; bar="hi"');
       assert.deepEqual(extensions, {
         foo: [{ bar: ['hi'] }]
       });
-    });
-  });
+    }
+  }
 
-  describe('format', function() {
-    it('should format', function() {
+  /*'format'*/
+  {
+    /*'should format'*/
+    {
       var extensions = Extensions.format({ foo: {} });
       assert.deepEqual(extensions, 'foo');
-    });
+    }
 
-    it('should format params', function() {
+    /*'should format params'*/
+    {
       var extensions = Extensions.format({ foo: { bar: [true, 2], baz: 1 } });
       assert.deepEqual(extensions, 'foo; bar; bar=2; baz=1');
-    });
+    }
 
-    it('should format multiple extensions', function() {
+    /*'should format multiple extensions'*/
+    {
       var extensions = Extensions.format({
         foo: [{}, { baz: true }],
         bar: { baz: true }
       });
       assert.deepEqual(extensions, 'foo, foo; baz, bar; baz');
-    });
-  });
-});
+    }
+  }
+}