Function compareEvents

test/tools/unified-spec-runner/match.ts:537–680

(
  actual: CommandEvent[] | CmapEvent[] | SdamEvent[],
  expected: (ExpectedCommandEvent & ExpectedCmapEvent & ExpectedSdamEvent)[],
  entities: EntitiesMap
)

}

function compareEvents(
  actual: CommandEvent[] | CmapEvent[] | SdamEvent[],
  expected: (ExpectedCommandEvent & ExpectedCmapEvent & ExpectedSdamEvent)[],
  entities: EntitiesMap
) {
  if (actual.length !== expected.length) {
    failOnMismatchedCount(actual, expected);
  }
  for (const [index, actualEvent] of actual.entries()) {
    const expectedEvent = expected[index];
    const rootPrefix = `events[${index}]`;

    if (expectedEvent.commandStartedEvent) {
      const path = `${rootPrefix}.commandStartedEvent`;
      expectInstanceOf(actualEvent, CommandStartedEvent);
      compareCommandStartedEvents(actualEvent, expectedEvent.commandStartedEvent, entities, path);
      if (expectedEvent.commandStartedEvent.hasServerConnectionId) {
        expect(actualEvent).property('serverConnectionId').to.be.a('bigint');
      } else if (expectedEvent.commandStartedEvent.hasServerConnectionId === false) {
        expect(actualEvent).property('serverConnectionId').to.be.null;
      }
    } else if (expectedEvent.commandSucceededEvent) {
      const path = `${rootPrefix}.commandSucceededEvent`;
      expectInstanceOf(actualEvent, CommandSucceededEvent);
      compareCommandSucceededEvents(
        actualEvent,
        expectedEvent.commandSucceededEvent,
        entities,
        path
      );
      if (expectedEvent.commandSucceededEvent.hasServerConnectionId) {
        expect(actualEvent).property('serverConnectionId').to.be.a('bigint');
      } else if (expectedEvent.commandSucceededEvent.hasServerConnectionId === false) {
        expect(actualEvent).property('serverConnectionId').to.be.null;
      }
    } else if (expectedEvent.commandFailedEvent) {
      const path = `${rootPrefix}.commandFailedEvent`;
      expectInstanceOf(actualEvent, CommandFailedEvent);
      compareCommandFailedEvents(actualEvent, expectedEvent.commandFailedEvent, entities, path);
      if (expectedEvent.commandFailedEvent.hasServerConnectionId) {
        expect(actualEvent).property('serverConnectionId').to.be.a('bigint');
      } else if (expectedEvent.commandFailedEvent.hasServerConnectionId === false) {
        expect(actualEvent).property('serverConnectionId').to.be.null;
      }
    } else if (expectedEvent.connectionClosedEvent) {
      expect(actualEvent).to.be.instanceOf(ConnectionClosedEvent);
      if (expectedEvent.connectionClosedEvent.hasServiceId) {
        expect(actualEvent).property('serviceId').to.exist;
      }
    } else if (expectedEvent.poolClearedEvent) {
      expect(actualEvent).to.be.instanceOf(ConnectionPoolClearedEvent);
      if (expectedEvent.poolClearedEvent.hasServiceId) {
        expect(actualEvent).property('serviceId').to.exist;
      }
      if (expectedEvent.poolClearedEvent.interruptInUseConnections != null) {
        expect(actualEvent)
          .property('interruptInUseConnections')
          .to.equal(expectedEvent.poolClearedEvent.interruptInUseConnections);