fix(NODE-6638): throw if all atomic updates are undefined

Author: durran

src/utils.ts

@@ -476,7 +476,10 @@ export function calculateDurationInMs(started: number | undefined): number {
 }
 
 /** @internal */
-export function hasAtomicOperators(doc: Document | Document[]): boolean {
+export function hasAtomicOperators(
+  doc: Document | Document[],
+  options?: CommandOperationOptions
+): boolean {
   if (Array.isArray(doc)) {
     for (const document of doc) {
       if (hasAtomicOperators(document)) {
@@ -487,6 +490,21 @@ export function hasAtomicOperators(doc: Document | Document[]): boolean {
   }
 
   const keys = Object.keys(doc);
+  // In this case we need to throw if all the atomic operators are undefined.
+  if (options?.ignoreUndefined) {
+    let allUndefined = true;
+    for (const key of keys) {
+      // eslint-disable-next-line no-restricted-syntax
+      if (doc[key] !== undefined) {
+        allUndefined = false;
+        break;
+      }
+    }
+    if (allUndefined) {
+      throw new MongoInvalidArgumentError('All atomic operators provided have undefined values.');
+    }
+  }
+
   return keys.length > 0 && keys[0][0] === '$';
 }
 

test/unit/utils.test.ts

@@ -11,6 +11,7 @@ import {
   compareObjectId,
   decorateWithExplain,
   Explain,
+  hasAtomicOperators,
   HostAddress,
   hostMatchesWildcards,
   isHello,
@@ -19,13 +20,74 @@ import {
   List,
   MongoDBCollectionNamespace,
   MongoDBNamespace,
+  MongoInvalidArgumentError,
   MongoRuntimeError,
   ObjectId,
   shuffle
 } from '../mongodb';
 import { sleep } from '../tools/utils';
 
 describe('driver utils', function () {
+  describe.only('.hasAtomicOperators', function () {
+    context('when ignoreUndefined is true', function () {
+      const options = { ignoreUndefined: true };
+
+      context('when no operator is undefined', function () {
+        const document = { $set: { n: 1 }, $unset: '' };
+
+        it('returns true', function () {
+          expect(hasAtomicOperators(document, options)).to.be.true;
+        });
+      });
+
+      context('when some operators are undefined', function () {
+        const document = { $set: { n: 1 }, $unset: undefined };
+
+        it('returns true', function () {
+          expect(hasAtomicOperators(document, options)).to.be.true;
+        });
+      });
+
+      context('when all operators are undefined', function () {
+        const document = { $set: undefined, $unset: undefined };
+
+        it('throws an error', function () {
+          expect(() => {
+            hasAtomicOperators(document, options);
+          }).to.throw(MongoInvalidArgumentError);
+        });
+      });
+    });
+
+    context('when ignoreUndefined is false', function () {
+      const options = { ignoreUndefined: false };
+
+      context('when no operator is undefined', function () {
+        const document = { $set: { n: 1 }, $unset: '' };
+
+        it('returns true', function () {
+          expect(hasAtomicOperators(document, options)).to.be.true;
+        });
+      });
+
+      context('when some operators are undefined', function () {
+        const document = { $set: { n: 1 }, $unset: undefined };
+
+        it('returns true', function () {
+          expect(hasAtomicOperators(document, options)).to.be.true;
+        });
+      });
+
+      context('when all operators are undefined', function () {
+        const document = { $set: undefined, $unset: undefined };
+
+        it('returns true', function () {
+          expect(hasAtomicOperators(document, options)).to.be.true;
+        });
+      });
+    });
+  });
+
   describe('.hostMatchesWildcards', function () {
     context('when using domains', function () {
       context('when using exact match', function () {