test(NODE-4917): remove grouped callback style tests (#3512)

Co-authored-by: Bailey Pearson <[email protected]>

Author: nbbeeken

test/integration/change-streams/change_stream.test.ts

@@ -214,66 +214,6 @@ describe('Change Streams', function () {
     }
   });
 
-  it(
-    'should create a ChangeStream on a collection and get change events through imperative callback form',
-    {
-      metadata: { requires: { topology: 'replicaset' } },
-
-      test: function (done) {
-        const configuration = this.configuration;
-        const client = configuration.newClient();
-
-        client.connect((err, client) => {
-          expect(err).to.not.exist;
-          this.defer(() => client.close());
-
-          const collection = client.db('integration_tests').collection('docsCallback');
-          const changeStream = collection.watch(pipeline);
-          this.defer(() => changeStream.close());
-
-          // Fetch the change notification
-          changeStream.hasNext((err, hasNext) => {
-            expect(err).to.not.exist;
-
-            assert.equal(true, hasNext);
-            changeStream.next((err, change) => {
-              expect(err).to.not.exist;
-              expect(change).to.have.property('operationType', 'insert');
-              expect(change).to.have.nested.property('fullDocument.e', 5);
-              expect(change).to.have.nested.property('ns.db', 'integration_tests');
-              expect(change).to.have.nested.property('ns.coll', 'docsCallback');
-              expect(change).to.not.have.property('documentKey');
-              expect(change).to.have.property(
-                'comment',
-                'The documentKey field has been projected out of this document.'
-              );
-
-              // Trigger the second database event
-              collection.updateOne({ e: 5 }, { $inc: { e: 2 } }, err => {
-                expect(err).to.not.exist;
-                changeStream.hasNext((err, hasNext) => {
-                  expect(err).to.not.exist;
-                  assert.equal(true, hasNext);
-                  changeStream.next((err, change) => {
-                    expect(err).to.not.exist;
-                    assert.equal(change.operationType, 'update');
-
-                    done();
-                  });
-                });
-              });
-            });
-          });
-
-          // Trigger the first database event
-          // NOTE: this needs to be triggered after the changeStream call so
-          // that the cursor is run
-          this.defer(collection.insertOne({ e: 5 }));
-        });
-      }
-    }
-  );
-
   it('should support creating multiple simultaneous ChangeStreams', {
     metadata: { requires: { topology: 'replicaset' } },
 

test/integration/collection-management/collection.test.ts

@@ -578,31 +578,10 @@ describe('Collection', function () {
       });
     });
 
-    context('when no callback passed', function () {
-      it('returns a promise', function () {
-        const docsPromise = collection.countDocuments();
-        expect(docsPromise).to.exist.and.to.be.an.instanceof(Promise);
-        return docsPromise.then(result => expect(result).to.equal(1));
-      });
-    });
-
-    context('when a callback is passed', function () {
-      it('does not return a promise', function (done) {
-        const notPromise = collection.countDocuments({ a: 1 }, () => {
-          expect(notPromise).to.be.undefined;
-          done();
-        });
-      });
-
-      it('calls the callback', function (done) {
-        const docs = [{ a: 1 }, { a: 2 }];
-        collection.insertMany(docs).then(() =>
-          collection.countDocuments({ a: 1 }, (err, data) => {
-            expect(data).to.equal(1);
-            done(err);
-          })
-        );
-      });
+    it('returns a promise', function () {
+      const docsPromise = collection.countDocuments();
+      expect(docsPromise).to.exist.and.to.be.an.instanceof(Promise);
+      return docsPromise.then(result => expect(result).to.equal(1));
     });
   });
 

test/integration/collection-management/promise_collection_db_management.test.ts renamed to test/integration/collection-management/collection_db_management.test.ts

@@ -1,6 +1,6 @@
 import { assert as test, setupDatabase } from '../shared';
 
-describe('Collection Management and Db Management (promise tests)', function () {
+describe('Collection Management and Db Management', function () {
   before(function () {
     return setupDatabase(this.configuration);
   });

test/integration/crud/bulk.test.ts

@@ -107,37 +107,35 @@ describe('Bulk', function () {
     });
   });
 
-  context('promise tests', () => {
-    it('Should correctly execute unordered bulk operation in promise form', async function () {
-      const db = client.db();
-      const bulk = db
-        .collection('unordered_bulk_promise_form')
-        .initializeUnorderedBulkOp({ writeConcern: { w: 1 } });
-      bulk.insert({ a: 1 });
-
-      const r = await bulk.execute();
-      test.ok(r);
-      test.deepEqual({ w: 1 }, bulk.s.writeConcern);
-    });
+  it('Should correctly execute unordered bulk operation', async function () {
+    const db = client.db();
+    const bulk = db
+      .collection('unordered_bulk_promise_form')
+      .initializeUnorderedBulkOp({ writeConcern: { w: 1 } });
+    bulk.insert({ a: 1 });
+
+    const r = await bulk.execute();
+    test.ok(r);
+    test.deepEqual({ w: 1 }, bulk.s.writeConcern);
+  });
 
-    it('Should correctly execute ordered bulk operation in promise form', async function () {
-      const db = client.db();
-      const bulk = db
-        .collection('unordered_bulk_promise_form')
-        .initializeOrderedBulkOp({ writeConcern: { w: 1 } });
-      bulk.insert({ a: 1 });
-
-      const r = await bulk.execute();
-      test.ok(r);
-      test.deepEqual({ w: 1 }, bulk.s.writeConcern);
-    });
+  it('Should correctly execute ordered bulk operation', async function () {
+    const db = client.db();
+    const bulk = db
+      .collection('unordered_bulk_promise_form')
+      .initializeOrderedBulkOp({ writeConcern: { w: 1 } });
+    bulk.insert({ a: 1 });
+
+    const r = await bulk.execute();
+    test.ok(r);
+    test.deepEqual({ w: 1 }, bulk.s.writeConcern);
+  });
 
-    it('Should correctly handle bulkWrite with no options', async function () {
-      const db = client.db();
-      const col = db.collection('find_one_and_replace_with_promise_no_option');
-      const result = await col.bulkWrite([{ insertOne: { document: { a: 1 } } }]);
-      expect(result).to.exist;
-    });
+  it('Should correctly handle bulkWrite with no options', async function () {
+    const db = client.db();
+    const col = db.collection('find_one_and_replace_with_promise_no_option');
+    const result = await col.bulkWrite([{ insertOne: { document: { a: 1 } } }]);
+    expect(result).to.exist;
   });
 
   it('should correctly handle ordered single batch api write command error', function (done) {

test/integration/crud/explain.test.js

@@ -744,7 +744,7 @@ describe('Explain', function () {
     });
   });
 
-  it('should throw a catchable error with invalid explain string (promise)', {
+  it('should throw a catchable error with invalid explain string', {
     metadata: {
       requires: {
         mongodb: '>=3.4'
@@ -764,22 +764,4 @@ describe('Explain', function () {
         });
     }
   });
-
-  it('should throw a catchable error with invalid explain string (callback)', {
-    metadata: {
-      requires: {
-        mongodb: '>=3.4'
-      }
-    },
-    test: function (done) {
-      const db = client.db('shouldThrowCatchableError');
-      const collection = db.collection('test');
-      collection.find({ a: 1 }).explain('invalidExplain', (err, result) => {
-        expect(err).to.exist;
-        expect(result).to.not.exist;
-        expect(err).to.be.instanceOf(MongoServerError);
-        done();
-      });
-    }
-  });
 });

test/integration/crud/find_and_modify.test.js

@@ -9,85 +9,83 @@ describe('Find and Modify', function () {
     return setupDatabase(this.configuration);
   });
 
-  context('promise tests', function () {
-    it('Should correctly execute findOneAndDelete operation With Promises and no options passed in', function (done) {
-      var configuration = this.configuration;
-      var client = configuration.newClient(configuration.writeConcernMax(), {
-        maxPoolSize: 1
-      });
-
-      client.connect().then(function (client) {
-        const db = client.db(configuration.db);
-        const col = db.collection('find_one_and_delete_with_promise_no_option');
-        col.insertMany([{ a: 1, b: 1 }], { writeConcern: { w: 1 } }).then(function (r) {
-          expect(r).property('insertedCount').to.equal(1);
-
-          col
-            .findOneAndDelete({ a: 1 })
-            .then(function (r) {
-              test.equal(1, r.lastErrorObject.n);
-              test.equal(1, r.value.b);
-
-              client.close(done);
-            })
-            .catch(function (err) {
-              test.ok(err != null);
-            });
-        });
-      });
+  it('Should correctly execute findOneAndDelete operation and no options passed in', function (done) {
+    var configuration = this.configuration;
+    var client = configuration.newClient(configuration.writeConcernMax(), {
+      maxPoolSize: 1
     });
 
-    it('Should correctly execute findOneAndUpate operation With Promises and no options passed in', function (done) {
-      var configuration = this.configuration;
-      var client = configuration.newClient(configuration.writeConcernMax(), {
-        maxPoolSize: 1
+    client.connect().then(function (client) {
+      const db = client.db(configuration.db);
+      const col = db.collection('find_one_and_delete_with_promise_no_option');
+      col.insertMany([{ a: 1, b: 1 }], { writeConcern: { w: 1 } }).then(function (r) {
+        expect(r).property('insertedCount').to.equal(1);
+
+        col
+          .findOneAndDelete({ a: 1 })
+          .then(function (r) {
+            test.equal(1, r.lastErrorObject.n);
+            test.equal(1, r.value.b);
+
+            client.close(done);
+          })
+          .catch(function (err) {
+            test.ok(err != null);
+          });
       });
+    });
+  });
 
-      client.connect().then(function (client) {
-        const db = client.db(configuration.db);
-        const col = db.collection('find_one_and_update_with_promise_no_option');
-        col.insertMany([{ a: 1, b: 1 }], { writeConcern: { w: 1 } }).then(function (r) {
-          expect(r).property('insertedCount').to.equal(1);
-
-          col
-            .findOneAndUpdate({ a: 1 }, { $set: { a: 1 } })
-            .then(function (r) {
-              test.equal(1, r.lastErrorObject.n);
-              test.equal(1, r.value.b);
-
-              client.close(done);
-            })
-            .catch(function (err) {
-              test.ok(err != null);
-            });
-        });
-      });
+  it('Should correctly execute findOneAndUpate operation and no options passed in', function (done) {
+    var configuration = this.configuration;
+    var client = configuration.newClient(configuration.writeConcernMax(), {
+      maxPoolSize: 1
     });
 
-    it('Should correctly execute findOneAndReplace operation With Promises and no options passed in', function (done) {
-      var configuration = this.configuration;
-      var client = configuration.newClient(configuration.writeConcernMax(), {
-        maxPoolSize: 1
+    client.connect().then(function (client) {
+      const db = client.db(configuration.db);
+      const col = db.collection('find_one_and_update_with_promise_no_option');
+      col.insertMany([{ a: 1, b: 1 }], { writeConcern: { w: 1 } }).then(function (r) {
+        expect(r).property('insertedCount').to.equal(1);
+
+        col
+          .findOneAndUpdate({ a: 1 }, { $set: { a: 1 } })
+          .then(function (r) {
+            test.equal(1, r.lastErrorObject.n);
+            test.equal(1, r.value.b);
+
+            client.close(done);
+          })
+          .catch(function (err) {
+            test.ok(err != null);
+          });
       });
+    });
+  });
 
-      client.connect().then(function (client) {
-        const db = client.db(configuration.db);
-        const col = db.collection('find_one_and_replace_with_promise_no_option');
-        col.insertMany([{ a: 1, b: 1 }], { writeConcern: { w: 1 } }).then(function (r) {
-          expect(r).property('insertedCount').to.equal(1);
-
-          col
-            .findOneAndReplace({ a: 1 }, { a: 1 })
-            .then(function (r) {
-              test.equal(1, r.lastErrorObject.n);
-              test.equal(1, r.value.b);
+  it('Should correctly execute findOneAndReplace operation and no options passed in', function (done) {
+    var configuration = this.configuration;
+    var client = configuration.newClient(configuration.writeConcernMax(), {
+      maxPoolSize: 1
+    });
 
-              client.close(done);
-            })
-            .catch(function (err) {
-              test.ok(err != null);
-            });
-        });
+    client.connect().then(function (client) {
+      const db = client.db(configuration.db);
+      const col = db.collection('find_one_and_replace_with_promise_no_option');
+      col.insertMany([{ a: 1, b: 1 }], { writeConcern: { w: 1 } }).then(function (r) {
+        expect(r).property('insertedCount').to.equal(1);
+
+        col
+          .findOneAndReplace({ a: 1 }, { a: 1 })
+          .then(function (r) {
+            test.equal(1, r.lastErrorObject.n);
+            test.equal(1, r.value.b);
+
+            client.close(done);
+          })
+          .catch(function (err) {
+            test.ok(err != null);
+          });
       });
     });
   });