use withClient for some tests

Author: HanaPearlman

test/functional/ignore_undefined.test.js

@@ -3,6 +3,7 @@ var test = require('./shared').assert;
 const { expect } = require('chai');
 var setupDatabase = require('./shared').setupDatabase;
 const { ObjectId } = require('../../src');
+const withClient = require('./shared').withClient;
 
 describe('Ignore Undefined', function () {
   before(function () {
@@ -152,23 +153,23 @@ describe('Ignore Undefined', function () {
   it('Should correctly inherit ignore undefined field from db during insert', {
     metadata: { requires: { topology: ['single'] } },
 
-    test: function (done) {
+    test: function () {
       var configuration = this.configuration;
       var client = configuration.newClient(configuration.writeConcernMax(), {
         poolSize: 1,
         ignoreUndefined: false
       });
 
-      client.connect(function (err, client) {
+      return withClient(client, (client, done) => {
         var db = client.db(configuration.db, { ignoreUndefined: true });
         var collection = db.collection('shouldCorrectlyIgnoreUndefinedValue3');
 
         // Ignore the undefined field
-        collection.insert({ a: 1, b: undefined }, configuration.writeConcernMax(), function (err) {
+        collection.insert({ a: 1, b: undefined }, configuration.writeConcernMax(), err => {
           expect(err).to.not.exist;
 
           // Locate the doument
-          collection.findOne(function (err, item) {
+          collection.findOne((err, item) => {
             test.equal(1, item.a);
             test.ok(item.b === undefined);
             client.close(done);
@@ -178,134 +179,111 @@ describe('Ignore Undefined', function () {
     }
   });
 
-  it('Should correctly inherit ignore undefined field from collection during insert', {
-    metadata: { requires: { topology: ['single'] } },
-
-    test: function (done) {
-      var configuration = this.configuration;
-      var client = configuration.newClient(configuration.writeConcernMax(), {
-        poolSize: 1
-      });
-
+  it(
+    'Should correctly inherit ignore undefined field from collection during insert',
+    withClient(function (client, done) {
       client.connect(function (err, client) {
-        var db = client.db(configuration.db, { ignoreUndefined: false });
+        var db = client.db('shouldCorrectlyIgnoreUndefinedValue4', { ignoreUndefined: false });
         var collection = db.collection('shouldCorrectlyIgnoreUndefinedValue4', {
           ignoreUndefined: true
         });
 
         // Ignore the undefined field
-        collection.insert({ a: 1, b: undefined }, configuration.writeConcernMax(), function (err) {
+        collection.insert({ a: 1, b: undefined }, err => {
           expect(err).to.not.exist;
 
           // Locate the doument
-          collection.findOne(function (err, item) {
+          collection.findOne((err, item) => {
             test.equal(1, item.a);
             test.ok(item.b === undefined);
-            client.close(done);
+            done();
           });
         });
       });
-    }
-  });
-
-  it('Should correctly inherit ignore undefined field from operation during insert', {
-    metadata: { requires: { topology: ['single'] } },
-
-    test: function (done) {
-      var configuration = this.configuration;
-      var client = configuration.newClient(configuration.writeConcernMax(), {
-        poolSize: 1
-      });
+    })
+  );
 
-      client.connect(function (err, client) {
-        var db = client.db(configuration.db);
+  it(
+    'Should correctly inherit ignore undefined field from operation during insert',
+    withClient(function (client, done) {
+      client.connect((err, client) => {
+        var db = client.db('shouldCorrectlyIgnoreUndefinedValue5');
         var collection = db.collection('shouldCorrectlyIgnoreUndefinedValue5', {
           ignoreUndefined: false
         });
 
         // Ignore the undefined field
-        collection.insert({ a: 1, b: undefined }, { ignoreUndefined: true }, function (err) {
+        collection.insert({ a: 1, b: undefined }, { ignoreUndefined: true }, err => {
           expect(err).to.not.exist;
 
           // Locate the doument
-          collection.findOne({}, function (err, item) {
+          collection.findOne({}, (err, item) => {
             expect(err).to.not.exist;
             test.equal(1, item.a);
             test.ok(item.b === undefined);
-            client.close(done);
+            done();
           });
         });
       });
-    }
-  });
-
-  it('Should correctly inherit ignore undefined field from operation during findOneAndReplace', {
-    metadata: { requires: { topology: ['single'] } },
-
-    test: function (done) {
-      var configuration = this.configuration;
-      var client = configuration.newClient(configuration.writeConcernMax(), {
-        poolSize: 1,
-        ignoreUndefined: false
-      });
+    })
+  );
 
-      client.connect(function (err, client) {
-        var db = client.db(configuration.db);
-        var collection = db.collection('shouldCorrectlyIgnoreUndefinedValue6');
+  it(
+    'Should correctly inherit ignore undefined field from operation during findOneAndReplace',
+    withClient(function (client, done) {
+      client.connect((err, client) => {
+        var db = client.db('shouldCorrectlyIgnoreUndefinedValue6');
+        var collection = db.collection('shouldCorrectlyIgnoreUndefinedValue6', {
+          ignoreUndefined: false
+        });
 
-        collection.insert({ a: 1, b: 2 }, configuration.writeConcernMax(), function (err) {
+        collection.insert({ a: 1, b: 2 }, err => {
           expect(err).to.not.exist;
 
           // Replace the doument, ignoring undefined fields
           collection.findOneAndReplace(
             {},
             { a: 1, b: undefined },
             { ignoreUndefined: true },
-            function (err) {
+            err => {
               expect(err).to.not.exist;
 
               // Locate the doument
-              collection.findOne(function (err, item) {
+              collection.findOne((err, item) => {
                 test.equal(1, item.a);
                 test.ok(item.b === undefined);
-                client.close(done);
+                done();
               });
             }
           );
         });
       });
-    }
-  });
-
-  it('Should correctly ignore undefined field during bulk write', {
-    metadata: { requires: { topology: ['single'] } },
-
-    test: function (done) {
-      var configuration = this.configuration;
-      var client = configuration.newClient(configuration.writeConcernMax(), {
-        poolSize: 1
-      });
+    })
+  );
 
-      client.connect(function (err, client) {
-        var db = client.db(configuration.db);
+  it(
+    'Should correctly ignore undefined field during bulk write',
+    withClient(function (client, done) {
+      client.connect((err, client) => {
+        var db = client.db('shouldCorrectlyIgnoreUndefinedValue7');
         var collection = db.collection('shouldCorrectlyIgnoreUndefinedValue7');
 
         // Ignore the undefined field
         collection.bulkWrite(
           [{ insertOne: { a: 0, b: undefined } }],
           { ignoreUndefined: true },
-          function (err) {
+          err => {
             expect(err).to.not.exist;
 
             // Locate the doument
-            collection.findOne(function (err, item) {
+            collection.findOne((err, item) => {
               test.equal(0, item.a);
               test.ok(item.b === undefined);
-              client.close(done);
+              done();
             });
           }
         );
       });
-    }
-  });
+    })
+  );
 });