minor cleanup

Author: baileympearson

test/unit/assorted/server_discovery_and_monitoring.spec.test.ts

@@ -191,7 +191,7 @@ function assertMonitoringOutcome(outcome: any): asserts outcome is MonitoringOut
   expect(outcome).to.have.property('events').that.is.an('array');
 }
 
-describe.only('Server Discovery and Monitoring (spec)', function () {
+describe('Server Discovery and Monitoring (spec)', function () {
   let serverConnect: sinon.SinonStub;
 
   before(() => {
@@ -314,87 +314,100 @@ const SDAM_EVENTS = [
   ...HEARTBEAT_EVENTS
 ];
 
-function checkoutStubImpl(appError: ApplicationError) {
-  return async function () {
-    const connectionPoolGeneration = this.generation;
-    const fakeConnection = {
-      generation:
-        typeof appError.generation === 'number' ? appError.generation : connectionPoolGeneration,
-      async command(_, __, ___) {
-        switch (appError.type) {
-          case 'network':
-            throw new MongoNetworkError('test generated');
-          case 'timeout':
-            throw new MongoNetworkTimeoutError('xxx timed out');
-          case 'command':
-            throw new MongoServerError(appError.response);
-          default:
-            throw new Error(
-              // @ts-expect-error `.type` is never, but we want to access it in this unreachable code to
-              // throw an error message.
-              `SDAM unit test runner error: unexpected appError.type field: ${appError.type}`
-            );
-        }
-      }
-    };
-    return fakeConnection as any as Connection;
-  };
-}
-
-function stubConnectionEstablishment(appError: ApplicationError) {
-  const stubs = [];
-  if (appError.when === 'afterHandshakeCompletes') {
-    const checkOutStub = sinon
-      .stub(ConnectionPool.prototype, 'checkOut')
-      .callsFake(checkoutStubImpl(appError));
-    stubs.push(checkOutStub);
-    return stubs;
+function makeConnectionsError(appError: ApplicationError): sinon.SinonStub[] {
+  switch (appError.when) {
+    case 'beforeHandshakeCompletes':
+      return stubBeforeHandshake(appError);
+    case 'afterHandshakeCompletes':
+      return [
+        sinon.stub(ConnectionPool.prototype, 'checkOut').callsFake(checkoutStubImpl(appError))
+      ];
+    default:
+      throw new Error('unexpected value for `.when`: ' + appError.when);
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const net: typeof import('net') = require('net');
-
-  const netStub = sinon.stub(net, 'createConnection');
+  // if `appError.when === 'beforeHandshake`:
+  //   "Simulate this mock error as if it occurred during a new connection's handshake for an application operation."
+  // This function mocks the basic `createConnection` API to return an unconnected socket, and uses a special connection
+  // subclass that always throws when `command()` is executed.
+  function stubBeforeHandshake(appError: ApplicationError) {
+    const stubs = [];
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const net: typeof import('net') = require('net');
+
+    const netStub = sinon.stub(net, 'createConnection');
+
+    netStub.callsFake(function createConnectionStub() {
+      const socket = new net.Socket();
+      process.nextTick(() => socket.emit('connect'));
+      return socket;
+    });
 
-  netStub.callsFake(function createConnectionStub() {
-    const socket = new net.Socket();
-    process.nextTick(() => socket.emit('connect'));
-    return socket;
-  });
+    stubs.push(netStub);
+
+    class StubbedConnection extends Connection {
+      override command(
+        _ns: unknown,
+        command: Document,
+        _options?: unknown,
+        _responseType?: unknown
+      ): Promise<any> {
+        if (command.hello || command[LEGACY_HELLO_COMMAND]) {
+          throw new MongoNetworkError(`error executing command`, { beforeHandshake: true });
+        }
 
-  stubs.push(netStub);
-
-  class StubbedConnection extends Connection {
-    override command(
-      _ns: unknown,
-      command: Document,
-      _options?: unknown,
-      _responseType?: unknown
-    ): Promise<any> {
-      if (command.hello || command[LEGACY_HELLO_COMMAND]) {
-        throw new MongoNetworkError(`error executing command`, { beforeHandshake: true });
+        throw new Error('unexpected command: ', command);
       }
-
-      throw new Error('unexpected command: ', command);
     }
-  }
 
-  // eslint-disable-next-line @typescript-eslint/no-require-imports
-  const connectionUtils: typeof import('../../../src/cmap/connect') = require('../../../src/cmap/connect');
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const connectionUtils: typeof import('../../../src/cmap/connect') = require('../../../src/cmap/connect');
+
+    const wrapped = sinon
+      .stub(connectionUtils, 'connect')
+      .callsFake(async function connect(options) {
+        const generation =
+          typeof appError.generation === 'number' ? appError.generation : options.generation;
+        return wrapped.wrappedMethod({
+          ...options,
+          generation,
+          connectionType: StubbedConnection
+        });
+      });
 
-  const wrapped = sinon.stub(connectionUtils, 'connect').callsFake(async function connect(options) {
-    const generation =
-      typeof appError.generation === 'number' ? appError.generation : options.generation;
-    return wrapped.wrappedMethod({
-      ...options,
-      generation,
-      connectionType: StubbedConnection
-    });
-  });
+    stubs.push(wrapped);
 
-  stubs.push(wrapped);
+    return stubs;
+  }
 
-  return stubs;
+  // "Simulate this mock error as if it occurred on an established connection for an application operation (i.e. after the connection pool check out succeeds)."
+  // This one is simple - return a stubbed connection that always throws.  No need to worry about the internals of `connect()`.
+  function checkoutStubImpl(appError: ApplicationError) {
+    return async function () {
+      const connectionPoolGeneration = this.generation;
+      const fakeConnection = {
+        generation:
+          typeof appError.generation === 'number' ? appError.generation : connectionPoolGeneration,
+        async command(_, __, ___) {
+          switch (appError.type) {
+            case 'network':
+              throw new MongoNetworkError('test generated');
+            case 'timeout':
+              throw new MongoNetworkTimeoutError('xxx timed out');
+            case 'command':
+              throw new MongoServerError(appError.response);
+            default:
+              throw new Error(
+                // @ts-expect-error `.type` is never, but we want to access it in this unreachable code to
+                // throw a helpful error message.
+                `SDAM unit test runner error: unexpected appError.type field: ${appError.type}`
+              );
+          }
+        }
+      };
+      return fakeConnection as any as Connection;
+    };
+  }
 }
 
 async function executeSDAMTest(testData: SDAMTest) {
@@ -424,7 +437,7 @@ async function executeSDAMTest(testData: SDAMTest) {
         for (const appError of phase.applicationErrors) {
           // Stub will return appError to SDAM machinery
 
-          const stubs = stubConnectionEstablishment(appError);
+          const stubs = makeConnectionsError(appError);
 
           const server = client.topology.s.servers.get(appError.address);