Function validateExpectations

test/tools/spec-runner/index.js:440–495

(commandEvents, spec, savedSessionData)

}

function validateExpectations(commandEvents, spec, savedSessionData) {
  if (!spec.expectations || !Array.isArray(spec.expectations) || spec.expectations.length === 0) {
    return;
  }

  const actualEvents = normalizeCommandShapes(commandEvents);
  const rawExpectedEvents = spec.expectations.map(x => x.command_started_event);
  const expectedEvents = normalizeCommandShapes(rawExpectedEvents);

  expect(actualEvents).to.have.lengthOf(expectedEvents.length);

  for (const [idx, expectedEvent] of expectedEvents.entries()) {
    const actualEvent = actualEvents[idx];

    if (typeof expectedEvent.commandName === 'string') {
      expect(actualEvent).to.have.property('commandName', expectedEvent.commandName);
    }

    if (typeof expectedEvent.databaseName === 'string') {
      expect(actualEvent).to.have.property('databaseName', expectedEvent.databaseName);
    }

    const actualCommand = actualEvent.command;
    const expectedCommand = expectedEvent.command;
    if (expectedCommand.sort) {
      // TODO(NODE-3235): This is a workaround that works because all sorts in the specs
      // are objects with one key; ideally we'd want to adjust the spec definitions
      // to indicate whether order matters for any given key and set general
      // expectations accordingly
      expect(Object.keys(expectedCommand.sort)).to.have.lengthOf(1);
      expect(actualCommand.sort).to.be.instanceOf(Map);
      expect(actualCommand.sort.size).to.equal(1);
      const expectedKey = Object.keys(expectedCommand.sort)[0];
      expect(actualCommand.sort).to.have.all.keys(expectedKey);
      actualCommand.sort = { [expectedKey]: actualCommand.sort.get(expectedKey) };
    }

    if (expectedCommand.createIndexes) {
      // TODO(NODE-3235): This is a workaround that works because all indexes in the specs
      // are objects with one key; ideally we'd want to adjust the spec definitions
      // to indicate whether order matters for any given key and set general
      // expectations accordingly
      for (const [i, dbIndex] of actualCommand.indexes.entries()) {
        expect(Object.keys(expectedCommand.indexes[i].key)).to.have.lengthOf(1);
        expect(dbIndex.key).to.be.instanceOf(Map);
        expect(dbIndex.key.size).to.equal(1);
      }
      actualCommand.indexes = actualCommand.indexes.map(dbIndex => ({
        ...dbIndex,
        key: Object.fromEntries(dbIndex.key)
      }));
    }

    expect(actualCommand).withSessionData(savedSessionData).to.matchMongoSpec(expectedCommand);
  }
}

function normalizeCommandShapes(commands) {