mongo 2.15.0 → 2.16.1

data/spec/mongo/server/push_monitor_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Server::PushMonitor do
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
+  let(:address) do
+    default_address
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  let(:monitor_options) do
+    {}
+  end
+
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
+  let(:cluster) do
+    double('cluster').tap do |cluster|
+      allow(cluster).to receive(:run_sdam_flow)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+    end
+  end
+
+  let(:server) do
+    Mongo::Server.new(address, cluster, Mongo::Monitoring.new, listeners,
+      monitoring_io: false)
+  end
+
+  let(:monitor) do
+    register_background_thread_object(
+      Mongo::Server::Monitor.new(server, listeners, Mongo::Monitoring.new,
+        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options).update(
+          app_metadata: monitor_app_metadata,
+          push_monitor_app_metadata: monitor_app_metadata))
+    )
+  end
+
+  let(:topology_version) do
+    Mongo::TopologyVersion.new('processId' => BSON::ObjectId.new, 'counter' => 1)
+  end
+
+  let(:check_document) do
+    {hello: 1}
+  end
+
+  let(:push_monitor) do
+    described_class.new(monitor, topology_version, monitor.monitoring,
+      **monitor.options.merge(check_document: check_document))
+  end
+
+  describe '#do_work' do
+    it 'works' do
+      lambda do
+        push_monitor.do_work
+      end.should_not raise_error
+    end
+
+    context 'network error during check' do
+      it 'does not propagate the exception' do
+        push_monitor
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+      end
+
+      it 'throttles checks' do
+        push_monitor
+
+        start = Mongo::Utils.monotonic_time
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        elapsed = Mongo::Utils.monotonic_time - start
+        elapsed.should > 0.5
+      end
+    end
+  end
+
+end

data/spec/mongo/session/session_pool_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 
 describe Mongo::Session::SessionPool do
   min_server_fcv '3.6'
-  require_topology :replica_set, :sharded
+  require_topology :replica_set, :sharded, :load_balanced
   clean_slate_for_all
 
   let(:cluster) do
@@ -113,10 +113,26 @@ describe Mongo::Session::SessionPool do
           pool.checkout
         end
 
-        it 'disposes of the old session and returns a new one' do
-          expect(checked_out_session).not_to be(old_session_a)
-          expect(checked_out_session).not_to be(old_session_b)
-          expect(pool.instance_variable_get(:@queue)).to be_empty
+        context "in non load-balanced topology" do
+          require_topology :replica_set, :sharded
+
+          it 'disposes of the old session and returns a new one' do
+            old_sessions = [old_session_a, old_session_b]
+            expect(old_sessions).not_to include(pool.checkout)
+            expect(old_sessions).not_to include(pool.checkout)
+            expect(pool.instance_variable_get(:@queue)).to be_empty
+          end
+        end
+
+        context "in load-balanced topology" do
+          require_topology :load_balanced
+
+          it 'doed not dispose of the old session' do
+            old_sessions = [old_session_a, old_session_b]
+            expect(old_sessions).to include(checked_out_session)
+            expect(old_sessions).to include(checked_out_session)
+            expect(pool.instance_variable_get(:@queue)).to be_empty
+          end
         end
       end
     end
@@ -138,10 +154,26 @@ describe Mongo::Session::SessionPool do
         pool.checkin(old_session_b)
       end
 
-      it 'disposes of the old sessions instead of adding them to the pool' do
-        expect(pool.checkout).not_to be(old_session_a)
-        expect(pool.checkout).not_to be(old_session_b)
-        expect(pool.instance_variable_get(:@queue)).to be_empty
+      context "in non load-balanced topology" do
+        require_topology :replica_set, :sharded
+
+        it 'disposes of the old sessions instead of adding them to the pool' do
+          old_sessions = [old_session_a, old_session_b]
+          expect(old_sessions).not_to include(pool.checkout)
+          expect(old_sessions).not_to include(pool.checkout)
+          expect(pool.instance_variable_get(:@queue)).to be_empty
+        end
+      end
+
+      context "in load-balanced topology" do
+        require_topology :load_balanced
+
+        it 'does not dispose of the old sessions' do
+          old_sessions = [old_session_a, old_session_b]
+          expect(old_sessions).to include(pool.checkout)
+          expect(old_sessions).to include(pool.checkout)
+          expect(pool.instance_variable_get(:@queue)).to be_empty
+        end
       end
     end
   end
@@ -160,7 +192,7 @@ describe Mongo::Session::SessionPool do
       pool.checkout
     end
 
-    let(:subscriber) { EventSubscriber.new }
+    let(:subscriber) { Mrss::EventSubscriber.new }
 
     let(:client) do
       authorized_client.tap do |client|

data/spec/mongo/session_transaction_spec.rb

@@ -117,25 +117,15 @@ describe Mongo::Session do
       max_example_run_time 7
 
       it 'times out' do
-        warp = Mongo::Utils.monotonic_time + 200
-        entered = false
+        start = Mongo::Utils.monotonic_time
 
-        Thread.new do
-          until entered
-            sleep 0.1
-          end
-          allow(Mongo::Utils).to receive(:monotonic_time).and_return(warp)
-        end
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 1)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 2)
+        expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 200)
 
         expect do
           session.with_transaction do
-            entered = true
-
-            # This sleep is to give the interrupting thread a chance to run,
-            # it significantly affects how much time is burned in this
-            # looping thread
-            sleep 0.1
-
             exc = Mongo::Error::OperationFailure.new('timeout test')
             exc.add_label('TransientTransactionError')
             raise exc
@@ -148,21 +138,23 @@ describe Mongo::Session do
       context "timeout with commit raising with #{label}" do
         max_example_run_time 7
 
+        # JRuby seems to burn through the monotonic time expectations
+        # very quickly and the retries of the transaction get the original
+        # time which causes the transaction to be stuck there.
+        fails_on_jruby
+
         before do
           # create collection if it does not exist
           collection.insert_one(a: 1)
         end
 
-        it 'times out' do
-          warp = Mongo::Utils.monotonic_time + 200
-          entered = false
+        it 'times out', retry: 3 do
+          start = Mongo::Utils.monotonic_time
 
-          Thread.new do
-            until entered
-              sleep 0.1
-            end
-            allow(Mongo::Utils).to receive(:monotonic_time).and_return(warp)
+          10.times do |i|
+            expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + i)
           end
+          expect(Mongo::Utils).to receive(:monotonic_time).ordered.and_return(start + 200)
 
           exc = Mongo::Error::OperationFailure.new('timeout test')
           exc.add_label(label)
@@ -171,13 +163,6 @@ describe Mongo::Session do
 
           expect do
             session.with_transaction do
-              entered = true
-
-              # This sleep is to give the interrupting thread a chance to run,
-              # it significantly affects how much time is burned in this
-              # looping thread
-              sleep 0.1
-
               collection.insert_one(a: 2)
             end
           end.to raise_error(Mongo::Error::OperationFailure, 'timeout test')

data/spec/mongo/socket/unix_spec.rb

@@ -4,6 +4,7 @@
 require 'spec_helper'
 
 describe Mongo::Socket::Unix do
+  require_unix_socket
 
   let(:path) { "/tmp/mongodb-#{SpecConfig.instance.any_port}.sock" }
 

data/spec/mongo/uri_option_parsing_spec.rb

@@ -267,19 +267,52 @@ describe Mongo::URI do
 
   context 'connect' do
 
-    let(:string) { 'mongodb://example.com/?connect=sharded' }
+    let(:client) { new_local_client_nmio(string) }
 
-    it_behaves_like 'parses successfully'
+    shared_examples 'raises an error when client is created' do
+      it 'raises an error when client is created' do
+        lambda do
+          client
+        end.should raise_error(ArgumentError, /Invalid :connect option value/)
+      end
+    end
 
-    it 'is a symbol' do
-      expect(uri.uri_options[:connect]).to eq(:sharded)
+    %i(direct sharded replica_set load_balanced).each do |value|
+      context "#{value}" do
+        let(:string) { "mongodb://example.com/?connect=#{value}" }
+
+        it_behaves_like 'parses successfully'
+
+        it 'is a symbol' do
+          expect(uri.uri_options[:connect]).to eq(value)
+        end
+      end
+    end
+
+    %i(replica-set load-balanced).each do |value|
+      context "#{value}" do
+        let(:string) { "mongodb://example.com/?connect=#{value}" }
+
+        it_behaves_like 'parses successfully'
+
+        it 'is a symbol' do
+          expect(uri.uri_options[:connect]).to eq(value)
+        end
+
+        include_examples 'raises an error when client is created'
+      end
     end
 
     context 'invalid value' do
       let(:string) { 'mongodb://example.com/?connect=bogus' }
 
-      # should raise an error
       it_behaves_like 'parses successfully'
+
+      it 'is a symbol' do
+        expect(uri.uri_options[:connect]).to eq(:bogus)
+      end
+
+      include_examples 'raises an error when client is created'
     end
   end
 

data/spec/runners/change_streams/test.rb

@@ -89,7 +89,7 @@ module Mongo
 
         setup_fail_point(client)
 
-        @subscriber = EventSubscriber.new
+        @subscriber = Mrss::EventSubscriber.new
         client.subscribe(Mongo::Monitoring::COMMAND, @subscriber)
 
         @target = case @target_type

data/spec/runners/cmap.rb

@@ -33,7 +33,7 @@ module Mongo
       # @return [ Mongo::ConnectionPool ] pool The connection pool to use for operations.
       attr_reader :pool
 
-      # @return [ EventSubscriber ] subscriber The subscriber receiving the CMAP events.
+      # @return [ Mrss::EventSubscriber ] subscriber The subscriber receiving the CMAP events.
       attr_reader :subscriber
 
       # Instantiate the new spec.

data/spec/runners/connection_string.rb

@@ -147,10 +147,14 @@ module Mongo
         end
       end
 
-      def options
+      def expected_options
         @spec['options']
       end
 
+      def non_uri_options
+        @spec['parsed_options']
+      end
+
       def client
         @client ||= ClientRegistry.instance.new_local_client(@spec['uri'], monitoring_io: false)
       rescue Mongo::Error::LintError => e
@@ -307,14 +311,14 @@ def define_connection_string_spec_tests(test_paths, spec_cls = Mongo::Connection
               expect(test.client).to match_auth(test)
             end
 
-            if test.options
+            if test.expected_options
               it 'creates a client with the correct options' do
                 mapped = Mongo::URI::OptionsMapper.new.ruby_to_smc(test.client.options)
                 # Connection string spec tests do not use canonical URI option names
                 actual = Utils.downcase_keys(mapped)
                 actual.delete('authsource')
                 expected = Mongo::ConnectionString.adjust_expected_mongo_client_options(
-                  test.options,
+                  test.expected_options,
                 )
                 actual.should == expected
               end

data/spec/runners/crud/operation.rb

@@ -376,9 +376,11 @@ module Mongo
         arguments.merge(arguments['options'] || {}).each do |spec_k, v|
           ruby_k = ::Utils.underscore(spec_k).to_sym
 
-          if v.is_a?(Hash) && v['$numberLong']
-            v = v['$numberLong'].to_i
-          end
+          ruby_k = {
+            min: :min_value,
+            max: :max_value,
+            show_record_id: :show_disk_loc
+          }[ruby_k] || ruby_k
 
           if respond_to?("transform_#{ruby_k}", true)
             v = send("transform_#{ruby_k}", v)

data/spec/runners/crud/requirement.rb

@@ -27,6 +27,7 @@ module Mongo
               'single' => :single,
               'sharded' => :sharded,
               'sharded-replicaset' => :sharded,
+              'load-balanced' => :load_balanced,
             }[topology].tap do |v|
               unless v
                 raise "Unknown topology #{topology}"

data/spec/runners/crud.rb

@@ -96,7 +96,7 @@ def define_crud_spec_test_examples(spec, req = nil, &block)
       end
 
       let(:event_subscriber) do
-        EventSubscriber.new
+        Mrss::EventSubscriber.new
       end
 
       let(:verifier) { Mongo::CRUD::Verifier.new(test) }

data/spec/runners/sdam.rb

@@ -37,6 +37,7 @@ module Mongo
           when 'PossiblePrimary' then server.unknown?
           when 'RSGhost' then server.ghost?
           when 'RSOther' then server.other?
+          when 'LoadBalancer' then server.load_balancer?
           else
             raise "Unknown type #{type}"
         end
@@ -252,7 +253,7 @@ module Mongo
         'server_opening_event' => Mongo::Monitoring::Event::ServerOpening,
         'topology_description_changed_event' => Mongo::Monitoring::Event::TopologyChanged,
         'topology_opening_event' => Mongo::Monitoring::Event::TopologyOpening
-      }
+      }.freeze
 
       attr_reader :name
       attr_reader :data

data/spec/runners/transactions/test.rb

@@ -141,11 +141,11 @@ module Mongo
       end
 
       def command_subscriber
-        @command_subscriber ||= EventSubscriber.new
+        @command_subscriber ||= Mrss::EventSubscriber.new
       end
 
       def sdam_subscriber
-        @sdam_subscriber ||= EventSubscriber.new(name: 'sdam subscriber')
+        @sdam_subscriber ||= Mrss::EventSubscriber.new(name: 'sdam subscriber')
       end
 
       # Run the test.

data/spec/runners/unified/assertions.rb

@@ -4,6 +4,7 @@
 module Unified
 
   module Assertions
+    include RSpec::Matchers
 
     def assert_result_matches(actual, expected)
       if Hash === expected
@@ -86,8 +87,6 @@ module Unified
 
     def assert_document_matches(actual, expected, msg)
       unless actual == expected
-    p actual
-    p expected
         raise Error::ResultMismatch, "#{msg} does not match"
       end
     end
@@ -130,7 +129,7 @@ module Unified
       expected_name = expected_name.sub(/Event$/, '').sub(/^(.)/) { $1.upcase }
       assert_eq(actual.class.name.sub(/.*::/, ''), expected_name, 'Event name does not match')
       if spec.use('hasServiceId')
-        # TODO: RUBY-2654
+        actual.service_id.should_not be nil
       end
       if db_name = spec.use('databaseName')
         assert_eq(actual.database_name, db_name, 'Database names differ')

data/spec/runners/unified/event_subscriber.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
-require 'support/event_subscriber'
+require 'mrss/event_subscriber'
 
 module Unified
 
-  class EventSubscriber < ::EventSubscriber
+  class EventSubscriber < Mrss::EventSubscriber
     def ignore_commands(command_names)
       @ignore_commands = command_names
     end

data/spec/runners/unified/support_operations.rb

@@ -208,12 +208,20 @@ module Unified
             else
               raise
             end
+          rescue Interrupt
+            raise
           rescue => e
-            if store_errors
+            if store_failures
+              STDERR.puts "Error: #{e.class}: #{e} (reporting as failure)"
+              entities.get(:failure_list, store_failures) << {
+                error: "#{e.class}: #{e}",
+                time: Time.now.to_f,
+              }
+            elsif store_errors
               STDERR.puts "Error: #{e.class}: #{e}"
               entities.get(:error_list, store_errors) << {
                 error: "#{e.class}: #{e}",
-                observedAt: Time.now.to_f,
+                time: Time.now.to_f,
               }
             else
               raise

data/spec/runners/unified/test.rb

@@ -165,6 +165,9 @@ module Unified
           database = entities.get(:database, spec.use!('database'))
           # TODO verify
           opts = Utils.snakeize_hash(spec.use('collectionOptions') || {})
+          if opts.key?(:read_preference)
+            opts[:read] = opts.delete(:read_preference)
+          end
           database[spec.use!('collectionName'), opts]
         when 'bucket'
           database = entities.get(:database, spec.use!('database'))

data/spec/runners/unified.rb

@@ -1,12 +1,12 @@
 # frozen_string_literal: true
 # encoding: utf-8
 
+require 'support/using_hash'
 require 'runners/unified/error'
 require 'runners/unified/entity_map'
 require 'runners/unified/event_subscriber'
 require 'runners/unified/test'
 require 'runners/unified/test_group'
-require 'runners/unified/using_hash'
 
 def define_unified_spec_tests(base_path, paths, expect_failure: false)
   paths.each do |path|

data/spec/shared/lib/mrss/cluster_config.rb

@@ -209,7 +209,12 @@ module Mrss
       @server_version = build_info['version']
       @enterprise = build_info['modules'] && build_info['modules'].include?('enterprise')
 
-      @server_parameters = client.use(:admin).command(getParameter: '*').first
+      @server_parameters = begin
+        client.use(:admin).command(getParameter: '*').first
+      rescue => e
+        STDERR.puts("WARNING: Failed to obtain server parameters: #{e.class}: #{e.message}")
+        {}
+      end
 
       if !sharded_ish? && short_server_version >= '3.4'
         rv = @server_parameters['featureCompatibilityVersion']

data/spec/shared/lib/mrss/constraints.rb

@@ -257,10 +257,14 @@ module Mrss
       end
     end
 
-    def require_multi_shard
+    def require_multi_mongos
       before(:all) do
         if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length == 1
-          skip 'Test requires a minimum of two shards if run in sharded topology'
+          skip 'Test requires a minimum of two mongoses if run in sharded topology'
+        end
+
+        if ClusterConfig.instance.topology == :load_balanced && SpecConfig.instance.single_mongos?
+          skip 'Test requires a minimum of two mongoses if run in load-balanced topology'
         end
       end
     end
@@ -273,17 +277,19 @@ module Mrss
     #
     # In load-balanced topology, the same problem can happen when there is
     # more than one mongos behind the load balancer.
-    def require_no_multi_shard
+    def require_no_multi_mongos
       before(:all) do
         if ClusterConfig.instance.topology == :sharded && SpecConfig.instance.addresses.length > 1
-          skip 'Test requires a single shard if run in sharded topology'
+          skip 'Test requires a single mongos if run in sharded topology'
         end
         if ClusterConfig.instance.topology == :load_balanced && !SpecConfig.instance.single_mongos?
-          skip 'Test requires a minimum of two shards if run in sharded topology'
+          skip 'Test requires a single mongos, as indicated by SINGLE_MONGOS=1 environment variable, if run in load-balanced topology'
         end
       end
     end
 
+    alias :require_no_multi_shard :require_no_multi_mongos
+
     def require_wired_tiger
       before(:all) do
         # Storage detection fails for serverless instances. However, it is safe to