Function runCmapTest

test/tools/cmap_spec_runner.ts:366–450

(test: CmapTest, threadContext: ThreadContext)

}

async function runCmapTest(test: CmapTest, threadContext: ThreadContext) {
  expect(CMAP_TEST_KEYS).to.include.members(Object.keys(test));

  const poolOptions = test.poolOptions || {};
  expect(CMAP_POOL_OPTION_NAMES).to.include.members(Object.keys(poolOptions));

  let minPoolSizeCheckFrequencyMS;
  if (poolOptions.backgroundThreadIntervalMS) {
    if (poolOptions.backgroundThreadIntervalMS !== -1) {
      minPoolSizeCheckFrequencyMS = poolOptions.backgroundThreadIntervalMS;
    }
    delete poolOptions.backgroundThreadIntervalMS;
  }

  delete poolOptions.appName;

  const operations = test.operations;
  const expectedError = test.error;
  const expectedEvents = test.events;
  const ignoreEvents = test.ignore || [];

  const MAIN_THREAD_KEY = Symbol('Main Thread');
  const mainThread = threadContext.getThread(MAIN_THREAD_KEY);
  mainThread.start();

  threadContext.createPool({
    ...poolOptions,
    minPoolSizeCheckFrequencyMS
  });
  // yield control back to the event loop so that the ConnectionPoolCreatedEvent
  // has a chance to be fired before any synchronously-emitted events from
  // the queued operations
  await sleep();

  for (const idx in operations) {
    const op = operations[idx];

    const threadKey = op.name === 'checkOut' ? op.thread || MAIN_THREAD_KEY : MAIN_THREAD_KEY;
    if (threadKey === MAIN_THREAD_KEY) {
      mainThread.queue(op);
    } else {
      const thread = threadContext.getThread(threadKey);
      mainThread.queue(op, thread);
    }
  }

  const actualError = await mainThread.finish().catch(e => e);

  if (expectedError) {
    expect(actualError).to.exist;
    const { type: errorType, message: errorMessage, ...errorPropsToCheck } = expectedError;
    expect(
      actualError,
      `${actualError.name} does not match "Mongo${errorType}", ${actualError.message} ${actualError.stack}`
    ).to.have.property('name', `Mongo${errorType}`);
    if (errorMessage) {
      if (
        errorMessage === 'Timed out while checking out a connection from connection pool' &&