mongo 2.0.0.rc → 2.0.0

data/spec/support/crud/write.rb

@@ -0,0 +1,214 @@
+# Copyright (C) 2014-2015 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.
+
+module Mongo
+  module CRUD
+    module Operation
+
+      # Defines common behaviour for running CRUD write operation tests on a
+      # collection.
+      #
+      # @since 2.0.0
+      class Write
+  
+        # Map of CRUD operation names to method names.
+        #
+        # @since 2.0.0
+        OPERATIONS = { 'deleteMany' => :delete_many,
+                       'deleteOne' => :delete_one,
+                       'insertMany' => :insert_many,
+                       'insertOne' => :insert_one,
+                       'replaceOne' => :replace_one,
+                       'updateMany' => :update_many,
+                       'updateOne' => :update_one,
+                       'findOneAndDelete' => :find_one_and_delete,
+                       'findOneAndReplace' => :find_one_and_replace,
+                       'findOneAndUpdate' => :find_one_and_update
+                     }
+
+        # Map of operation options to method names.
+        #
+        # @since 2.0.0
+        ARGUMENT_MAP = {
+                        :sort => 'sort',
+                        :projection => 'projection'
+                       }
+
+        # Operations that need a check if results on < 2.6 will match.
+        #
+        # @since 2.0.0
+        REQUIRES_2_6 = ['findOneAndReplace',
+                        'updateMany',
+                        'updateOne',
+                        'replaceOne']
+  
+        # The operation name.
+        #
+        # @return [ String ] name The operation name.
+        #
+        # @since 2.0.0
+        attr_reader :name
+
+        def initialize(spec)
+          @spec = spec
+          @name = spec['name']
+        end
+
+        # Whether the operation is expected to have restuls.
+        #
+        # @example Whether the operation is expected to have results.
+        #   operation.has_results?
+        #
+        # @return [ true ] If the operation is expected to have results.
+        #
+        # @since 2.0.0
+        def has_results?
+          true
+        end
+
+        # Execute the operation.
+        #
+        # @example Execute the operation.
+        #   operation.execute
+        #
+        # @param [ Collection ] collection The collection to execute
+        #   the operation on.
+        #
+        # @return [ Result, Array<Hash> ] The result of executing the operation.
+        #
+        # @since 2.0.0
+        def execute(collection)
+          send(OPERATIONS[name], collection)
+        end
+
+        # Whether this operation requires >= 2.6 to be tested.
+        #
+        # @example Determine whether this operation requires >= 2.6.
+        #   operation.requires_2_6?(collection)
+        #
+        # @param [ Collection ] collection The collection the operation
+        #   should be executed on.
+        #
+        # @return [ true, false ] Whether this operation requires 2.6
+        #   to be tested.
+        #
+        # @since 2.0.0
+        def requires_2_6?(collection)
+          REQUIRES_2_6.include?(name) && upsert
+        end
+  
+        private
+  
+        def delete_many(collection)
+          result = collection.find(filter).delete_many
+          { 'deletedCount' => result.deleted_count }
+        end
+
+        def delete_one(collection)
+          result = collection.find(filter).delete_one
+          { 'deletedCount' => result.deleted_count }
+        end
+
+        def insert_many(collection)
+          collection.insert_many(documents)
+          # returning inserted_ids is optional
+          { 'insertedIds' => documents.collect { |d| d['_id'] } }
+        end
+
+        def insert_one(collection)
+          result = collection.insert_one(document)
+          # returning inserted_id is optional
+          { 'insertedId' => document['_id'] }
+        end
+
+        def update_return_doc(result)
+          return_doc = { 'upsertedId' => result.upserted_id } if upsert
+          (return_doc || {}).merge!({ 'matchedCount' => result.matched_count,
+                                      'modifiedCount' => result.modified_count })
+        end
+
+        def replace_one(collection)
+          result = collection.find(filter).replace_one(replacement, upsert: upsert)
+          update_return_doc(result)
+        end
+
+        def update_many(collection)
+          result = collection.find(filter).update_many(update, upsert: upsert)
+          update_return_doc(result)
+        end
+
+        def update_one(collection)
+          result = collection.find(filter).update_one(update, upsert: upsert)
+          update_return_doc(result)
+        end
+
+        def find_one_and_delete(collection)
+          view = collection.find(filter)
+          ARGUMENT_MAP.each do |key, value|
+            view = view.send(key, arguments[value]) if arguments[value]
+          end
+          view.find_one_and_delete
+        end
+
+        def find_one_and_replace(collection)
+          view = collection.find(filter)
+          ARGUMENT_MAP.each do |key, value|
+            view = view.send(key, arguments[value]) if arguments[value]
+          end
+          view.find_one_and_replace(replacement, upsert: upsert, return_document: return_document)
+        end
+
+        def find_one_and_update(collection)
+          view = collection.find(filter)
+          ARGUMENT_MAP.each do |key, value|
+            view = view.send(key, arguments[value]) if arguments[value]
+          end
+          view.find_one_and_update(update, upsert: upsert, return_document: return_document)
+        end
+
+        def replacement
+          arguments['replacement']
+        end
+
+        def documents
+          arguments['documents']
+        end
+
+        def document
+          arguments['document']
+        end
+
+        def filter
+          arguments['filter']
+        end
+
+        def upsert
+          arguments['upsert']
+        end
+
+        def return_document
+          :after if arguments['returnDocument']
+        end
+
+        def update
+          arguments['update']
+        end
+
+        def arguments
+          @spec['arguments']
+        end
+      end
+    end
+  end
+end

data/spec/support/crud_tests/read/aggregate.yml

@@ -0,0 +1,43 @@
+data:
+    - {_id: 1, x: 11}
+    - {_id: 2, x: 22}
+    - {_id: 3, x: 33}
+
+tests:
+    -
+        description: "Aggregate with multiple stages"
+        operation:
+            name: aggregate
+            arguments:
+                pipeline:
+                    - $sort: {x: 1}
+                    - $match: 
+                        _id: {$gt: 1}
+                batchSize: 2
+
+        outcome:
+            result:
+                - {_id: 2, x: 22}
+                - {_id: 3, x: 33}
+    -
+        description: "Aggregate with $out"
+        operation:
+            name: aggregate
+            arguments:
+                pipeline: 
+                    - $sort: {x: 1}
+                    - $match:
+                        _id: {$gt: 1}
+                    - $out: "other_test_collection"
+                batchSize: 2
+
+        outcome:
+            result:
+                - {_id: 2, x: 22}
+                - {_id: 3, x: 33}
+            collection:
+                name: "other_test_collection"
+                data:
+                    - {_id: 2, x: 22}
+                    - {_id: 3, x: 33}
+  

data/spec/support/crud_tests/read/count.yml

@@ -0,0 +1,37 @@
+data:
+    - {_id: 1, x: 11}
+    - {_id: 2, x: 22}
+    - {_id: 3, x: 33}
+
+tests:
+    -
+        description: "Count without a filter"
+        operation:
+            name: count
+            arguments:
+                filter: { }
+
+        outcome:
+            result: 3
+    -
+        description: "Count with a filter"
+        operation:
+            name: count
+            arguments:
+                filter: 
+                    _id: {$gt: 1}
+
+        outcome:
+            result: 2
+    -
+        description: "Count with skip and limit"
+        operation:
+            name: count
+            arguments:
+                filter: {}
+                skip: 1
+                limit: 3
+
+        outcome:
+            result: 2
+  

data/spec/support/crud_tests/read/distinct.yml

@@ -0,0 +1,33 @@
+data:
+    - {_id: 1, x: 11}
+    - {_id: 2, x: 22}
+    - {_id: 3, x: 33}
+
+tests:
+    -
+        description: "Distinct without a filter"
+        operation:
+            name: distinct
+            arguments:
+                fieldName: "x"
+                filter: {}
+
+        outcome:
+            result: 
+                - 11
+                - 22
+                - 33
+    -
+        description: "Distinct with a filter"
+        operation:
+            name: distinct
+            arguments:
+                fieldName: "x"
+                filter: 
+                    _id: {$gt: 1}
+
+        outcome:
+            result: 
+                - 22
+                - 33
+  

data/spec/support/crud_tests/read/find.yml

@@ -0,0 +1,50 @@
+data:
+    - {_id: 1, x: 11}
+    - {_id: 2, x: 22}
+    - {_id: 3, x: 33}
+    - {_id: 4, x: 44}
+    - {_id: 5, x: 55}
+
+tests:
+    -
+        description: "Find with filter"
+        operation:
+            name: "find"
+            arguments:
+                filter: {_id: 1}
+
+        outcome:
+            result:
+                - {_id: 1, x: 11}
+
+    - 
+        description: "Find with filter, sort, skip, and limit"
+        operation: 
+            name: "find"
+            arguments:
+                filter: 
+                    _id: {$gt: 2}
+                sort: {_id: 1}
+                skip: 2
+                limit: 2
+
+        outcome:
+            result:
+                - {_id: 5, x: 55}
+    -
+        description: "Find with limit, sort, and batchsize"
+        operation: 
+            name: "find"
+            arguments:
+                filter: {}
+                sort: {_id: 1}
+                limit: 4
+                batchSize: 2
+
+        outcome:
+            result:
+                - {_id: 1, x: 11}
+                - {_id: 2, x: 22}
+                - {_id: 3, x: 33}
+                - {_id: 4, x: 44}
+  

data/spec/support/crud_tests/write/deleteMany.yml

@@ -0,0 +1,36 @@
+data:
+    - {_id: 1, x: 11}
+    - {_id: 2, x: 22}
+    - {_id: 3, x: 33}
+
+tests:
+    -
+        description: "DeleteMany when many documents match"
+        operation:
+            name: "deleteMany"
+            arguments:
+                filter: 
+                    _id: {$gt: 1}
+
+        outcome:
+            result:
+                deletedCount: 2
+            collection:
+                data:
+                    - {_id: 1, x: 11}
+    -
+        description: "DeleteMany when no document matches"
+        operation:
+            name: "deleteMany"
+            arguments:
+                filter: {_id: 4}
+
+        outcome:
+            result:
+                deletedCount: 0
+            collection:
+                data:
+                    - {_id: 1, x: 11}
+                    - {_id: 2, x: 22}
+                    - {_id: 3, x: 33}
+  

data/spec/support/crud_tests/write/deleteOne.yml

@@ -0,0 +1,49 @@
+data:
+    - {_id: 1, x: 11}
+    - {_id: 2, x: 22}
+    - {_id: 3, x: 33}
+
+tests:
+    -
+        description: "DeleteOne when many documents match"
+        operation:
+            name: "deleteOne"
+            arguments:
+                filter: 
+                    _id: {$gt: 1}
+
+        outcome:
+            result:
+                deletedCount: 1
+            # can't verify collection because we don't have a way
+            # of knowing which document gets deleted.
+    -
+        description: "DeleteOne when one document matches"
+        operation:
+            name: "deleteOne"
+            arguments:
+                filter: {_id: 2}
+
+        outcome:
+            result:
+                deletedCount: 1
+            collection:
+                data:
+                    - {_id: 1, x: 11}
+                    - {_id: 3, x: 33}
+    -
+        description: "DeleteOne when no documents match"
+        operation:
+            name: "deleteOne"
+            arguments:
+                filter: {_id: 4}
+
+        outcome:
+            result:
+                deletedCount: 0
+            collection:
+                data:
+                    - {_id: 1, x: 11}
+                    - {_id: 2, x: 22}
+                    - {_id: 3, x: 33}
+