fix SDAM unit test behavior

Author: baileympearson

test/spec/server-discovery-and-monitoring/errors/error_handling_handshake.json

@@ -97,14 +97,22 @@
       "outcome": {
         "servers": {
           "a:27017": {
-            "type": "Unknown",
-            "topologyVersion": null,
+            "type": "RSPrimary",
+            "setName": "rs",
+            "topologyVersion": {
+              "processId": {
+                "$oid": "000000000000000000000001"
+              },
+              "counter": {
+                "$numberLong": "1"
+              }
+            },
             "pool": {
-              "generation": 1
+              "generation": 0
             }
           }
         },
-        "topologyType": "ReplicaSetNoPrimary",
+        "topologyType": "ReplicaSetWithPrimary",
         "logicalSessionTimeoutMinutes": null,
         "setName": "rs"
       }

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

@@ -4,9 +4,11 @@ import * as fs from 'fs';
 import * as path from 'path';
 import * as sinon from 'sinon';
 
+import { Connection } from '../../../src/cmap/connection';
 import { ConnectionPool } from '../../../src/cmap/connection_pool';
 import {
   HEARTBEAT_EVENTS,
+  LEGACY_HELLO_COMMAND,
   SERVER_CLOSED,
   SERVER_DESCRIPTION_CHANGED,
   SERVER_OPENING,
@@ -37,6 +39,7 @@ import {
 import { Server } from '../../../src/sdam/server';
 import { ServerDescription, type TopologyVersion } from '../../../src/sdam/server_description';
 import { Topology } from '../../../src/sdam/topology';
+import { TimeoutContext } from '../../../src/timeout';
 import { isRecord, ns, squashError } from '../../../src/utils';
 import { ejson, fakeServer } from '../../tools/utils';
 
@@ -188,7 +191,7 @@ function assertMonitoringOutcome(outcome: any): asserts outcome is MonitoringOut
   expect(outcome).to.have.property('events').that.is.an('array');
 }
 
-describe('Server Discovery and Monitoring (spec)', function () {
+describe.only('Server Discovery and Monitoring (spec)', function () {
   let serverConnect: sinon.SinonStub;
 
   before(() => {
@@ -311,6 +314,89 @@ 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;
+  }
+
+  // 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;
+  });
+
+  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);
+    }
+  }
+
+  // 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
+    });
+  });
+
+  stubs.push(wrapped);
+
+  return stubs;
+}
+
 async function executeSDAMTest(testData: SDAMTest) {
   const client = new MongoClient(testData.uri);
   // listen for SDAM monitoring events
@@ -337,20 +423,23 @@ async function executeSDAMTest(testData: SDAMTest) {
         // phase with applicationErrors simulating error's from network, timeouts, server
         for (const appError of phase.applicationErrors) {
           // Stub will return appError to SDAM machinery
-          const checkOutStub = sinon
-            .stub(ConnectionPool.prototype, 'checkOut')
-            .callsFake(checkoutStubImpl(appError));
+
+          const stubs = stubConnectionEstablishment(appError);
 
           const server = client.topology.s.servers.get(appError.address);
 
           // Run a dummy command to encounter the error
-          const res = server.command.bind(server)(
-            new RunCommandOperation(ns('admin.$cmd'), { ping: 1 }, {})
+          const res = server.command(
+            new RunCommandOperation(ns('admin.$cmd'), { ping: 1 }, {}),
+            TimeoutContext.create({
+              serverSelectionTimeoutMS: 30_000,
+              waitQueueTimeoutMS: 10_000
+            })
           );
           const thrownError = await res.catch(error => error);
 
           // Restore the stub before asserting anything in case of errors
-          checkOutStub.restore();
+          stubs.forEach(stub => stub.restore());
 
           const isApplicationError = error => {
             // These errors all come from the withConnection stub
@@ -412,28 +501,6 @@ async function executeSDAMTest(testData: SDAMTest) {
   }
 }
 
-function checkoutStubImpl(appError) {
-  return async function () {
-    const connectionPoolGeneration = this.generation;
-    const fakeConnection = {
-      generation:
-        typeof appError.generation === 'number' ? appError.generation : connectionPoolGeneration,
-      async command(_, __, ___) {
-        if (appError.type === 'network') {
-          throw new MongoNetworkError('test generated');
-        } else if (appError.type === 'timeout') {
-          throw new MongoNetworkTimeoutError('xxx timed out', {
-            beforeHandshake: appError.when === 'beforeHandshakeCompletes'
-          });
-        } else {
-          throw new MongoServerError(appError.response);
-        }
-      }
-    };
-    return fakeConnection;
-  };
-}
-
 function assertTopologyDescriptionOutcomeExpectations(
   topology: Topology,
   outcome: TopologyDescriptionOutcome