Update CRUD yaml test runner

Author: estolfo

lib/mongo/collection/view/aggregation.rb

@@ -42,8 +42,7 @@ class Aggregation
         # @since 2.1.0
         OPTIONS_MAP = {
                        :allow_disk_use => :allowDiskUse,
-                       :max_time_ms => :maxTimeMS,
-                       :batch_size => :batchSize
+                       :max_time_ms => :maxTimeMS
                       }
 
         # Set to true if disk usage is allowed during the aggregation.
@@ -105,11 +104,7 @@ def aggregate_spec
 
         def process_options
           @agg_options ||= @options.each.reduce({}) do |opts, (key, value)|
-            if OPTIONS_MAP[key]
-              opts.merge(OPTIONS_MAP[key] => value)
-            else
-              opts.merge(key => value)
-            end
+            OPTIONS_MAP[key] ? opts.merge(OPTIONS_MAP[key] => value) : opts
           end
         end
 
@@ -121,7 +116,7 @@ def cursor
 
         def batch_size_doc
           (value = options[:batch_size] || view.batch_size) ?
-              { OPTIONS_MAP[:batch_size] => value } : {}
+              { :batchSize => value } : {}
         end
 
         def explain_options

spec/support/crud/read.rb

@@ -93,30 +93,29 @@ def requires_2_6?(collection)
         private
 
         def count(collection)
-          view = collection.find(filter)
           options = ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
             opts.merge!(key => arguments[value]) if arguments[value]
             opts
           end
-          view.count(options)
+          collection.count(filter, options)
         end
 
         def aggregate(collection)
-          collection.find.tap do |view|
-            view = view.batch_size(batch_size) if batch_size
-          end.aggregate(pipeline).to_a
+          collection.aggregate(pipeline, options).to_a
         end
 
         def distinct(collection)
-          collection.find(filter).distinct(field_name)
+          collection.distinct(field_name, filter)
         end
 
         def find(collection)
-          view = collection.find(filter)
-          ARGUMENT_MAP.each do |key, value|
-            view = view.send(key, arguments[value]) if arguments[value]
+          collection.find(filter, options).to_a
+        end
+
+        def options
+          ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
+            arguments[value] ? opts.merge!(key => arguments[value]) : opts
           end
-          view.to_a
         end
 
         def batch_size

spec/support/crud/write.rb

@@ -42,7 +42,9 @@ class Write
         # @since 2.0.0
         ARGUMENT_MAP = {
                         :sort => 'sort',
-                        :projection => 'projection'
+                        :projection => 'projection',
+                        :return_document => 'returnDocument',
+                        :upsert => 'upsert'
                        }
 
         # Operations that need a check if results on < 2.6 will match.
@@ -111,12 +113,12 @@ def requires_2_6?(collection)
         private
 
         def delete_many(collection)
-          result = collection.find(filter).delete_many
+          result = collection.delete_many(filter)
           { 'deletedCount' => result.deleted_count }
         end
 
         def delete_one(collection)
-          result = collection.find(filter).delete_one
+          result = collection.delete_one(filter)
           { 'deletedCount' => result.deleted_count }
         end
 
@@ -137,48 +139,50 @@ def update_return_doc(result)
         end
 
         def replace_one(collection)
-          result = collection.find(filter).replace_one(replacement, upsert: upsert)
+          result = collection.replace_one(filter, replacement, options)
           update_return_doc(result)
         end
 
         def update_many(collection)
-          result = collection.find(filter).update_many(update, upsert: upsert)
+          result = collection.update_many(filter, update, options)
           update_return_doc(result)
         end
 
         def update_one(collection)
-          result = collection.find(filter).update_one(update, upsert: upsert)
+          result = collection.update_one(filter, update, options)
           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
+          collection.find_one_and_delete(filter, options)
         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)
+          collection.find_one_and_replace(filter, replacement,options)
         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]
+          collection.find_one_and_update(filter, update, options)
+        end
+
+        def options
+          ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
+            arguments[value] ? opts.merge!(key => send(key)) : opts
           end
-          view.find_one_and_update(update, upsert: upsert, return_document: return_document)
         end
 
         def replacement
           arguments['replacement']
         end
 
+        def sort
+          arguments['sort']
+        end
+
+        def projection
+          arguments['projection']
+        end
+
         def documents
           arguments['documents']
         end