mongo 2.9.2 → 2.10.0.rc0

data/spec/support/spec_setup.rb

@@ -29,12 +29,12 @@ class SpecSetup
         raise
       end
     end
-    admin_unauthorized_client.close
+    admin_unauthorized_client.close(true)
 
     # Adds the test user to the test database with permissions on all
     # databases that will be used in the test suite.
     create_user(admin_authorized_test_client, SpecConfig.instance.test_user)
-    admin_authorized_test_client.close
+    admin_authorized_test_client.close(true)
   end
 
   def create_user(client, user)

data/spec/support/transactions.rb

@@ -12,6 +12,93 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'support/transactions/context'
 require 'support/transactions/operation'
 require 'support/transactions/spec'
 require 'support/transactions/test'
+
+def define_transactions_spec_tests(test_paths)
+
+  test_paths.each do |file|
+
+    spec = Mongo::Transactions::Spec.new(file)
+
+    context(spec.description) do
+      require_wired_tiger
+
+      define_spec_tests_with_requirements(spec) do |req|
+        spec.tests.each do |test|
+
+          before do
+            if test.multiple_mongoses?
+              unless SpecConfig.instance.addresses.length > 1
+                skip "Test requires multiple mongoses"
+              end
+            else
+              # Many transaction spec tests that do not specifically deal with
+              # sharded transactions fail when run against a multi-mongos cluster
+              if SpecConfig.instance.addresses.length > 1
+                skip "Test does not specify multiple mongoses"
+              end
+            end
+          end
+
+          context(test.description) do
+
+            if test.skip_reason
+              before(:all) do
+                skip test.skip_reason
+              end
+            end
+
+            before(:all) do
+              if req.satisfied?
+                test.setup_test
+              end
+            end
+
+            after(:all) do
+              if req.satisfied?
+                test.teardown_test
+              end
+            end
+
+            let(:results) do
+              $tx_spec_results_cache ||= {}
+              $tx_spec_results_cache[test.object_id] ||= test.run
+            end
+
+            let(:verifier) { Mongo::CRUD::Verifier.new(test) }
+
+            it 'returns the correct results' do
+              verifier.verify_operation_result(test.expected_results, results[:results])
+            end
+
+            if test.outcome && test.outcome.collection_data?
+              it 'has the correct data in the collection' do
+                results
+                verifier.verify_collection_data(
+                  test.outcome.collection_data,
+                  results[:contents])
+              end
+            end
+
+            if test.expectations
+              it 'has the correct number of command_started events' do
+                verifier.verify_command_started_event_count(
+                  test.expectations, results[:events])
+              end
+
+              test.expectations.each_with_index do |expectation, i|
+                it "has the correct command_started event #{i}" do
+                  verifier.verify_command_started_event(
+                    test.expectations, results[:events], i)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/transactions/context.rb

@@ -0,0 +1,33 @@
+# Copyright (C) 2019 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 Transactions
+    Context = Struct.new(
+      :session0,
+      :session1,
+      :session,
+    ) do
+      def transform_arguments(arguments)
+        arguments.dup.tap do |out|
+          [:session].each do |key|
+            if out[key]
+              out[key] = send(key)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/support/transactions/operation.rb

@@ -14,126 +14,42 @@
 
 module Mongo
   module Transactions
-    class Operation
-
-      # Map of operation names to method names.
-      #
-      # @since 2.6.0
-      OPERATIONS = {
-        'startTransaction' => :start_transaction,
-        'abortTransaction' => :abort_transaction,
-        'commitTransaction' => :commit_transaction,
-        'withTransaction' => :with_transaction,
-        'aggregate' => :aggregate,
-        '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,
-        'bulkWrite' => :bulk_write,
-        'count' => :count,
-        'countDocuments' => :count_documents,
-        'distinct' => :distinct,
-        'find' => :find,
-        'runCommand' => :run_command,
-      }.freeze
-
-      # Map of operation options to method names.
-      #
-      # @since 2.6.0
-      ARGUMENT_MAP = {
-        array_filters: 'arrayFilters',
-        batch_size: 'batchSize',
-        collation: 'collation',
-        read_preference: 'readPreference',
-        document: 'document',
-        field_name: 'fieldName',
-        filter: 'filter',
-        ordered: 'ordered',
-        pipeline: 'pipeline',
-        projection: 'projection',
-        replacement: 'replacement',
-        return_document: 'returnDocument',
-        session: 'session',
-        sort: 'sort',
-        update: 'update',
-        upsert: 'upsert'
-      }.freeze
-
-      # The operation name.
-      #
-      # @return [ String ] name The operation name.
-      #
-      # @since 2.6.0
-      attr_reader :name
-
-      # Instantiate the operation.
-      #
-      # @return [ Hash ] spec The operation spec.
-      #
-      # @since 2.6.0
-      def initialize(spec, session0, session1, transaction_session=nil)
-        @spec = spec
-        @name = spec['name']
-        @session0 = session0
-        @session1 = session1
-        @arguments = case spec['arguments'] && spec['arguments']['session']
-                    when 'session0'
-                      spec['arguments'].merge('session' => @session0)
-                    when 'session1'
-                      spec['arguments'].merge('session' => @session1)
-                    else
-                      args = spec['arguments'] || {}
-                      if transaction_session
-                        args = args.merge('session' => transaction_session)
-                      end
-                      args
-                    end
-      end
-
-      attr_reader :arguments
+    class Operation < Mongo::CRUD::Operation
+      include RSpec::Matchers
+
+      def execute(target, session0, session1, active_session=nil)
+        session = case arguments && arguments['session']
+        when 'session0'
+          session0
+        when 'session1'
+          session1
+        else
+          # active session could be nil
+          active_session
+        end
 
-      # Execute the operation.
-      #
-      # @example Execute the operation.
-      #   operation.execute
-      #
-      # @param [ Collection ] collection The collection to execute
-      #   the operation on.
-      #
-      # @return [ Result ] The result of executing the operation.
-      #
-      # @since 2.6.0
-      def execute(collection)
-        # Determine which object the operation method should be called on.
-        obj = case object
-              when 'session0'
-                @session0
-              when 'session1'
-                @session1
-              when 'database'
-                collection.database
-              else
-                collection = collection.with(read: read_preference) if collection_read_preference
-                collection = collection.with(read_concern: read_concern) if read_concern
-                collection = collection.with(write: write_concern) if write_concern
-                collection
-              end
+        context = Context.new(
+          session0,
+          session1,
+          session)
 
-        if (op_name = OPERATIONS[name]) == :with_transaction
-          args = [collection]
+        op_name = Utils.underscore(name).to_sym
+        if op_name == :with_transaction
+          args = [target]
         else
           args = []
         end
         if op_name.nil?
           raise "Unknown operation #{name}"
         end
-        send(op_name, obj, *args)
+        result = send(op_name, target, context, *args)
+        if result
+          if result.is_a?(Hash)
+            result = result.dup
+            result['error'] = false
+          end
+        end
+        result
       rescue Mongo::Error::OperationFailure => e
         err_doc = e.instance_variable_get(:@result).send(:first_document)
         error_code_name = err_doc['codeName'] || err_doc['writeConcernError'] && err_doc['writeConcernError']['codeName']
@@ -142,55 +58,81 @@ module Mongo
           # but does return the error code (or we can parse the error code
           # out of the message).
           # https://jira.mongodb.org/browse/SERVER-39706
-          if e.code == 11000
-            error_code_name = 'DuplicateKey'
-          else
-            warn "Error without error code name: #{e.code}"
-          end
+          warn "Error without error code name: #{e.code}"
         end
 
         {
-          'errorCodeName' => error_code_name,
+          'errorCode' => e.code,
+          'errorCodeName' => e.code_name,
           'errorContains' => e.message,
           'errorLabels' => e.labels,
           'exception' => e,
+          'error' => true,
         }
       rescue Mongo::Error => e
         {
           'errorContains' => e.message,
           'errorLabels' => e.labels,
           'exception' => e,
+          'error' => true,
+        }
+      # We do not have a base class for client side BSON-related errors.
+      # See https://jira.mongodb.org/browse/RUBY-1806.
+      # Rescue this particular exception for the time being.
+      rescue BSON::String::IllegalKey => e
+        {
+          'exception' => e,
+          'clientError' => true,
+          'error' => true,
         }
       end
 
       private
 
-      def start_transaction(session)
-        session.start_transaction(Utils.snakeize_hash(arguments['options'])) ; nil
+      # operations
+
+      def run_command(database, context)
+        # Convert the first key (i.e. the command name) to a symbol.
+        cmd = arguments['command'].dup
+        command_name = cmd.first.first
+        command_value = cmd.delete(command_name)
+        cmd = { command_name.to_sym => command_value }.merge(cmd)
+
+        opts = Utils.snakeize_hash(context.transform_arguments(options)).dup
+        opts[:read] = opts.delete(:read_preference)
+        database.command(cmd, opts).documents.first
+      end
+
+      def start_transaction(session, context)
+        session.start_transaction(Utils.convert_operation_options(arguments['options']))
+        nil
       end
 
-      def commit_transaction(session)
-        session.commit_transaction ; nil
+      def commit_transaction(session, context)
+        session.commit_transaction
+        nil
       end
 
-      def abort_transaction(session)
-        session.abort_transaction ; nil
+      def abort_transaction(session, context)
+        session.abort_transaction
+        nil
       end
 
-      def with_transaction(session, collection)
-        unless callback = @spec['arguments']['callback']
+      def with_transaction(session, context, collection)
+        unless callback = arguments['callback']
           raise ArgumentError, 'with_transaction requires a callback to be present'
         end
 
-        if @spec['arguments']['options']
-          options = Utils.snakeize_hash(@spec['arguments']['options'])
+        if arguments['options']
+          options = Utils.snakeize_hash(arguments['options'])
         else
           options = nil
         end
         session.with_transaction(options) do
           callback['operations'].each do |op_spec|
-            op = Operation.new(op_spec, @session0, @session1, session)
-            rv = op.execute(collection)
+            op = Operation.new(@crud_test, op_spec)
+            target = @crud_test.resolve_target(@crud_test.test_client, op)
+            rv = op.execute(target, context.session0, context.session1, session)
             if rv && rv['exception']
               raise rv['exception']
             end
@@ -198,237 +140,45 @@ module Mongo
         end
       end
 
-      def run_command(database)
-        # Convert the first key (i.e. the command name) to a symbol.
-        cmd = command.dup
-        command_name = cmd.first.first
-        command_value = cmd.delete(command_name)
-        cmd = { command_name.to_sym => command_value }.merge(cmd)
-
-        opts = Utils.snakeize_hash(options)
-        opts[:read] = opts.delete(:read_preference)
-        database.command(cmd, opts).documents.first
-      end
-
-      def aggregate(collection)
-        collection.aggregate(pipeline, options).to_a
-      end
-
-      def bulk_write(collection)
-        result = collection.bulk_write(requests, options)
-        return_doc = {}
-        return_doc['deletedCount'] = result.deleted_count || 0
-        return_doc['insertedIds'] = result.inserted_ids if result.inserted_ids
-        return_doc['upsertedId'] = result.upserted_id if upsert
-        return_doc['upsertedCount'] = result.upserted_count || 0
-        return_doc['matchedCount'] = result.matched_count || 0
-        return_doc['modifiedCount'] = result.modified_count || 0
-        return_doc['upsertedIds'] = result.upserted_ids if result.upserted_ids
-        return_doc
-      end
-
-      def count(collection)
-        collection.count(filter, options).to_s
-      end
-
-      def count_documents(collection)
-        collection.count_documents(filter, options)
-      end
-
-      def delete_many(collection)
-        result = collection.delete_many(filter, options)
-        { 'deletedCount' => result.deleted_count }
-      end
-
-      def delete_one(collection)
-        result = collection.delete_one(filter, options)
-        { 'deletedCount' => result.deleted_count }
-      end
-
-      def distinct(collection)
-        collection.distinct(field_name, filter, options)
-      end
-
-      def find(collection)
-        opts = modifiers ? options.merge(modifiers: BSON::Document.new(modifiers)) : options
-        collection.find(filter, opts).to_a
-      end
-
-      def insert_many(collection)
-        result = collection.insert_many(documents, options)
-        { 'insertedIds' => result.inserted_ids }
+      def assert_session_transaction_state(collection, context)
+        session = context.send(arguments['session'])
+        actual_state = session.instance_variable_get('@state').to_s.sub(/^transaction_|_transaction$/, '').sub(/^no$/, 'none')
+        expect(actual_state).to eq(arguments['state'])
       end
 
-      def insert_one(collection)
-        result = collection.insert_one(document, options)
-        { 'insertedId' => result.inserted_id }
-      end
-
-      def update_return_doc(result)
-        return_doc = {}
-        return_doc['upsertedId'] = result.upserted_id if upsert
-        return_doc['upsertedCount'] = result.upserted_count
-        return_doc['matchedCount'] = result.matched_count
-        return_doc['modifiedCount'] = result.modified_count if result.modified_count
-        return_doc
-      end
-
-      def replace_one(collection)
-        result = collection.replace_one(filter, replacement, options)
-        update_return_doc(result)
-      end
-
-      def update_many(collection)
-        result = collection.update_many(filter, update, options)
-        update_return_doc(result)
-      end
-
-      def update_one(collection)
-        result = collection.update_one(filter, update, options)
-        update_return_doc(result)
-      end
-
-      def find_one_and_delete(collection)
-        collection.find_one_and_delete(filter, options)
-      end
-
-      def find_one_and_replace(collection)
-        collection.find_one_and_replace(filter, replacement, options)
-      end
-
-      def find_one_and_update(collection)
-        collection.find_one_and_update(filter, update, options)
-      end
-
-      def object
-        @spec['object']
-      end
-
-      def options
-        ARGUMENT_MAP.reduce({}) do |opts, (key, value)|
-          arguments.key?(value) ? opts.merge!(key => send(key)) : opts
+      def targeted_fail_point(collection, context)
+        args = context.transform_arguments(options)
+        session = args[:session]
+        unless session.pinned_server
+          raise ArgumentError, 'Targeted fail point requires session to be pinned to a server'
         end
-      end
-
-      def collation
-        arguments['collation']
-      end
 
-      def command
-        arguments['command']
-      end
-
-      def replacement
-        arguments['replacement']
-      end
-
-      def sort
-        arguments['sort']
-      end
-
-      def projection
-        arguments['projection']
-      end
+        client = ClusterTools.instance.direct_client(session.pinned_server.address,
+          database: 'admin')
+        client.command(arguments['failPoint'])
 
-      def documents
-        arguments['documents']
+        $disable_fail_points ||= []
+        $disable_fail_points << [
+          arguments['failPoint'],
+          session.pinned_server.address,
+        ]
       end
 
-      def document
-        arguments['document']
-      end
-
-      def ordered
-        arguments['ordered']
-      end
-
-      def field_name
-        arguments['fieldName']
-      end
-
-      def filter
-        arguments['filter']
-      end
-
-      def pipeline
-        arguments['pipeline']
-      end
-
-      def array_filters
-        arguments['arrayFilters']
-      end
-
-      def batch_size
-        arguments['batchSize']
-      end
-
-      def session
-        arguments['session']
-      end
-
-      def requests
-        arguments['requests'].map do |request|
-          case request.keys.first
-          when 'insertOne' then
-            { insert_one: request['insertOne']['document'] }
-          when 'updateOne' then
-            update = request['updateOne']
-            { update_one: { filter: update['filter'], update: update['update'] } }
-          when 'name' then
-            bulk_request(request)
-          end
+      def assert_session_pinned(collection, context)
+        args = context.transform_arguments(options)
+        session = args[:session]
+        unless session.pinned_server
+          raise ArgumentError, 'Expected session to be pinned'
         end
       end
 
-      def bulk_request(request)
-        op_name = OPERATIONS[request['name']]
-        op = { op_name => {} }
-
-        op[op_name][:filter] = request['arguments']['filter'] if request['arguments']['filter']
-        op[op_name][:update] = request['arguments']['update'] if request['arguments']['update']
-        op[op_name][:upsert] = request['arguments']['upsert'] if request['arguments']['upsert']
-        op[op_name][:replacement] = request['arguments']['replacement'] if request['arguments']['replacement']
-        op[op_name][:array_filters] =  request['arguments']['arrayFilters'] if request['arguments']['arrayFilters']
-        op[op_name] = request['arguments']['document'] if request['arguments']['document']
-        op
-      end
-
-      def upsert
-        arguments['upsert']
-      end
-
-      def return_document
-        case arguments['returnDocument']
-        when 'Before'
-          :before
-        when 'After'
-          :after
+      def assert_session_unpinned(collection, context)
+        args = context.transform_arguments(options)
+        session = args[:session]
+        if session.pinned_server
+          raise ArgumentError, 'Expected session to not be pinned'
         end
       end
-
-      def update
-        arguments['update']
-      end
-
-      def modifiers
-        arguments['modifiers']
-      end
-
-      def read_concern
-        Utils.snakeize_hash(@spec['collectionOptions'] && @spec['collectionOptions']['readConcern'])
-      end
-
-      def write_concern
-        Utils.snakeize_hash(@spec['collectionOptions'] && @spec['collectionOptions']['writeConcern'])
-      end
-
-      def read_preference
-        Utils.snakeize_hash(arguments['readPreference'])
-      end
-
-      def collection_read_preference
-        Utils.snakeize_hash(@spec['collectionOptions'] && @spec['collectionOptions']['readPreference'])
-      end
     end
   end
 end