diff --git a/README.md b/README.md
index 99fc0bb7..047a9d48 100644
--- a/README.md
+++ b/README.md
@@ -7,6 +7,7 @@
 1. [Introduction](#introduction)
 1. [Release Notes](#release-notes)
 1. [Implemented Changes](#implemented-changes)
+1. [Connection String Formats](#connection-string)
 1. [Getting Started](#getting-started)
 1. [Running tests](#running-tests)
 1. [Integration](#integration)
@@ -28,9 +29,11 @@ Liquibase turned to be the most feasible tool to extend as it allows to define c
 ## Release Notes
 
 #### 4.2.2.1
+* Fixed [Issue-64:Support for DNS Seed List Connection Format or Atlas Cluster](https://github.com/liquibase/liquibase-mongodb/issues/66)
 * Fixed [Issue-69: Does it support preconditions](https://github.com/liquibase/liquibase-mongodb/issues/69)
 * Added DocumentExistsPrecondition, ExpectedDocumentCountPrecondition
 * Fixed [Issue-74: createIndex with TTL (expireAfterSeconds) is ignored and normal index created](https://github.com/liquibase/liquibase-mongodb/issues/74)
+* Fixed [Issue-79: CreateCollection silently drops supported options](https://github.com/liquibase/liquibase-mongodb/issues/79)
 
 #### 4.2.2
 * Support for Liquibase 4.2.2
@@ -101,6 +104,24 @@ Provides a helper to run specified database commands. This is the preferred meth
 * [__adminCommand__](https://docs.mongodb.com/manual/reference/method/db.adminCommand/#db.adminCommand) - 
 Provides a helper to run specified database commands against the admin database
 
+<a name="connection-string"></a>
+## Connection String Formats
+
+### [Standard Connection String Format](https://docs.mongodb.com/manual/reference/connection-string/index.html#standard-connection-string-format)
+
+`
+mongodb://[username:password@]host1[:port1][,...hostN[:portN]][/[defaultauthdb][?options]]
+mongodb://mongodb1.example.com:27317,mongodb2.example.com:27017/?replicaSet=mySet&authSource=authDB
+`
+
+### [DNS Seed List Connection Format](https://docs.mongodb.com/manual/reference/connection-string/index.html#dns-seed-list-connection-format)
+
+`
+mongodb+srv://[username:password@]host[/[database][?options]]
+mongodb+srv://server.example.com/
+mongodb+srv://:@cluster0.example.com/testdb?authSource=$external&authMechanism=MONGODB-AWS
+`
+
 <a name="getting-started"></a>
 ## Getting Started
 
@@ -115,6 +136,10 @@ mongo-java-driver:3.12.7
 ### Installing
 
 * Clone the project
+
+```shell
+git clone https://github.com/liquibase/liquibase-mongodb
+```  
 * [Run tests](#running-tests)
 
 <a name="running-tests"></a>
@@ -128,7 +153,7 @@ Run Integration tests by enabling `run-its` profile
 
 ### Run integration tests
 
-```shell script
+```shell
 mvn clean install -Prun-its
 ```
 
diff --git a/src/main/java/liquibase/ext/mongodb/database/MongoClientDriver.java b/src/main/java/liquibase/ext/mongodb/database/MongoClientDriver.java
index 139c5b57..ea66d83a 100644
--- a/src/main/java/liquibase/ext/mongodb/database/MongoClientDriver.java
+++ b/src/main/java/liquibase/ext/mongodb/database/MongoClientDriver.java
@@ -5,6 +5,7 @@
 import com.mongodb.client.MongoClients;
 import liquibase.Scope;
 import liquibase.exception.DatabaseException;
+import liquibase.util.StringUtil;
 
 import java.sql.Connection;
 import java.sql.Driver;
@@ -12,10 +13,12 @@
 import java.util.Properties;
 import java.util.logging.Logger;
 
+import static java.util.Objects.nonNull;
+
 public class MongoClientDriver implements Driver {
 
     @Override
-    public Connection connect(String url, Properties info) {
+    public Connection connect(final String url, final Properties info) {
         //Not applicable for non JDBC DBs
         throw new UnsupportedOperationException("Cannot initiate a SQL Connection for a NoSql DB");
     }
@@ -32,8 +35,9 @@ public MongoClient connect(final ConnectionString connectionString) throws Datab
     }
 
     @Override
-    public boolean acceptsURL(String url) {
-        return false;
+    public boolean acceptsURL(final String url) {
+        final String trimmedUrl = StringUtil.trimToEmpty(url);
+        return trimmedUrl.startsWith(MongoConnection.MONGO_DNS_PREFIX) || trimmedUrl.startsWith(MongoConnection.MONGO_PREFIX);
     }
 
     @Override
diff --git a/src/main/java/liquibase/ext/mongodb/database/MongoConnection.java b/src/main/java/liquibase/ext/mongodb/database/MongoConnection.java
index 88b05def..673ebc63 100644
--- a/src/main/java/liquibase/ext/mongodb/database/MongoConnection.java
+++ b/src/main/java/liquibase/ext/mongodb/database/MongoConnection.java
@@ -38,8 +38,10 @@
 import java.util.Optional;
 import java.util.Properties;
 
+import static java.util.Objects.isNull;
 import static java.util.Objects.nonNull;
 import static java.util.Optional.ofNullable;
+import static liquibase.ext.mongodb.database.MongoLiquibaseDatabase.MONGODB_PRODUCT_SHORT_NAME;
 
 @Getter
 @Setter
@@ -47,8 +49,8 @@
 public class MongoConnection extends AbstractNoSqlConnection {
 
     public static final int DEFAULT_PORT = 27017;
-    public static final String MONGO_PREFIX = MongoLiquibaseDatabase.MONGODB_PRODUCT_SHORT_NAME + "://";
-    public static final String MONGO_CONNECTION_STRING_PATTERN = "%s/%s";
+    public static final String MONGO_PREFIX = MONGODB_PRODUCT_SHORT_NAME + "://";
+    public static final String MONGO_DNS_PREFIX = MONGODB_PRODUCT_SHORT_NAME + "+srv://";
 
     private ConnectionString connectionString;
 
@@ -80,24 +82,16 @@ public String getConnectionUserName() {
                 .map(MongoCredential::getUserName).orElse("");
     }
 
+    @Override
+    public boolean isClosed() throws DatabaseException {
+        return isNull(client);
+    }
+
     @Override
     public void open(final String url, final Driver driverObject, final Properties driverProperties) throws DatabaseException {
 
         try {
-
-            String urlWithCredentials = url;
-
-            if (nonNull(driverProperties)) {
-
-                final Optional<String> user = Optional.ofNullable(StringUtil.trimToNull(driverProperties.getProperty("user")));
-                final Optional<String> password = Optional.ofNullable(StringUtil.trimToNull(driverProperties.getProperty("password")));
-
-                if (user.isPresent() && password.isPresent()) {
-                    // injects credentials
-                    // mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database.collection][?options]]
-                    urlWithCredentials = MONGO_PREFIX + user.get() + ":" + password.get() + "@" + StringUtil.trimToEmpty(url).replaceFirst(MONGO_PREFIX, "");
-                }
-            }
+            final String urlWithCredentials = injectCredentials(StringUtil.trimToEmpty(url), driverProperties);
 
             this.connectionString = new ConnectionString(urlWithCredentials);
 
@@ -111,10 +105,33 @@ public void open(final String url, final Driver driverObject, final Properties d
         }
     }
 
+    private String injectCredentials(final String url, final Properties driverProperties) {
+
+        if (nonNull(driverProperties)) {
+
+            final Optional<String> user = Optional.ofNullable(StringUtil.trimToNull(driverProperties.getProperty("user")));
+            final Optional<String> password = Optional.ofNullable(StringUtil.trimToNull(driverProperties.getProperty("password")));
+
+            if (user.isPresent()) {
+                // injects credentials
+                // mongodb://[username:password@]host1[:port1][,host2[:port2],...[,hostN[:portN]]][/[database.collection][?options]]
+                // mongodb+srv://[username:password@]host[:port1][?options]]
+                final String mongoPrefix = url.startsWith(MONGO_DNS_PREFIX) ? MONGO_DNS_PREFIX : MONGO_PREFIX;
+                return mongoPrefix + user.get() + password.map(p -> ":" + p).orElse("") + "@" +
+                        url.substring(mongoPrefix.length());
+            }
+        }
+        return url;
+    }
+
+
     @Override
     public void close() throws DatabaseException {
         try {
-            client.close();
+            if (!isClosed()) {
+                client.close();
+                client = null;
+            }
         } catch (final Exception e) {
             throw new DatabaseException(e);
         }
diff --git a/src/main/java/liquibase/ext/mongodb/database/MongoLiquibaseDatabase.java b/src/main/java/liquibase/ext/mongodb/database/MongoLiquibaseDatabase.java
index 0d0c55f4..7953f8d7 100644
--- a/src/main/java/liquibase/ext/mongodb/database/MongoLiquibaseDatabase.java
+++ b/src/main/java/liquibase/ext/mongodb/database/MongoLiquibaseDatabase.java
@@ -23,14 +23,13 @@
 import liquibase.CatalogAndSchema;
 import liquibase.Scope;
 import liquibase.changelog.ChangeLogHistoryServiceFactory;
-import liquibase.configuration.GlobalConfiguration;
 import liquibase.configuration.LiquibaseConfiguration;
-import liquibase.ext.mongodb.configuration.MongoConfiguration;
-import liquibase.nosql.database.AbstractNoSqlDatabase;
 import liquibase.exception.LiquibaseException;
 import liquibase.executor.Executor;
 import liquibase.executor.ExecutorService;
+import liquibase.ext.mongodb.configuration.MongoConfiguration;
 import liquibase.ext.mongodb.statement.DropAllCollectionsStatement;
+import liquibase.nosql.database.AbstractNoSqlDatabase;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
 
@@ -41,6 +40,7 @@ public class MongoLiquibaseDatabase extends AbstractNoSqlDatabase {
 
     public static final String MONGODB_PRODUCT_NAME = "MongoDB";
     public static final String MONGODB_PRODUCT_SHORT_NAME = "mongodb";
+    public static final String ADMIN_DATABSE_NAME = "admin";
 
     @Setter
     private Boolean adjustTrackingTablesOnStartup;
@@ -58,7 +58,7 @@ public void dropDatabaseObjects(final CatalogAndSchema schemaToDrop) throws Liqu
 
     @Override
     public String getDefaultDriver(final String url) {
-        if (url.startsWith(MongoConnection.MONGO_PREFIX)) {
+        if (url.startsWith(MongoConnection.MONGO_DNS_PREFIX) || url.startsWith(MongoConnection.MONGO_PREFIX)) {
             return MongoClientDriver.class.getName();
         }
         return null;
@@ -90,7 +90,7 @@ protected String getDefaultDatabaseProductName() {
 
     @Override
     public String getSystemSchema() {
-        return "admin";
+        return ADMIN_DATABSE_NAME;
     }
 
     /*********************************
diff --git a/src/main/java/liquibase/nosql/database/AbstractNoSqlConnection.java b/src/main/java/liquibase/nosql/database/AbstractNoSqlConnection.java
index 9cf21659..11676e87 100644
--- a/src/main/java/liquibase/nosql/database/AbstractNoSqlConnection.java
+++ b/src/main/java/liquibase/nosql/database/AbstractNoSqlConnection.java
@@ -23,7 +23,6 @@
 import liquibase.database.Database;
 import liquibase.database.DatabaseConnection;
 import liquibase.exception.DatabaseException;
-import lombok.AllArgsConstructor;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -51,8 +50,6 @@ public void setAutoCommit(boolean autoCommit) throws DatabaseException {
 
     @Override
     public String nativeSQL(String sql) {
-        //TODO: Investigate whether can be thrown not applicable
-        //throw new UnsupportedOperationException();
         return null;
     }
 
@@ -86,9 +83,4 @@ public void rollback() throws DatabaseException {
         // Do nothing
     }
 
-    @Override
-    public boolean isClosed() throws DatabaseException {
-        return false;
-    }
-
 }
diff --git a/src/test/java/liquibase/ext/mongodb/database/MongoClientDriverTest.java b/src/test/java/liquibase/ext/mongodb/database/MongoClientDriverTest.java
new file mode 100644
index 00000000..7299b1ec
--- /dev/null
+++ b/src/test/java/liquibase/ext/mongodb/database/MongoClientDriverTest.java
@@ -0,0 +1,46 @@
+package liquibase.ext.mongodb.database;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInstance;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
+
+@TestInstance(TestInstance.Lifecycle.PER_METHOD)
+class MongoClientDriverTest {
+
+    protected MongoClientDriver mongoClientDriver;
+
+    @BeforeEach
+    void setUp() {
+        mongoClientDriver = new MongoClientDriver();
+    }
+
+    @Test
+    void acceptsURL() {
+        assertThat(mongoClientDriver.acceptsURL(null)).isFalse();
+        assertThat(mongoClientDriver.acceptsURL("")).isFalse();
+        assertThat(mongoClientDriver.acceptsURL("jdbc:oracle:thin:@localhost:1521:xe")).isFalse();
+        assertThat(mongoClientDriver.acceptsURL("mongodbsuffix://localhost")).isFalse();
+        assertThat(mongoClientDriver.acceptsURL("mongodb://localhost")).isTrue();
+        assertThat(mongoClientDriver.acceptsURL("       mongodb://localhost")).isTrue();
+        assertThat(mongoClientDriver.acceptsURL("mongodb+srv://localhost")).isTrue();
+        assertThat(mongoClientDriver.acceptsURL("       mongodb+srv://localhost")).isTrue();
+    }
+
+    @Test
+    void getMajorVersion() {
+        assertThat(mongoClientDriver.getMajorVersion()).isEqualTo(0);
+    }
+
+    @Test
+    void getMinorVersion() {
+        assertThat(mongoClientDriver.getMinorVersion()).isEqualTo(0);
+    }
+
+    @Test
+    void jdbcCompliant() {
+        assertThat(mongoClientDriver.jdbcCompliant()).isFalse();
+    }
+}
\ No newline at end of file
diff --git a/src/test/java/liquibase/ext/mongodb/database/MongoConnectionTest.java b/src/test/java/liquibase/ext/mongodb/database/MongoConnectionTest.java
index 61ae52cf..6fa971c9 100644
--- a/src/test/java/liquibase/ext/mongodb/database/MongoConnectionTest.java
+++ b/src/test/java/liquibase/ext/mongodb/database/MongoConnectionTest.java
@@ -3,9 +3,11 @@
 import com.mongodb.ConnectionString;
 import com.mongodb.client.MongoClient;
 import com.mongodb.client.MongoDatabase;
+import liquibase.exception.DatabaseException;
 import lombok.SneakyThrows;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Disabled;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.TestInstance;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -15,6 +17,7 @@
 import java.util.Properties;
 
 import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatExceptionOfType;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
@@ -74,38 +77,75 @@ void getDatabaseMinorVersion() {
         assertThat(connection.getDatabaseMinorVersion()).isEqualTo(0);
     }
 
+    @SneakyThrows
     @Test
     void getConnectionUserName() {
+
+        when(driverMock.connect(any(ConnectionString.class))).thenReturn(clientMock);
+        when(clientMock.getDatabase(any())).thenReturn(databaseMock);
+
+        assertThat(connection.getConnectionUserName()).isEmpty();
+
+        connection.open("mongodb://localhost:27017/test_db", driverMock, null);
+        assertThat(connection.getConnectionUserName()).isEmpty();
+
+        connection.open("mongodb://user1:pass1@localhost:27017/test_db", driverMock, null);
+        assertThat(connection.getConnectionUserName()).isEqualTo("user1");
     }
 
+    @SneakyThrows
     @Test
     void isClosed() {
+
+        when(driverMock.connect(any(ConnectionString.class))).thenReturn(clientMock);
+        when(clientMock.getDatabase(any())).thenReturn(databaseMock);
+
+        assertThat(connection.isClosed()).isTrue();
+
+        connection.open("mongodb://localhost:27017/test_db?socketTimeoutMS=1000&connectTimeoutMS=1000&serverSelectionTimeoutMS=1000", driverMock, null);
+        assertThat(connection.isClosed()).isFalse();
+
+        connection.close();
+        assertThat(connection.isClosed()).isTrue();
+
+        //close a closed connection
+        connection.close();
+        assertThat(connection.isClosed()).isTrue();
     }
 
+    @SneakyThrows
     @Test
     void getCatalog() {
-    }
+        when(driverMock.connect(any(ConnectionString.class))).thenReturn(clientMock);
+        when(clientMock.getDatabase(any())).thenReturn(databaseMock);
+        when(databaseMock.getName()).thenReturn("test_db");
+        when(databaseMock.withCodecRegistry(any())).thenReturn(databaseMock);
 
-    @Test
-    void getDatabaseProductName() {
+        assertThatExceptionOfType(DatabaseException.class).isThrownBy(() -> connection.getCatalog()).withCauseInstanceOf(NullPointerException.class);
+
+        connection.open("mongodb://localhost:27017/test_db?socketTimeoutMS=1000&connectTimeoutMS=1000&serverSelectionTimeoutMS=1000", driverMock, null);
+        assertThat(connection.getCatalog()).isEqualTo("test_db");
     }
 
+    @SneakyThrows
     @Test
-    void getURL() {
+    void getDatabaseProductName() {
+        assertThat(connection.getDatabaseProductName()).isEqualTo("MongoDB");
     }
 
     @SneakyThrows
     @Test
-    @SuppressWarnings("ConstantConditions")
     void open() {
         when(driverMock.connect(any(ConnectionString.class))).thenReturn(clientMock);
         when(clientMock.getDatabase(any())).thenReturn(databaseMock);
         when(databaseMock.withCodecRegistry(any())).thenReturn(databaseMock);
 
         connection.open("mongodb://localhost:27017/test_db?socketTimeoutMS=1000&connectTimeoutMS=1000&serverSelectionTimeoutMS=1000", driverMock, null);
+        assertThat(connection.getConnectionString().isSrvProtocol()).isFalse();
         assertThat(connection.getConnectionString().getDatabase()).isEqualTo("test_db");
         assertThat(connection.getConnectionString().getCredential()).isNull();
         assertThat(connection.getConnectionUserName()).isEmpty();
+        assertThat(connection.getURL()).isEqualTo("localhost:27017");
 
         verify(driverMock).connect(any(ConnectionString.class));
         verify(clientMock).getDatabase(any());
@@ -113,39 +153,119 @@ void open() {
         verifyNoMoreInteractions(driverMock, clientMock, databaseMock);
 
         connection.open("mongodb://user1:password1@localhost:27017/test_db?socketTimeoutMS=1000&connectTimeoutMS=1000&serverSelectionTimeoutMS=1000", driverMock, null);
-
+        assertThat(connection.getConnectionString().isSrvProtocol()).isFalse();
         assertThat(connection.getConnectionString().getDatabase()).isEqualTo("test_db");
-
         assertThat(connection.getConnectionString().getCredential()).isNotNull();
         assertThat(connection.getConnectionString().getCredential().getUserName()).isEqualTo("user1");
-        assertThat(String.valueOf(connection.getConnectionString().getCredential().getPassword())).isEqualTo("password1");
+        assertThat(connection.getConnectionString().getCredential().getPassword()).containsExactly('p','a','s','s','w','o','r','d','1');
         assertThat(connection.getConnectionUserName()).isEqualTo("user1");
+        assertThat(connection.getURL()).isEqualTo("localhost:27017");
 
         verify(driverMock, times(2)).connect(any(ConnectionString.class));
         verify(clientMock, times(2)).getDatabase(any());
         verify(databaseMock, times(2)).withCodecRegistry(any());
         verifyNoMoreInteractions(driverMock, clientMock, databaseMock);
 
-        final Properties properties = new Properties();
+        Properties properties = new Properties();
         properties.setProperty("user", "user2");
         properties.setProperty("password", "password2");
-        connection.open("mongodb://localhost:27017/test_db?socketTimeoutMS=1000&connectTimeoutMS=1000&serverSelectionTimeoutMS=1000", driverMock, properties);
-
+        connection.open("mongodb://mongodb1.example.com:27317,mongodb2.example.com:27017/test_db?socketTimeoutMS=1000&connectTimeoutMS=1000&serverSelectionTimeoutMS=1000", driverMock, properties);
+        assertThat(connection.getConnectionString().isSrvProtocol()).isFalse();
         assertThat(connection.getConnectionString().getDatabase()).isEqualTo("test_db");
         assertThat(connection.getConnectionString().getCredential()).isNotNull();
         assertThat(connection.getConnectionString().getCredential().getUserName()).isEqualTo("user2");
-        assertThat(String.valueOf(connection.getConnectionString().getCredential().getPassword())).isEqualTo("password2");
+        assertThat(connection.getConnectionString().getCredential().getPassword()).containsExactly('p','a','s','s','w','o','r','d','2');
         assertThat(connection.getConnectionUserName()).isEqualTo("user2");
+        assertThat(connection.getURL()).isEqualTo("mongodb1.example.com:27317,mongodb2.example.com:27017");
 
         verify(driverMock, times(3)).connect(any(ConnectionString.class));
         verify(clientMock, times(3)).getDatabase(any());
         verify(databaseMock, times(3)).withCodecRegistry(any());
         verifyNoMoreInteractions(driverMock, clientMock, databaseMock);
 
+        properties = new Properties();
+        properties.setProperty("user", "user3");
+        connection.open("mongodb://localhost:27017/test_db?authMechanism=MONGODB-X509&socketTimeoutMS=1000&connectTimeoutMS=1000&serverSelectionTimeoutMS=1000", driverMock, properties);
+        assertThat(connection.getConnectionString().isSrvProtocol()).isFalse();
+        assertThat(connection.getConnectionString().getDatabase()).isEqualTo("test_db");
+        assertThat(connection.getConnectionString().getCredential()).isNotNull();
+        assertThat(connection.getConnectionString().getCredential().getUserName()).isEqualTo("user3");
+        assertThat(connection.getConnectionString().getCredential().getPassword()).isNull();
+        assertThat(connection.getConnectionUserName()).isEqualTo("user3");
+        assertThat(connection.getURL()).isEqualTo("localhost:27017");
+
+        verify(driverMock, times(4)).connect(any(ConnectionString.class));
+        verify(clientMock, times(4)).getDatabase(any());
+        verify(databaseMock, times(4)).withCodecRegistry(any());
+        verifyNoMoreInteractions(driverMock, clientMock, databaseMock);
     }
 
+    @SneakyThrows
     @Test
-    void close() {
+    @Disabled("Travis - DNS name not found")
+    void openDNS() {
+        when(driverMock.connect(any(ConnectionString.class))).thenReturn(clientMock);
+        when(clientMock.getDatabase(any())).thenReturn(databaseMock);
+        when(databaseMock.withCodecRegistry(any())).thenReturn(databaseMock);
+
+        connection.open("mongodb+srv://localhost/test_db", driverMock, null);
+        assertThat(connection.getConnectionString().isSrvProtocol()).isTrue();
+        assertThat(connection.getConnectionString().getDatabase()).isEqualTo("test_db");
+        assertThat(connection.getConnectionString().getCredential()).isNull();
+        assertThat(connection.getConnectionUserName()).isEmpty();
+        assertThat(connection.getURL()).isEqualTo("localhost");
+
+        verify(driverMock).connect(any(ConnectionString.class));
+        verify(clientMock).getDatabase(any());
+        verify(databaseMock).withCodecRegistry(any());
+        verifyNoMoreInteractions(driverMock, clientMock, databaseMock);
+
+        connection.open("mongodb+srv://user1:password1@localhost/test_db", driverMock, null);
+        assertThat(connection.getConnectionString().isSrvProtocol()).isTrue();
+        assertThat(connection.getConnectionString().getDatabase()).isEqualTo("test_db");
+        assertThat(connection.getConnectionString().getCredential()).isNotNull();
+        assertThat(connection.getConnectionString().getCredential().getUserName()).isEqualTo("user1");
+        assertThat(connection.getConnectionString().getCredential().getPassword()).containsExactly('p','a','s','s','w','o','r','d','1');
+        assertThat(connection.getConnectionUserName()).isEqualTo("user1");
+        assertThat(connection.getURL()).isEqualTo("localhost");
+
+        verify(driverMock, times(2)).connect(any(ConnectionString.class));
+        verify(clientMock, times(2)).getDatabase(any());
+        verify(databaseMock, times(2)).withCodecRegistry(any());
+        verifyNoMoreInteractions(driverMock, clientMock, databaseMock);
+
+        Properties properties = new Properties();
+        properties.setProperty("user", "user2");
+        properties.setProperty("password", "password2");
+        connection.open("mongodb+srv://localhost/test_db", driverMock, properties);
+        assertThat(connection.getConnectionString().isSrvProtocol()).isTrue();
+        assertThat(connection.getConnectionString().getDatabase()).isEqualTo("test_db");
+        assertThat(connection.getConnectionString().getCredential()).isNotNull();
+        assertThat(connection.getConnectionString().getCredential().getUserName()).isEqualTo("user2");
+        assertThat(connection.getConnectionString().getCredential().getPassword()).containsExactly('p','a','s','s','w','o','r','d','2');
+        assertThat(connection.getConnectionUserName()).isEqualTo("user2");
+        assertThat(connection.getURL()).isEqualTo("localhost");
+
+        verify(driverMock, times(3)).connect(any(ConnectionString.class));
+        verify(clientMock, times(3)).getDatabase(any());
+        verify(databaseMock, times(3)).withCodecRegistry(any());
+        verifyNoMoreInteractions(driverMock, clientMock, databaseMock);
+
+        properties = new Properties();
+        properties.setProperty("user", "user3");
+        connection.open("mongodb+srv://localhost/test_db?authMechanism=MONGODB-X509", driverMock, properties);
+        assertThat(connection.getConnectionString().isSrvProtocol()).isTrue();
+        assertThat(connection.getConnectionString().getDatabase()).isEqualTo("test_db");
+        assertThat(connection.getConnectionString().getCredential()).isNotNull();
+        assertThat(connection.getConnectionString().getCredential().getUserName()).isEqualTo("user3");
+        assertThat(connection.getConnectionString().getCredential().getPassword()).isNull();
+        assertThat(connection.getConnectionUserName()).isEqualTo("user3");
+        assertThat(connection.getURL()).isEqualTo("localhost");
+
+        verify(driverMock, times(4)).connect(any(ConnectionString.class));
+        verify(clientMock, times(4)).getDatabase(any());
+        verify(databaseMock, times(4)).withCodecRegistry(any());
+        verifyNoMoreInteractions(driverMock, clientMock, databaseMock);
     }
 
 }
\ No newline at end of file
diff --git a/src/test/java/liquibase/ext/mongodb/database/MongoLiquibaseDatabaseTest.java b/src/test/java/liquibase/ext/mongodb/database/MongoLiquibaseDatabaseTest.java
index 7a8fac46..1fa91e26 100644
--- a/src/test/java/liquibase/ext/mongodb/database/MongoLiquibaseDatabaseTest.java
+++ b/src/test/java/liquibase/ext/mongodb/database/MongoLiquibaseDatabaseTest.java
@@ -48,8 +48,9 @@ void getDefaultDriver() {
         database = (MongoLiquibaseDatabase) DatabaseFactory.getInstance()
                 .findCorrectDatabaseImplementation(new MongoConnection());
 
-        assertThat(database.getDefaultDriver("mongodb://qwe")).isEqualTo(MongoClientDriver.class.getName());
         assertThat(database.getDefaultDriver("cosmos://qwe")).isNull();
+        assertThat(database.getDefaultDriver("mongodb://qwe")).isEqualTo(MongoClientDriver.class.getName());
+        assertThat(database.getDefaultDriver("mongodb+srv://qwe")).isEqualTo(MongoClientDriver.class.getName());
     }
 
     @Test