{
  "id": "repro-hang",
  "topology": "sharded",
  "host": "localhost",
  "tmpDir": "/tmp/mr-repro",
  "runnerDir": "/tmp/mr-repro",
  "logDir": "/tmp/mr-repro/logs",
  "binDir": "/path/to/mongodb/bin",
  "args": [],
  "shards": [
    { "args": [], "rsMembers": [{}] },
    {
      "args": [],
      "rsMembers": [
        { "args": ["--port", "27217"] },
        { "args": ["--port", "27218"] },
        { "args": ["--port", "27219"] }
      ]
    }
  ],
  "mongosArgs": [
    ["--ipv6", "--bind_ip", "127.0.0.1,::1", "--port", "27017"],
    ["--ipv6", "--bind_ip", "127.0.0.1,::1", "--port", "27018"]
  ]
}

mongodb-runner start --debug --config repro.json

import { expect } from 'chai';
import { MongoCluster } from './mongocluster';
import { promises as fs } from 'fs';
import path from 'path';
import os from 'os';

// Regression test for #952, which removed the configsvr 127.0.0.1 carve-out
// added in #620 (DRIVERS-3335): with a named host option, a dual-stack mongos
// pins ::1 for --configdb against an IPv4-only config server, and
// MongoCluster.start never returns. The race bounds the failure to 90s
// instead of hanging the suite.
describe('MongoCluster sharded config server host', function () {
  this.timeout(120_000);

  let tmpDir: string;
  let cluster: MongoCluster;

  before(async function () {
    tmpDir = path.join(os.tmpdir(), `runner-configsvr-host-${Date.now()}`);
    await fs.mkdir(tmpDir, { recursive: true });
  });

  afterEach(async function () {
    await cluster?.close();
  });

  after(async function () {
    await fs.rm(tmpDir, { recursive: true, maxRetries: 100 });
  });

  it('starts a sharded cluster when the host option is a dual-stack name', async function () {
    // `localhost` is dual-stack. A mongos pins the first address it resolves
    // to (::1 on many hosts) while the node driver falls back across
    // addresses, which is why only the mongos side hangs.
    const host = 'localhost';

    const startPromise = MongoCluster.start({
      version: '8.x',
      topology: 'sharded',
      host,
      tmpDir,
      // One blank shard entry is the config server (processShardOptions adds
      // --configsvr to the first entry). The mongos runs dual-stack, as real
      // deployments do; only then does it resolve the host name to ::1.
      shards: [{ args: [], rsMembers: [{}] }],
      mongosArgs: [['--ipv6', '--bind_ip', '127.0.0.1,::1']],
    });
    // When the regression is present, start never resolves and the race
    // below rejects; the mongos leaves its servers running, which is
    // acceptable on the ephemeral hosts this failure mode bites on.
    startPromise.catch(() => {});

    let timer: NodeJS.Timeout | undefined;
    try {
      cluster = await Promise.race([
        startPromise,
        new Promise<never>((_, reject) => {
          timer = setTimeout(() => {
            // The runner waits for the mongos port without a timeout, so a
            // regression leaves the event loop full of live handles and the
            // process must be terminated after mocha records the failure.
            setTimeout(() => process.exit(1), 1_000).unref();
            reject(
              new Error(
                `sharded start with host "${host}" did not finish in 90s; ` +
                  'the mongos cannot reach the config server over ::1 ' +
                  '(regression from mongodb-js/devtools-shared#952)',
              ),
            );
          }, 90_000);
          timer.unref();
        }),
      ]);
    } finally {
      clearTimeout(timer);
    }

    await cluster.withClient(async (client) => {
      const res = await client.db('admin').command({ ping: 1 });
      expect(res.ok).to.equal(1);
    });
  });
});