Ensure all DBCollectionFindOptions are applied correctly

JAVA-2329

Author: rozza

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

@@ -485,13 +485,11 @@ private FindOperation<DBObject> getQueryOperation(final Decoder<DBObject> decode
                                                 .batchSize(findOptions.getBatchSize())
                                                 .skip(findOptions.getSkip())
                                                 .limit(findOptions.getLimit())
+                                                .maxAwaitTime(findOptions.getMaxAwaitTime(MILLISECONDS), MILLISECONDS)
                                                 .maxTime(findOptions.getMaxTime(MILLISECONDS), MILLISECONDS)
                                                 .modifiers(collection.wrapAllowNull(findOptions.getModifiers()))
                                                 .projection(collection.wrapAllowNull(findOptions.getProjection()))
                                                 .sort(collection.wrapAllowNull(findOptions.getSort()))
-                                                .noCursorTimeout(findOptions.isNoCursorTimeout())
-                                                .oplogReplay(findOptions.isOplogReplay())
-                                                .partial(findOptions.isPartial())
                                                 .collation(findOptions.getCollation());
 
         if ((this.options & Bytes.QUERYOPTION_TAILABLE) != 0) {
@@ -500,15 +498,23 @@ private FindOperation<DBObject> getQueryOperation(final Decoder<DBObject> decode
             } else {
                 operation.cursorType(CursorType.Tailable);
             }
+        } else {
+            operation.cursorType(findOptions.getCursorType());
         }
         if ((this.options & Bytes.QUERYOPTION_OPLOGREPLAY) != 0) {
             operation.oplogReplay(true);
+        } else {
+            operation.oplogReplay(findOptions.isOplogReplay());
         }
         if ((this.options & Bytes.QUERYOPTION_NOTIMEOUT) != 0) {
             operation.noCursorTimeout(true);
+        } else {
+            operation.noCursorTimeout(findOptions.isNoCursorTimeout());
         }
         if ((this.options & Bytes.QUERYOPTION_PARTIAL) != 0) {
             operation.partial(true);
+        } else {
+            operation.partial(findOptions.isPartial());
         }
         return operation;
     }

driver/src/test/unit/com/mongodb/DBCursorSpecification.groovy

@@ -17,12 +17,15 @@
 package com.mongodb
 
 import com.mongodb.client.model.Collation
+import com.mongodb.client.model.DBCollectionFindOptions
 import com.mongodb.operation.BatchCursor
 import com.mongodb.operation.CountOperation
 import com.mongodb.operation.FindOperation
 import org.bson.BsonDocument
 import spock.lang.Specification
 
+import java.util.concurrent.TimeUnit
+
 import static com.mongodb.CustomMatchers.isTheSameAs
 import static com.mongodb.Fixture.getMongoClient
 import static spock.util.matcher.HamcrestSupport.expect
@@ -109,59 +112,34 @@ class DBCursorSpecification extends Specification {
 
     def 'find should create the correct FindOperation'() {
         given:
-        def dbObject = new BasicDBObject('_id', 1)
-        def executor = new TestOperationExecutor([Stub(BatchCursor) {
-            def count = 0
-            next() >> {
-                count++
-                [dbObject]
-            }
-            hasNext() >> {
-                count == 0
-            }
-            getServerCursor() >> {
-                null
-            }
-        }]);
+        def executor = new TestOperationExecutor([stubBatchCursor()]);
         def collection = new DB(getMongoClient(), 'myDatabase', executor).getCollection('test')
         def cursor = new DBCursor(collection, new BasicDBObject(), new BasicDBObject(), ReadPreference.primary())
         cursor.setReadConcern(ReadConcern.MAJORITY)
 
         when:
-        def results = cursor.toArray()
+        cursor.toArray()
 
         then:
-        results == [dbObject]
         expect executor.getReadOperation(), isTheSameAs(new FindOperation(collection.getNamespace(), collection.getObjectCodec())
                                                                 .readConcern(ReadConcern.MAJORITY)
                                                                 .filter(new BsonDocument())
                                                                 .projection(new BsonDocument())
                                                                 .modifiers(new BsonDocument()))
     }
 
+
     def 'one should create the correct FindOperation'() {
         given:
-        def dbObject = new BasicDBObject('_id', 1)
-        def executor = new TestOperationExecutor([Stub(BatchCursor) {
-            def count = 0
-            next() >> {
-                count++
-                [dbObject]
-            }
-            hasNext() >> {
-                count == 0
-            }
-            getServerCursor() >> new ServerCursor(12L, new ServerAddress())
-        }]);
+        def executor = new TestOperationExecutor([stubBatchCursor()]);
         def collection = new DB(getMongoClient(), 'myDatabase', executor).getCollection('test')
         def cursor = new DBCursor(collection, new BasicDBObject(), new BasicDBObject(), ReadPreference.primary())
         cursor.setReadConcern(ReadConcern.MAJORITY)
 
         when:
-        def result = cursor.one()
+        cursor.one()
 
         then:
-        result == dbObject
         expect executor.getReadOperation(), isTheSameAs(new FindOperation(collection.getNamespace(), collection.getObjectCodec())
                                                                 .readConcern(ReadConcern.MAJORITY)
                                                                 .limit(-1)
@@ -170,6 +148,104 @@ class DBCursorSpecification extends Specification {
                                                                 .modifiers(new BsonDocument()))
     }
 
+    def 'DBCollectionFindOptions should be used to create the expected operation'() {
+        given:
+        def executor = new TestOperationExecutor([stubBatchCursor()]);
+        def collection = new DB(getMongoClient(), 'myDatabase', executor).getCollection('test')
+        def collation = Collation.builder().locale('en').build()
+        def cursorType = CursorType.NonTailable
+        def filter = new BasicDBObject()
+        def projection = BasicDBObject.parse('{a: 1, _id: 0}')
+        def sort = BasicDBObject.parse('{a: 1}')
+        def modifiers = BasicDBObject.parse('{$comment: 1}')
+        def bsonFilter = new BsonDocument()
+        def bsonModifiers = BsonDocument.parse(modifiers.toJson())
+        def bsonProjection = BsonDocument.parse(projection.toJson())
+        def bsonSort = BsonDocument.parse(sort.toJson())
+        def readConcern = ReadConcern.LOCAL
+        def readPreference = ReadPreference.nearest()
+        def findOptions = new DBCollectionFindOptions()
+                .batchSize(1)
+                .collation(collation)
+                .cursorType(cursorType)
+                .limit(1)
+                .maxAwaitTime(1, TimeUnit.MILLISECONDS)
+                .maxTime(1, TimeUnit.MILLISECONDS)
+                .modifiers(modifiers)
+                .noCursorTimeout(true)
+                .oplogReplay(true)
+                .partial(true)
+                .projection(projection)
+                .readConcern(readConcern)
+                .readPreference(readPreference)
+                .skip(1)
+                .sort(sort)
+        def cursor = new DBCursor(collection, filter, findOptions)
+
+        when:
+        cursor.toArray()
+
+        then:
+        expect executor.getReadOperation(), isTheSameAs(new FindOperation(collection.getNamespace(), collection.getObjectCodec())
+                .batchSize(1)
+                .collation(collation)
+                .cursorType(cursorType)
+                .filter(bsonFilter)
+                .limit(1)
+                .maxAwaitTime(1, TimeUnit.MILLISECONDS)
+                .maxTime(1, TimeUnit.MILLISECONDS)
+                .modifiers(bsonModifiers)
+                .noCursorTimeout(true)
+                .oplogReplay(true)
+                .partial(true)
+                .projection(bsonProjection)
+                .readConcern(readConcern)
+                .skip(1)
+                .sort(bsonSort)
+        )
+
+        executor.getReadPreference() == findOptions.getReadPreference()
+    }
+
+    def 'DBCursor options should override DBCollectionFindOptions'() {
+        given:
+        def executor = new TestOperationExecutor([stubBatchCursor()]);
+        def collection = new DB(getMongoClient(), 'myDatabase', executor).getCollection('test')
+        def cursorType = CursorType.NonTailable
+        def readPreference = ReadPreference.primary()
+        def filter = new BasicDBObject()
+        def bsonFilter = new BsonDocument()
+        def findOptions = new DBCollectionFindOptions()
+                .cursorType(cursorType)
+                .noCursorTimeout(false)
+                .oplogReplay(false)
+                .partial(false)
+                .readPreference(readPreference)
+
+        def cursor = new DBCursor(collection, filter , findOptions)
+                .addOption(Bytes.QUERYOPTION_AWAITDATA)
+                .addOption(Bytes.QUERYOPTION_NOTIMEOUT)
+                .addOption(Bytes.QUERYOPTION_OPLOGREPLAY)
+                .addOption(Bytes.QUERYOPTION_PARTIAL)
+                .addOption(Bytes.QUERYOPTION_SLAVEOK)
+                .addOption(Bytes.QUERYOPTION_TAILABLE)
+
+        when:
+        cursor.toArray()
+
+        then:
+        expect executor.getReadOperation(), isTheSameAs(new FindOperation(collection.getNamespace(), collection.getObjectCodec())
+                .modifiers(new BsonDocument())
+                .cursorType(CursorType.TailableAwait)
+                .filter(bsonFilter)
+                .noCursorTimeout(true)
+                .oplogReplay(true)
+                .partial(true)
+        )
+
+        executor.getReadPreference() == ReadPreference.secondaryPreferred()
+    }
+
     def 'count should create the correct CountOperation'() {
         def executor = new TestOperationExecutor([42L]);
         def collection = new DB(getMongoClient(), 'myDatabase', executor).getCollection('test')
@@ -201,4 +277,18 @@ class DBCursorSpecification extends Specification {
                                                                 .readConcern(ReadConcern.MAJORITY)
                                                                 .filter(new BsonDocument()))
     }
+
+    private stubBatchCursor() {
+        Stub(BatchCursor) {
+            def count = 0
+            next() >> {
+                count++
+                [new BasicDBObject('_id', 1)]
+            }
+            hasNext() >> {
+                count == 0
+            }
+            getServerCursor() >> new ServerCursor(12L, new ServerAddress())
+        };
+    }
 }