lint

Author: W-A-James

test/node/bigint.test.ts

@@ -3,14 +3,14 @@ import { bufferFromHexArray } from './tools/utils';
 import { expect } from 'chai';
 import { BSON_DATA_LONG } from '../../src/constants';
 
-describe('BSON BigInt support', function() {
-  beforeEach(function() {
+describe('BSON BigInt support', function () {
+  beforeEach(function () {
     if (__noBigInt__) {
       this.currentTest?.skip();
     }
   });
 
-  describe('BSON.deserialize()', function() {
+  describe('BSON.deserialize()', function () {
     type DeserialzationOptions = {
       useBigInt64: boolean | undefined;
       promoteValues: boolean | undefined;
@@ -65,12 +65,15 @@ describe('BSON BigInt support', function() {
 
     function generateTestDescription(entry: TestTableEntry): string {
       const options = entry.options;
-      const promoteValues = `promoteValues ${options.promoteValues === undefined ? 'is default' : `is ${options.promoteValues}`
-        }`;
-      const promoteLongs = `promoteLongs ${options.promoteLongs === undefined ? 'is default' : `is ${options.promoteLongs}`
-        }`;
-      const useBigInt64 = `useBigInt64 ${options.useBigInt64 === undefined ? 'is default' : `is ${options.useBigInt64}`
-        }`;
+      const promoteValues = `promoteValues ${
+        options.promoteValues === undefined ? 'is default' : `is ${options.promoteValues}`
+      }`;
+      const promoteLongs = `promoteLongs ${
+        options.promoteLongs === undefined ? 'is default' : `is ${options.promoteLongs}`
+      }`;
+      const useBigInt64 = `useBigInt64 ${
+        options.useBigInt64 === undefined ? 'is default' : `is ${options.useBigInt64}`
+      }`;
       const flagString = `${useBigInt64}, ${promoteValues}, and ${promoteLongs}`;
       if (entry.shouldThrow) {
         return `throws when ${flagString}`;
@@ -103,33 +106,48 @@ describe('BSON BigInt support', function() {
       it(description, test);
     }
 
-    it('correctly deserializes min 64 bit int (-2n**63n)', function() {
-      expect(BSON.deserialize(Buffer.from('10000000126100000000000000008000', 'hex'), { useBigInt64: true })).to.deep.equal(
-        -(2n ** 63n));
+    it('correctly deserializes min 64 bit int (-2n**63n)', function () {
+      expect(
+        BSON.deserialize(Buffer.from('10000000126100000000000000008000', 'hex'), {
+          useBigInt64: true
+        })
+      ).to.deep.equal(-(2n ** 63n));
     });
 
-    it('correctly deserializes -1n', function() {
-      expect(BSON.deserialize(Buffer.from('10000000126100FFFFFFFFFFFFFFFF00', 'hex'), { useBigInt64: true })).to.deep.equal(
-        -1n);
+    it('correctly deserializes -1n', function () {
+      expect(
+        BSON.deserialize(Buffer.from('10000000126100FFFFFFFFFFFFFFFF00', 'hex'), {
+          useBigInt64: true
+        })
+      ).to.deep.equal(-1n);
     });
 
-    it('correctly deserializes 0n', function() {
-      expect(BSON.deserialize(Buffer.from('10000000126100000000000000008000', 'hex'), { useBigInt64: true })).to.deep.equal(
-        0n);
+    it('correctly deserializes 0n', function () {
+      expect(
+        BSON.deserialize(Buffer.from('10000000126100000000000000008000', 'hex'), {
+          useBigInt64: true
+        })
+      ).to.deep.equal(0n);
     });
 
-    it('correctly deserializes 1n', function() {
-      expect(BSON.deserialize(Buffer.from('10000000126100010000000000000000', 'hex'), { useBigInt64: true })).to.deep.equal(
-        1n);
+    it('correctly deserializes 1n', function () {
+      expect(
+        BSON.deserialize(Buffer.from('10000000126100010000000000000000', 'hex'), {
+          useBigInt64: true
+        })
+      ).to.deep.equal(1n);
     });
 
-    it('correctly deserializes max 64 bit int (2n**63n -1n)', function() {
-      expect(BSON.deserialize(Buffer.from('10000000126100FFFFFFFFFFFFFF7F00', 'hex'), { useBigInt64: true })).to.deep.equal(
-        (2n ** 63n - 1n));
+    it('correctly deserializes max 64 bit int (2n**63n -1n)', function () {
+      expect(
+        BSON.deserialize(Buffer.from('10000000126100FFFFFFFFFFFFFF7F00', 'hex'), {
+          useBigInt64: true
+        })
+      ).to.deep.equal(2n ** 63n - 1n);
     });
   });
 
-  describe('BSON.serialize()', function() {
+  describe('BSON.serialize()', function () {
     // Index for the data type byte of a BSON document with a
     // NOTE: These offsets only apply for documents with the shape {a : <n>}
     // where n is a BigInt
@@ -169,13 +187,13 @@ describe('BSON BigInt support', function() {
       };
     }
 
-    it('serializes bigints with the correct BSON type', function() {
+    it('serializes bigints with the correct BSON type', function () {
       const testDoc = { a: 0n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       expect(serializedDoc.dataType).to.equal(BSON_DATA_LONG);
     });
 
-    it('serializes bigints into little-endian byte order', function() {
+    it('serializes bigints into little-endian byte order', function () {
       const testDoc = { a: 0x1234567812345678n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       const expectedResult = getSerializedDocParts(
@@ -189,7 +207,7 @@ describe('BSON BigInt support', function() {
       expect(expectedResult.value).to.equal(serializedDoc.value);
     });
 
-    it('serializes a BigInt that can be safely represented as a Number', function() {
+    it('serializes a BigInt that can be safely represented as a Number', function () {
       const testDoc = { a: 0x23n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       const expectedResult = getSerializedDocParts(
@@ -202,7 +220,7 @@ describe('BSON BigInt support', function() {
       expect(serializedDoc).to.deep.equal(expectedResult);
     });
 
-    it('serializes a BigInt in the valid range [-2^63, 2^63 - 1]', function() {
+    it('serializes a BigInt in the valid range [-2^63, 2^63 - 1]', function () {
       const testDoc = { a: 0xfffffffffffffff1n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       const expectedResult = getSerializedDocParts(
@@ -215,7 +233,7 @@ describe('BSON BigInt support', function() {
       expect(serializedDoc).to.deep.equal(expectedResult);
     });
 
-    it('wraps to negative on a BigInt that is larger than (2^63 -1)', function() {
+    it('wraps to negative on a BigInt that is larger than (2^63 -1)', function () {
       const maxIntPlusOne = { a: 2n ** 63n };
       const serializedMaxIntPlusOne = getSerializedDocParts(BSON.serialize(maxIntPlusOne));
       const expectedResultForMaxIntPlusOne = getSerializedDocParts(
@@ -228,7 +246,7 @@ describe('BSON BigInt support', function() {
       expect(serializedMaxIntPlusOne).to.deep.equal(expectedResultForMaxIntPlusOne);
     });
 
-    it('serializes BigInts at the edges of the valid range [-2^63, 2^63 - 1]', function() {
+    it('serializes BigInts at the edges of the valid range [-2^63, 2^63 - 1]', function () {
       const maxPositiveInt64 = { a: 2n ** 63n - 1n };
       const serializedMaxPositiveInt64 = getSerializedDocParts(BSON.serialize(maxPositiveInt64));
       const expectedSerializationForMaxPositiveInt64 = getSerializedDocParts(
@@ -252,7 +270,7 @@ describe('BSON BigInt support', function() {
       expect(serializedMinPositiveInt64).to.deep.equal(expectedSerializationForMinPositiveInt64);
     });
 
-    it('truncates a BigInt that is larger than a 64-bit int', function() {
+    it('truncates a BigInt that is larger than a 64-bit int', function () {
       const testDoc = { a: 2n ** 64n + 1n };
       const serializedDoc = getSerializedDocParts(BSON.serialize(testDoc));
       const expectedSerialization = getSerializedDocParts(
@@ -265,7 +283,7 @@ describe('BSON BigInt support', function() {
       expect(serializedDoc).to.deep.equal(expectedSerialization);
     });
 
-    it('serializes array of BigInts', function() {
+    it('serializes array of BigInts', function () {
       const testArr = { a: [1n] };
       const serializedArr = BSON.serialize(testArr);
       const expectedSerialization = bufferFromHexArray([
@@ -280,7 +298,7 @@ describe('BSON BigInt support', function() {
       expect(serializedArr).to.deep.equal(expectedSerialization);
     });
 
-    it('serializes Map with BigInt values', function() {
+    it('serializes Map with BigInt values', function () {
       const testMap = new Map();
       testMap.set('a', 1n);
       const serializedMap = getSerializedDocParts(BSON.serialize(testMap));
@@ -295,7 +313,7 @@ describe('BSON BigInt support', function() {
     });
   });
 
-  describe('EJSON.parse()', function() {
+  describe('EJSON.parse()', function () {
     type ParseOptions = {
       useBigInt64: boolean | undefined;
       relaxed: boolean | undefined;
@@ -352,13 +370,13 @@ describe('BSON BigInt support', function() {
         const condDescription = generateConditionDescription(entry);
         const behaviourDescription = generateBehaviourDescription(entry, sampleString);
 
-        describe(condDescription, function() {
+        describe(condDescription, function () {
           it(behaviourDescription, test);
         });
       }
     }
 
-    describe('canonical input', function() {
+    describe('canonical input', function () {
       const canonicalInputTestTable = useBigInt64Values.flatMap(useBigInt64 => {
         return relaxedValues.flatMap(relaxed => {
           return genTestTable(
@@ -381,7 +399,7 @@ describe('BSON BigInt support', function() {
       createTestsFromTestTable(canonicalInputTestTable, sampleCanonicalString);
     });
 
-    describe('relaxed integer input', function() {
+    describe('relaxed integer input', function () {
       const relaxedIntegerInputTestTable = useBigInt64Values.flatMap(useBigInt64 => {
         return relaxedValues.flatMap(relaxed => {
           return genTestTable(
@@ -403,7 +421,7 @@ describe('BSON BigInt support', function() {
       createTestsFromTestTable(relaxedIntegerInputTestTable, sampleRelaxedIntegerString);
     });
 
-    describe('relaxed double input where double is outside of int32 range and useBigInt64 is true', function() {
+    describe('relaxed double input where double is outside of int32 range and useBigInt64 is true', function () {
       const relaxedDoubleInputTestTable = relaxedValues.flatMap(relaxed => {
         return genTestTable(true, relaxed, (_, relaxedIsSet: boolean) =>
           relaxedIsSet ? { a: 2147483647.9 } : { a: new BSON.Double(2147483647.9) }
@@ -418,15 +436,15 @@ describe('BSON BigInt support', function() {
     });
   });
 
-  describe('EJSON.stringify()', function() {
-    context('canonical mode (relaxed=false)', function() {
-      it('truncates bigint values when they are outside the range [BSON_INT64_MIN, BSON_INT64_MAX]', function() {
+  describe('EJSON.stringify()', function () {
+    context('canonical mode (relaxed=false)', function () {
+      it('truncates bigint values when they are outside the range [BSON_INT64_MIN, BSON_INT64_MAX]', function () {
         const numbers = { a: 2n ** 64n + 1n, b: -(2n ** 64n) - 1n };
         const serialized = EJSON.stringify(numbers, { relaxed: false });
         expect(serialized).to.equal('{"a":{"$numberLong":"1"},"b":{"$numberLong":"-1"}}');
       });
 
-      it('truncates bigint values in the same way as BSON.serialize', function() {
+      it('truncates bigint values in the same way as BSON.serialize', function () {
         const number = { a: 0x1234_5678_1234_5678_9999n };
         const stringified = EJSON.stringify(number, { relaxed: false });
         const serialized = BSON.serialize(number);
@@ -446,15 +464,15 @@ describe('BSON BigInt support', function() {
 
         expect(parsed.a.$numberLong).to.equal(serializedValue.toString());
       });
-      it('serializes bigint values to numberLong in canonical mode', function() {
+      it('serializes bigint values to numberLong in canonical mode', function () {
         const number = { a: 2n };
         const serialized = EJSON.stringify(number, { relaxed: false });
         expect(serialized).to.equal('{"a":{"$numberLong":"2"}}');
       });
     });
 
-    context('relaxed mode (relaxed=true)', function() {
-      it('truncates bigint values in the same way as BSON.serialize', function() {
+    context('relaxed mode (relaxed=true)', function () {
+      it('truncates bigint values in the same way as BSON.serialize', function () {
         const number = { a: 0x1234_0000_1234_5678_9999n }; // Ensure that the truncated number can be exactly represented as a JS number
         const stringified = EJSON.stringify(number, { relaxed: true });
         const serializedDoc = BSON.serialize(number);
@@ -473,23 +491,23 @@ describe('BSON BigInt support', function() {
         expect(parsed.a).to.equal(Number(dataView.getBigInt64(VALUE_OFFSET, true)));
       });
 
-      it('serializes bigint values to Number', function() {
+      it('serializes bigint values to Number', function () {
         const number = { a: 10000n };
         const serialized = EJSON.stringify(number, { relaxed: true });
         expect(serialized).to.equal('{"a":10000}');
       });
 
-      it('loses precision when serializing bigint values outside of range [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]', function() {
+      it('loses precision when serializing bigint values outside of range [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER]', function () {
         const numbers = { a: -(2n ** 53n) - 1n, b: 2n ** 53n + 2n };
         const serialized = EJSON.stringify(numbers, { relaxed: true });
         expect(serialized).to.equal('{"a":-9007199254740992,"b":9007199254740994}');
       });
     });
 
-    context('when passed bigint values that are 64 bits wide or less', function() {
+    context('when passed bigint values that are 64 bits wide or less', function () {
       let parsed;
 
-      before(function() {
+      before(function () {
         if (__noBigInt__) {
           return;
         }
@@ -498,20 +516,20 @@ describe('BSON BigInt support', function() {
         parsed = JSON.parse(serialized);
       });
 
-      it('passes loose equality checks with native bigint values', function() {
+      it('passes loose equality checks with native bigint values', function () {
         // eslint-disable-next-line eqeqeq
         expect(parsed.a.$numberLong == 12345n).true;
       });
 
-      it('equals the result of BigInt.toString', function() {
+      it('equals the result of BigInt.toString', function () {
         expect(parsed.a.$numberLong).to.equal(12345n.toString());
       });
     });
 
-    context('when passed bigint values that are more than 64 bits wide', function() {
+    context('when passed bigint values that are more than 64 bits wide', function () {
       let parsed;
 
-      before(function() {
+      before(function () {
         if (__noBigInt__) {
           return;
         }
@@ -520,12 +538,12 @@ describe('BSON BigInt support', function() {
         parsed = JSON.parse(serialized);
       });
 
-      it('fails loose equality checks with native bigint values', function() {
+      it('fails loose equality checks with native bigint values', function () {
         // eslint-disable-next-line eqeqeq
         expect(parsed.a.$numberLong == 0x1234_5678_1234_5678_9999n).false;
       });
 
-      it('not equal to results of BigInt.toString', function() {
+      it('not equal to results of BigInt.toString', function () {
         expect(parsed.a.$numberLong).to.not.equal(0x1234_5678_1234_5678_9999n.toString());
       });
     });