fix(NODE-4905): double precision accuracy in canonical EJSON (#549)

Author: nbbeeken

src/double.ts

@@ -52,23 +52,17 @@ export class Double {
  return this.value;
  }
 
- // NOTE: JavaScript has +0 and -0, apparently to model limit calculations. If a user
- // explicitly provided `-0` then we need to ensure the sign makes it into the output
  if (Object.is(Math.sign(this.value), -0)) {
- return { $numberDouble: `-${this.value.toFixed(1)}` };
+ // NOTE: JavaScript has +0 and -0, apparently to model limit calculations. If a user
+ // explicitly provided `-0` then we need to ensure the sign makes it into the output
+ return { $numberDouble: '-0.0' };
  }
 
- let $numberDouble: string;
  if (Number.isInteger(this.value)) {
- $numberDouble = this.value.toFixed(1);
- if ($numberDouble.length >= 13) {
- $numberDouble = this.value.toExponential(13).toUpperCase();
- }
+ return { $numberDouble: `${this.value}.0` };
  } else {
- $numberDouble = this.value.toString();
+ return { $numberDouble: `${this.value}` };
  }
-
- return { $numberDouble };
  }
 
  /** @internal */

test/mocha.opts

@@ -1,4 +1,3 @@
 --require ts-node/register
---require chai/register-expect
 --require source-map-support/register
 --timeout 10000

test/node/bson_corpus.spec.test.js

@@ -181,8 +181,26 @@ describe('BSON Corpus', function () {
  // convert inputs to native Javascript objects
  const nativeFromCB = bsonToNative(cB);
 
- // round tripped EJSON should match the original
- expect(nativeToCEJSON(jsonToNative(cEJ))).to.equal(cEJ);
+ if (cEJ.includes('1.2345678921232E+18')) {
+ // The following is special test logic for a "Double type" bson corpus test that uses a different
+ // string format for the resulting double value
+ // The test does not have a loss in precision, just different exponential output
+ // We want to ensure that the stringified value when interpreted as a double is equal
+ // as opposed to the string being precisely the same
+ if (description !== 'Double type') {
+ throw new Error('Unexpected test using 1.2345678921232E+18');
+ }
+ const eJSONParsedAsJSON = JSON.parse(cEJ);
+ const eJSONParsed = EJSON.parse(cEJ, { relaxed: false });
+ expect(eJSONParsedAsJSON).to.have.nested.property('d.$numberDouble');
+ expect(eJSONParsed).to.have.nested.property('d._bsontype', 'Double');
+ const testInputAsFloat = Number.parseFloat(eJSONParsedAsJSON.d.$numberDouble);
+ const ejsonOutputAsFloat = eJSONParsed.d.valueOf();
+ expect(ejsonOutputAsFloat).to.equal(testInputAsFloat);
+ } else {
+ // round tripped EJSON should match the original
+ expect(nativeToCEJSON(jsonToNative(cEJ))).to.equal(cEJ);
+ }
 
  // invalid, but still parseable, EJSON. if provided, make sure that we
  // properly convert it to canonical EJSON and BSON.
@@ -202,8 +220,22 @@ describe('BSON Corpus', function () {
  expect(nativeToBson(jsonToNative(cEJ))).to.deep.equal(cB);
  }
 
- // the reverse direction, BSON -> native -> EJSON, should match canonical EJSON.
- expect(nativeToCEJSON(nativeFromCB)).to.equal(cEJ);
+ if (cEJ.includes('1.2345678921232E+18')) {
+ // The round tripped value should be equal in interpreted value, not in exact character match
+ const eJSONFromBSONAsJSON = JSON.parse(
+ EJSON.stringify(BSON.deserialize(cB), { relaxed: false })
+ );
+ const eJSONParsed = EJSON.parse(cEJ, { relaxed: false });
+ // TODO(NODE-4377): EJSON transforms large doubles into longs
+ expect(eJSONFromBSONAsJSON).to.have.nested.property('d.$numberLong');
+ expect(eJSONParsed).to.have.nested.property('d._bsontype', 'Double');
+ const testInputAsFloat = Number.parseFloat(eJSONFromBSONAsJSON.d.$numberLong);
+ const ejsonOutputAsFloat = eJSONParsed.d.valueOf();
+ expect(ejsonOutputAsFloat).to.equal(testInputAsFloat);
+ } else {
+ // the reverse direction, BSON -> native -> EJSON, should match canonical EJSON.
+ expect(nativeToCEJSON(nativeFromCB)).to.equal(cEJ);
+ }
 
  if (v.relaxed_extjson) {
  let rEJ = normalize(v.relaxed_extjson);

test/node/double_tests.js

@@ -2,6 +2,7 @@
 
 const BSON = require('../register-bson');
 const Double = BSON.Double;
+const inspect = require('util').inspect;
 
 describe('BSON Double Precision', function () {
  context('class Double', function () {
@@ -34,6 +35,32 @@ describe('BSON Double Precision', function () {
  });
  }
  });
+
+ describe('.toExtendedJSON()', () => {
+ const tests = [
+ { input: new Double(0), output: { $numberDouble: '0.0' } },
+ { input: new Double(-0), output: { $numberDouble: '-0.0' } },
+ { input: new Double(3), output: { $numberDouble: '3.0' } },
+ { input: new Double(-3), output: { $numberDouble: '-3.0' } },
+ { input: new Double(3.4), output: { $numberDouble: '3.4' } },
+ { input: new Double(Number.EPSILON), output: { $numberDouble: '2.220446049250313e-16' } },
+ { input: new Double(12345e7), output: { $numberDouble: '123450000000.0' } },
+ { input: new Double(12345e-1), output: { $numberDouble: '1234.5' } },
+ { input: new Double(-12345e-1), output: { $numberDouble: '-1234.5' } },
+ { input: new Double(Infinity), output: { $numberDouble: 'Infinity' } },
+ { input: new Double(-Infinity), output: { $numberDouble: '-Infinity' } },
+ { input: new Double(NaN), output: { $numberDouble: 'NaN' } }
+ ];
+
+ for (const test of tests) {
+ const input = test.input;
+ const output = test.output;
+ const title = `returns ${inspect(output)} when Double is ${input}`;
+ it(title, () => {
+ expect(output).to.deep.equal(input.toExtendedJSON({ relaxed: false }));
+ });
+ }
+ });
  });
 
  function serializeThenDeserialize(value) {

test/register-bson.js

@@ -7,7 +7,7 @@
 // and make sure you run mocha using our .mocharc.json or with --require ts-node/register
 
 // This should be done by mocha --require, but that isn't supported until mocha version 7+
-require('chai/register-expect');
+global.expect = require('chai').expect;
 require('array-includes/auto');
 require('object.entries/auto');
 require('array.prototype.flatmap/auto');