mongo 2.15.0 → 2.17.0

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/ssl_spec.rb

@@ -306,67 +306,40 @@ describe Mongo::Socket::SSL, retry: 3 do
       end
     end
 
-    context 'when ruby version is < 2.4.1' do
-      ruby_version_lt '2.4.1'
-
-      context 'when a key is passed, but it is not of the right type' do
-
-        let(:ssl_options) do
-          key = "This is a string not a key"
-          {
-              :ssl => true,
-              :ssl_key_object => key,
-              :ssl_cert => SpecConfig.instance.client_cert_path,
-              :ssl_verify => false
-          }
-        end
-
-        it 'raises a TypeError' do
-          expect do
-            socket
-          end.to raise_exception(TypeError)
-        end
-      end
-    end
-
     # Note that as of MRI 2.4, Creating a socket with the wrong key type raises
     # a NoMethodError because #private? is attempted to be called on the key.
     # In jruby 9.2 a TypeError is raised.
     # In jruby 9.1 a OpenSSL::PKey::PKeyError is raised.
-    context 'when ruby version is >= 2.4.1' do
-      ruby_version_gte '2.4.1'
+    context 'when a key is passed, but it is not of the right type' do
 
-      context 'when a key is passed, but it is not of the right type' do
+      let(:ssl_options) do
+        key = "This is a string not a key"
+        {
+            :ssl => true,
+            :ssl_key_object => key,
+            :ssl_cert => SpecConfig.instance.client_cert_path,
+            :ssl_verify => false
+        }
+      end
 
-        let(:ssl_options) do
-          key = "This is a string not a key"
-          {
-              :ssl => true,
-              :ssl_key_object => key,
-              :ssl_cert => SpecConfig.instance.client_cert_path,
-              :ssl_verify => false
-          }
-        end
-
-        let(:expected_exception) do
-          if SpecConfig.instance.jruby?
-            if RUBY_VERSION >= '2.5.0'
-              # jruby 9.2
-              TypeError
-            else
-              # jruby 9.1
-              OpenSSL::OpenSSLError
-            end
+      let(:expected_exception) do
+        if SpecConfig.instance.jruby?
+          if RUBY_VERSION >= '2.5.0'
+            # jruby 9.2
+            TypeError
           else
-            NoMethodError
+            # jruby 9.1
+            OpenSSL::OpenSSLError
           end
+        else
+          NoMethodError
         end
+      end
 
-        it 'raises a NoMethodError' do
-          expect do
-            socket
-          end.to raise_exception(expected_exception)
-        end
+      it 'raises a NoMethodError' do
+        expect do
+          socket
+        end.to raise_exception(expected_exception)
       end
     end
 
@@ -403,13 +376,8 @@ describe Mongo::Socket::SSL, retry: 3 do
         context 'when a bad key is provided' do
 
           let(:expected_exception) do
-            if RUBY_VERSION >= '2.4.0'
-              # OpenSSL::PKey::PKeyError: Could not parse PKey: no start line
-              [OpenSSL::OpenSSLError, /Could not parse PKey/]
-            else
-              # ArgumentError: Could not parse PKey: no start line
-              [ArgumentError, /Could not parse PKey/]
-            end
+            # OpenSSL::PKey::PKeyError: Could not parse PKey: no start line
+            [OpenSSL::OpenSSLError, /Could not parse PKey/]
           end
 
           let(:ssl_options) do

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/mongo/utils_spec.rb

@@ -39,18 +39,4 @@ describe Mongo::Utils do
       }
     end
   end
-
-  describe '#slice_hash' do
-    it do
-      hash = {'key1' => 1, :key2 => 's', :key3 => true}
-      expect(
-        described_class.slice_hash(hash, 'key1', :key3)
-      ).to eq(
-        {
-          'key1' => 1,
-          :key3 => true
-        }
-      )
-    end
-  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/verifier.rb

@@ -110,8 +110,7 @@ EOT
         expected_command = expected_event.delete('command')
         actual_command = actual_event.delete('command')
 
-        # Hash#compact is ruby 2.4+
-        expected_presence = expected_command.select { |k, v| !v.nil? }
+        expected_presence = expected_command.compact
         expected_absence = expected_command.select { |k, v| v.nil? }
 
         expected_presence.each do |k, v|

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
@@ -61,7 +62,7 @@ module Unified
     def assert_outcome
       return unless outcome
 
-      client = ClientRegistry.instance.global_client('authorized')
+      client = ClientRegistry.instance.global_client('root_authorized')
       outcome.each do |spec|
         spec = UsingHash[spec]
         collection = client.use(spec.use!('databaseName'))[spec.use!('collectionName')]
@@ -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')
@@ -218,6 +217,8 @@ module Unified
         BSON::ObjectId === object
       when 'date'
         Time === object
+      when 'double'
+        Float === object
       else
         raise NotImplementedError, "Unhandled type #{type}"
       end