From b13919965251ef7b370f34bc39318c6a68f7ce39 Mon Sep 17 00:00:00 2001
From: Valentin Kovalenko <valentin.kovalenko@mongodb.com>
Date: Sat, 17 Feb 2024 15:44:04 -0700
Subject: [PATCH] Support the `serverMonitoringMode` connection string option

This change is with accordance to source/uri-options/uri-options.rst.

JAVA-4936
---
 .../main/com/mongodb/ConnectionString.java    |  33 +++++-
 .../connection/ServerMonitoringMode.java      |  74 ++++++++++++
 .../mongodb/connection/ServerSettings.java    |  72 ++++++++----
 .../resources/uri-options/sdam-options.json   |  46 ++++++++
 .../mongodb/AbstractConnectionStringTest.java |   3 +
 .../ConnectionStringSpecification.groovy      |   3 +
 .../com/mongodb/ConnectionStringUnitTest.java |  62 ++++++++++
 .../connection/ServerMonitoringModeTest.java  |  43 +++++++
 .../ServerSettingsSpecification.groovy        |   3 +
 .../connection/ServerSettingsTest.java        | 106 ++++++++++++++++++
 10 files changed, 420 insertions(+), 25 deletions(-)
 create mode 100644 driver-core/src/main/com/mongodb/connection/ServerMonitoringMode.java
 create mode 100644 driver-core/src/test/resources/uri-options/sdam-options.json
 create mode 100644 driver-core/src/test/unit/com/mongodb/ConnectionStringUnitTest.java
 create mode 100644 driver-core/src/test/unit/com/mongodb/connection/ServerMonitoringModeTest.java
 create mode 100644 driver-core/src/test/unit/com/mongodb/connection/ServerSettingsTest.java

diff --git a/driver-core/src/main/com/mongodb/ConnectionString.java b/driver-core/src/main/com/mongodb/ConnectionString.java
index 5e6a5b7d81a..d9fa22fec44 100644
--- a/driver-core/src/main/com/mongodb/ConnectionString.java
+++ b/driver-core/src/main/com/mongodb/ConnectionString.java
@@ -18,6 +18,8 @@
 
 import com.mongodb.connection.ClusterSettings;
 import com.mongodb.connection.ConnectionPoolSettings;
+import com.mongodb.connection.ServerMonitoringMode;
+import com.mongodb.connection.ServerSettings;
 import com.mongodb.connection.SocketSettings;
 import com.mongodb.event.ConnectionCheckOutStartedEvent;
 import com.mongodb.event.ConnectionCheckedInEvent;
@@ -111,6 +113,13 @@
  * <ul>
  * <li>{@code heartbeatFrequencyMS=ms}: The frequency that the driver will attempt to determine the current state of each server in the
  * cluster.</li>
+ * <li>{@code serverMonitoringMode=enum}: The server monitoring mode, which defines the monitoring protocol to use. Enumerated values:
+ *  <ul>
+ *      <li>{@code stream};</li>
+ *      <li>{@code poll};</li>
+ *      <li>{@code auto} - the default.</li>
+ *  </ul>
+ * </li>
  * </ul>
  * <p>Replica set configuration:</p>
  * <ul>
@@ -307,6 +316,7 @@ public class ConnectionString {
     private Integer serverSelectionTimeout;
     private Integer localThreshold;
     private Integer heartbeatFrequency;
+    private ServerMonitoringMode serverMonitoringMode;
     private String applicationName;
     private List<MongoCompressor> compressorList;
     private UuidRepresentation uuidRepresentation;
@@ -529,6 +539,7 @@ public ConnectionString(final String connectionString, @Nullable final DnsClient
         GENERAL_OPTIONS_KEYS.add("serverselectiontimeoutms");
         GENERAL_OPTIONS_KEYS.add("localthresholdms");
         GENERAL_OPTIONS_KEYS.add("heartbeatfrequencyms");
+        GENERAL_OPTIONS_KEYS.add("servermonitoringmode");
         GENERAL_OPTIONS_KEYS.add("retrywrites");
         GENERAL_OPTIONS_KEYS.add("retryreads");
 
@@ -665,6 +676,9 @@ private void translateOptions(final Map<String, List<String>> optionsMap) {
                 case "heartbeatfrequencyms":
                     heartbeatFrequency = parseInteger(value, "heartbeatfrequencyms");
                     break;
+                case "servermonitoringmode":
+                    serverMonitoringMode = ServerMonitoringMode.fromString(value);
+                    break;
                 case "appname":
                     applicationName = value;
                     break;
@@ -1623,6 +1637,20 @@ public Integer getHeartbeatFrequency() {
         return heartbeatFrequency;
     }
 
+    /**
+     * The server monitoring mode, which defines the monitoring protocol to use.
+     * <p>
+     * Default is {@link ServerMonitoringMode#AUTO}.</p>
+     *
+     * @return The {@link ServerMonitoringMode}, or {@code null} if unset and the default is to be used.
+     * @see ServerSettings#getServerMonitoringMode()
+     * @since 5.1
+     */
+    @Nullable
+    public ServerMonitoringMode getServerMonitoringMode() {
+        return serverMonitoringMode;
+    }
+
     /**
      * Gets the logical name of the application.  The application name may be used by the client to identify the application to the server,
      * for use in server logs, slow query logs, and profile collection.
@@ -1704,6 +1732,7 @@ public boolean equals(final Object o) {
                 && Objects.equals(serverSelectionTimeout, that.serverSelectionTimeout)
                 && Objects.equals(localThreshold, that.localThreshold)
                 && Objects.equals(heartbeatFrequency, that.heartbeatFrequency)
+                && Objects.equals(serverMonitoringMode, that.serverMonitoringMode)
                 && Objects.equals(applicationName, that.applicationName)
                 && Objects.equals(compressorList, that.compressorList)
                 && Objects.equals(uuidRepresentation, that.uuidRepresentation)
@@ -1717,7 +1746,7 @@ public int hashCode() {
                 writeConcern, retryWrites, retryReads, readConcern, minConnectionPoolSize, maxConnectionPoolSize, maxWaitTime,
                 maxConnectionIdleTime, maxConnectionLifeTime, maxConnecting, connectTimeout, socketTimeout, sslEnabled,
                 sslInvalidHostnameAllowed, requiredReplicaSetName, serverSelectionTimeout, localThreshold, heartbeatFrequency,
-                applicationName, compressorList, uuidRepresentation, srvServiceName, srvMaxHosts, proxyHost, proxyPort,
-                proxyUsername, proxyPassword);
+                serverMonitoringMode, applicationName, compressorList, uuidRepresentation, srvServiceName, srvMaxHosts, proxyHost,
+                proxyPort, proxyUsername, proxyPassword);
     }
 }
diff --git a/driver-core/src/main/com/mongodb/connection/ServerMonitoringMode.java b/driver-core/src/main/com/mongodb/connection/ServerMonitoringMode.java
new file mode 100644
index 00000000000..a88c4c3afb7
--- /dev/null
+++ b/driver-core/src/main/com/mongodb/connection/ServerMonitoringMode.java
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.connection;
+
+import static com.mongodb.assertions.Assertions.notNull;
+import static java.lang.String.format;
+
+/**
+ * The server monitoring mode, which defines the monitoring protocol to use.
+ *
+ * @since 5.1
+ */
+public enum ServerMonitoringMode {
+    /**
+     * Use the streaming protocol whe the server supports it or fall back to the polling protocol otherwise.
+     */
+    STREAM("stream"),
+    /**
+     * Use the polling protocol.
+     */
+    POLL("poll"),
+    /**
+     * Behave the same as {@link #POLL} if running in a FaaS environment, otherwise behave as {@link #STREAM}.
+     * This is the default.
+     */
+    AUTO("auto");
+
+    private final String value;
+
+    ServerMonitoringMode(final String value) {
+        this.value = value;
+    }
+
+    /**
+     * Parses a string into {@link ServerMonitoringMode}.
+     *
+     * @param serverMonitoringMode A server monitoring mode string.
+     * @return The corresponding {@link ServerMonitoringMode} value.
+     * @see #getValue()
+     */
+    public static ServerMonitoringMode fromString(final String serverMonitoringMode) {
+        notNull("serverMonitoringMode", serverMonitoringMode);
+        for (ServerMonitoringMode mode : ServerMonitoringMode.values()) {
+            if (serverMonitoringMode.equalsIgnoreCase(mode.value)) {
+                return mode;
+            }
+        }
+        throw new IllegalArgumentException(format("'%s' is not a valid %s",
+                serverMonitoringMode, ServerMonitoringMode.class.getSimpleName()));
+    }
+
+    /**
+     * The string value.
+     *
+     * @return The string value.
+     * @see #fromString(String)
+     */
+    public String getValue() {
+        return value;
+    }
+}
diff --git a/driver-core/src/main/com/mongodb/connection/ServerSettings.java b/driver-core/src/main/com/mongodb/connection/ServerSettings.java
index d4ef398a047..b4394d0dc79 100644
--- a/driver-core/src/main/com/mongodb/connection/ServerSettings.java
+++ b/driver-core/src/main/com/mongodb/connection/ServerSettings.java
@@ -24,6 +24,7 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Objects;
 import java.util.concurrent.TimeUnit;
 
 import static com.mongodb.assertions.Assertions.notNull;
@@ -38,6 +39,7 @@
 public class ServerSettings {
     private final long heartbeatFrequencyMS;
     private final long minHeartbeatFrequencyMS;
+    private final ServerMonitoringMode serverMonitoringMode;
     private final List<ServerListener> serverListeners;
     private final List<ServerMonitorListener> serverMonitorListeners;
 
@@ -68,6 +70,7 @@ public static Builder builder(final ServerSettings serverSettings) {
     public static final class Builder {
         private long heartbeatFrequencyMS = 10000;
         private long minHeartbeatFrequencyMS = 500;
+        private ServerMonitoringMode serverMonitoringMode = ServerMonitoringMode.AUTO;
         private List<ServerListener> serverListeners = new ArrayList<>();
         private List<ServerMonitorListener> serverMonitorListeners = new ArrayList<>();
 
@@ -87,6 +90,7 @@ public Builder applySettings(final ServerSettings serverSettings) {
             notNull("serverSettings", serverSettings);
             heartbeatFrequencyMS = serverSettings.heartbeatFrequencyMS;
             minHeartbeatFrequencyMS = serverSettings.minHeartbeatFrequencyMS;
+            serverMonitoringMode = serverSettings.serverMonitoringMode;
             serverListeners = new ArrayList<>(serverSettings.serverListeners);
             serverMonitorListeners = new ArrayList<>(serverSettings.serverMonitorListeners);
             return this;
@@ -117,6 +121,20 @@ public Builder minHeartbeatFrequency(final long minHeartbeatFrequency, final Tim
             return this;
         }
 
+        /**
+         * Sets the server monitoring mode, which defines the monitoring protocol to use.
+         * The default value is {@link ServerMonitoringMode#AUTO}.
+         *
+         * @param serverMonitoringMode The {@link ServerMonitoringMode}.
+         * @return {@code this}.
+         * @see #getServerMonitoringMode()
+         * @since 5.1
+         */
+        public Builder serverMonitoringMode(final ServerMonitoringMode serverMonitoringMode) {
+            this.serverMonitoringMode = notNull("serverMonitoringMode", serverMonitoringMode);
+            return this;
+        }
+
         /**
          * Add a server listener.
          *
@@ -181,6 +199,10 @@ public Builder applyConnectionString(final ConnectionString connectionString) {
             if (heartbeatFrequency != null) {
                 heartbeatFrequencyMS = heartbeatFrequency;
             }
+            ServerMonitoringMode serverMonitoringMode = connectionString.getServerMonitoringMode();
+            if (serverMonitoringMode != null) {
+                this.serverMonitoringMode = serverMonitoringMode;
+            }
             return this;
         }
 
@@ -215,6 +237,19 @@ public long getMinHeartbeatFrequency(final TimeUnit timeUnit) {
         return timeUnit.convert(minHeartbeatFrequencyMS, TimeUnit.MILLISECONDS);
     }
 
+    /**
+     * Gets the server monitoring mode, which defines the monitoring protocol to use.
+     * The default value is {@link ServerMonitoringMode#AUTO}.
+     *
+     * @return The {@link ServerMonitoringMode}.
+     * @see Builder#serverMonitoringMode(ServerMonitoringMode)
+     * @see ConnectionString#getServerMonitoringMode()
+     * @since 5.1
+     */
+    public ServerMonitoringMode getServerMonitoringMode() {
+        return serverMonitoringMode;
+    }
+
     /**
      * Gets the server listeners.  The default value is an empty list.
      *
@@ -243,33 +278,22 @@ public boolean equals(final Object o) {
         if (o == null || getClass() != o.getClass()) {
             return false;
         }
-
-        ServerSettings that = (ServerSettings) o;
-
-        if (heartbeatFrequencyMS != that.heartbeatFrequencyMS) {
-            return false;
-        }
-        if (minHeartbeatFrequencyMS != that.minHeartbeatFrequencyMS) {
-            return false;
-        }
-
-        if (!serverListeners.equals(that.serverListeners)) {
-            return false;
-        }
-        if (!serverMonitorListeners.equals(that.serverMonitorListeners)) {
-            return false;
-        }
-
-        return true;
+        final ServerSettings that = (ServerSettings) o;
+        return heartbeatFrequencyMS == that.heartbeatFrequencyMS
+                && minHeartbeatFrequencyMS == that.minHeartbeatFrequencyMS
+                && serverMonitoringMode == that.serverMonitoringMode
+                && Objects.equals(serverListeners, that.serverListeners)
+                && Objects.equals(serverMonitorListeners, that.serverMonitorListeners);
     }
 
     @Override
     public int hashCode() {
-        int result = (int) (heartbeatFrequencyMS ^ (heartbeatFrequencyMS >>> 32));
-        result = 31 * result + (int) (minHeartbeatFrequencyMS ^ (minHeartbeatFrequencyMS >>> 32));
-        result = 31 * result + serverListeners.hashCode();
-        result = 31 * result + serverMonitorListeners.hashCode();
-        return result;
+        return Objects.hash(
+                heartbeatFrequencyMS,
+                minHeartbeatFrequencyMS,
+                serverMonitoringMode,
+                serverListeners,
+                serverMonitorListeners);
     }
 
     @Override
@@ -277,6 +301,7 @@ public String toString() {
         return "ServerSettings{"
                + "heartbeatFrequencyMS=" + heartbeatFrequencyMS
                + ", minHeartbeatFrequencyMS=" + minHeartbeatFrequencyMS
+               + ", serverMonitoringMode=" + serverMonitoringMode
                + ", serverListeners='" + serverListeners + '\''
                + ", serverMonitorListeners='" + serverMonitorListeners + '\''
                + '}';
@@ -285,6 +310,7 @@ public String toString() {
     ServerSettings(final Builder builder) {
         heartbeatFrequencyMS = builder.heartbeatFrequencyMS;
         minHeartbeatFrequencyMS = builder.minHeartbeatFrequencyMS;
+        serverMonitoringMode = builder.serverMonitoringMode;
         serverListeners = unmodifiableList(builder.serverListeners);
         serverMonitorListeners = unmodifiableList(builder.serverMonitorListeners);
     }
diff --git a/driver-core/src/test/resources/uri-options/sdam-options.json b/driver-core/src/test/resources/uri-options/sdam-options.json
new file mode 100644
index 00000000000..673f5607ee9
--- /dev/null
+++ b/driver-core/src/test/resources/uri-options/sdam-options.json
@@ -0,0 +1,46 @@
+{
+  "tests": [
+    {
+      "description": "serverMonitoringMode=auto",
+      "uri": "mongodb://example.com/?serverMonitoringMode=auto",
+      "valid": true,
+      "warning": false,
+      "hosts": null,
+      "auth": null,
+      "options": {
+        "serverMonitoringMode": "auto"
+      }
+    },
+    {
+      "description": "serverMonitoringMode=stream",
+      "uri": "mongodb://example.com/?serverMonitoringMode=stream",
+      "valid": true,
+      "warning": false,
+      "hosts": null,
+      "auth": null,
+      "options": {
+        "serverMonitoringMode": "stream"
+      }
+    },
+    {
+      "description": "serverMonitoringMode=poll",
+      "uri": "mongodb://example.com/?serverMonitoringMode=poll",
+      "valid": true,
+      "warning": false,
+      "hosts": null,
+      "auth": null,
+      "options": {
+        "serverMonitoringMode": "poll"
+      }
+    },
+    {
+      "description": "invalid serverMonitoringMode",
+      "uri": "mongodb://example.com/?serverMonitoringMode=invalid",
+      "valid": true,
+      "warning": true,
+      "hosts": null,
+      "auth": null,
+      "options": {}
+    }
+  ]
+}
diff --git a/driver-core/src/test/unit/com/mongodb/AbstractConnectionStringTest.java b/driver-core/src/test/unit/com/mongodb/AbstractConnectionStringTest.java
index c5b90aa95fa..9e07b9758a6 100644
--- a/driver-core/src/test/unit/com/mongodb/AbstractConnectionStringTest.java
+++ b/driver-core/src/test/unit/com/mongodb/AbstractConnectionStringTest.java
@@ -139,6 +139,9 @@ protected void testValidOptions() {
             } else if (option.getKey().equalsIgnoreCase("heartbeatfrequencyms")) {
                 int expected = option.getValue().asInt32().getValue();
                 assertEquals(expected, connectionString.getHeartbeatFrequency().intValue());
+            } else if (option.getKey().equalsIgnoreCase("servermonitoringmode")) {
+                String expected = option.getValue().asString().getValue();
+                assertEquals(expected, connectionString.getServerMonitoringMode().getValue());
             } else if (option.getKey().equalsIgnoreCase("localthresholdms")) {
                 int expected = option.getValue().asInt32().getValue();
                 assertEquals(expected, connectionString.getLocalThreshold().intValue());
diff --git a/driver-core/src/test/unit/com/mongodb/ConnectionStringSpecification.groovy b/driver-core/src/test/unit/com/mongodb/ConnectionStringSpecification.groovy
index e0245e80092..e8731439a84 100644
--- a/driver-core/src/test/unit/com/mongodb/ConnectionStringSpecification.groovy
+++ b/driver-core/src/test/unit/com/mongodb/ConnectionStringSpecification.groovy
@@ -35,6 +35,9 @@ import static com.mongodb.ReadPreference.secondaryPreferred
 import static java.util.Arrays.asList
 import static java.util.concurrent.TimeUnit.MILLISECONDS
 
+/**
+ * Update {@link ConnectionStringUnitTest} instead.
+ */
 class ConnectionStringSpecification extends Specification {
     static final LONG_STRING = new String((1..256).collect { (byte) 1 } as byte[])
 
diff --git a/driver-core/src/test/unit/com/mongodb/ConnectionStringUnitTest.java b/driver-core/src/test/unit/com/mongodb/ConnectionStringUnitTest.java
new file mode 100644
index 00000000000..d2e41ebeafd
--- /dev/null
+++ b/driver-core/src/test/unit/com/mongodb/ConnectionStringUnitTest.java
@@ -0,0 +1,62 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb;
+
+import com.mongodb.connection.ServerMonitoringMode;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+final class ConnectionStringUnitTest {
+    private static final String DEFAULT_OPTIONS = "mongodb://localhost/?";
+    @Test
+    void defaults() {
+        ConnectionString connectionStringDefault = new ConnectionString(DEFAULT_OPTIONS);
+        assertAll(() -> assertNull(connectionStringDefault.getServerMonitoringMode()));
+    }
+
+    @ParameterizedTest
+    @ValueSource(strings = {DEFAULT_OPTIONS + "serverMonitoringMode=stream"})
+    void equalAndHashCode(final String connectionString) {
+        ConnectionString default1 = new ConnectionString(DEFAULT_OPTIONS);
+        ConnectionString default2 = new ConnectionString(DEFAULT_OPTIONS);
+        ConnectionString actual1 = new ConnectionString(connectionString);
+        ConnectionString actual2 = new ConnectionString(connectionString);
+        assertAll(
+                () -> assertEquals(default1, default2),
+                () -> assertEquals(default1.hashCode(), default2.hashCode()),
+                () -> assertEquals(actual1, actual2),
+                () -> assertEquals(actual1.hashCode(), actual2.hashCode()),
+                () -> assertNotEquals(default1, actual1)
+        );
+    }
+
+    @Test
+    void serverMonitoringMode() {
+        assertAll(
+                () -> assertEquals(ServerMonitoringMode.POLL,
+                        new ConnectionString(DEFAULT_OPTIONS + "serverMonitoringMode=poll").getServerMonitoringMode()),
+                () -> assertThrows(IllegalArgumentException.class,
+                        () -> new ConnectionString(DEFAULT_OPTIONS + "serverMonitoringMode=invalid"))
+        );
+    }
+}
diff --git a/driver-core/src/test/unit/com/mongodb/connection/ServerMonitoringModeTest.java b/driver-core/src/test/unit/com/mongodb/connection/ServerMonitoringModeTest.java
new file mode 100644
index 00000000000..1aba44d476e
--- /dev/null
+++ b/driver-core/src/test/unit/com/mongodb/connection/ServerMonitoringModeTest.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.connection;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+final class ServerMonitoringModeTest {
+    @Test
+    public void fromString() {
+        assertAll(
+                () -> assertEquals(ServerMonitoringMode.STREAM, ServerMonitoringMode.fromString("stream")),
+                () -> assertEquals(ServerMonitoringMode.POLL, ServerMonitoringMode.fromString("poll")),
+                () -> assertEquals(ServerMonitoringMode.AUTO, ServerMonitoringMode.fromString("auto")),
+                () -> assertThrows(IllegalArgumentException.class, () -> ServerMonitoringMode.fromString("invalid"))
+        );
+    }
+
+    @Test
+    public void getValue() {
+        assertAll(
+                () -> assertEquals("stream", ServerMonitoringMode.STREAM.getValue()),
+                () -> assertEquals("poll", ServerMonitoringMode.POLL.getValue()),
+                () -> assertEquals("auto", ServerMonitoringMode.AUTO.getValue())
+        );
+    }
+}
diff --git a/driver-core/src/test/unit/com/mongodb/connection/ServerSettingsSpecification.groovy b/driver-core/src/test/unit/com/mongodb/connection/ServerSettingsSpecification.groovy
index b92d8630f14..b11ed3a65a3 100644
--- a/driver-core/src/test/unit/com/mongodb/connection/ServerSettingsSpecification.groovy
+++ b/driver-core/src/test/unit/com/mongodb/connection/ServerSettingsSpecification.groovy
@@ -24,6 +24,9 @@ import spock.lang.Specification
 import static java.util.concurrent.TimeUnit.MILLISECONDS
 import static java.util.concurrent.TimeUnit.SECONDS
 
+/**
+ * Update {@link ServerSettingsTest} instead.
+ */
 class ServerSettingsSpecification extends Specification {
     def 'should have correct defaults'() {
         when:
diff --git a/driver-core/src/test/unit/com/mongodb/connection/ServerSettingsTest.java b/driver-core/src/test/unit/com/mongodb/connection/ServerSettingsTest.java
new file mode 100644
index 00000000000..e8868813b03
--- /dev/null
+++ b/driver-core/src/test/unit/com/mongodb/connection/ServerSettingsTest.java
@@ -0,0 +1,106 @@
+/*
+ * Copyright 2008-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.mongodb.connection;
+
+import com.mongodb.ConnectionString;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertAll;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+
+final class ServerSettingsTest {
+    private static final String DEFAULT_OPTIONS = "mongodb://localhost/?";
+
+    @Test
+    void defaults() {
+        ServerSettings defaultServerSettings = ServerSettings.builder().build();
+        assertAll(() -> assertEquals(ServerMonitoringMode.AUTO, defaultServerSettings.getServerMonitoringMode()));
+    }
+
+    @ParameterizedTest
+    @MethodSource("equalAndHashCodeArgs")
+    void equalAndHashCode(final ServerSettings.Builder serverSettingsBuilder) {
+        ServerSettings default1 = ServerSettings.builder().build();
+        ServerSettings default2 = ServerSettings.builder().build();
+        ServerSettings actual1 = serverSettingsBuilder.build();
+        ServerSettings actual2 = serverSettingsBuilder.build();
+        assertAll(
+                () -> assertEquals(default1, default2),
+                () -> assertEquals(default1.hashCode(), default2.hashCode()),
+                () -> assertEquals(actual1, actual2),
+                () -> assertEquals(actual1.hashCode(), actual2.hashCode()),
+                () -> assertNotEquals(default1, actual1)
+        );
+    }
+
+    private static Stream<Arguments> equalAndHashCodeArgs() {
+        return Stream.of(
+                Arguments.of(ServerSettings.builder().serverMonitoringMode(ServerMonitoringMode.POLL))
+        );
+    }
+
+    @Test
+    void serverMonitoringMode() {
+        assertAll(
+                () -> assertEquals(
+                        ServerMonitoringMode.POLL,
+                        ServerSettings.builder()
+                                .serverMonitoringMode(ServerMonitoringMode.POLL)
+                                .build()
+                                .getServerMonitoringMode(),
+                        "should set"),
+                () -> assertEquals(
+                        ServerMonitoringMode.STREAM,
+                        ServerSettings.builder()
+                                .applySettings(ServerSettings.builder()
+                                        .serverMonitoringMode(ServerMonitoringMode.STREAM)
+                                        .build())
+                                .build()
+                                .getServerMonitoringMode(),
+                        "should apply from settings"),
+                () -> assertEquals(
+                        ServerMonitoringMode.AUTO,
+                        ServerSettings.builder()
+                                .serverMonitoringMode(ServerMonitoringMode.STREAM)
+                                .applySettings(ServerSettings.builder()
+                                        .build())
+                                .build()
+                                .getServerMonitoringMode(),
+                        "should apply unset from settings"),
+                () -> assertEquals(
+                        ServerMonitoringMode.POLL,
+                        ServerSettings.builder()
+                                .applyConnectionString(new ConnectionString(DEFAULT_OPTIONS + "serverMonitoringMode=POLL"))
+                                .build()
+                                .getServerMonitoringMode(),
+                        "should apply from connection string"),
+                () -> assertEquals(
+                        ServerMonitoringMode.STREAM,
+                        ServerSettings.builder()
+                                .serverMonitoringMode(ServerMonitoringMode.STREAM)
+                                .applyConnectionString(new ConnectionString(DEFAULT_OPTIONS))
+                                .build()
+                                .getServerMonitoringMode(),
+                        "should not apply unset from connection string")
+        );
+    }
+}