Cleanup tests.

Moved service_node_test to assert to keep consistency.

libloki/test/proof-of-work_test.js

@@ -8,7 +8,8 @@ const {
   greaterThan,
 } = pow;
 
-describe('Proof of Work Worker', () => {
+describe('Proof of Work', () => {
+  describe('#incrementNonce', () => {
     it('should increment a Uint8Array nonce correctly', () => {
       const arr1Before = new Uint8Array([0,0,0,0,0,0,0,0]);
       const arr1After = incrementNonce(arr1Before);
@@ -22,7 +23,7 @@ describe('Proof of Work Worker', () => {
       assert.strictEqual(arr1After[7], 1);
     });
 
-  it('should increment a Uint8Array nonce correctly', () => {
+    it('should increment a Uint8Array nonce correctly in a loop', () => {
       let arr = new Uint8Array([0,0,0,0,0,0,0,0]);
       assert.deepEqual(incrementNonce(arr), new Uint8Array([0,0,0,0,0,0,0,1]));
       arr = new Uint8Array([0,0,0,0,0,0,0,0]);
@@ -33,7 +34,9 @@ describe('Proof of Work Worker', () => {
       arr = new Uint8Array([255,255,255,255,255,255,255,255]);
       assert.deepEqual(incrementNonce(arr), new Uint8Array([0,0,0,0,0,0,0,0]));
     });
+  });
 
+  describe('#calcTarget', () => {
     it('should calculate a correct difficulty target', () => {
       // These values will need to be updated if we adjust the difficulty settings
       let payloadLen = 625;
@@ -47,7 +50,9 @@ describe('Proof of Work Worker', () => {
       actualTarget = calcTarget(ttl, payloadLen, 10);
       assert.deepEqual(actualTarget, expectedTarget);
     });
+  });
 
+  describe('#greaterThan', () => {
     it('should correclty compare two Uint8Arrays', () => {
       let arr1 = new Uint8Array([0,0,0,0,0,0,0,0,0,1]);
       let arr2 = new Uint8Array([0,0,0,0,0,0,0,0,0,1]);
@@ -65,7 +70,9 @@ describe('Proof of Work Worker', () => {
       arr2 = new Uint8Array([0,0]);
       assert.isFalse(greaterThan(arr1, arr2))
     });
+  });
 
+  describe('#bufferToBase64', () => {
     it('should correclty convert a Uint8Array to a base64 string', () => {
       let arr = new Uint8Array([1,2,3]);
       let expected = 'AQID';
@@ -77,7 +84,9 @@ describe('Proof of Work Worker', () => {
       expected = '';
       assert.strictEqual(bufferToBase64(arr), expected);
     });
+  });
 
+  describe('#bigIntToUint8Array', () => {
     it('should correclty convert a BigInteger to a Uint8Array', () => {
       let bigInt = JSBI.BigInt(Number.MAX_SAFE_INTEGER);
       let expected = new Uint8Array([0, 31, 255, 255, 255, 255, 255, 255]);
@@ -93,3 +102,4 @@ describe('Proof of Work Worker', () => {
       assert.deepEqual(bigIntToUint8Array(bigInt), expected);
     });
   });
+});

libloki/test/service_nodes_test.js

@@ -1,40 +1,50 @@
-/* global libloki, chai */
+/* global libloki, assert */
 
 describe('ServiceNodes', () => {
   describe('#consolidateLists', () => {
     it('should throw when provided a non-iterable list', () => {
-      chai.expect(() => libloki.serviceNodes.consolidateLists(null, 1)).to.throw();
+      assert.throws(() => libloki.serviceNodes.consolidateLists(null, 1), Error);
     });
+
     it('should throw when provided a non-iterable item in the list', () => {
-      chai.expect(() => libloki.serviceNodes.consolidateLists([1, 2, 3], 1)).to.throw();
+      assert.throws(() => libloki.serviceNodes.consolidateLists([1, 2, 3], 1), Error);
     });
+
     it('should throw when provided a non-number threshold', () => {
-      chai.expect(() => libloki.serviceNodes.consolidateLists([], 'a')).to.throw();
+      assert.throws(
+        () => libloki.serviceNodes.consolidateLists([], 'a'),
+        'Provided threshold is not a number'
+      );
     });
+
     it('should return an empty array when the input is an empty array', () => {
       const result = libloki.serviceNodes.consolidateLists([]);
-      chai.expect(result).to.deep.equal([]);
+      assert.deepEqual(result, []);
     });
+
     it('should return the input when only 1 list is provided', () => {
       const result = libloki.serviceNodes.consolidateLists([['a', 'b', 'c']]);
-      chai.expect(result).to.deep.equal(['a', 'b', 'c']);
+      assert.deepEqual(result, ['a', 'b', 'c']);
     });
+
     it('should return the union of all lists when threshold is 0', () => {
       const result = libloki.serviceNodes.consolidateLists([
         ['a', 'b', 'c', 'h'],
         ['d', 'e', 'f', 'g'],
         ['g', 'h'],
       ], 0);
-      chai.expect(result.sort()).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
+      assert.deepEqual(result.sort(), ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
     });
+
     it('should return the intersection of all lists when threshold is 1', () => {
       const result = libloki.serviceNodes.consolidateLists([
         ['a', 'b', 'c', 'd'],
         ['a', 'e', 'f', 'g'],
         ['a', 'h'],
       ], 1);
-      chai.expect(result).to.deep.equal(['a']);
+      assert.deepEqual(result, ['a']);
     });
+
     it('should return the elements that have an occurence >= the provided threshold', () => {
       const result = libloki.serviceNodes.consolidateLists([
         ['a', 'b', 'c', 'd', 'e', 'f', 'g'],
@@ -42,8 +52,9 @@ describe('ServiceNodes', () => {
         ['a', 'b', 'c', 'd', 'e', 'f', 'g'],
         ['a', 'b', 'c', 'd', 'e', 'g', 'h'],
       ], 3/4);
-      chai.expect(result).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
+      assert.deepEqual(result, ['a', 'b', 'c', 'd', 'e', 'f', 'g']);
     });
+
     it('should work with sets as well', () => {
       const result = libloki.serviceNodes.consolidateLists(new Set([
         new Set(['a', 'b', 'c', 'd', 'e', 'f', 'g']),
@@ -51,7 +62,7 @@ describe('ServiceNodes', () => {
         new Set(['a', 'b', 'c', 'd', 'e', 'f', 'g']),
         new Set(['a', 'b', 'c', 'd', 'e', 'g', 'h']),
       ]), 3/4);
-      chai.expect(result).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
+      assert.deepEqual(result, ['a', 'b', 'c', 'd', 'e', 'f', 'g']);
     });
   });
 });