JAVA-6174 Fix sdam eventType to assert serverDescriptionChangedEvent (#1978)

Author: nhachicha

driver-sync/src/test/functional/com/mongodb/client/unified/ContextElement.java

@@ -26,6 +26,7 @@
 import com.mongodb.event.CommandFailedEvent;
 import com.mongodb.event.CommandStartedEvent;
 import com.mongodb.event.CommandSucceededEvent;
+import com.mongodb.event.ServerDescriptionChangedEvent;
 import com.mongodb.internal.logging.LogMessage;
 import com.mongodb.lang.Nullable;
 import org.bson.BsonArray;
@@ -509,6 +510,10 @@ private static BsonDocument connectionPoolEventToDocument(final Object event) {
     }
 
     private static BsonDocument serverMonitorEventToDocument(final Object event) {
+        // ServerDescriptionChangedEvent is not a heartbeat event and has no 'awaited' field.
+        if (event instanceof ServerDescriptionChangedEvent) {
+            return new BsonDocument(EventMatcher.getEventType(event.getClass()), new BsonDocument());
+        }
         return new BsonDocument(EventMatcher.getEventType(event.getClass()),
                 new BsonDocument("awaited", BsonBoolean.valueOf(EventMatcher.getAwaitedFromServerMonitorEvent(event))));
     }

driver-sync/src/test/functional/com/mongodb/client/unified/EventMatcher.java

@@ -513,6 +513,13 @@ private static <T> boolean serverMonitorEventMatches(
         if (expectedEventContents.size() > 1) {
             throw new UnsupportedOperationException("Matching for the following event is not implemented " + expectedEventContents.toJson());
         }
+        if (event instanceof ServerDescriptionChangedEvent) {
+            boolean matches = serverDescriptionChangedEventMatches(expectedEventContents, (ServerDescriptionChangedEvent) event);
+            if (context != null) {
+                assertTrue(context.getMessage("Expected serverDescriptionChangedEvent contents to match"), matches);
+            }
+            return matches;
+        }
         if (expectedEventContents.containsKey("awaited")) {
             boolean expectedAwaited = expectedEventContents.getBoolean("awaited").getValue();
             boolean actualAwaited = getAwaitedFromServerMonitorEvent(event);
@@ -545,7 +552,7 @@ static String getEventType(final Class<?> eventClass) {
             return eventClassName.replace("ConnectionPool", "pool");
         } else if (eventClassName.startsWith("Connection")) {
             return eventClassName.replace("Connection", "connection");
-        } else if (eventClassName.startsWith("ServerHeartbeat")) {
+        } else if (eventClassName.startsWith("Server")) {
             StringBuilder eventTypeBuilder = new StringBuilder(eventClassName);
             eventTypeBuilder.setCharAt(0, Character.toLowerCase(eventTypeBuilder.charAt(0)));
             return eventTypeBuilder.toString();

driver-sync/src/test/functional/com/mongodb/client/unified/UnifiedTest.java

@@ -40,6 +40,7 @@
 import com.mongodb.internal.connection.TestClusterListener;
 import com.mongodb.internal.connection.TestCommandListener;
 import com.mongodb.internal.connection.TestConnectionPoolListener;
+import com.mongodb.internal.connection.TestServerListener;
 import com.mongodb.internal.logging.LogMessage;
 import com.mongodb.lang.NonNull;
 import com.mongodb.lang.Nullable;
@@ -71,7 +72,6 @@
 import java.util.Collections;
 import java.util.HashSet;
 import java.util.List;
-import java.util.Map;
 import java.util.Set;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.ExecutorService;
@@ -119,6 +119,7 @@ public abstract class UnifiedTest {
     private static final String TOPOLOGY_CLOSED_EVENT = "topologyClosedEvent";
     private static final List<String> TOPOLOGY_EVENT_NAMES = asList("topologyOpeningEvent", "topologyDescriptionChangedEvent",
             TOPOLOGY_CLOSED_EVENT);
+    private static final String SERVER_DESCRIPTION_CHANGED_EVENT = "serverDescriptionChangedEvent";
 
     public static final int RETRY_ATTEMPTS = 3;
     public static final int FORCE_FLAKY_ATTEMPTS = 10;
@@ -421,33 +422,46 @@ private void compareEvents(final UnifiedTestContext context, final BsonDocument
                 context.getEventMatcher().assertConnectionPoolEventsEquality(client, ignoreExtraEvents, expectedEvents,
                         listener.getEvents());
             } else if (eventType.equals("sdam")) {
+                List<BsonDocument> expectedTopologyEvents = new ArrayList<>();
+                List<BsonDocument> expectedServerDescriptionChangedEvents = new ArrayList<>();
+                List<BsonDocument> expectedHeartbeatEvents = new ArrayList<>();
+
+                for (BsonValue event : expectedEvents) {
+                    BsonDocument doc = event.asDocument();
+                    if (TOPOLOGY_EVENT_NAMES.stream().anyMatch(doc::containsKey)) {
+                        expectedTopologyEvents.add(doc);
+                    } else if (doc.containsKey(SERVER_DESCRIPTION_CHANGED_EVENT)) {
+                        expectedServerDescriptionChangedEvents.add(doc);
+                    } else {
+                        expectedHeartbeatEvents.add(doc);
+                    }
+                }
 
-                // SDAM tests also include topology events, so we need to separate them to be able to assert them separately.
-                // Partition the expected events into two lists with the key being if it's a topology based event or not.
-                Map<Boolean, List<BsonDocument>> partitionedEventsMap = expectedEvents.stream()
-                        .map(BsonValue::asDocument)
-                        .collect(Collectors.partitioningBy(doc -> TOPOLOGY_EVENT_NAMES.stream().anyMatch(doc::containsKey)));
-
-                BsonArray expectedTopologyEvents = new BsonArray(partitionedEventsMap.get(true));
                 if (!expectedTopologyEvents.isEmpty()) {
                     TestClusterListener clusterListener = entities.getClusterListener(client);
-                    // Unfortunately, some tests expect the cluster to be closed, but do not define it as a waitForEvent in the spec -
-                    // causing a race condition in the test.
-                    if (expectedTopologyEvents.stream().anyMatch(doc -> doc.asDocument().containsKey(TOPOLOGY_CLOSED_EVENT))) {
+                    // Race guard: some tests expect topologyClosedEvent without a prior waitForEvent.
+                    if (expectedTopologyEvents.stream().anyMatch(doc -> doc.containsKey(TOPOLOGY_CLOSED_EVENT))) {
                         context.getEventMatcher().waitForClusterClosedEvent(client, clusterListener);
                     }
-
                     List<Object> topologyEvents = new ArrayList<>();
                     topologyEvents.add(clusterListener.getClusterOpeningEvent());
                     topologyEvents.addAll(clusterListener.getClusterDescriptionChangedEvents());
                     topologyEvents.add(clusterListener.getClusterClosingEvent());
-                    context.getEventMatcher().assertTopologyEventsEquality(client, ignoreExtraEvents, expectedTopologyEvents, topologyEvents);
+                    context.getEventMatcher().assertTopologyEventsEquality(client, ignoreExtraEvents,
+                            new BsonArray(expectedTopologyEvents), topologyEvents);
+                }
+
+                if (!expectedServerDescriptionChangedEvents.isEmpty()) {
+                    TestServerListener serverListener = entities.getServerListener(client);
+                    context.getEventMatcher().assertServerMonitorEventsEquality(client, ignoreExtraEvents,
+                            new BsonArray(expectedServerDescriptionChangedEvents),
+                            serverListener.getServerDescriptionChangedEvents());
                 }
 
-                BsonArray expectedSdamEvents = new BsonArray(partitionedEventsMap.get(false));
-                if (!expectedSdamEvents.isEmpty()) {
+                if (!expectedHeartbeatEvents.isEmpty()) {
                     TestServerMonitorListener serverMonitorListener = entities.getServerMonitorListener(client);
-                    context.getEventMatcher().assertServerMonitorEventsEquality(client, ignoreExtraEvents, expectedSdamEvents, serverMonitorListener.getEvents());
+                    context.getEventMatcher().assertServerMonitorEventsEquality(client, ignoreExtraEvents,
+                            new BsonArray(expectedHeartbeatEvents), serverMonitorListener.getEvents());
                 }
             } else {
                 throw new UnsupportedOperationException("Unexpected event type: " + eventType);

driver-sync/src/test/functional/com/mongodb/client/unified/UnifiedTestModifications.java

@@ -429,9 +429,6 @@ public static void applyCustomizations(final TestDef def) {
                 .file("server-discovery-and-monitoring", "pool-clear-on-error-checkout");
         def.skipJira("https://jira.mongodb.org/browse/JAVA-5664")
                 .file("server-discovery-and-monitoring", "pool-cleared-on-min-pool-size-population-error");
-        // TODO-BACKPRESSURE Nabil - This issue is unrelated to backpressure but consider fixing it before merging to main
-        def.skipJira("https://jira.mongodb.org/browse/JAVA-6174")
-                .file("server-discovery-and-monitoring", "backpressure-server-description-unchanged-on-min-pool-size-population-error");
 
         // session tests
         def.skipJira("https://jira.mongodb.org/browse/JAVA-5968")