test: some cleanup re: #12890

Author: vkarpov15

lib/cursor/ChangeStream.js

@@ -54,6 +54,12 @@ class ChangeStream extends EventEmitter {
 
         ['close', 'change', 'end', 'error'].forEach(ev => {
           this.driverChangeStream.on(ev, data => {
+            // Sometimes Node driver still polls after close, so
+            // avoid any uncaught exceptions due to closed change streams
+            // See tests for gh-7022
+            if (ev === 'error' && this.closed) {
+              return;
+            }
             if (data != null && data.fullDocument != null && this.options && this.options.hydrate) {
               data.fullDocument = this.options.model.hydrate(data.fullDocument);
             }
@@ -71,6 +77,12 @@ class ChangeStream extends EventEmitter {
 
     ['close', 'change', 'end', 'error'].forEach(ev => {
       this.driverChangeStream.on(ev, data => {
+        // Sometimes Node driver still polls after close, so
+        // avoid any uncaught exceptions due to closed change streams
+        // See tests for gh-7022
+        if (ev === 'error' && this.closed) {
+          return;
+        }
         this.emit(ev, data);
       });
     });

test/collection.capped.test.js

@@ -19,15 +19,12 @@ const Schema = mongoose.Schema;
 describe('collections: capped:', function() {
   let db;
 
-  const connectionsToClose = [];
-
-  before(function() {
-    db = start();
-  });
-
-  after(async function() {
+  afterEach(async function() {
+    if (db == null) {
+      return;
+    }
     await db.close();
-    await Promise.all(connectionsToClose.map((v) => v.close()));
+    db = null;
   });
 
   it('schemas should have option size', function() {
@@ -41,6 +38,8 @@ describe('collections: capped:', function() {
   it('creation', async function() {
     this.timeout(15000);
 
+    db = start();
+
     await db.dropCollection('Test').catch(() => {});
 
     const capped = new Schema({ key: String });
@@ -55,7 +54,6 @@ describe('collections: capped:', function() {
 
   it('skips when setting autoCreate to false (gh-8566)', async function() {
     const db = start();
-    connectionsToClose.push(db);
     this.timeout(30000);
     await db.dropDatabase();
 

test/collection.test.js

@@ -8,15 +8,18 @@ const assert = require('assert');
 const mongoose = start.mongoose;
 
 describe('collections:', function() {
-  const connectionsToClose = [];
+  let db = null;
 
-  after(async function() {
-    await Promise.all(connectionsToClose.map((v) => v.close()));
+  this.afterEach(async function() {
+    if (db == null) {
+      return;
+    }
+    await db.close();
+    db = null;
   });
 
   it('should buffer commands until connection is established', function(done) {
-    const db = mongoose.createConnection();
-    connectionsToClose.push(db);
+    db = mongoose.createConnection();
     const collection = db.collection('test-buffering-collection');
     let connected = false;
     let insertedId = undefined;
@@ -49,8 +52,7 @@ describe('collections:', function() {
   });
 
   it('returns a promise if buffering and no callback (gh-7676)', function(done) {
-    const db = mongoose.createConnection();
-    connectionsToClose.push(db);
+    db = mongoose.createConnection();
     const collection = db.collection('gh7676');
 
     const promise = collection.insertOne({ foo: 'bar' }, {})
@@ -152,8 +154,7 @@ describe('collections:', function() {
   });
 
   it('buffers for sync methods (gh-10610)', function(done) {
-    const db = mongoose.createConnection();
-    connectionsToClose.push(db);
+    mongoose.createConnection();
     const collection = db.collection('gh10610');
 
     collection.find({}, {}, function(err, res) {

test/connection.test.js

@@ -773,29 +773,29 @@ describe('connections:', function() {
       db2.close();
     });
 
-    it('cache connections to the same db', function(done) {
+    it('cache connections to the same db', function() {
       const db = start();
       const db2 = db.useDb(start.databases[1], { useCache: true });
       const db3 = db.useDb(start.databases[1], { useCache: true });
 
       assert.strictEqual(db2, db3);
-      db.close(done);
+      return db.close();
     });
   });
 
   describe('shouldAuthenticate()', function() {
     describe('when using standard authentication', function() {
       describe('when username and password are undefined', function() {
-        it('should return false', function(done) {
+        it('should return false', function() {
           const db = mongoose.createConnection(start.uri, {});
 
           assert.equal(db.shouldAuthenticate(), false);
 
-          db.close(done);
+          return db.close();
         });
       });
       describe('when username and password are empty strings', function() {
-        it('should return false', function(done) {
+        it('should return false', function() {
           const db = mongoose.createConnection(start.uri, {
             user: '',
             pass: ''
@@ -804,7 +804,7 @@ describe('connections:', function() {
 
           assert.equal(db.shouldAuthenticate(), false);
 
-          db.close(done);
+          return db.close();
         });
       });
       describe('when both username and password are defined', function() {
@@ -823,14 +823,14 @@ describe('connections:', function() {
     });
     describe('when using MONGODB-X509 authentication', function() {
       describe('when username and password are undefined', function() {
-        it('should return false', function(done) {
+        it('should return false', function() {
           const db = mongoose.createConnection(start.uri, {});
           db.on('error', function() {
           });
 
           assert.equal(db.shouldAuthenticate(), false);
 
-          db.close(done);
+          return db.close();
         });
       });
       describe('when only username is defined', function() {

test/model.test.js

@@ -20,13 +20,10 @@ const EmbeddedDocument = mongoose.Types.Subdocument;
 const MongooseError = mongoose.Error;
 
 describe('Model', function() {
-
   let db;
   let Comments;
   let BlogPost;
 
-  const connectionsToClose = [];
-
   beforeEach(() => db.deleteModel(/.*/));
 
   beforeEach(function() {
@@ -84,7 +81,6 @@ describe('Model', function() {
 
   after(async function() {
     await db.close();
-    await Promise.all(connectionsToClose.map(async(v) => /* v instanceof Promise ? (await v).close() : */ v.close()));
   });
 
   afterEach(() => util.clearTestData(db));
@@ -3722,9 +3718,6 @@ describe('Model', function() {
     });
 
     it('with positional notation on path not existing in schema (gh-1048)', function(done) {
-      const db = start();
-      connectionsToClose.push(db);
-
       const M = db.model('Test', Schema({ name: 'string' }));
       db.on('open', function() {
         const o = {
@@ -4336,7 +4329,6 @@ describe('Model', function() {
   it('save max bson size error with buffering (gh-3906)', async function() {
     this.timeout(10000);
     const db = start({ noErrorListener: true });
-    connectionsToClose.push(db);
     const Test = db.model('Test', { name: Object });
 
     const test = new Test({
@@ -4355,7 +4347,6 @@ describe('Model', function() {
   it('reports max bson size error in save (gh-3906)', async function() {
     this.timeout(10000);
     const db = await start({ noErrorListener: true });
-    connectionsToClose.push(db);
     const Test = db.model('Test', { name: Object });
 
     const test = new Test({
@@ -5339,63 +5330,6 @@ describe('Model', function() {
           assert.equal(changeData.operationType, 'insert');
           assert.equal(changeData.fullDocument.name, 'Child');
         });
-
-        it('watch() before connecting (gh-5964)', async function() {
-          const db = start();
-          connectionsToClose.push(db);
-
-          const MyModel = db.model('Test5964', new Schema({ name: String }));
-
-          // Synchronous, before connection happens
-          const changeStream = MyModel.watch();
-          const changed = new global.Promise(resolve => {
-            changeStream.once('change', data => resolve(data));
-          });
-
-          await db;
-          await MyModel.create({ name: 'Ned Stark' });
-
-          const changeData = await changed;
-          assert.equal(changeData.operationType, 'insert');
-          assert.equal(changeData.fullDocument.name, 'Ned Stark');
-        });
-
-        it('watch() close() prevents buffered watch op from running (gh-7022)', async function() {
-          const db = start();
-          connectionsToClose.push(db);
-          const MyModel = db.model('Test', new Schema({}));
-          const changeStream = MyModel.watch();
-          const ready = new global.Promise(resolve => {
-            changeStream.once('data', () => {
-              resolve(true);
-            });
-            setTimeout(resolve, 500, false);
-          });
-
-          changeStream.close();
-          await db;
-          const readyCalled = await ready;
-          assert.strictEqual(readyCalled, false);
-        });
-
-        it('watch() close() closes the stream (gh-7022)', async function() {
-          const db = await start();
-          connectionsToClose.push(db);
-          const MyModel = db.model('Test', new Schema({ name: String }));
-
-          await MyModel.init();
-
-          const changeStream = MyModel.watch();
-          const closed = new global.Promise(resolve => {
-            changeStream.once('close', () => resolve(true));
-          });
-
-          await MyModel.create({ name: 'Hodor' });
-
-          changeStream.close();
-          const closedData = await closed;
-          assert.strictEqual(closedData, true);
-        });
       });
 
       describe('sessions (gh-6362)', function() {
@@ -5429,9 +5363,7 @@ describe('Model', function() {
         });
 
         it('startSession() before connecting', async function() {
-
           const db = start();
-          connectionsToClose.push(db);
 
           const MyModel = db.model('Test', new Schema({ name: String }));
 
@@ -5446,6 +5378,7 @@ describe('Model', function() {
 
           session.endSession();
 
+          await db.close();
         });
 
         it('sets session when pulling a document from db', async function() {

test/model.watch.test.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const assert = require('assert');
+const start = require('./common');
+
+const mongoose = start.mongoose;
+const Schema = mongoose.Schema;
+
+describe('model: watch: ', function() {
+  describe('with buffering', function() {
+    let db;
+
+    before(function() {
+      if (!process.env.REPLICA_SET) {
+        this.skip();
+      }
+    });
+
+    beforeEach(function() {
+      db = start();
+    });
+
+    afterEach(() => db.close());
+
+    it('watch() before connecting (gh-5964)', async function() {
+      const MyModel = db.model('Test5964', new Schema({ name: String }));
+
+      // Synchronous, before connection happens
+      const changeStream = MyModel.watch();
+      const changed = new global.Promise(resolve => {
+        changeStream.once('change', data => resolve(data));
+      });
+
+      await db.asPromise();
+      await MyModel.create({ name: 'Ned Stark' });
+
+      const changeData = await changed;
+      assert.equal(changeData.operationType, 'insert');
+      assert.equal(changeData.fullDocument.name, 'Ned Stark');
+    });
+
+    it('watch() close() prevents buffered watch op from running (gh-7022)', async function() {
+      const MyModel = db.model('Test', new Schema({}));
+      const changeStream = MyModel.watch();
+      const ready = new global.Promise(resolve => {
+        changeStream.once('data', () => {
+          resolve(true);
+        });
+        setTimeout(resolve, 500, false);
+      });
+
+      const close = changeStream.close();
+      await db.asPromise();
+      const readyCalled = await ready;
+      assert.strictEqual(readyCalled, false);
+
+      await close;
+    });
+
+    it('watch() close() closes the stream (gh-7022)', async function() {
+      const MyModel = db.model('Test', new Schema({ name: String }));
+
+      await db.asPromise();
+      await MyModel.init();
+
+      const changeStream = MyModel.watch();
+      const closed = new global.Promise(resolve => {
+        changeStream.once('close', () => resolve(true));
+      });
+
+      await MyModel.create({ name: 'Hodor' });
+
+      await changeStream.close();
+
+      const closedData = await closed;
+      assert.strictEqual(closedData, true);
+    });
+  });
+});