mongo 2.17.3 → 2.18.0.beta1

data/spec/mongo/server/connection_spec.rb

@@ -612,6 +612,7 @@ describe Mongo::Server::Connection do
   end
 
   describe '#dispatch' do
+    require_no_required_api_version
 
     let(:server) { monitored_server }
 
@@ -634,50 +635,31 @@ describe Mongo::Server::Connection do
       end
     end
 
-    let(:documents) do
-      [{ 'name' => 'testing' }]
-    end
-
-    let(:insert) do
-      Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
-    end
-
-    let(:query) do
-      Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { 'name' => 'testing' })
+    (0..2).each do |i|
+      let("msg#{i}".to_sym) do
+        Mongo::Protocol::Msg.new(
+          [],
+          {},
+          {ping: 1, :$db => SpecConfig.instance.test_db}
+        )
+      end
     end
 
     context 'when providing a single message' do
 
       let(:reply) do
-        connection.dispatch([ query ], context)
-      end
-
-      before do
-        authorized_collection.delete_many
-        authorized_collection.insert_one(name: 'testing')
+        connection.dispatch([ msg0 ], context)
       end
 
       it 'it dispatches the message to the socket' do
-        expect(reply.documents.first['name']).to eq('testing')
+        expect(reply.payload['reply']['ok']).to eq(1.0)
       end
     end
 
     context 'when providing multiple messages' do
 
-      let(:selector) do
-        { :getlasterror => 1 }
-      end
-
-      let(:command) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, '$cmd', selector, :limit => -1)
-      end
-
       let(:reply) do
-        connection.dispatch([ insert, command ], context)
-      end
-
-      before do
-        authorized_collection.delete_many
+        connection.dispatch([ msg0, msg1 ], context)
       end
 
       it 'raises ArgumentError' do
@@ -689,43 +671,23 @@ describe Mongo::Server::Connection do
 
     context 'when the response_to does not match the request_id' do
 
-      let(:documents) do
-        [{ 'name' => 'bob' }, { 'name' => 'alice' }]
-      end
-
-      let(:insert) do
-        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
-      end
-
-      let(:query_bob) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'bob' })
-      end
-
-      let(:query_alice) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'alice' })
-      end
-
       before do
-        authorized_collection.delete_many
-      end
-
-      before do
-        connection.dispatch([ insert ], context)
+        connection.dispatch([ msg0 ], context)
         # Fake a query for which we did not read the response. See RUBY-1117
-        allow(query_bob).to receive(:replyable?) { false }
-        connection.dispatch([ query_bob ], context)
+        allow(msg1).to receive(:replyable?) { false }
+        connection.dispatch([ msg1 ], context)
       end
 
       it 'raises an UnexpectedResponse error' do
         expect {
-          connection.dispatch([ query_alice ], context)
+          connection.dispatch([ msg0 ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse,
           /Got response for request ID \d+ but expected response for request ID \d+/)
       end
 
       it 'marks connection perished' do
         expect {
-          connection.dispatch([ query_alice ], context)
+          connection.dispatch([ msg0 ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
         connection.should be_error
@@ -733,11 +695,11 @@ describe Mongo::Server::Connection do
 
       it 'makes the connection no longer usable' do
         expect {
-          connection.dispatch([ query_alice ], context)
+          connection.dispatch([ msg0 ], context)
         }.to raise_error(Mongo::Error::UnexpectedResponse)
 
         expect {
-          connection.dispatch([ query_alice ], context)
+          connection.dispatch([ msg0 ], context)
         }.to raise_error(Mongo::Error::ConnectionPerished)
       end
     end
@@ -745,92 +707,47 @@ describe Mongo::Server::Connection do
     context 'when a request is interrupted (Thread.kill)' do
       require_no_required_api_version
 
-      let(:documents) do
-        [{ 'name' => 'bob' }, { 'name' => 'alice' }]
-      end
-
-      let(:insert) do
-        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
-      end
-
-      let(:query_bob) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'bob' })
-      end
-
-      let(:query_alice) do
-        Mongo::Protocol::Query.new(SpecConfig.instance.test_db, TEST_COLL, { name: 'alice' })
-      end
-
       before do
         authorized_collection.delete_many
-        connection.dispatch([ insert ], context)
+        connection.dispatch([ msg0 ], context)
       end
 
       it 'closes the socket and does not use it for subsequent requests' do
         t = Thread.new {
           # Kill the thread just before the reply is read
           allow(Mongo::Protocol::Reply).to receive(:deserialize_header) { t.kill && !t.alive? }
-          connection.dispatch([ query_bob ], context)
+          connection.dispatch([ msg1 ], context)
         }
         t.join
         allow(Mongo::Protocol::Message).to receive(:deserialize_header).and_call_original
-        resp = connection.dispatch([ query_alice ], context)
-        expect(resp.documents.first['name']).to eq('alice')
+        resp = connection.dispatch([ msg2 ], context)
+        expect(resp.payload['reply']['ok']).to eq(1.0)
       end
     end
 
     context 'when the message exceeds the max size' do
+      require_no_linting
 
-      context 'when the message is an insert' do
-
-        before do
-          allow(connection).to receive(:max_message_size).and_return(200)
-        end
-
-        let(:documents) do
-          [{ 'name' => 'testing' } ] * 10
-        end
-
-        let(:reply) do
-          connection.dispatch([ insert ], context)
-        end
-
-        it 'checks the size against the max message size' do
-          expect {
-            reply
-          }.to raise_exception(Mongo::Error::MaxMessageSize)
-        end
+      let(:command) do
+        Mongo::Protocol::Msg.new(
+          [],
+          {},
+          {ping: 1, padding: 'x'*16384, :$db => SpecConfig.instance.test_db}
+        )
       end
 
-      context 'when the message is a command' do
-        # Server description is frozen when linting is enabled, which is
-        # incompatible with expectations set on it in this test
-        require_no_linting
-
-        let(:selector) do
-          # The driver allows up to 16KiB for command overhead on top of
-          # the max bson object size reported by the server.
-          # Add that much padding.
-          { :getlasterror => '1', 'padding' => 'x'*16384 }
-        end
-
-        let(:command) do
-          Mongo::Protocol::Query.new(SpecConfig.instance.test_db, '$cmd', selector, :limit => -1)
-        end
-
-        let(:reply) do
-          connection.dispatch([ command ], context)
-        end
+      let(:reply) do
+        connection.dispatch([ command ], context)
+      end
 
-        it 'checks the size against the max bson size' do
-          # 100 works for non-x509 auth.
-          # 10 is needed for x509 auth due to smaller payloads, apparently.
-          expect_any_instance_of(Mongo::Server::Description).to receive(
-            :max_bson_object_size).at_least(:once).and_return(10)
-          expect do
-            reply
-          end.to raise_exception(Mongo::Error::MaxBSONSize)
-        end
+      it 'checks the size against the max bson size' do
+        # 100 works for non-x509 auth.
+        # 10 is needed for x509 auth due to smaller payloads, apparently.
+        expect_any_instance_of(Mongo::Server::Description).to receive(
+          :max_bson_object_size).at_least(:once).and_return(10)
+        expect do
+          reply
+        end.to raise_exception(Mongo::Error::MaxBSONSize)
       end
     end
 
@@ -861,7 +778,7 @@ describe Mongo::Server::Connection do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ], context)
+            connection.dispatch([ msg0 ], context)
           end.to raise_error(Mongo::Error::SocketError)
         end
 
@@ -874,10 +791,12 @@ describe Mongo::Server::Connection do
           require_topology :load_balanced
 
           it 'disconnects connection pool for service id' do
-            connection.service_id.should_not be nil
+            connection.global_id.should_not be nil
 
             RSpec::Mocks.with_temporary_scope do
-              expect(server.pool).to receive(:disconnect!).with(service_id: connection.service_id)
+              expect(server.pool).to receive(:disconnect!).with(
+                service_id: connection.service_id
+              )
               result
             end
           end
@@ -918,7 +837,7 @@ describe Mongo::Server::Connection do
 
         let(:result) do
           expect do
-            connection.dispatch([ insert ], context)
+            connection.dispatch([ msg0 ], context)
           end.to raise_error(Mongo::Error::SocketTimeoutError)
         end
 
@@ -991,20 +910,16 @@ describe Mongo::Server::Connection do
           end
         end
 
-        let(:message) do
-          insert
-        end
-
         before do
-          expect(message).to receive(:replyable?) { false }
-          connection.send(:deliver, message, context)
+          expect(msg0).to receive(:replyable?) { false }
+          connection.send(:deliver, msg0, context)
 
           connection.send(:socket).instance_variable_set(:@timeout, -(Time.now.to_i))
         end
 
         let(:reply) do
           Mongo::Protocol::Message.deserialize(connection.send(:socket),
-            16*1024*1024, message.request_id)
+            16*1024*1024, msg0.request_id)
         end
 
         it 'raises a timeout error' do
@@ -1014,30 +929,6 @@ describe Mongo::Server::Connection do
         end
       end
     end
-
-=begin this is now handled by connection pool
-    context 'when the process is forked' do
-
-      let(:insert) do
-        Mongo::Protocol::Insert.new(SpecConfig.instance.test_db, TEST_COLL, documents)
-      end
-
-      before do
-        authorized_collection.delete_many
-        expect(Process).to receive(:pid).at_least(:once).and_return(1)
-      end
-
-      it 'disconnects the connection' do
-        expect(connection).to receive(:disconnect!).and_call_original
-        connection.dispatch([ insert ])
-      end
-
-      it 'sets a new pid' do
-        connection.dispatch([ insert ])
-        expect(connection.send(:pid)).to eq(1)
-      end
-    end
-=end
   end
 
   describe '#initialize' do

data/spec/mongo/server/description/features_spec.rb

@@ -247,4 +247,28 @@ describe Mongo::Server::Description::Features do
       end
     end
   end
+
+  describe '#get_more_comment_enabled?' do
+    context 'when the wire range includes 9' do
+
+      let(:wire_versions) do
+        0..9
+      end
+
+      it 'returns true' do
+        expect(features).to be_get_more_comment_enabled
+      end
+    end
+
+    context 'when the wire range does not include 9' do
+
+      let(:wire_versions) do
+        0..8
+      end
+
+      it 'returns false' do
+        expect(features).to_not be_get_more_comment_enabled
+      end
+    end
+  end
 end

data/spec/mongo/server/push_monitor_spec.rb

@@ -77,7 +77,7 @@ describe Mongo::Server::PushMonitor do
         end.should_not raise_error
       end
 
-      it 'throttles checks' do
+      it 'stops the monitoring' do
         push_monitor
 
         start = Mongo::Utils.monotonic_time
@@ -87,13 +87,7 @@ describe Mongo::Server::PushMonitor 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
+        push_monitor.running?.should be false
       end
     end
   end

data/spec/mongo/session_spec.rb

@@ -268,6 +268,21 @@ describe Mongo::Session do
         end.to raise_error(Mongo::Error::SessionEnded)
       end
     end
+
+    context "when the sesion is not materialized" do
+      let(:session) { authorized_client.get_session(implicit: true) }
+
+      before do
+        expect(session.materialized?).to be false
+      end
+
+      it "raises SessionNotMaterialized" do
+
+        expect do
+          session.session_id
+        end.to raise_error(Mongo::Error::SessionNotMaterialized)
+      end
+    end
   end
 
   describe '#txn_num' do
@@ -312,12 +327,12 @@ describe Mongo::Session do
   end
 
   describe '#start_session' do
-    context 'when block doesn\'t raise an error' do 
-      it 'closes the session after the block' do 
+    context 'when block doesn\'t raise an error' do
+      it 'closes the session after the block' do
         block_session = nil
-        authorized_client.start_session do |session| 
+        authorized_client.start_session do |session|
           expect(session.ended?).to be false
-          block_session = session 
+          block_session = session
         end
         expect(block_session.ended?).to be true
       end
@@ -326,7 +341,7 @@ describe Mongo::Session do
     context 'when block raises an error' do
       it 'closes the session after the block' do
         block_session = nil
-        expect do 
+        expect do
           authorized_client.start_session do |session|
             block_session = session
             raise 'This is an error!'
@@ -338,11 +353,16 @@ describe Mongo::Session do
 
     context 'when block returns value' do
       it 'is returned by the function' do
-        res = authorized_client.start_session do |session| 
+        res = authorized_client.start_session do |session|
           4
         end
         expect(res).to be 4
       end
     end
+
+    it 'returns a session with session id' do
+      session = authorized_client.start_session
+      session.session_id.should be_a(BSON::Document)
+    end
   end
 end

data/spec/mongo/session_transaction_spec.rb

@@ -148,7 +148,8 @@ describe Mongo::Session do
           collection.insert_one(a: 1)
         end
 
-        it 'times out', retry: 3 do
+        retry_test
+        it 'times out' do
           start = Mongo::Utils.monotonic_time
 
           10.times do |i|

data/spec/mongo/socket/ssl_spec.rb

@@ -5,7 +5,8 @@ require 'spec_helper'
 
 # this test performs direct network connections without retries.
 # In case of intermittent network issues, retry the entire failing test.
-describe Mongo::Socket::SSL, retry: 3 do
+describe Mongo::Socket::SSL do
+  retry_test
   clean_slate_for_all
   require_tls
 
@@ -332,7 +333,12 @@ describe Mongo::Socket::SSL, retry: 3 do
             OpenSSL::OpenSSLError
           end
         else
-          NoMethodError
+          # MRI
+          if RUBY_VERSION >= '3.1.0'
+            TypeError
+          else
+            NoMethodError
+          end
         end
       end
 
@@ -359,8 +365,13 @@ describe Mongo::Socket::SSL, retry: 3 do
         context 'when a bad certificate is provided' do
 
           let(:expected_exception) do
-            # OpenSSL::X509::CertificateError: nested asn1 error
-            [OpenSSL::OpenSSLError, /asn1 error/i]
+            if RUBY_VERSION >= '3.1.0'
+              # OpenSSL::X509::CertificateError: PEM_read_bio_X509: no start line
+              OpenSSL::X509::CertificateError
+            else
+              # OpenSSL::X509::CertificateError: nested asn1 error
+              [OpenSSL::OpenSSLError, /asn1 error/i]
+            end
           end
 
           let(:ssl_options) do

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -6,6 +6,7 @@ require 'lite_spec_helper'
 describe Mongo::URI::SRVProtocol do
   require_external_connectivity
   clean_slate_for_all_if_possible
+  retry_test
 
   let(:scheme) { 'mongodb+srv://' }
   let(:uri) { described_class.new(string) }
@@ -263,15 +264,68 @@ describe Mongo::URI::SRVProtocol do
     end
 
     describe '#servers' do
-      let(:string) { "#{scheme}#{servers}" }
+      let(:string) { "#{scheme}#{servers}#{options}" }
+      let(:servers) { 'test1.test.build.10gen.cc' }
+      let(:options) { '' }
 
       context 'single server' do
         let(:servers) { 'test5.test.build.10gen.cc' }
-
         it 'returns an array with the parsed server' do
           expect(uri.servers).to eq(['localhost.test.build.10gen.cc:27017'])
         end
       end
+
+      context 'multiple servers' do
+        let(:hosts) { ['localhost.test.build.10gen.cc:27017', 'localhost.test.build.10gen.cc:27018'] }
+
+        context 'without srvMaxHosts' do
+          it 'returns an array with the parsed servers' do
+            expect(uri.servers.length).to eq 2
+            uri.servers.should =~ hosts
+          end
+        end
+
+        context 'with srvMaxHosts' do
+          let(:options) { '/?srvMaxHosts=1' }
+          it 'returns an array with only one of the parsed servers' do
+            expect(uri.servers.length).to eq 1
+            expect(hosts.include?(uri.servers.first)).to be true
+          end
+        end
+
+        context 'with srvMaxHosts > total hosts' do
+          let(:options) { '/?srvMaxHosts=3' }
+          it 'returns an array with only one of the parsed servers' do
+            expect(uri.servers.length).to eq 2
+            uri.servers.should =~ hosts
+          end
+        end
+
+        context 'with srvMaxHosts == total hosts' do
+          let(:options) { '/?srvMaxHosts=2' }
+          it 'returns an array with only one of the parsed servers' do
+            expect(uri.servers.length).to eq 2
+            uri.servers.should =~ hosts
+          end
+        end
+
+        context 'with srvMaxHosts=0' do
+          let(:options) { '/?srvMaxHosts=0' }
+          it 'returns an array with only one of the parsed servers' do
+            expect(uri.servers.length).to eq 2
+            uri.servers.should =~ hosts
+          end
+        end
+
+        context 'when setting the srvServiceName' do
+          let(:servers) { 'test22.test.build.10gen.cc' }
+          let(:options) { '/?srvServiceName=customname' }
+
+          it 'returns an array with the parsed server' do
+            uri.servers.should =~ hosts
+          end
+        end
+      end
     end
 
     describe '#client_options' do
@@ -894,6 +948,51 @@ describe Mongo::URI::SRVProtocol do
         end
       end
 
+      context 'when providing srvMaxHosts' do
+        let(:srv_max_hosts) { 1 }
+        let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+        it 'sets the srv max hosts option' do
+          expect(uri.uri_options[:srv_max_hosts]).to eq(srv_max_hosts)
+        end
+      end
+
+      context 'when providing srvMaxHosts as 0' do
+        let(:srv_max_hosts) { 0 }
+        let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+        it 'doesn\'t set the srv max hosts option' do
+          expect(uri.uri_options[:srv_max_hosts]).to eq(srv_max_hosts)
+        end
+      end
+
+      context 'when providing invalid integer to srvMaxHosts' do
+        let(:srv_max_hosts) { -1 }
+        let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+        it 'does not set the srv max hosts option' do
+          expect(uri.uri_options).to_not have_key(:srv_max_hosts)
+        end
+      end
+
+      context 'when providing invalid type to srvMaxHosts' do
+        let(:srv_max_hosts) { "foo" }
+        let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+        it 'does not set the srv max hosts option' do
+          expect(uri.uri_options).to_not have_key(:srv_max_hosts)
+        end
+      end
+
+      context 'when providing srvServiceName' do
+        let(:srv_service_name) { "mongodb" }
+        let(:options) { "srvServiceName=#{srv_service_name}" }
+
+        it 'sets the srv service name option' do
+          expect(uri.uri_options[:srv_service_name]).to eq(srv_service_name)
+        end
+      end
+
       context 'ssl' do
         let(:options) { "ssl=#{ssl}" }
 

data/spec/mongo/uri_spec.rb

@@ -1178,6 +1178,31 @@ describe Mongo::URI do
       end
     end
 
+    context 'when providing srvMaxHosts with non-SRV URI' do
+
+      let(:srv_max_hosts) { 5 }
+      let(:options) { "srvMaxHosts=#{srv_max_hosts}" }
+
+      it 'raises an error' do
+        lambda do
+          uri
+        end.should raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'when providing srvServiceName with non-SRV URI' do
+
+      let(:scheme) { "mongodb+srv://" }
+      let(:srv_service_name) { "customname" }
+      let(:options) { "srvServiceName=#{srv_service_name}" }
+
+      it 'raises an error' do
+        lambda do
+          uri
+        end.should raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
     context 'when providing waitQueueTimeoutMS' do
 
       let(:wait_queue_timeout) { 500 }

data/spec/runners/connection_string.rb

@@ -182,6 +182,14 @@ module Mongo
       def write_concern_expectation
         @spec['writeConcern']
       end
+
+      def num_seeds
+        @spec['numSeeds']
+      end
+
+      def num_hosts
+        @spec['numHosts']
+      end
     end
 
     class Host