add tests, fix behaviors

addaleax · addaleax · commit fea6cebe2629 · 2025-11-18T03:48:02.000+01:00
diff --git a/packages/mongodb-runner/src/mongocluster.spec.ts b/packages/mongodb-runner/src/mongocluster.spec.ts
@@ -345,4 +345,172 @@ describe('MongoCluster', function () {
       baddoc: 1,
     });
   });
+
+  it('can pass custom arguments for replica set members', async function () {
+    cluster = await MongoCluster.start({
+      version: '6.x',
+      topology: 'replset',
+      tmpDir,
+      rsMembers: [
+        { args: ['--setParameter', 'cursorTimeoutMillis=60000'] },
+        { args: ['--setParameter', 'cursorTimeoutMillis=50000'] },
+      ],
+    });
+
+    expect(cluster.connectionString).to.be.a('string');
+    expect(cluster.serverVersion).to.match(/^6\./);
+    const hello = await cluster.withClient(async (client) => {
+      return await client.db('admin').command({ hello: 1 });
+    });
+    expect(hello.hosts).to.have.lengthOf(1);
+    expect(hello.passives).to.have.lengthOf(1);
+
+    const servers = cluster['servers'];
+    expect(servers).to.have.lengthOf(2);
+    const values = await Promise.all(
+      servers.map((srv) =>
+        srv.withClient(async (client) => {
+          return await Promise.all([
+            client
+              .db('admin')
+              .command({ getParameter: 1, cursorTimeoutMillis: 1 }),
+            client.db('admin').command({ hello: 1 }),
+          ]);
+        }),
+      ),
+    );
+
+    expect(
+      values.map((v) => [v[0].cursorTimeoutMillis, v[1].isWritablePrimary]),
+    ).to.deep.equal([
+      [60000, true],
+      [50000, false],
+    ]);
+  });
+
+  it('can pass custom arguments for shards', async function () {
+    cluster = await MongoCluster.start({
+      version: '6.x',
+      topology: 'sharded',
+      tmpDir,
+      secondaries: 0,
+      shardArgs: [
+        ['--setParameter', 'cursorTimeoutMillis=60000'],
+        ['--setParameter', 'cursorTimeoutMillis=50000'],
+      ],
+    });
+
+    expect(cluster.connectionString).to.be.a('string');
+    expect(cluster.serverVersion).to.match(/^6\./);
+
+    const shards = cluster['shards'];
+    expect(shards).to.have.lengthOf(2);
+    const values = await Promise.all(
+      shards.map((srv) =>
+        srv.withClient(async (client) => {
+          return await Promise.all([
+            client
+              .db('admin')
+              .command({ getParameter: 1, cursorTimeoutMillis: 1 }),
+            client.db('admin').command({ hello: 1 }),
+          ]);
+        }),
+      ),
+    );
+
+    expect(
+      values.map((v) => [
+        v[0].cursorTimeoutMillis,
+        v[1].setName === values[0][1].setName,
+      ]),
+    ).to.deep.equal([
+      [60000, true],
+      [50000, false],
+    ]);
+  });
+
+  it('can pass custom arguments for mongoses', async function () {
+    cluster = await MongoCluster.start({
+      version: '6.x',
+      topology: 'sharded',
+      tmpDir,
+      secondaries: 0,
+      mongosArgs: [
+        ['--setParameter', 'cursorTimeoutMillis=60000'],
+        ['--setParameter', 'cursorTimeoutMillis=50000'],
+      ],
+    });
+
+    expect(cluster.connectionString).to.be.a('string');
+    expect(cluster.serverVersion).to.match(/^6\./);
+
+    const mongoses = cluster['servers'];
+    expect(mongoses).to.have.lengthOf(2);
+    const values = await Promise.all(
+      mongoses.map((srv) =>
+        srv.withClient(async (client) => {
+          return await Promise.all([
+            client
+              .db('admin')
+              .command({ getParameter: 1, cursorTimeoutMillis: 1 }),
+            client.db('admin').command({ hello: 1 }),
+          ]);
+        }),
+      ),
+    );
+
+    const processIdForMongos = (v: any) =>
+      v[1].topologyVersion.processId.toHexString();
+    expect(
+      values.map((v) => [
+        v[0].cursorTimeoutMillis,
+        v[1].msg,
+        processIdForMongos(v) === processIdForMongos(values[0]),
+      ]),
+    ).to.deep.equal([
+      [60000, 'isdbgrid', true],
+      [50000, 'isdbgrid', false],
+    ]);
+  });
+
+  it('can add authentication options and verify them after serialization', async function () {
+    cluster = await MongoCluster.start({
+      version: '6.x',
+      topology: 'sharded',
+      tmpDir,
+      secondaries: 1,
+      shards: 1,
+      users: [
+        {
+          username: 'testuser',
+          password: 'testpass',
+          roles: [{ role: 'readWriteAnyDatabase', db: 'admin' }],
+        },
+      ],
+      mongosArgs: [[], []],
+    });
+    expect(cluster.connectionString).to.be.a('string');
+    expect(cluster.serverVersion).to.match(/^6\./);
+    expect(cluster.connectionString).to.include('testuser:testpass@');
+    await cluster.withClient(async (client) => {
+      const result = await client
+        .db('test')
+        .collection('test')
+        .insertOne({ foo: 42 });
+      expect(result.insertedId).to.exist;
+    });
+
+    cluster = await MongoCluster.deserialize(cluster.serialize());
+    expect(cluster.connectionString).to.include('testuser:testpass@');
+    const [doc, status] = await cluster.withClient(async (client) => {
+      return Promise.all([
+        client.db('test').collection('test').findOne({ foo: 42 }),
+        client.db('admin').command({ connectionStatus: 1 }),
+      ] as const);
+    });
+    expect(doc?.foo).to.equal(42);
+    expect(status.authInfo.authenticatedUsers).to.deep.equal([
+      { user: 'testuser', db: 'admin' },
+    ]);
+  });
 });
diff --git a/packages/mongodb-runner/src/mongocluster.ts b/packages/mongodb-runner/src/mongocluster.ts
@@ -5,7 +5,15 @@ import type { DownloadOptions } from '@mongodb-js/mongodb-downloader';
 import { downloadMongoDb } from '@mongodb-js/mongodb-downloader';
 import type { Document, MongoClientOptions, TagSet } from 'mongodb';
 import { MongoClient } from 'mongodb';
-import { sleep, range, uuid, debug, jsonClone } from './util';
+import {
+  sleep,
+  range,
+  uuid,
+  debug,
+  jsonClone,
+  debugVerbose,
+  makeConnectionString,
+} from './util';
 import { OIDCMockProviderProcess } from './oidc';
 import { EventEmitter } from 'events';
 import assert from 'assert';
@@ -156,7 +164,7 @@ function processShardOptions(options: MongoClusterOptions): {
   mongosArgs: string[][];
 } {
   const {
-    shardArgs = range(options.shards ?? 1).map(() => []),
+    shardArgs = range((options.shards ?? 3) + 1).map(() => []),
     mongosArgs = [[]],
     args = [],
   } = options;
@@ -258,13 +266,11 @@ export class MongoCluster extends EventEmitter<MongoClusterEvents> {
   }
 
   get connectionString(): string {
-    const cs = new ConnectionString(`mongodb://${this.hostport}/`);
-    if (this.replSetName)
-      cs.typedSearchParams<MongoClientOptions>().set(
-        'replicaSet',
-        this.replSetName,
-      );
-    return cs.toString();
+    return makeConnectionString(
+      this.hostport,
+      this.replSetName,
+      this.defaultConnectionOptions,
+    );
   }
 
   get oidcIssuer(): string | undefined {
@@ -367,11 +373,12 @@ export class MongoCluster extends EventEmitter<MongoClusterEvents> {
               _id: i,
               host: srv.hostport,
               arbiterOnly: member.arbiterOnly ?? false,
-              priority: member.priority ?? 1,
+              priority: member.priority ?? (i === primaryIndex ? 1 : 0),
               tags: member.tags || {},
             };
           }),
         };
+        debugVerbose('replSetInitiate:', rsConf);
         await client.db('admin').command({
           replSetInitiate: rsConf,
         });
@@ -398,48 +405,58 @@ export class MongoCluster extends EventEmitter<MongoClusterEvents> {
     } else if (options.topology === 'sharded') {
       const { shardArgs, mongosArgs } = processShardOptions(options);
       debug('starting config server and shard servers', shardArgs);
-      const [configsvr, ...shardsvrs] = await Promise.all(
-        shardArgs.map((args) => {
-          return MongoCluster.start({
+      const allShards = await Promise.all(
+        shardArgs.map(async (args) => {
+          const isConfig = args.includes('--configsvr');
+          const cluster = await MongoCluster.start({
             ...options,
             args,
             topology: 'replset',
+            users: isConfig ? undefined : options.users, // users go on the mongos/config server only for the config set
           });
+          return [cluster, isConfig] as const;
         }),
       );
+      const configsvr = allShards.find(([, isConfig]) => isConfig)![0];
+      const shardsvrs = allShards
+        .filter(([, isConfig]) => !isConfig)
+        .map(([shard]) => shard);
       cluster.shards.push(configsvr, ...shardsvrs);
 
-      for (let i = 0; i < mongosArgs.length; i++) {
-        debug('starting mongos');
-        const mongos = await MongoServer.start({
-          ...options,
-          binary: 'mongos',
-          args: [
-            ...(options.args ?? []),
-            ...mongosArgs[i],
-            '--configdb',
-            `${configsvr.replSetName!}/${configsvr.hostport}`,
-          ],
-        });
-        cluster.servers.push(mongos);
-        await mongos.withClient(async (client) => {
-          for (const shard of shardsvrs) {
-            const shardSpec = `${shard.replSetName!}/${shard.hostport}`;
-            debug('adding shard', shardSpec);
-            await client.db('admin').command({
-              addShard: shardSpec,
-            });
-          }
-          debug('added shards');
-        });
-      }
+      const mongosServers: MongoServer[] = await Promise.all(
+        mongosArgs.map(async (args) => {
+          debug('starting mongos');
+          return await MongoServer.start({
+            ...options,
+            binary: 'mongos',
+            args: [
+              ...(options.args ?? []),
+              ...args,
+              '--configdb',
+              `${configsvr.replSetName!}/${configsvr.hostport}`,
+            ],
+          });
+        }),
+      );
+      cluster.servers.push(...mongosServers);
+      const mongos = mongosServers[0];
+      await mongos.withClient(async (client) => {
+        for (const shard of shardsvrs) {
+          const shardSpec = `${shard.replSetName!}/${shard.hostport}`;
+          debug('adding shard', shardSpec);
+          await client.db('admin').command({
+            addShard: shardSpec,
+          });
+        }
+        debug('added shards');
+      });
     }
 
     await cluster.addAuthIfNeeded();
     return cluster;
   }
 
-  *children(): Iterable<MongoServer | MongoCluster> {
+  private *children(): Iterable<MongoServer | MongoCluster> {
     yield* this.servers;
     yield* this.shards;
   }
diff --git a/packages/mongodb-runner/src/mongoserver.ts b/packages/mongodb-runner/src/mongoserver.ts
@@ -13,7 +13,14 @@ import type { Document, MongoClientOptions } from 'mongodb';
 import { MongoClient } from 'mongodb';
 import path from 'path';
 import { EventEmitter, once } from 'events';
-import { uuid, debug, pick, debugVerbose, jsonClone } from './util';
+import {
+  uuid,
+  debug,
+  pick,
+  debugVerbose,
+  jsonClone,
+  makeConnectionString,
+} from './util';
 
 export interface MongoServerOptions {
   binDir?: string;
@@ -345,8 +352,17 @@ export class MongoServer extends EventEmitter<MongoServerEvents> {
       .collection<
         Omit<SerializedServerProperties, 'hasInsertedMetadataCollEntry'>
       >('mongodbrunner');
+    // mongos hosts require a bit of special treatment because they do not have
+    // local storage of their own, so we store the metadata in the config database,
+    // which may be accessed by multiple mongos instances.
     debug('ensuring metadata collection entry', insertedInfo, { isMongoS });
     if (mode === 'insert-new') {
+      const existingEntry = await runnerColl.findOne();
+      if (!isMongoS && existingEntry) {
+        throw new Error(
+          `Unexpected mongodbrunner entry when creating new server: ${JSON.stringify(existingEntry)}`,
+        );
+      }
       await runnerColl.insertOne(insertedInfo);
       debug('inserted metadata collection entry', insertedInfo);
       this.hasInsertedMetadataCollEntry = true;
@@ -357,7 +373,9 @@ export class MongoServer extends EventEmitter<MongoServerEvents> {
         );
         return;
       }
-      const match = await runnerColl.findOne();
+      const match = await runnerColl.findOne(
+        isMongoS ? { _id: this.uuid } : {},
+      );
       debug('read metadata collection entry', insertedInfo, match);
       if (!match) {
         throw new Error(
@@ -397,11 +415,19 @@ export class MongoServer extends EventEmitter<MongoServerEvents> {
     return null;
   }
 
+  get connectionString(): string {
+    return makeConnectionString(
+      this.hostport,
+      undefined,
+      this.defaultConnectionOptions,
+    );
+  }
+
   async withClient<Fn extends (client: MongoClient) => any>(
     fn: Fn,
     clientOptions: MongoClientOptions = {},
   ): Promise<ReturnType<Fn>> {
-    const client = await MongoClient.connect(`mongodb://${this.hostport}/`, {
+    const client = await MongoClient.connect(this.connectionString, {
       directConnection: true,
       ...this.defaultConnectionOptions,
       ...clientOptions,
diff --git a/packages/mongodb-runner/src/util.ts b/packages/mongodb-runner/src/util.ts
