validate collection

Author: baileympearson

src/operations/validate_collection.ts

@@ -1,58 +1,59 @@
+import { type Connection } from '..';
 import type { Admin } from '../admin';
-import type { Document } from '../bson';
+import { BSONType, type Document } from '../bson';
+import { MongoDBResponse } from '../cmap/wire_protocol/responses';
 import { MongoUnexpectedServerResponseError } from '../error';
-import type { Server } from '../sdam/server';
 import type { ClientSession } from '../sessions';
-import { type TimeoutContext } from '../timeout';
-import { CommandOperation, type CommandOperationOptions } from './command';
+import { type CommandOperationOptions, ModernizedCommandOperation } from './command';
 
 /** @public */
 export interface ValidateCollectionOptions extends CommandOperationOptions {
   /** Validates a collection in the background, without interrupting read or write traffic (only in MongoDB 4.4+) */
   background?: boolean;
 }
 
+class ValidateCollectionResponse extends MongoDBResponse {
+  get result(): string | null {
+    return this.get('result', BSONType.string);
+  }
+
+  get valid(): boolean | null {
+    return this.get('valid', BSONType.bool);
+  }
+}
+
 /** @internal */
-export class ValidateCollectionOperation extends CommandOperation<Document> {
+export class ValidateCollectionOperation extends ModernizedCommandOperation<Document> {
+  override SERVER_COMMAND_RESPONSE_TYPE = ValidateCollectionResponse;
   override options: ValidateCollectionOptions;
   collectionName: string;
-  command: Document;
 
   constructor(admin: Admin, collectionName: string, options: ValidateCollectionOptions) {
-    // Decorate command with extra options
-    const command: Document = { validate: collectionName };
-    const keys = Object.keys(options);
-    for (let i = 0; i < keys.length; i++) {
-      if (Object.prototype.hasOwnProperty.call(options, keys[i]) && keys[i] !== 'session') {
-        command[keys[i]] = (options as Document)[keys[i]];
-      }
-    }
-
     super(admin.s.db, options);
     this.options = options;
-    this.command = command;
     this.collectionName = collectionName;
   }
 
   override get commandName() {
     return 'validate' as const;
   }
 
-  override async execute(
-    server: Server,
-    session: ClientSession | undefined,
-    timeoutContext: TimeoutContext
-  ): Promise<Document> {
-    const collectionName = this.collectionName;
+  override buildCommandDocument(_connection: Connection, _session?: ClientSession): Document {
+    // Decorate command with extra options
+    return {
+      validate: this.collectionName,
+      ...Object.fromEntries(Object.entries(this.options).filter(entry => entry[0] !== 'session'))
+    };
+  }
 
-    const doc = await super.executeCommand(server, session, this.command, timeoutContext);
-    if (doc.result != null && typeof doc.result !== 'string')
+  override handleOk(response: InstanceType<typeof this.SERVER_COMMAND_RESPONSE_TYPE>): Document {
+    if (response.result != null && typeof response.result !== 'string')
       throw new MongoUnexpectedServerResponseError('Error with validation data');
-    if (doc.result != null && doc.result.match(/exception|corrupt/) != null)
-      throw new MongoUnexpectedServerResponseError(`Invalid collection ${collectionName}`);
-    if (doc.valid != null && !doc.valid)
-      throw new MongoUnexpectedServerResponseError(`Invalid collection ${collectionName}`);
+    if (response.result != null && response.result.match(/exception|corrupt/) != null)
+      throw new MongoUnexpectedServerResponseError(`Invalid collection ${this.collectionName}`);
+    if (response.valid != null && !response.valid)
+      throw new MongoUnexpectedServerResponseError(`Invalid collection ${this.collectionName}`);
 
-    return doc;
+    return response.toObject(this.bsonOptions);
   }
 }

test/integration/node-specific/validate_collection.test.ts

@@ -0,0 +1,84 @@
+import { expect } from 'chai';
+
+import { ValidateCollectionOperation } from '../../mongodb';
+
+describe('ValidateCollectionOperation', function () {
+  let client;
+
+  beforeEach(function () {
+    client = this.configuration.newClient();
+  });
+
+  afterEach(async function () {
+    await client.close();
+  });
+
+  describe('buildCommandDocument()', function () {
+    it('builds the base command when no options are provided', function () {
+      client = this.configuration.newClient();
+      const op = new ValidateCollectionOperation(client.db('foo').admin(), 'bar', {});
+
+      const doc = op.buildCommandDocument({} as any, {} as any);
+      expect(doc).to.deep.equal({
+        validate: 'bar'
+      });
+    });
+
+    it('supports background=true', function () {
+      client = this.configuration.newClient();
+      const op = new ValidateCollectionOperation(client.db('foo').admin(), 'bar', {
+        background: true
+      });
+
+      const doc = op.buildCommandDocument({} as any, {} as any);
+      expect(doc).to.deep.equal({
+        validate: 'bar',
+        background: true
+      });
+    });
+
+    it('supports background=false', function () {
+      client = this.configuration.newClient();
+      const op = new ValidateCollectionOperation(client.db('foo').admin(), 'bar', {
+        background: false
+      });
+
+      const doc = op.buildCommandDocument({} as any, {} as any);
+      expect(doc).to.deep.equal({
+        validate: 'bar',
+        background: false
+      });
+    });
+
+    it('attaches all options to the command document', function () {
+      client = this.configuration.newClient();
+      const op = new ValidateCollectionOperation(client.db('foo').admin(), 'bar', {
+        background: false,
+        a: 1,
+        b: 2,
+        c: 3
+      });
+
+      const doc = op.buildCommandDocument({} as any, {} as any);
+      expect(doc).to.deep.equal({
+        validate: 'bar',
+        background: false,
+        a: 1,
+        b: 2,
+        c: 3
+      });
+    });
+
+    it('does not attach session command document', function () {
+      client = this.configuration.newClient();
+      const op = new ValidateCollectionOperation(client.db('foo').admin(), 'bar', {
+        session: client.startSession()
+      });
+
+      const doc = op.buildCommandDocument({} as any, {} as any);
+      expect(doc).to.deep.equal({
+        validate: 'bar'
+      });
+    });
+  });
+});