mongo 2.13.0.beta1 → 2.14.0

data/spec/runners/crud/spec.rb

@@ -11,14 +11,6 @@ module Mongo
       def initialize(test_path)
         contents = File.read(test_path)
 
-        # Since Ruby driver binds a client to a database, change the
-        # database name in the spec to the one we are using
-        contents.sub!(/"crud-tests"/, '"ruby-driver"')
-        contents.sub!(/"retryable-reads-tests"/, '"ruby-driver"')
-        contents.sub!(/"transaction-tests"/, '"ruby-driver"')
-        contents.sub!(/"withTransaction-tests"/, '"ruby-driver"')
-        contents.sub!(/ default_write_concern_db/, ' ruby-driver')
-
         @spec = YAML.load(contents)
         @description = File.basename(test_path)
         @data = BSON::ExtJSON.parse_obj(@spec['data'])

data/spec/runners/crud/test.rb

@@ -28,7 +28,7 @@ module Mongo
         @spec = crud_spec
         @data = data
         @description = test['description']
-        @client_options = Utils.convert_client_options(test['clientOptions'] || {})
+        @client_options = ::Utils.convert_client_options(test['clientOptions'] || {})
 
         if test['failPoint']
           @fail_point_command = FAIL_POINT_BASE_COMMAND.merge(test['failPoint'])

data/spec/runners/crud/test_base.rb

@@ -45,25 +45,6 @@ module Mongo
           raise "Unknown target #{operation.object}"
         end
       end
-
-      # If the deployment is a sharded cluster, creates a direct client
-      # to each of the mongos nodes and yields each in turn to the
-      # provided block. Does nothing in other topologies.
-      def mongos_each_direct_client
-        if ClusterConfig.instance.topology == :sharded
-          client = ClientRegistry.instance.global_client('basic')
-          client.cluster.next_primary
-          client.cluster.servers.each do |server|
-            direct_client = ClientRegistry.instance.new_local_client(
-              [server.address.to_s],
-              SpecConfig.instance.test_options.merge(
-                connect: :sharded
-              ).merge(SpecConfig.instance.auth_options))
-            yield direct_client
-            direct_client.close
-          end
-        end
-      end
     end
   end
 end

data/spec/runners/sdam.rb

@@ -149,7 +149,7 @@ module Mongo
       end
 
       def when
-        Utils.underscore(@spec.fetch('when'))
+        ::Utils.underscore(@spec.fetch('when'))
       end
 
       def max_wire_version
@@ -161,7 +161,7 @@ module Mongo
       end
 
       def type
-        Utils.underscore(@spec.fetch('type'))
+        ::Utils.underscore(@spec.fetch('type'))
       end
 
       def result

data/spec/runners/server_selection.rb

@@ -73,19 +73,6 @@ module Mongo
           @type = Mongo::Cluster::Topology.const_get(@test['topology_description']['type'])
         end
 
-        # Whether this spec describes a replica set.
-        #
-        # @example Determine if the spec describes a replica set.
-        #   spec.replica_set?
-        #
-        # @return [true, false] If the spec describes a replica set.
-        #
-        # @since 2.0.0
-        def replica_set?
-          type == Mongo::Cluster::Topology::ReplicaSetNoPrimary ||
-          type == Mongo::Cluster::Topology::ReplicaSetWithPrimary
-        end
-
         # Does this spec expect a server to be found.
         #
         # @example Will a server be found with this spec.
@@ -98,15 +85,10 @@ module Mongo
           !in_latency_window.empty?
         end
 
-        # Is the max staleness setting invalid.
+        # Whether the test requires an error to be raised during server selection.
         #
-        # @example Will the max staleness setting be valid with other options.
-        #   spec.invalid_max_staleness?
-        #
-        # @return [ true, false ] If an error will be raised by the max staleness setting.
-        #
-        # @since 2.4.0
-        def invalid_max_staleness?
+        # @return [ true, false ] Whether the test expects an error.
+        def error?
           @test['error']
         end
 
@@ -122,9 +104,6 @@ module Mongo
         #
         # @since 2.0.0
         def in_latency_window
-          if read_preference['mode'] == :secondary_preferred && primary
-            return @in_latency_window.push(primary).uniq
-          end
           @in_latency_window
         end
 
@@ -134,13 +113,248 @@ module Mongo
         #
         # @since 2.0.0
         def candidate_servers
-          @candidate_servers.select { |s| !['Unknown', 'PossiblePrimary'].include?(s['type']) }
+          @candidate_servers
+        end
+      end
+    end
+  end
+end
+
+def define_server_selection_spec_tests(test_paths)
+  # Linter insists that a server selection semaphore is present when
+  # performing server selection.
+  require_no_linting
+
+  test_paths.each do |file|
+
+    spec = Mongo::ServerSelection::Read::Spec.new(file)
+
+    context(spec.description) do
+      # Cluster needs a topology and topology needs a cluster...
+      # This temporary cluster is used for topology construction.
+      let(:temp_cluster) do
+        double('temp cluster').tap do |cluster|
+          allow(cluster).to receive(:servers_list).and_return([])
+        end
+      end
+
+      let(:topology) do
+        options = if spec.type <= Mongo::Cluster::Topology::ReplicaSetNoPrimary
+          {replica_set_name: 'foo'}
+        else
+          {}
+        end
+        spec.type.new(options, monitoring, temp_cluster)
+      end
+
+      let(:monitoring) do
+        Mongo::Monitoring.new(monitoring: false)
+      end
+
+      let(:listeners) do
+        Mongo::Event::Listeners.new
+      end
+
+      let(:options) do
+        if spec.heartbeat_frequency
+          {server_selection_timeout: 0.1, heartbeat_frequency: spec.heartbeat_frequency}
+        else
+          {server_selection_timeout: 0.1}
+        end
+      end
+
+      let(:cluster) do
+        double('cluster').tap do |c|
+          allow(c).to receive(:server_selection_semaphore)
+          allow(c).to receive(:connected?).and_return(true)
+          allow(c).to receive(:summary)
+          allow(c).to receive(:topology).and_return(topology)
+          allow(c).to receive(:single?).and_return(topology.single?)
+          allow(c).to receive(:sharded?).and_return(topology.sharded?)
+          allow(c).to receive(:replica_set?).and_return(topology.replica_set?)
+          allow(c).to receive(:unknown?).and_return(topology.unknown?)
+          allow(c).to receive(:options).and_return(options)
+          allow(c).to receive(:scan!).and_return(true)
+          allow(c).to receive(:app_metadata).and_return(app_metadata)
+          allow(c).to receive(:heartbeat_interval).and_return(
+            spec.heartbeat_frequency || Mongo::Server::Monitor::DEFAULT_HEARTBEAT_INTERVAL)
         end
+      end
+
+      # One of the spec test assertions is on the set of servers that are
+      # eligible for selection without taking latency into account.
+      # In the driver, latency is taken into account at various points during
+      # server selection, hence there isn't a method that can be called to
+      # retrieve the list of servers without accounting for latency.
+      # Work around this by executing server selection with all servers set
+      # to zero latency, when evaluating the candidate server set.
+      let(:ignore_latency) { false }
+
+      let(:candidate_servers) do
+        spec.candidate_servers.collect do |server|
+          features = double('features').tap do |feat|
+            allow(feat).to receive(:max_staleness_enabled?).and_return(server['maxWireVersion'] && server['maxWireVersion'] >= 5)
+            allow(feat).to receive(:check_driver_support!).and_return(true)
+          end
+          address = Mongo::Address.new(server['address'])
+          Mongo::Server.new(address, cluster, monitoring, listeners,
+            {monitoring_io: false}.update(options)
+          ).tap do |s|
+            allow(s).to receive(:average_round_trip_time) do
+              if ignore_latency
+                0
+              elsif server['avg_rtt_ms']
+                server['avg_rtt_ms'] / 1000.0
+              end
+            end
+            allow(s).to receive(:tags).and_return(server['tags'])
+            allow(s).to receive(:secondary?).and_return(server['type'] == 'RSSecondary')
+            allow(s).to receive(:primary?).and_return(server['type'] == 'RSPrimary')
+            allow(s).to receive(:mongos?).and_return(server['type'] == 'Mongos')
+            allow(s).to receive(:standalone?).and_return(server['type'] == 'Standalone')
+            allow(s).to receive(:unknown?).and_return(server['type'] == 'Unknown')
+            allow(s).to receive(:connectable?).and_return(true)
+            allow(s).to receive(:last_write_date).and_return(
+              Time.at(server['lastWrite']['lastWriteDate']['$numberLong'].to_f / 1000)) if server['lastWrite']
+            allow(s).to receive(:last_scan).and_return(
+              Time.at(server['lastUpdateTime'].to_f / 1000))
+            allow(s).to receive(:features).and_return(features)
+            allow(s).to receive(:replica_set_name).and_return('foo')
+          end
+        end
+      end
+
+      let(:suitable_servers) do
+        spec.suitable_servers.collect do |server|
+          Mongo::Server.new(Mongo::Address.new(server['address']), cluster, monitoring, listeners,
+            options.merge(monitoring_io: false))
+        end
+      end
 
-        private
+      let(:in_latency_window) do
+        spec.in_latency_window.collect do |server|
+          Mongo::Server.new(Mongo::Address.new(server['address']), cluster, monitoring, listeners,
+            options.merge(monitoring_io: false))
+        end
+      end
+
+      let(:server_selector_definition) do
+        { mode: spec.read_preference['mode'] }.tap do |definition|
+          definition[:tag_sets] = spec.read_preference['tag_sets']
+          definition[:max_staleness] = spec.max_staleness if spec.max_staleness
+        end
+      end
+
+      let(:server_selector) do
+        Mongo::ServerSelector.get(server_selector_definition)
+      end
+
+      let(:app_metadata) do
+        Mongo::Server::AppMetadata.new({})
+      end
+
+      before do
+        allow(cluster).to receive(:servers_list).and_return(candidate_servers)
+        allow(cluster).to receive(:servers) do
+          # Copy Cluster#servers definition because clusters is a double
+          cluster.topology.servers(cluster.servers_list)
+        end
+        allow(cluster).to receive(:addresses).and_return(candidate_servers.map(&:address))
+      end
+
+      if spec.error?
+
+        it 'Raises an InvalidServerPreference exception' do
+
+          expect do
+            server_selector.select_server(cluster)
+          end.to raise_exception(Mongo::Error::InvalidServerPreference)
+        end
+
+      else
+
+        if spec.server_available?
+
+          it 'has non-empty suitable servers' do
+            spec.suitable_servers.should be_a(Array)
+            spec.suitable_servers.should_not be_empty
+          end
+
+          if spec.in_latency_window.length == 1
+
+            it 'selects the expected server' do
+              [server_selector.select_server(cluster)].should == in_latency_window
+            end
+
+          else
+
+            it 'selects a server in the suitable list' do
+              in_latency_window.should include(server_selector.select_server(cluster))
+            end
+
+            let(:expected_addresses) do
+              in_latency_window.map(&:address).map(&:seed).sort
+            end
+
+            let(:actual_addresses) do
+              server_selector.suitable_servers(cluster).map(&:address).map(&:seed).sort
+            end
+
+            it 'identifies expected suitable servers' do
+              actual_addresses.should == expected_addresses
+            end
+
+          end
+
+          context 'candidate servers without taking latency into account' do
+            let(:ignore_latency) { true }
+
+            let(:expected_addresses) do
+              suitable_servers.map(&:address).map(&:seed).sort
+            end
+
+            let(:actual_addresses) do
+              servers = server_selector.send(:suitable_servers, cluster)
+
+              # The tests expect that only secondaries are "suitable" for
+              # server selection with secondary preferred read preference.
+              # In actuality, primaries are also suitable, and the driver
+              # returns the primaries also. Remove primaries from the
+              # actual set when read preference is secondary preferred.
+              # HOWEVER, if a test ends up selecting a primary, then it
+              # includes that primary into its suitable servers. Therefore
+              # only remove primaries when the number of suitable servers
+              # is greater than 1.
+              servers.delete_if do |server|
+                server_selector.is_a?(Mongo::ServerSelector::SecondaryPreferred) &&
+                  server.primary? &&
+                  servers.length > 1
+              end
+
+              # Since we remove the latency requirement, the servers
+              # may be returned in arbitrary order.
+              servers.map(&:address).map(&:seed).sort
+            end
+
+            it 'identifies expected suitable servers' do
+              actual_addresses.should == expected_addresses
+            end
+          end
+
+        else
+
+          # Runner does not handle non-empty suitable servers with
+          # no servers in latency window.
+          it 'has empty suitable servers' do
+            expect(spec.suitable_servers).to eq([])
+          end
+
+          it 'Raises a NoServerAvailable Exception' do
+            expect do
+              server_selector.select_server(cluster)
+            end.to raise_exception(Mongo::Error::NoServerAvailable)
+          end
 
-        def primary
-          @candidate_servers.find { |s| s['type'] == 'RSPrimary' }
         end
       end
     end

data/spec/runners/transactions.rb

@@ -12,7 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-require 'runners/transactions/context'
 require 'runners/transactions/operation'
 require 'runners/transactions/spec'
 require 'runners/transactions/test'
@@ -26,21 +25,22 @@ def define_transactions_spec_tests(test_paths)
     context(spec.description) do
 
       define_spec_tests_with_requirements(spec) do |req|
+
         spec.tests.each do |test|
 
-          before do
-            if ClusterConfig.instance.topology == :sharded
-              if test.multiple_mongoses? && SpecConfig.instance.addresses.length == 1
-                skip "Test requires multiple mongoses"
-              elsif !test.multiple_mongoses? && SpecConfig.instance.addresses.length > 1
-                # Many transaction spec tests that do not specifically deal with
-                # sharded transactions fail when run against a multi-mongos cluster
-                skip "Test does not specify multiple mongoses"
+          context(test.description) do
+
+            before(:all) do
+              if ClusterConfig.instance.topology == :sharded
+                if test.multiple_mongoses? && SpecConfig.instance.addresses.length == 1
+                  skip "Test requires multiple mongoses"
+                elsif !test.multiple_mongoses? && SpecConfig.instance.addresses.length > 1
+                  # Many transaction spec tests that do not specifically deal with
+                  # sharded transactions fail when run against a multi-mongos cluster
+                  skip "Test does not specify multiple mongoses"
+                end
               end
             end
-          end
-
-          context(test.description) do
 
             if test.skip_reason
               before(:all) do

data/spec/runners/transactions/operation.rb

@@ -21,23 +21,8 @@ module Mongo
         arguments && arguments['session'] || object =~ /session/
       end
 
-      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
-
-        context = Context.new(
-          session0,
-          session1,
-          session)
-
-        op_name = Utils.underscore(name).to_sym
+      def execute(target, context)
+        op_name = ::Utils.underscore(name).to_sym
         if op_name == :with_transaction
           args = [target]
         else
@@ -53,9 +38,14 @@ module Mongo
             result['error'] = false
           end
         end
+
         result
       rescue Mongo::Error::OperationFailure => e
-        err_doc = e.instance_variable_get(:@result).send(:first_document)
+        result = e.instance_variable_get(:@result)
+        if result.nil?
+          raise "OperationFailure had nil result: #{e}"
+        end
+        err_doc = result.send(:first_document)
         error_code_name = err_doc['codeName'] || err_doc['writeConcernError'] && err_doc['writeConcernError']['codeName']
         if error_code_name.nil?
           # Sometimes the server does not return the error code name,
@@ -102,13 +92,13 @@ module Mongo
         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 = ::Utils.snakeize_hash(transformed_options(context)).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']))
+        session.start_transaction(::Utils.convert_operation_options(arguments['options']))
         nil
       end
 
@@ -128,7 +118,7 @@ module Mongo
         end
 
         if arguments['options']
-          options = Utils.snakeize_hash(arguments['options'])
+          options = ::Utils.snakeize_hash(arguments['options'])
         else
           options = nil
         end
@@ -136,7 +126,7 @@ module Mongo
           callback['operations'].each do |op_spec|
             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)
+            rv = op.execute(target, context)
             if rv && rv['exception']
               raise rv['exception']
             end
@@ -151,7 +141,7 @@ module Mongo
       end
 
       def targeted_fail_point(collection, context)
-        args = context.transform_arguments(options)
+        args = transformed_options(context)
         session = args[:session]
         unless session.pinned_server
           raise ArgumentError, 'Targeted fail point requires session to be pinned to a server'
@@ -169,7 +159,7 @@ module Mongo
       end
 
       def assert_session_pinned(collection, context)
-        args = context.transform_arguments(options)
+        args = transformed_options(context)
         session = args[:session]
         unless session.pinned_server
           raise ArgumentError, 'Expected session to be pinned'
@@ -177,12 +167,148 @@ module Mongo
       end
 
       def assert_session_unpinned(collection, context)
-        args = context.transform_arguments(options)
+        args = transformed_options(context)
         session = args[:session]
         if session.pinned_server
           raise ArgumentError, 'Expected session to not be pinned'
         end
       end
+
+      def wait_for_event(client, context)
+        deadline = Time.now + 5
+        loop do
+          events = _select_events(context)
+          if events.length >= arguments['count']
+            break
+          end
+          if Time.now >= deadline
+            raise "Did not receive an event matching #{arguments} in 5 seconds; received #{events.length} but expected #{arguments['count']} events"
+          else
+            sleep 0.1
+          end
+        end
+      end
+
+      def assert_event_count(client, context)
+        events = _select_events(context)
+        unless events.length == arguments['count']
+          raise "Exppected #{arguments['count']} #{arguments['event']} events, but have #{events.length}"
+        end
+      end
+
+      def _select_events(context)
+        case arguments['event']
+        when 'ServerMarkedUnknownEvent'
+          context.sdam_subscriber.all_events.select do |event|
+            event.is_a?(Mongo::Monitoring::Event::ServerDescriptionChanged) &&
+            event.new_description.unknown?
+          end
+        else
+          context.sdam_subscriber.all_events.select do |event|
+            event.class.name.sub(/.*::/, '') == arguments['event'].sub(/Event$/, '')
+          end
+        end
+      end
+
+      class ThreadContext
+        def initialize
+          @operations = Queue.new
+          @unexpected_operation_results = []
+        end
+
+        def stop?
+          !!@stop
+        end
+
+        def signal_stop
+          @stop = true
+        end
+
+        attr_reader :operations
+        attr_reader :unexpected_operation_results
+      end
+
+      def start_thread(client, context)
+        thread_context = ThreadContext.new
+        thread = Thread.new do
+          loop do
+            begin
+              op_spec = thread_context.operations.pop(true)
+              op = Operation.new(@crud_test, op_spec)
+              target = @crud_test.resolve_target(@crud_test.test_client, op)
+              result = op.execute(target, context)
+              if op_spec['error']
+                unless result['error']
+                  thread_context.unexpected_operation_results << result
+                end
+              else
+                if result['error']
+                  thread_context.unexpected_operation_results << result
+                end
+              end
+            rescue ThreadError
+              # Queue is empty
+            end
+            if thread_context.stop?
+              break
+            else
+              sleep 1
+            end
+          end
+        end
+        class << thread
+          attr_accessor :context
+        end
+        thread.context = thread_context
+        unless context.threads
+          context.threads ||= {}
+        end
+        context.threads[arguments['name']] = thread
+      end
+
+      def run_on_thread(client, context)
+        thread = context.threads.fetch(arguments['name'])
+        thread.context.operations << arguments['operation']
+      end
+
+      def wait_for_thread(client, context)
+        thread = context.threads.fetch(arguments['name'])
+        thread.context.signal_stop
+        thread.join
+        unless thread.context.unexpected_operation_results.empty?
+          raise "Thread #{arguments['name']} had #{thread.context.unexpected_operation_results}.length unexpected operation results"
+        end
+      end
+
+      def wait(client, context)
+        sleep arguments['ms'] / 1000.0
+      end
+
+      def record_primary(client, context)
+        context.primary_address = client.cluster.next_primary.address
+      end
+
+      def run_admin_command(support_client, context)
+        support_client.use('admin').database.command(arguments['command'])
+      end
+
+      def wait_for_primary_change(client, context)
+        timeout = if arguments['timeoutMS']
+          arguments['timeoutMS'] / 1000.0
+        else
+          10
+        end
+        deadline = Time.now + timeout
+        loop do
+          client.cluster.scan!
+          if client.cluster.next_primary.address != context.primary_address
+            break
+          end
+          if Time.now >= deadline
+            raise "Failed to change primary in #{timeout} seconds"
+          end
+        end
+      end
     end
   end
 end