mongo 2.13.0.beta1 → 2.13.0.rc1

data/spec/runners/change_streams/test.rb

@@ -67,7 +67,7 @@ module Mongo
         end
 
         # Work around https://jira.mongodb.org/browse/SERVER-17397
-        if ClusterConfig.instance.server_version < '4.3' &&
+        if ClusterConfig.instance.server_version < '4.4' &&
           global_client.cluster.servers.length > 1
         then
           mongos_each_direct_client do |client|
@@ -107,7 +107,7 @@ module Mongo
 
       def run
         change_stream = begin
-          @target.watch(@pipeline, Utils.snakeize_hash(@options))
+          @target.watch(@pipeline, ::Utils.snakeize_hash(@options))
         rescue Mongo::Error::OperationFailure => e
           return {
             result: {

data/spec/runners/cmap.rb

@@ -40,7 +40,7 @@ module Mongo
         @test = YAML.load(File.read(test_path))
 
         @description = @test['description']
-        @pool_options = Utils.snakeize_hash(process_options(@test['poolOptions']))
+        @pool_options = ::Utils.snakeize_hash(process_options(@test['poolOptions']))
         @spec_ops = @test['operations'].map { |o| Operation.new(self, o) }
         @processed_ops = []
         @expected_error = @test['error']

data/spec/runners/command_monitoring.rb

@@ -135,7 +135,7 @@ module Mongo
         if expected.keys.first == '$numberLong'
           converted = expected.values.first.to_i
           if actual.is_a?(BSON::Int64)
-            actual = Utils.int64_value(actual)
+            actual = ::Utils.int64_value(actual)
           elsif actual.is_a?(BSON::Int32)
             return false
           end
@@ -260,8 +260,9 @@ module Mongo
       # @param [ Mongo::Collection ] collection The collection.
       #
       # @since 2.1.0
-      def run(collection)
+      def run(collection, subscriber)
         collection.insert_many(@data)
+        subscriber.clear_events!
         @operation.execute(collection)
       end
     end
@@ -338,37 +339,5 @@ module Mongo
         "match_#{event_type}"
       end
     end
-
-    # The test subscriber to track the events.
-    #
-    # @since 2.1.0
-    class TestSubscriber
-
-      def started(event)
-        command_started_event[event.command_name] = event
-      end
-
-      def succeeded(event)
-        command_succeeded_event[event.command_name] = event
-      end
-
-      def failed(event)
-        command_failed_event[event.command_name] = event
-      end
-
-      private
-
-      def command_started_event
-        @started_events ||= BSON::Document.new
-      end
-
-      def command_succeeded_event
-        @succeeded_events ||= BSON::Document.new
-      end
-
-      def command_failed_event
-        @failed_events ||= BSON::Document.new
-      end
-    end
   end
 end

data/spec/runners/crud/context.rb

@@ -12,12 +12,16 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'support/keyword_struct'
+
 module Mongo
   module CRUD
-    class Context
-      def transform_arguments(arguments)
-        arguments
-      end
-    end
+    Context = KeywordStruct.new(
+      :session0,
+      :session1,
+      :sdam_subscriber,
+      :threads,
+      :primary_address,
+    )
   end
 end

data/spec/runners/crud/operation.rb

@@ -88,7 +88,7 @@ module Mongo
       #
       # @since 2.0.0
       def execute(target)
-        op_name = Utils.underscore(name)
+        op_name = ::Utils.underscore(name)
         if target.is_a?(Mongo::Database)
           op_name = "db_#{op_name}"
         elsif target.is_a?(Mongo::Client)
@@ -99,14 +99,14 @@ module Mongo
 
       def database_options
         if opts = @spec['databaseOptions']
-          Utils.convert_operation_options(opts)
+          ::Utils.convert_operation_options(opts)
         else
           nil
         end
       end
 
       def collection_options
-        Utils.convert_operation_options(@spec['collectionOptions'])
+        ::Utils.convert_operation_options(@spec['collectionOptions'])
       end
 
       private
@@ -114,31 +114,31 @@ module Mongo
       # read operations
 
       def aggregate(collection, context)
-        collection.aggregate(arguments['pipeline'], context.transform_arguments(options)).to_a
+        collection.aggregate(arguments['pipeline'], transformed_options(context)).to_a
       end
 
       def db_aggregate(database, context)
-        database.aggregate(arguments['pipeline'], context.transform_arguments(options)).to_a
+        database.aggregate(arguments['pipeline'], transformed_options(context)).to_a
       end
 
       def count(collection, context)
-        collection.count(arguments['filter'], context.transform_arguments(options))
+        collection.count(arguments['filter'], transformed_options(context))
       end
 
       def count_documents(collection, context)
-        collection.count_documents(arguments['filter'], context.transform_arguments(options))
+        collection.count_documents(arguments['filter'], transformed_options(context))
       end
 
       def distinct(collection, context)
-        collection.distinct(arguments['fieldName'], arguments['filter'], context.transform_arguments(options))
+        collection.distinct(arguments['fieldName'], arguments['filter'], transformed_options(context))
       end
 
       def estimated_document_count(collection, context)
-        collection.estimated_document_count(context.transform_arguments(options))
+        collection.estimated_document_count(transformed_options(context))
       end
 
       def find(collection, context)
-        opts = context.transform_arguments(options)
+        opts = transformed_options(context)
         if arguments['modifiers']
           opts = opts.merge(modifiers: BSON::Document.new(arguments['modifiers']))
         end
@@ -183,7 +183,7 @@ module Mongo
       # write operations
 
       def bulk_write(collection, context)
-        result = collection.bulk_write(requests, context.transform_arguments(options))
+        result = collection.bulk_write(requests, transformed_options(context))
         return_doc = {}
         return_doc['deletedCount'] = result.deleted_count || 0
         return_doc['insertedIds'] = result.inserted_ids if result.inserted_ids
@@ -197,50 +197,50 @@ module Mongo
       end
 
       def delete_many(collection, context)
-        result = collection.delete_many(arguments['filter'], context.transform_arguments(options))
+        result = collection.delete_many(arguments['filter'], transformed_options(context))
         { 'deletedCount' => result.deleted_count }
       end
 
       def delete_one(collection, context)
-        result = collection.delete_one(arguments['filter'], context.transform_arguments(options))
+        result = collection.delete_one(arguments['filter'], transformed_options(context))
         { 'deletedCount' => result.deleted_count }
       end
 
       def insert_many(collection, context)
-        result = collection.insert_many(arguments['documents'], context.transform_arguments(options))
+        result = collection.insert_many(arguments['documents'], transformed_options(context))
         { 'insertedIds' => result.inserted_ids }
       end
 
       def insert_one(collection, context)
-        result = collection.insert_one(arguments['document'], context.transform_arguments(options))
+        result = collection.insert_one(arguments['document'], transformed_options(context))
         { 'insertedId' => result.inserted_id }
       end
 
       def replace_one(collection, context)
-        result = collection.replace_one(arguments['filter'], arguments['replacement'], context.transform_arguments(options))
+        result = collection.replace_one(arguments['filter'], arguments['replacement'], transformed_options(context))
         update_return_doc(result)
       end
 
       def update_many(collection, context)
-        result = collection.update_many(arguments['filter'], arguments['update'], context.transform_arguments(options))
+        result = collection.update_many(arguments['filter'], arguments['update'], transformed_options(context))
         update_return_doc(result)
       end
 
       def update_one(collection, context)
-        result = collection.update_one(arguments['filter'], arguments['update'], context.transform_arguments(options))
+        result = collection.update_one(arguments['filter'], arguments['update'], transformed_options(context))
         update_return_doc(result)
       end
 
       def find_one_and_delete(collection, context)
-        collection.find_one_and_delete(arguments['filter'], context.transform_arguments(options))
+        collection.find_one_and_delete(arguments['filter'], transformed_options(context))
       end
 
       def find_one_and_replace(collection, context)
-        collection.find_one_and_replace(arguments['filter'], arguments['replacement'], context.transform_arguments(options))
+        collection.find_one_and_replace(arguments['filter'], arguments['replacement'], transformed_options(context))
       end
 
       def find_one_and_update(collection, context)
-        collection.find_one_and_update(arguments['filter'], arguments['update'], context.transform_arguments(options))
+        collection.find_one_and_update(arguments['filter'], arguments['update'], transformed_options(context))
       end
 
       # ddl
@@ -270,7 +270,8 @@ module Mongo
       end
 
       def create_collection(database, context)
-        database[arguments.fetch('collection')].create(session: context.session)
+        opts = transformed_options(context)
+        database[arguments.fetch('collection')].create(session: opts[:session])
       end
 
       def rename(collection, context)
@@ -351,6 +352,16 @@ module Mongo
         end
       end
 
+      def configure_fail_point(client, context)
+        fp = arguments.fetch('failPoint')
+        $disable_fail_points ||= []
+        $disable_fail_points << [
+          fp,
+          ClusterConfig.instance.primary_address,
+        ]
+        client.use('admin').database.command(fp)
+      end
+
       # options & arguments
 
       def options
@@ -360,7 +371,7 @@ module Mongo
         # bulk write test is an exception in that it has an "options" key
         # with the options.
         arguments.merge(arguments['options'] || {}).each do |spec_k, v|
-          ruby_k = Utils.underscore(spec_k).to_sym
+          ruby_k = ::Utils.underscore(spec_k).to_sym
 
           if v.is_a?(Hash) && v['$numberLong']
             v = v['$numberLong'].to_i
@@ -390,8 +401,8 @@ module Mongo
       end
 
       def bulk_request(request)
-        op_name = Utils.underscore(request['name'])
-        args = Utils.shallow_snakeize_hash(request['arguments'])
+        op_name = ::Utils.underscore(request['name'])
+        args = ::Utils.shallow_snakeize_hash(request['arguments'])
         if args[:document]
           unless args.keys == [:document]
             raise "If :document is given, it must be the only key"
@@ -406,7 +417,7 @@ module Mongo
       end
 
       def transform_return_document(v)
-        Utils.underscore(v).to_sym
+        ::Utils.underscore(v).to_sym
       end
 
       def update
@@ -414,7 +425,7 @@ module Mongo
       end
 
       def transform_read_preference(v)
-        Utils.snakeize_hash(v)
+        ::Utils.snakeize_hash(v)
       end
 
       def read_preference
@@ -429,6 +440,27 @@ module Mongo
         return_doc['modifiedCount'] = result.modified_count if result.modified_count
         return_doc
       end
+
+      def transformed_options(context)
+        opts = options.dup
+        if opts[:session]
+          opts[:session] = case opts[:session]
+          when 'session0'
+            unless context.session0
+              raise "Trying to use session0 but it is not in context"
+            end
+            context.session0
+          when 'session1'
+            unless context.session1
+              raise "Trying to use session1 but it is not in context"
+            end
+            context.session1
+          else
+            raise "Invalid session name '#{opts[:session]}'"
+          end
+        end
+        opts
+      end
     end
   end
 end

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/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.
+  skip_if_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