JAVA-1644: Check validity of database name and collection name

   Add static helper methods to MongoNamespace for checking validity prior to construction

   Check validity of database name and collection name in high-level API

Author: jyemin

driver-async/src/main/com/mongodb/async/client/MongoClient.java

@@ -37,6 +37,8 @@ public interface MongoClient extends Closeable {
      *
      * @param name the name of the database
      * @return the database
+     * @throws IllegalArgumentException if databaseName is invalid
+     * @see com.mongodb.MongoNamespace#checkDatabaseNameValidity(String)
      */
     MongoDatabase getDatabase(String name);
 

driver-async/src/main/com/mongodb/async/client/MongoDatabase.java

@@ -117,6 +117,8 @@ public interface MongoDatabase {
      *
      * @param collectionName the name of the collection to return
      * @return the collection
+     * @throws IllegalArgumentException if collectionName is invalid
+     * @see com.mongodb.MongoNamespace#checkCollectionNameValidity(String)
      */
     MongoCollection<Document> getCollection(String collectionName);
 

driver-async/src/main/com/mongodb/async/client/MongoDatabaseImpl.java

@@ -39,6 +39,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import static com.mongodb.MongoNamespace.checkDatabaseNameValidity;
 import static com.mongodb.assertions.Assertions.notNull;
 
 class MongoDatabaseImpl implements MongoDatabase {
@@ -51,6 +52,7 @@ class MongoDatabaseImpl implements MongoDatabase {
 
     MongoDatabaseImpl(final String name, final CodecRegistry codecRegistry, final ReadPreference readPreference,
                       final WriteConcern writeConcern, final ReadConcern readConcern, final AsyncOperationExecutor executor) {
+        checkDatabaseNameValidity(name);
         this.name = notNull("name", name);
         this.codecRegistry = notNull("codecRegistry", codecRegistry);
         this.readPreference = notNull("readPreference", readPreference);

driver-async/src/test/unit/com/mongodb/async/client/MongoDatabaseSpecification.groovy

@@ -57,6 +57,25 @@ class MongoDatabaseSpecification extends Specification {
     def readConcern = ReadConcern.DEFAULT
     def collation = Collation.builder().locale('en').build()
 
+    def 'should throw IllegalArgumentException if name is invalid'() {
+        when:
+        new MongoDatabaseImpl('a.b', codecRegistry, readPreference, writeConcern, readConcern, new TestOperationExecutor([]))
+
+        then:
+        thrown(IllegalArgumentException)
+    }
+
+    def 'should throw IllegalArgumentException from getCollection if collectionName is invalid'() {
+        given:
+        def database = new MongoDatabaseImpl(name, codecRegistry, readPreference, writeConcern, readConcern, new TestOperationExecutor([]))
+
+        when:
+        database.getCollection('')
+
+        then:
+        thrown(IllegalArgumentException)
+    }
+
     def 'should return the correct name from getName'() {
         given:
         def database = new MongoDatabaseImpl(name, codecRegistry, readPreference, writeConcern, readConcern, new TestOperationExecutor([]))

driver-core/src/main/com/mongodb/MongoNamespace.java

@@ -20,6 +20,7 @@
 
 import static com.mongodb.assertions.Assertions.isTrueArgument;
 import static com.mongodb.assertions.Assertions.notNull;
+import static java.util.Arrays.asList;
 
 /**
  * A MongoDB namespace, which includes a database name and collection name.
@@ -35,30 +36,66 @@ public final class MongoNamespace {
     private final String fullName;  // cache to avoid repeated string building
 
     /**
-     * Construct an instance.
+     * Check the validity of the given database name. A valid database name is non-null, non-empty, and does not contain any of the
+     * following strings: {@code " ", "."}. The server may impose additional restrictions on database names.
      *
-     * @param fullName the full namespace
+     * @param databaseName the database name
+     * @throws IllegalArgumentException if the database name is invalid
+     * @since 3.4
+     * @mongodb.driver.manual reference/limits/#naming-restrictions Naming Restrictions
      */
-    public MongoNamespace(final String fullName) {
-        notNull("fullName", fullName);
-        isTrueArgument("fullName is of form <db>.<collection>", isFullNameValid(fullName));
+    public static void checkDatabaseNameValidity(final String databaseName) {
+        notNull("databaseName", databaseName);
+        isTrueArgument("databaseName is not empty", !databaseName.isEmpty());
+        for (String cur : asList(" ", ".")) {
+            isTrueArgument("databaseName does not contain '" + cur + "'", !databaseName.contains(cur));
+        }
+    }
 
+    /**
+     * Check the validity of the given collection name.   A valid collection name is non-null and non-empty.  The server may impose
+     * additional restrictions on collection names.
+     *
+     * @param collectionName the collection name
+     * @throws IllegalArgumentException if the collection name is invalid
+     * @since 3.4
+     * @mongodb.driver.manual reference/limits/#naming-restrictions Naming Restrictions
+     */
+    public static void checkCollectionNameValidity(final String collectionName) {
+        notNull("collectionName", collectionName);
+        isTrueArgument("collectionName is not empty", !collectionName.isEmpty());
+    }
 
+    /**
+     * Construct an instance for the given full name.  The database name is the string preceding the first {@code "."} character.
+     *
+     * @param fullName the non-null full namespace
+     * @see #checkDatabaseNameValidity(String)
+     * @see #checkCollectionNameValidity(String)
+     */
+    public MongoNamespace(final String fullName) {
+        notNull("fullName", fullName);
+        this.fullName = fullName;
         this.databaseName = getDatatabaseNameFromFullName(fullName);
         this.collectionName = getCollectionNameFullName(fullName);
-        this.fullName = fullName;
+        checkDatabaseNameValidity(databaseName);
+        checkCollectionNameValidity(collectionName);
     }
 
     /**
-     * Construct an instance.
+     * Construct an instance from the given database name and collection name.
      *
-     * @param databaseName the non-null database name
-     * @param collectionName the non-null collection name
+     * @param databaseName   the valid database name
+     * @param collectionName the valid collection name
+     * @see #checkDatabaseNameValidity(String)
+     * @see #checkCollectionNameValidity(String)
      */
     public MongoNamespace(final String databaseName, final String collectionName) {
-        this.databaseName = notNull("databaseName", databaseName);
-        this.collectionName = notNull("collectionName", collectionName);
-        this.fullName = databaseName + "." + collectionName;
+        checkDatabaseNameValidity(databaseName);
+        checkCollectionNameValidity(collectionName);
+        this.databaseName = databaseName;
+        this.collectionName = collectionName;
+        this.fullName = databaseName + '.' + collectionName;
     }
 
     /**
@@ -126,29 +163,25 @@ public int hashCode() {
         return result;
     }
 
-    private static boolean isFullNameValid(final String fullName) {
-        int firstDotIndex = fullName.indexOf(".");
-
-        if (firstDotIndex == -1) {
-            return false;
-        }
-        if (firstDotIndex == 0) {
-            return false;
-        }
-        if (fullName.charAt(fullName.length() - 1) == '.') {
-            return false;
+    private static String getCollectionNameFullName(final String namespace) {
+        if (namespace == null) {
+            return null;
         }
-        if (fullName.charAt(firstDotIndex + 1) == '.') {
-            return false;
+        int firstDot = namespace.indexOf('.');
+        if (firstDot == -1) {
+            return namespace;
         }
-        return true;
-    }
-
-    private static String getCollectionNameFullName(final String namespace) {
-        return namespace.substring(namespace.indexOf('.') + 1);
+        return namespace.substring(firstDot + 1);
     }
 
     private static String getDatatabaseNameFromFullName(final String namespace) {
-        return namespace.substring(0, namespace.indexOf('.'));
+        if (namespace == null) {
+            return null;
+        }
+        int firstDot = namespace.indexOf('.');
+        if (firstDot == -1) {
+            return "";
+        }
+        return namespace.substring(0, firstDot);
     }
 }

driver-core/src/test/unit/com/mongodb/MongoNamespaceSpecification.groovy

@@ -19,28 +19,38 @@ package com.mongodb
 import spock.lang.Specification
 
 class MongoNamespaceSpecification extends Specification {
-    def 'null database name should throw IllegalArgumentException'() {
+    def 'invalid database name should throw IllegalArgumentException'() {
         when:
-        new MongoNamespace(null, 'test');
+        new MongoNamespace(databaseName, 'test');
 
         then:
         thrown(IllegalArgumentException)
-    }
 
-    def 'null collection name should throw IllegalArgumentException'() {
         when:
-        new MongoNamespace('test', null);
+        MongoNamespace.checkDatabaseNameValidity(databaseName)
 
         then:
         thrown(IllegalArgumentException)
+
+        where:
+        databaseName << [null, '', 'a ', 'a.b' ]
     }
 
-    def 'null full name should throw IllegalArgumentException'() {
+    def 'invalid collection name should throw IllegalArgumentException'() {
+        when:
+        new MongoNamespace('test', collectionName);
+
+        then:
+        thrown(IllegalArgumentException)
+
         when:
-        new MongoNamespace(null)
+        MongoNamespace.checkCollectionNameValidity(collectionName)
 
         then:
         thrown(IllegalArgumentException)
+
+        where:
+        collectionName << [null, '']
     }
 
     def 'invalid full name should throw IllegalArgumentException'() {
@@ -51,7 +61,7 @@ class MongoNamespaceSpecification extends Specification {
         thrown(IllegalArgumentException)
 
         where:
-        fullName << ['db', '.db', 'db.', 'db..coll', 'db.coll.']
+        fullName << [null, '', 'db', '.db', 'db.', 'a .b']
     }
 
     def 'test getters'() {

driver/src/main/com/mongodb/DB.java

@@ -49,6 +49,7 @@
 
 import static com.mongodb.DBCollection.createWriteConcernException;
 import static com.mongodb.MongoCredential.createMongoCRCredential;
+import static com.mongodb.MongoNamespace.checkDatabaseNameValidity;
 import static com.mongodb.ReadPreference.primary;
 import static com.mongodb.assertions.Assertions.notNull;
 import static java.util.Arrays.asList;
@@ -81,9 +82,7 @@ public class DB {
     private volatile ReadConcern readConcern;
 
     DB(final Mongo mongo, final String name, final OperationExecutor executor) {
-        if (!isValidName(name)) {
-            throw new IllegalArgumentException("Invalid database name format. Database name is either empty or it contains spaces.");
-        }
+        checkDatabaseNameValidity(name);
         this.mongo = mongo;
         this.name = name;
         this.executor = executor;
@@ -184,6 +183,8 @@ public ReadConcern getReadConcern() {
      *
      * @param name the name of the collection
      * @return the collection
+     * @throws IllegalArgumentException if the name is invalid
+     * @see MongoNamespace#checkCollectionNameValidity(String)
      */
     protected DBCollection doGetCollection(final String name) {
         return getCollection(name);
@@ -194,6 +195,8 @@ protected DBCollection doGetCollection(final String name) {
      *
      * @param name the name of the collection to return
      * @return the collection
+     * @throws IllegalArgumentException if the name is invalid
+     * @see MongoNamespace#checkCollectionNameValidity(String)
      */
     public DBCollection getCollection(final String name) {
         DBCollection collection = collectionCache.get(name);
@@ -740,10 +743,6 @@ BufferProvider getBufferPool() {
         return getMongo().getBufferProvider();
     }
 
-    private boolean isValidName(final String databaseName) {
-        return databaseName.length() != 0 && !databaseName.contains(" ");
-    }
-
     private BsonDocument wrap(final DBObject document) {
         return new BsonDocumentWrapper<DBObject>(document, commandCodec);
     }

driver/src/main/com/mongodb/DBCollection.java

@@ -77,6 +77,7 @@
 import static com.mongodb.AggregationOptions.OutputMode.INLINE;
 import static com.mongodb.BulkWriteHelper.translateBulkWriteResult;
 import static com.mongodb.BulkWriteHelper.translateWriteRequestsToNew;
+import static com.mongodb.MongoNamespace.checkCollectionNameValidity;
 import static com.mongodb.ReadPreference.primary;
 import static com.mongodb.ReadPreference.primaryPreferred;
 import static com.mongodb.assertions.Assertions.notNull;
@@ -142,6 +143,7 @@ public class DBCollection {
      * @param database      the database to which this collections belongs to
      */
     DBCollection(final String name, final DB database, final OperationExecutor executor) {
+        checkCollectionNameValidity(name);
         this.name = name;
         this.database = database;
         this.executor = executor;

driver/src/main/com/mongodb/Mongo.java

@@ -483,6 +483,8 @@ public String apply(final DBObject result) {
      *
      * @param dbName the name of the database to retrieve
      * @return a DB representing the specified database
+     * @throws IllegalArgumentException if the name is invalid
+     * @see MongoNamespace#checkDatabaseNameValidity(String)
      * @deprecated use {@link com.mongodb.MongoClient#getDatabase(String)}
      */
     @Deprecated

driver/src/main/com/mongodb/MongoClient.java

@@ -396,6 +396,8 @@ public <T> ListDatabasesIterable<T> listDatabases(final Class<T> clazz) {
     /**
      * @param databaseName the name of the database to retrieve
      * @return a {@code MongoDatabase} representing the specified database
+     * @throws IllegalArgumentException if databaseName is invalid
+     * @see MongoNamespace#checkDatabaseNameValidity(String)
      */
     public MongoDatabase getDatabase(final String databaseName) {
         MongoClientOptions clientOptions = getMongoClientOptions();