Relaxed command event assertions of requestId. Since the requestId is based on a static AtomicInteger, it may be changed by other threads.

Therefore it's not reliable to assert anything that's based on it.  Instead, simply assert that the requestId of a CommandSucceededEvent or
CommandFailedEvent matches the requestId of the previous CommandStartedEvent.

Changed TestCommandListener#eventsWereDelivered to use assertions directly instead of returning a boolean

Author: jyemin

driver-core/src/test/functional/com/mongodb/connection/TestCommandListener.java

@@ -37,9 +37,12 @@
 import java.util.List;
 import java.util.concurrent.TimeUnit;
 
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNull;
+import static org.junit.Assert.assertTrue;
+
 public class TestCommandListener implements CommandListener {
     private final List<CommandEvent> events = new ArrayList<CommandEvent>();
-    private int firstRequestId = RequestMessage.getCurrentGlobalId();
     private static final CodecRegistry CODEC_REGISTRY_HACK;
 
     static {
@@ -59,7 +62,6 @@ public <T> Codec<T> get(final Class<T> clazz, final CodecRegistry registry) {
 
     public void reset() {
         events.clear();
-        firstRequestId = RequestMessage.getCurrentGlobalId();
     }
 
     public List<CommandEvent> getEvents() {
@@ -92,79 +94,54 @@ public void commandFailed(final CommandFailedEvent event) {
         events.add(event);
     }
 
-    public boolean eventsWereDelivered(final List<CommandEvent> expectedEvents) {
-        if (expectedEvents.size() != events.size()) {
-            return false;
-        }
-        int currentlyExpectedRequestId = firstRequestId;
+    public void eventsWereDelivered(final List<CommandEvent> expectedEvents) {
+        assertEquals(expectedEvents.size(), events.size());
+
+        int currentlyExpectedRequestId = 0;
         for (int i = 0; i < events.size(); i++) {
             CommandEvent actual = events.get(i);
             CommandEvent expected = expectedEvents.get(i);
-            if (!actual.getClass().equals(expected.getClass())) {
-                return false;
-            }
 
-            if (actual.getRequestId() != currentlyExpectedRequestId) {
-                return false;
-            }
+            assertEquals(expected.getClass(), actual.getClass());
 
-            if (!(actual instanceof CommandStartedEvent)) {
-                currentlyExpectedRequestId++;
+            if (actual instanceof CommandStartedEvent) {
+                currentlyExpectedRequestId = actual.getRequestId();
+            } else {
+                assertEquals(currentlyExpectedRequestId, actual.getRequestId());
             }
 
-            if (!actual.getConnectionDescription().equals(expected.getConnectionDescription())) {
-                return false;
-            }
+            assertEquals(expected.getConnectionDescription(), actual.getConnectionDescription());
 
-            if (!actual.getCommandName().equals(expected.getCommandName())) {
-                return false;
-            }
+            assertEquals(expected.getCommandName(), actual.getCommandName());
 
             if (actual.getClass().equals(CommandStartedEvent.class)) {
-                if (!isEquivalent((CommandStartedEvent) actual, (CommandStartedEvent) expected)) {
-                    return false;
-                }
+                assertEquivalence((CommandStartedEvent) actual, (CommandStartedEvent) expected);
             } else if (actual.getClass().equals(CommandSucceededEvent.class)) {
-                if (!isEquivalent((CommandSucceededEvent) actual, (CommandSucceededEvent) expected)) {
-                    return false;
-                }
+                assertEquivalence((CommandSucceededEvent) actual, (CommandSucceededEvent) expected);
             } else if (actual.getClass().equals(CommandFailedEvent.class)) {
-                if (!isEquivalent((CommandFailedEvent) actual, (CommandFailedEvent) expected)) {
-                    return false;
-                }
+                assertEquivalence((CommandFailedEvent) actual, (CommandFailedEvent) expected);
             } else {
                 throw new UnsupportedOperationException("Unsupported event type: " + actual.getClass());
             }
         }
-
-        return true;
     }
 
-    private boolean isEquivalent(final CommandFailedEvent actual, final CommandFailedEvent expected) {
-        if (!actual.getThrowable().equals(expected.getThrowable())) {
-            return false;
-        }
-        return true;
+    private void assertEquivalence(final CommandFailedEvent actual, final CommandFailedEvent expected) {
+        assertEquals(expected.getThrowable(), actual.getThrowable());
     }
 
-    private boolean isEquivalent(final CommandSucceededEvent actual, final CommandSucceededEvent expected) {
+    private void assertEquivalence(final CommandSucceededEvent actual, final CommandSucceededEvent expected) {
         if (actual.getResponse() == null) {
-            return expected.getResponse() == null;
+            assertNull(expected.getResponse());
+        } else {
+            // ignore extra elements in the actual response
+            assertTrue("Expected response contains elements not in the actual response",
+                       actual.getResponse().entrySet().containsAll(expected.getResponse().entrySet()));
         }
-        // ignore extra elements in the actual response
-        if (!actual.getResponse().entrySet().containsAll(expected.getResponse().entrySet())) {
-            return false;
-        }
-        return true;
     }
 
-    private boolean isEquivalent(final CommandStartedEvent actual, final CommandStartedEvent expected) {
-        if (!actual.getDatabaseName().equals(expected.getDatabaseName())) {
-            return false;
-        }
-        if (!actual.getCommand().equals(expected.getCommand())) {
-            return false;
-        }
-        return true;
+    private void assertEquivalence(final CommandStartedEvent actual, final CommandStartedEvent expected) {
+        assertEquals(expected.getDatabaseName(), actual.getDatabaseName());
+        assertEquals(expected.getCommand(), actual.getCommand());
     }
 }

driver-core/src/test/functional/com/mongodb/connection/WriteProtocolCommandEventSpecification.groovy

@@ -110,31 +110,30 @@ class WriteProtocolCommandEventSpecification extends OperationFunctionalSpecific
         def commandListener = new TestCommandListener()
         protocol.commandListener = commandListener
 
-        def expectedEvents = [
+        when:
+        protocol.execute(connection)
+
+        then:
+        commandListener.eventsWereDelivered([
                 new CommandStartedEvent(1, connection.getDescription(), getDatabaseName(), 'insert',
-                        new BsonDocument('insert', new BsonString(getCollectionName()))
-                                .append('ordered', BsonBoolean.TRUE)
-                                .append('writeConcern',
-                                new BsonDocument('w', new BsonInt32(0)))
-                                .append('documents',
-                                new BsonArray([documentOne, documentTwo,
-                                               documentThree]))),
+                                        new BsonDocument('insert', new BsonString(getCollectionName()))
+                                                .append('ordered', BsonBoolean.TRUE)
+                                                .append('writeConcern',
+                                                        new BsonDocument('w', new BsonInt32(0)))
+                                                .append('documents',
+                                                        new BsonArray([documentOne, documentTwo,
+                                                                       documentThree]))),
                 new CommandSucceededEvent(1, connection.getDescription(), 'insert',
-                        new BsonDocument('ok', new BsonInt32(1)), 0),
+                                          new BsonDocument('ok', new BsonInt32(1)), 0),
                 new CommandStartedEvent(1, connection.getDescription(), getDatabaseName(), 'insert',
-                        new BsonDocument('insert', new BsonString(getCollectionName()))
-                                .append('ordered', BsonBoolean.TRUE)
-                                .append('writeConcern',
-                                new BsonDocument('w', new BsonInt32(0)))
-                                .append('documents', new BsonArray([documentFour]))),
+                                        new BsonDocument('insert', new BsonString(getCollectionName()))
+                                                .append('ordered', BsonBoolean.TRUE)
+                                                .append('writeConcern',
+                                                        new BsonDocument('w', new BsonInt32(0)))
+                                                .append('documents', new BsonArray([documentFour]))),
                 new CommandSucceededEvent(1, connection.getDescription(), 'insert',
-                        new BsonDocument('ok', new BsonInt32(1)), 0)]
+                                          new BsonDocument('ok', new BsonInt32(1)), 0)])
 
-        when:
-        protocol.execute(connection)
-
-        then:
-        commandListener.eventsWereDelivered(expectedEvents)
         cleanup:
         // force acknowledgement
         new CommandProtocol(getDatabaseName(), new BsonDocument('drop', new BsonString(getCollectionName())),