migrate killCursors

Author: baileympearson

src/operations/kill_cursors.ts

@@ -1,10 +1,12 @@
 import type { Long } from '../bson';
-import { MongoRuntimeError } from '../error';
-import type { Server } from '../sdam/server';
+import { type Connection } from '../cmap/connection';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
+import { type MongoError, MongoRuntimeError } from '../error';
+import type { Server, ServerCommandOptions } from '../sdam/server';
 import type { ClientSession } from '../sessions';
 import { type TimeoutContext } from '../timeout';
-import { type MongoDBNamespace, squashError } from '../utils';
-import { AbstractOperation, Aspect, defineAspects, type OperationOptions } from './operation';
+import { type MongoDBNamespace } from '../utils';
+import { Aspect, defineAspects, ModernizedOperation, type OperationOptions } from './operation';
 
 /**
  * https://www.mongodb.com/docs/manual/reference/command/killCursors/
@@ -16,7 +18,8 @@ interface KillCursorsCommand {
   comment?: unknown;
 }
 
-export class KillCursorsOperation extends AbstractOperation {
+export class KillCursorsOperation extends ModernizedOperation<void> {
+  override SERVER_COMMAND_RESPONSE_TYPE = MongoDBResponse;
   cursorId: Long;
 
   constructor(cursorId: Long, ns: MongoDBNamespace, server: Server, options: OperationOptions) {
@@ -30,15 +33,7 @@ export class KillCursorsOperation extends AbstractOperation {
     return 'killCursors' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<void> {
-    if (server !== this.server) {
-      throw new MongoRuntimeError('Killcursor must run on the same server operation began on');
-    }
-
+  override buildCommand(_connection: Connection, _session?: ClientSession): KillCursorsCommand {
     const killCursors = this.ns.collection;
     if (killCursors == null) {
       // Cursors should have adopted the namespace returned by MongoDB
@@ -50,15 +45,19 @@ export class KillCursorsOperation extends AbstractOperation {
       killCursors,
       cursors: [this.cursorId]
     };
-    try {
-      await server.command(this.ns, killCursorsCommand, {
-        session,
-        timeoutContext
-      });
-    } catch (error) {
-      // The driver should never emit errors from killCursors, this is spec-ed behavior
-      squashError(error);
-    }
+
+    return killCursorsCommand;
+  }
+
+  override buildOptions(timeoutContext: TimeoutContext): ServerCommandOptions {
+    return {
+      session: this.session,
+      timeoutContext
+    };
+  }
+
+  override handleError(_error: MongoError): void {
+    // The driver should never emit errors from killCursors, this is spec-ed behavior
   }
 }
 

test/unit/operations/kill_cursors.test.ts

@@ -1,22 +1,16 @@
 import { expect } from 'chai';
-import * as sinon from 'sinon';
 
 import {
   KillCursorsOperation,
   Long,
   MongoDBNamespace,
-  MongoRuntimeError,
   ns,
   Server,
   ServerDescription
 } from '../../mongodb';
 import { topologyWithPlaceholderClient } from '../../tools/utils';
 
 describe('class KillCursorsOperation', () => {
-  afterEach(function () {
-    sinon.restore();
-  });
-
   describe('constructor()', () => {
     const cursorId = Long.fromBigInt(0xffff_ffffn);
     const namespace = ns('db.collection');
@@ -43,60 +37,22 @@ describe('class KillCursorsOperation', () => {
 
   describe('execute()', () => {
     const cursorId = Long.fromBigInt(0xffff_ffffn);
-    const namespace = ns('db.collection');
     const server = new Server(
       topologyWithPlaceholderClient([], {} as any),
       new ServerDescription('a:1'),
       {} as any
     );
-    const differentServer = new Server(
-      topologyWithPlaceholderClient([], {} as any),
-      new ServerDescription('a:1'),
-      {} as any
-    );
     const options = {};
 
-    it('should throw if the server defined from the constructor changes', async () => {
-      const killCursorsOperation = new KillCursorsOperation(
-        cursorId,
-        namespace,
-        server,
-        options
-      ) as any;
-
-      const error = await killCursorsOperation
-        .execute(differentServer, undefined)
-        .catch(error => error);
-
-      expect(error).to.be.instanceOf(MongoRuntimeError);
-    });
-
     it('should throw if the namespace does not define a collection', async () => {
-      const killCursorsOperation = new KillCursorsOperation(
-        cursorId,
-        ns('db'),
-        server,
-        options
-      ) as any;
-
-      const error = await killCursorsOperation.execute(server, undefined).catch(error => error);
-
-      expect(error).to.be.instanceOf(MongoRuntimeError);
-    });
-
-    it('should construct a killCursors command', async () => {
-      const killCursorsOperation = new KillCursorsOperation(
-        cursorId,
-        namespace,
-        server,
-        options
-      ) as any;
-      const stub = sinon.stub(server, 'command').resolves({});
-      await killCursorsOperation.execute(server, undefined);
-      expect(stub).to.have.been.calledOnceWith(namespace, {
-        killCursors: namespace.collection,
-        cursors: [cursorId]
-      });
+      const killCursorsOperation = new KillCursorsOperation(cursorId, ns('db'), server, options);
+
+      const connection = {
+        description: {}
+      } as any;
+      expect(() => {
+        killCursorsOperation.buildCommand(connection);
+      }).to.throw(/A collection name must be determined before killCursors/);
     });
   });
 });