refactor: make event names consistent with spec, remove error types

Author: mbroadst

lib/cmap/connection_pool.js

@@ -14,16 +14,16 @@ const PoolClosedError = errors.PoolClosedError;
 const WaitQueueTimeoutError = errors.WaitQueueTimeoutError;
 
 const events = require('./events');
-const PoolCreatedEvent = events.PoolCreatedEvent;
-const PoolClosedEvent = events.PoolClosedEvent;
+const ConnectionPoolCreatedEvent = events.ConnectionPoolCreatedEvent;
+const ConnectionPoolClosedEvent = events.ConnectionPoolClosedEvent;
 const ConnectionCreatedEvent = events.ConnectionCreatedEvent;
 const ConnectionReadyEvent = events.ConnectionReadyEvent;
 const ConnectionClosedEvent = events.ConnectionClosedEvent;
 const ConnectionCheckOutStartedEvent = events.ConnectionCheckOutStartedEvent;
 const ConnectionCheckOutFailedEvent = events.ConnectionCheckOutFailedEvent;
 const ConnectionCheckedOutEvent = events.ConnectionCheckedOutEvent;
 const ConnectionCheckedInEvent = events.ConnectionCheckedInEvent;
-const PoolClearedEvent = events.PoolClearedEvent;
+const ConnectionPoolClearedEvent = events.ConnectionPoolClearedEvent;
 
 const kConnections = Symbol('connections');
 const kPermits = Symbol('permits');
@@ -147,7 +147,7 @@ class ConnectionPool extends EventEmitter {
     this[kWaitQueue] = new Denque();
 
     process.nextTick(() => {
-      this.emit('connectionPoolCreated', new PoolCreatedEvent(this));
+      this.emit('connectionPoolCreated', new ConnectionPoolCreatedEvent(this));
       ensureMinPoolSize(this);
     });
   }
@@ -223,7 +223,7 @@ class ConnectionPool extends EventEmitter {
    */
   clear() {
     this[kGeneration] += 1;
-    this.emit('connectionPoolCleared', new PoolClearedEvent(this));
+    this.emit('connectionPoolCleared', new ConnectionPoolClearedEvent(this));
   }
 
   /**
@@ -276,7 +276,7 @@ class ConnectionPool extends EventEmitter {
       },
       err => {
         this[kConnections].clear();
-        this.emit('connectionPoolClosed', new PoolClosedEvent(this));
+        this.emit('connectionPoolClosed', new ConnectionPoolClosedEvent(this));
         callback(err);
       }
     );

lib/cmap/errors.js

@@ -4,17 +4,15 @@ const MongoError = require('../core/error').MongoError;
 class PoolClosedError extends MongoError {
   constructor(pool) {
     super('Attempted to check out a connection from closed connection pool');
-    Error.captureStackTrace(this, this.constructor);
-    this.type = 'PoolClosedError';
+    this.name = 'MongoPoolClosedError';
     this.address = pool.address;
   }
 }
 
 class WaitQueueTimeoutError extends MongoError {
   constructor(pool) {
     super('Timed out while checking out a connection from connection pool');
-    Error.captureStackTrace(this, this.constructor);
-    this.type = 'WaitQueueTimeoutError';
+    this.name = 'MongoWaitQueueTimeoutError';
     this.address = pool.address;
   }
 }

lib/cmap/events.js

@@ -1,90 +1,90 @@
 'use strict';
 
-class PoolMonitoringEvent {
+class ConnectionPoolMonitoringEvent {
   constructor(type, pool) {
     this.time = new Date();
     this.type = type;
     this.address = pool.address;
   }
 }
 
-class PoolCreatedEvent extends PoolMonitoringEvent {
+class ConnectionPoolCreatedEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool) {
     super('ConnectionPoolCreated', pool);
     this.options = pool.options;
   }
 }
 
-class PoolClosedEvent extends PoolMonitoringEvent {
+class ConnectionPoolClosedEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool) {
     super('ConnectionPoolClosed', pool);
   }
 }
 
-class ConnectionCreatedEvent extends PoolMonitoringEvent {
+class ConnectionCreatedEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool, connection) {
     super('ConnectionCreated', pool);
     this.connectionId = connection.id;
   }
 }
 
-class ConnectionReadyEvent extends PoolMonitoringEvent {
+class ConnectionReadyEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool, connection) {
     super('ConnectionReady', pool);
     this.connectionId = connection.id;
   }
 }
 
-class ConnectionClosedEvent extends PoolMonitoringEvent {
+class ConnectionClosedEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool, connection, reason) {
     super('ConnectionClosed', pool);
     this.connectionId = connection.id;
     this.reason = reason || 'unknown';
   }
 }
 
-class ConnectionCheckOutStartedEvent extends PoolMonitoringEvent {
+class ConnectionCheckOutStartedEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool) {
     super('ConnectionCheckOutStarted', pool);
   }
 }
 
-class ConnectionCheckOutFailedEvent extends PoolMonitoringEvent {
+class ConnectionCheckOutFailedEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool, reason) {
     super('ConnectionCheckOutFailed', pool);
     this.reason = reason;
   }
 }
 
-class ConnectionCheckedOutEvent extends PoolMonitoringEvent {
+class ConnectionCheckedOutEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool, connection) {
     super('ConnectionCheckedOut', pool);
     this.connectionId = connection.id;
   }
 }
 
-class ConnectionCheckedInEvent extends PoolMonitoringEvent {
+class ConnectionCheckedInEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool, connection) {
     super('ConnectionCheckedIn', pool);
     this.connectionId = connection.id;
   }
 }
 
-class PoolClearedEvent extends PoolMonitoringEvent {
+class ConnectionPoolClearedEvent extends ConnectionPoolMonitoringEvent {
   constructor(pool) {
     super('ConnectionPoolCleared', pool);
   }
 }
 
 module.exports = {
-  PoolCreatedEvent,
-  PoolClosedEvent,
+  ConnectionPoolCreatedEvent,
+  ConnectionPoolClosedEvent,
   ConnectionCreatedEvent,
   ConnectionReadyEvent,
   ConnectionClosedEvent,
   ConnectionCheckOutStartedEvent,
   ConnectionCheckOutFailedEvent,
   ConnectionCheckedOutEvent,
   ConnectionCheckedInEvent,
-  PoolClearedEvent
+  ConnectionPoolClearedEvent
 };

test/unit/cmap/connection_pool.test.js

@@ -250,6 +250,11 @@ describe('Connection Pool', function() {
       return thread;
     }
 
+    function eventType(event) {
+      const eventName = event.constructor.name;
+      return eventName.substring(0, eventName.lastIndexOf('Event'));
+    }
+
     const OPERATION_FUNCTIONS = {
       checkOut: function(op) {
         return PROMISIFIED_POOL_FUNCTIONS.checkOut.call(pool).then(connection => {
@@ -307,7 +312,7 @@ describe('Connection Pool', function() {
         const count = options.count;
         return new Promise(resolve => {
           function run() {
-            if (poolEvents.filter(ev => ev.type === event).length >= count) {
+            if (poolEvents.filter(ev => eventType(ev) === event).length >= count) {
               return resolve();
             }