test(7200): refactor tests

Author: tadjik1

test/integration/crud/remove.test.ts

@@ -1,6 +1,6 @@
 import { expect } from 'chai';
 
-import { type MongoClient } from '../../mongodb';
+import { type MongoClient } from '../../../src';
 
 describe('Remove', function () {
   let client: MongoClient;
@@ -13,123 +13,44 @@ describe('Remove', function () {
     await client.close();
   });
 
-  it('should correctly clear out collection', {
-    metadata: {
-      requires: { topology: ['single', 'replicaset', 'sharded', 'ssl', 'heap', 'wiredtiger'] }
-    },
+  it('should correctly clear out collection', async function () {
+    const db = client.db();
 
-    test: function (done) {
-      const db = client.db();
+    const collection = await db.createCollection('test_clear');
 
-      db.createCollection('test_clear', function (err) {
-        expect(err).to.not.exist;
+    await collection.insertOne({ i: 1 }, { writeConcern: { w: 1 } });
 
-        const collection = db.collection('test_clear');
+    await collection.insertOne({ i: 2 }, { writeConcern: { w: 1 } });
+    const count = await collection.countDocuments();
+    expect(count).to.equal(2);
 
-        collection.insert({ i: 1 }, { writeConcern: { w: 1 } }, function (err) {
-          expect(err).to.not.exist;
+    // Clear the collection
+    const r = await collection.deleteMany({}, { writeConcern: { w: 1 } });
+    expect(r).property('deletedCount').to.equal(2);
 
-          collection.insert({ i: 2 }, { writeConcern: { w: 1 } }, function (err) {
-            expect(err).to.not.exist;
+    const c = await collection.countDocuments();
+    expect(c).to.equal(0);
+  });
 
-            collection.count(function (err, count) {
-              expect(err).to.not.exist;
-              expect(count).to.equal(2);
+  it('should correctly remove document using RegExp', async function () {
+    const db = client.db(this.configuration.db);
 
-              // Clear the collection
-              collection.deleteMany({}, { writeConcern: { w: 1 } }, function (err, r) {
-                expect(err).to.not.exist;
-                expect(r).property('deletedCount').to.equal(2);
+    const collection = await db.createCollection('test_remove_regexp');
 
-                collection.count(function (err, count) {
-                  expect(err).to.not.exist;
-                  expect(count).to.equal(0);
+    await collection.insertOne({ address: '485 7th ave new york' }, { writeConcern: { w: 1 } });
 
-                  // Let's close the db
-                  client.close(done);
-                });
-              });
-            });
-          });
-        });
-      });
-    }
-  });
+    // Clear the collection
+    const r = await collection.deleteMany({ address: /485 7th ave/ }, { writeConcern: { w: 1 } });
+    expect(r).property('deletedCount').to.equal(1);
 
-  it('should correctly remove document using RegExp', {
-    metadata: {
-      requires: { topology: ['single', 'replicaset', 'sharded', 'ssl', 'heap', 'wiredtiger'] }
-    },
-
-    test: function (done) {
-      const self = this;
-      const client = self.configuration.newClient(self.configuration.writeConcernMax(), {
-        maxPoolSize: 1
-      });
-
-      client.connect(function (err, client) {
-        const db = client.db(self.configuration.db);
-        expect(err).to.not.exist;
-
-        db.createCollection('test_remove_regexp', function (err) {
-          expect(err).to.not.exist;
-
-          const collection = db.collection('test_remove_regexp');
-
-          collection.insert(
-            { address: '485 7th ave new york' },
-            { writeConcern: { w: 1 } },
-            function (err) {
-              expect(err).to.not.exist;
-
-              // Clear the collection
-              collection.deleteMany(
-                { address: /485 7th ave/ },
-                { writeConcern: { w: 1 } },
-                function (err, r) {
-                  expect(r).property('deletedCount').to.equal(1);
-
-                  collection.count(function (err, count) {
-                    expect(err).to.not.exist;
-                    expect(count).to.equal(0);
-
-                    // Let's close the db
-                    client.close(done);
-                  });
-                }
-              );
-            }
-          );
-        });
-      });
-    }
+    const count = await collection.countDocuments();
+    expect(count).to.equal(0);
   });
 
-  it('should not error on empty remove', {
-    metadata: {
-      requires: { topology: ['single', 'replicaset', 'sharded', 'ssl', 'heap', 'wiredtiger'] }
-    },
-
-    test: function (done) {
-      const self = this;
-      const client = self.configuration.newClient(self.configuration.writeConcernMax(), {
-        maxPoolSize: 1
-      });
-
-      client.connect(function (err, client) {
-        const db = client.db(self.configuration.db);
-        expect(err).to.not.exist;
-        const collection = db.collection('remove_test');
-
-        collection.deleteMany({}).then(
-          () => {
-            client.close(done);
-          },
-          err => {
-            client.close(err2 => done(err || err2));
-          }
-        );
-      });
-    }
+  it('should not throw error on empty remove', async function () {
+    const db = client.db(this.configuration.db);
+    const collection = db.collection('remove_test');
+
+    await collection.deleteMany({});
   });
 });