double test refactoring and PR fixes

Author: aditi-khare-mongoDB

test/node/bson_corpus.spec.test.js

@@ -3,7 +3,6 @@
 
 const Buffer = require('buffer').Buffer;
 const BSON = require('../register-bson');
-const { getNodeMajor, isBrowser } = require('./tools/utils');
 const BSONError = BSON.BSONError;
 const EJSON = BSON.EJSON;
 
@@ -122,10 +121,6 @@ describe('BSON Corpus', function () {
         describe('valid-bson', function () {
           for (const v of valid) {
             it(v.description, function () {
-              if (v.description === 'NaN with payload' && !isBrowser() && getNodeMajor() < 10) {
-                this.skip();
-              }
-
               if (
                 v.description === 'All BSON types' &&
                 scenario._filename === 'multi-type-deprecated'

test/node/double_tests.js

@@ -1,109 +1,96 @@
 'use strict';
 
 const BSON = require('../register-bson');
-const { getNodeMajor, isBrowser } = require('./tools/utils');
 const Double = BSON.Double;
 
-describe('Double', function () {
-  describe('Constructor', function () {
-    var value = 42.3456;
+describe('BSON Double Precision', function () {
+  context('class Double', function () {
+    describe('constructor()', function () {
+      const value = 42.3456;
 
-    it('Primitive number', function (done) {
-      expect(new Double(value).valueOf()).to.equal(value);
-      done();
-    });
-
-    it('Number object', function (done) {
-      expect(new Double(new Number(value)).valueOf()).to.equal(value);
-      done();
-    });
-  });
+      it('Primitive number', function (done) {
+        expect(new Double(value).valueOf()).to.equal(value);
+        done();
+      });
 
-  describe('toString', () => {
-    it('should serialize to a string', () => {
-      const testNumber = Math.random() * Number.MAX_VALUE;
-      const double = new Double(testNumber);
-      expect(double.toString()).to.equal(testNumber.toString());
+      it('Number object', function (done) {
+        expect(new Double(new Number(value)).valueOf()).to.equal(value);
+        done();
+      });
     });
 
-    const testRadices = [2, 8, 10, 16, 22];
-
-    for (const radix of testRadices) {
-      it(`should support radix argument: ${radix}`, () => {
+    describe('#toString()', () => {
+      it('should serialize to a string', () => {
         const testNumber = Math.random() * Number.MAX_VALUE;
         const double = new Double(testNumber);
-        expect(double.toString(radix)).to.equal(testNumber.toString(radix));
+        expect(double.toString()).to.equal(testNumber.toString());
       });
-    }
-  });
-
-  describe('specialValues', () => {
-    function twiceSerialized(value) {
-      let serializedDouble = BSON.serialize({ d: value });
-      let deserializedDouble = BSON.deserialize(serializedDouble, { promoteValues: true });
-      let newVal = deserializedDouble.d;
-      return newVal;
-    }
-
-    it('inf', () => {
-      let value = Infinity;
-      let newVal = twiceSerialized(value);
-      expect(value).to.equal(newVal);
-    });
 
-    it('-inf', () => {
-      let value = -Infinity;
-      let newVal = twiceSerialized(value);
-      expect(value).to.equal(newVal);
-    });
+      const testRadices = [2, 8, 10, 16, 22];
 
-    it('NaN', () => {
-      let value = NaN;
-      let newVal = twiceSerialized(value);
-      expect(Number.isNaN(newVal)).to.equal(true);
-    });
-
-    it('NaN with payload', function () {
-      if (!isBrowser() && getNodeMajor() < 10) {
-        this.skip();
+      for (const radix of testRadices) {
+        it(`should support radix argument: ${radix}`, () => {
+          const testNumber = Math.random() * Number.MAX_VALUE;
+          const double = new Double(testNumber);
+          expect(double.toString(radix)).to.equal(testNumber.toString(radix));
+        });
       }
-      let buffer = Buffer.from('120000000000F87F', 'hex');
-
-      const dv = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
-      let value = dv.getFloat64(0, true);
-
-      let serializedDouble = BSON.serialize({ d: value });
-      expect(serializedDouble.subarray(7, 15)).to.deep.equal(buffer);
-      let { d: newVal } = BSON.deserialize(serializedDouble, { promoteValues: true });
-      expect(Number.isNaN(newVal)).to.equal(true);
     });
+  });
 
-    it('0', () => {
-      let value = 0;
-      let orig = new Double(value);
-      let newVal = twiceSerialized(orig);
-      expect(value).to.equal(newVal);
+  function serializeThenDeserialize(value) {
+    const serializedDouble = BSON.serialize({ d: value });
+    const deserializedDouble = BSON.deserialize(serializedDouble, { promoteValues: false });
+    return deserializedDouble.d;
+  }
+
+  const testCases = [
+    { name: 'Infinity', input: new Double(Infinity) },
+    { name: '-Infinity', input: new Double(-Infinity) },
+    { name: 'Number.EPSILON', input: new Double(Number.EPSILON) },
+    { name: 'Zero', input: new Double(0) },
+    { name: 'Double (Negative Zero)', input: new Double(-0) }
+  ];
+
+  for (const { name, input } of testCases) {
+    it(`should return Double from serialize-deserialize roundtrip when value is: ${name}`, () => {
+      const outcome = serializeThenDeserialize(input);
+      expect(outcome.value).to.equal(input.value);
+      expect(Object.is(outcome.value, input.value)).to.be.true;
     });
+  }
 
-    it('-0', () => {
-      let value = -0;
-      let orig = new Double(value);
-      let newVal = twiceSerialized(orig);
-      expect(Object.is(newVal, -0)).to.be.true;
-    });
+  it('should preserve NaN value in serialize-deserialize roundtrip', () => {
+    const value = NaN;
+    const newVal = serializeThenDeserialize(value);
+    expect(Number.isNaN(newVal.value)).to.equal(true);
+  });
 
-    // TODO (NODE-4335): -0 should be serialized as double
-    it.skip('-0 serializes as Double', () => {
-      let value = -0;
-      let serializedDouble = BSON.serialize({ d: value });
-      let type = serializedDouble[5];
-      expect(type).to.not.equal(BSON.BSON_DATA_NUMBER);
+  context('NaN with Payload', function () {
+    const NanPayloadBuffer = Buffer.from('120000000000F87F', 'hex');
+    const NanPayloadDV = new DataView(
+      NanPayloadBuffer.buffer,
+      NanPayloadBuffer.byteOffset,
+      NanPayloadBuffer.byteLength
+    );
+    const NanPayloadDouble = NanPayloadDV.getFloat64(0, true);
+    const serializedNanPayloadDouble = BSON.serialize({ d: NanPayloadDouble });
+
+    it('should keep payload in serialize-deserialize roundtrip', function () {
+      expect(serializedNanPayloadDouble.subarray(7, 15)).to.deep.equal(NanPayloadBuffer);
     });
 
-    it('Number.EPSILON', () => {
-      let value = Number.EPSILON;
-      let newVal = twiceSerialized(value);
-      expect(value).to.equal(newVal);
+    it('should preserve NaN value in serialize-deserialize roundtrip', function () {
+      const { d: newVal } = BSON.deserialize(serializedNanPayloadDouble, { promoteValues: true });
+      expect(Number.isNaN(newVal)).to.equal(true);
     });
   });
+  it('NODE-4335: does not preserve -0 in serialize-deserialize roundtrip if JS number is used', () => {
+    // TODO (NODE-4335): -0 should be serialized as double
+    const value = -0;
+    const serializedDouble = BSON.serialize({ d: value });
+    const type = serializedDouble[4];
+    expect(type).to.not.equal(BSON.BSON_DATA_NUMBER);
+    expect(type).to.equal(BSON.BSON_DATA_INT);
+  });
 });