mongo 2.9.2 → 2.10.0.rc0

data/spec/mongo/server/monitor/connection_spec.rb

@@ -1,14 +1,7 @@
 require 'spec_helper'
 
 describe Mongo::Server::Monitor::Connection do
-
-  before do
-    ClientRegistry.instance.close_all_clients
-  end
-
-  let(:client) do
-    authorized_client.with(options)
-  end
+  clean_slate
 
   let(:address) do
     Mongo::Address.new(ClusterConfig.instance.primary_address, options)
@@ -19,7 +12,7 @@ describe Mongo::Server::Monitor::Connection do
   let(:cluster) do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
-      allow(cl).to receive(:app_metadata).and_return(Mongo::Server::Monitor::AppMetadata.new(authorized_client.cluster.options))
+      allow(cl).to receive(:app_metadata).and_return(Mongo::Server::Monitor::AppMetadata.new({}))
       allow(cl).to receive(:options).and_return({})
     end
   end
@@ -147,6 +140,16 @@ describe Mongo::Server::Monitor::Connection do
         connection.ismaster
       end
 
+      before do
+        # Since we set expectations on the connection, kill the
+        # background thread (but without disconnecting the connection).
+        # Note also that we need to have the connection connected in
+        # the first place, thus the scan! call here.
+        monitor.scan!
+        monitor.instance_variable_get('@thread').kill
+        monitor.instance_variable_get('@thread').join
+      end
+
       it 'retries ismaster and is successful' do
         expect(result).to be_a(Hash)
         expect(result['ok']).to eq(1.0)
@@ -154,7 +157,7 @@ describe Mongo::Server::Monitor::Connection do
 
       it 'logs the retry' do
         expect(Mongo::Logger.logger).to receive(:warn) do |msg|
-          expect(msg).to match(/Retrying ismaster on #{connection.address}/)
+          expect(msg).to match(/Retrying ismaster in monitor for #{connection.address}/)
         end
         expect(result).to be_a(Hash)
       end

data/spec/mongo/server_selector_spec.rb

@@ -341,7 +341,7 @@ describe Mongo::ServerSelector do
         Mongo::Error::UnsupportedFeatures.new('Test UnsupportedFeatures')
       end
 
-      let(:selector) { described_class.get(mode: :primary) }
+      let(:selector) { described_class.primary }
 
       it 'raises Error::UnsupportedFeatures' do
         expect(topology).to receive(:compatible?).and_return(false)
@@ -351,6 +351,38 @@ describe Mongo::ServerSelector do
         end.to raise_error(Mongo::Error::UnsupportedFeatures, 'Test UnsupportedFeatures')
       end
     end
+
+    context 'sharded topology' do
+
+      let(:cluster) do
+        double('cluster').tap do |c|
+          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(:servers).and_return(servers)
+          allow(c).to receive(:addresses).and_return(servers.map(&:address))
+          allow(c).to receive(:replica_set?).and_return(false)
+          allow(c).to receive(:single?).and_return(false)
+          allow(c).to receive(:sharded?).and_return(true)
+          allow(c).to receive(:unknown?).and_return(false)
+          allow(c).to receive(:scan!)
+          allow(c).to receive(:options).and_return(local_threshold: 0.050)
+          allow(topology).to receive(:compatible?).and_return(true)
+          allow(topology).to receive(:single?).and_return(false)
+        end
+      end
+
+      context 'unknown and mongos' do
+        let(:mongos) { make_server(:mongos, address: Mongo::Address.new('localhost')) }
+        let(:unknown) { make_server(:unknown, address: Mongo::Address.new('localhost')) }
+        let(:servers) { [unknown, mongos] }
+        let(:selector) { described_class.primary }
+
+        it 'returns the mongos' do
+          expect(selector.select_server(cluster)).to eq(mongos)
+        end
+      end
+    end
   end
 
   shared_context 'a ServerSelector' do
@@ -378,7 +410,7 @@ describe Mongo::ServerSelector do
       end
 
       let(:read_pref) do
-        described_class.get(mode: :primary)
+        described_class.primary
       end
 
       it 'raises a NoServerAvailable error' do

data/spec/mongo/session/session_pool_spec.rb

@@ -3,9 +3,15 @@ require 'spec_helper'
 describe Mongo::Session::SessionPool do
   min_server_fcv '3.6'
   require_topology :replica_set, :sharded
+  clean_slate_for_all
 
   let(:cluster) do
-    authorized_client.cluster
+    authorized_client.cluster.tap do |cluster|
+      # Cluster time assertions can fail if there are background operations
+      # that cause cluster time to be updated. This also necessitates clean
+      # state requirement.
+      authorized_client.close(true)
+    end
   end
 
   describe '.create' do
@@ -156,7 +162,7 @@ describe Mongo::Session::SessionPool do
     end
 
     after do
-      client.close
+      client.close(true)
     end
 
     context 'when the number of ids is not larger than 10,000' do
@@ -185,10 +191,15 @@ describe Mongo::Session::SessionPool do
       context 'when talking to a replica set or mongos' do
 
         it 'sends the endSessions command with all the session ids and cluster time' do
+          start_time = client.cluster.cluster_time
           end_sessions_command
+          end_time = client.cluster.cluster_time
           expect(end_sessions_command.command[:endSessions]).to include(BSON::Document.new(session_a.session_id))
           expect(end_sessions_command.command[:endSessions]).to include(BSON::Document.new(session_b.session_id))
-          expect(end_sessions_command.command[:$clusterTime]).to eq(client.cluster.cluster_time)
+          # cluster time may have been advanced due to background operations
+          actual_cluster_time = Mongo::ClusterTime.new(end_sessions_command.command[:$clusterTime])
+          expect(actual_cluster_time).to be >= start_time
+          expect(actual_cluster_time).to be <= end_time
         end
       end
     end

data/spec/mongo/session_spec.rb

@@ -80,7 +80,7 @@ describe Mongo::Session do
       context 'when the original cluster time is less than the new cluster time' do
 
         let(:original_cluster_time) do
-          { 'clusterTime' => BSON::Timestamp.new(0, 1) }
+          Mongo::ClusterTime.new('clusterTime' => BSON::Timestamp.new(0, 1))
         end
 
         before do
@@ -96,7 +96,7 @@ describe Mongo::Session do
       context 'when the original cluster time is equal or greater than the new cluster time' do
 
         let(:original_cluster_time) do
-          { 'clusterTime' => BSON::Timestamp.new(0, 6) }
+          Mongo::ClusterTime.new('clusterTime' => BSON::Timestamp.new(0, 6))
         end
 
         before do
@@ -232,7 +232,7 @@ describe Mongo::Session do
       end
 
       after do
-        client.close
+        client.close(true)
       end
 
       it 'returns false' do

data/spec/mongo/session_transaction_spec.rb

@@ -3,6 +3,7 @@ require 'spec_helper'
 class SessionTransactionSpecError < StandardError; end
 
 describe Mongo::Session do
+  require_wired_tiger
   min_server_fcv '4.0'
   require_topology :replica_set, :sharded
 
@@ -137,14 +138,14 @@ describe Mongo::Session do
             sleep 0.1
 
             exc = Mongo::Error::OperationFailure.new('timeout test')
-            exc.send(:add_label, Mongo::Error::TRANSIENT_TRANSACTION_ERROR_LABEL)
+            exc.add_label('TransientTransactionError')
             raise exc
           end
         end.to raise_error(Mongo::Error::OperationFailure, 'timeout test')
       end
     end
 
-    %w(UNKNOWN_TRANSACTION_COMMIT_RESULT_LABEL TRANSIENT_TRANSACTION_ERROR_LABEL).each do |label|
+    %w(UnknownTransactionCommitResult TransientTransactionError).each do |label|
       context "timeout with commit raising with #{label}" do
         max_example_run_time 7
 
@@ -169,7 +170,7 @@ describe Mongo::Session do
           end
 
           exc = Mongo::Error::OperationFailure.new('timeout test')
-          exc.send(:add_label, Mongo::Error.const_get(label))
+          exc.add_label(label)
 
           expect(session).to receive(:commit_transaction).and_raise(exc).at_least(:once)
 

data/spec/mongo/socket/ssl_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
-describe Mongo::Socket::SSL do
+# 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
   require_tls
 
   let(:address) do
@@ -478,7 +480,7 @@ describe Mongo::Socket::SSL do
       end
 
       let(:connection) do
-        Mongo::Server::Connection.new(server, options)
+        Mongo::Server::Connection.new(server, options.merge(socket_timeout: 2))
       end
 
       context 'as a file' do
@@ -509,7 +511,7 @@ describe Mongo::Socket::SSL do
       end
 
       let(:connection) do
-        Mongo::Server::Connection.new(server, options)
+        Mongo::Server::Connection.new(server, options.merge(socket_timeout: 2))
       end
 
       context 'as a file' do
@@ -564,7 +566,7 @@ describe Mongo::Socket::SSL do
       end
 
       let(:connection) do
-        Mongo::Server::Connection.new(server, options)
+        Mongo::Server::Connection.new(server, options.merge(socket_timeout: 2))
       end
 
       context 'as a path to a file' do
@@ -666,7 +668,7 @@ describe Mongo::Socket::SSL do
       end
 
       let(:connection) do
-        Mongo::Server::Connection.new(server, options)
+        Mongo::Server::Connection.new(server, options.merge(socket_timeout: 2))
       end
 
       let(:options) do
@@ -729,6 +731,18 @@ describe Mongo::Socket::SSL do
         expect(socket).to be_alive
       end
     end
+
+    context 'when OpenSSL allows disabling renegotiation 'do
+      before do
+        unless OpenSSL::SSL.const_defined?(:OP_NO_RENEGOTIATION)
+          skip 'OpenSSL::SSL::OP_NO_RENEGOTIATION is not defined'
+        end
+      end
+
+      it 'disables TLS renegotiation' do
+        expect(socket.context.options & OpenSSL::SSL::OP_NO_RENEGOTIATION).to eq(OpenSSL::SSL::OP_NO_RENEGOTIATION)
+      end
+    end
   end
 
   describe '#readbyte' do

data/spec/mongo/socket_spec.rb

@@ -1,4 +1,4 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
 describe Mongo::Socket do
 
@@ -51,65 +51,4 @@ describe Mongo::Socket do
       end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address) (MongoDB may not be configured with SSL support)')
     end
   end
-
-  describe '#read' do
-    let(:target_host) do
-      host = ClusterConfig.instance.primary_address_host
-      # Take ipv4 address
-      Socket.getaddrinfo(host, 0).detect { |ai| ai.first == 'AF_INET' }[3]
-    end
-
-    let(:socket) do
-      Mongo::Socket::TCP.new(target_host, ClusterConfig.instance.primary_address_port, 1, Socket::PF_INET)
-    end
-
-    let(:raw_socket) { socket.instance_variable_get('@socket') }
-
-    let(:wait_readable_class) do
-      Class.new(Exception) do
-        include IO::WaitReadable
-      end
-    end
-
-    context 'timeout' do
-
-      shared_examples_for 'times out' do
-        it 'times out' do
-          expect(socket).to receive(:timeout).at_least(:once).and_return(0.2)
-          # When we raise WaitWritable, the socket object is ready for
-          # writing which makes the read method invoke read_nonblock many times
-          expect(raw_socket).to receive(:read_nonblock).at_least(:once) do |len, buf|
-            sleep 0.01
-            raise exception_class
-          end
-
-          expect do
-            socket.read(10)
-          end.to raise_error(Mongo::Error::SocketTimeoutError, /Took more than .* seconds to receive data \(for /)
-        end
-      end
-
-      context 'with WaitReadable' do
-
-        let(:exception_class) do
-          Class.new(Exception) do
-            include IO::WaitReadable
-          end
-        end
-
-        it_behaves_like 'times out'
-      end
-
-      context 'with WaitWritable' do
-
-        let(:exception_class) do
-          Class.new(Exception) do
-            include IO::WaitWritable
-          end
-        end
-
-        it_behaves_like 'times out'
-      end
-    end
-  end
 end

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -1,19 +1,13 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
 describe Mongo::URI::SRVProtocol do
+  clean_slate_for_all
 
   let(:scheme) { 'mongodb+srv://' }
   let(:uri) { described_class.new(string) }
 
-  before(:all) do
-    # Since these tests assert on warnings being produced,
-    # close clients to ensure background threads do not interfere with
-    # their warnings.
-    ClientRegistry.instance.close_all_clients
-  end
-
   let(:client) do
-    new_local_client(string, monitoring_io: false)
+    new_local_client_nmio(string)
   end
 
   describe 'invalid uris' do
@@ -364,11 +358,11 @@ describe Mongo::URI::SRVProtocol do
           let(:concern) { Mongo::Options::Redacted.new(:w => 1)}
 
           it 'sets the write concern options' do
-            expect(uri.uri_options[:write]).to eq(concern)
+            expect(uri.uri_options[:write_concern]).to eq(concern)
           end
 
           it 'sets the options on a client created with the uri' do
-            expect(client.options[:write]).to eq(concern)
+            expect(client.options[:write_concern]).to eq(concern)
           end
         end
 
@@ -377,11 +371,11 @@ describe Mongo::URI::SRVProtocol do
           let(:concern) { Mongo::Options::Redacted.new(:w => :majority) }
 
           it 'sets the write concern options' do
-            expect(uri.uri_options[:write]).to eq(concern)
+            expect(uri.uri_options[:write_concern]).to eq(concern)
           end
 
           it 'sets the options on a client created with the uri' do
-            expect(client.options[:write]).to eq(concern)
+            expect(client.options[:write_concern]).to eq(concern)
           end
         end
 
@@ -390,11 +384,11 @@ describe Mongo::URI::SRVProtocol do
           let(:concern) { Mongo::Options::Redacted.new(:j => true) }
 
           it 'sets the write concern options' do
-            expect(uri.uri_options[:write]).to eq(concern)
+            expect(uri.uri_options[:write_concern]).to eq(concern)
           end
 
           it 'sets the options on a client created with the uri' do
-            expect(client.options[:write]).to eq(concern)
+            expect(client.options[:write_concern]).to eq(concern)
           end
         end
 
@@ -403,11 +397,11 @@ describe Mongo::URI::SRVProtocol do
           let(:concern) { Mongo::Options::Redacted.new(:fsync => true) }
 
           it 'sets the write concern options' do
-            expect(uri.uri_options[:write]).to eq(concern)
+            expect(uri.uri_options[:write_concern]).to eq(concern)
           end
 
           it 'sets the options on a client created with the uri' do
-            expect(client.options[:write]).to eq(concern)
+            expect(client.options[:write_concern]).to eq(concern)
           end
         end
 
@@ -417,11 +411,11 @@ describe Mongo::URI::SRVProtocol do
           let(:concern) { Mongo::Options::Redacted.new(:w => 2, :wtimeout => timeout) }
 
           it 'sets the write concern options' do
-            expect(uri.uri_options[:write]).to eq(concern)
+            expect(uri.uri_options[:write_concern]).to eq(concern)
           end
 
           it 'sets the options on a client created with the uri' do
-            expect(client.options[:write]).to eq(concern)
+            expect(client.options[:write_concern]).to eq(concern)
           end
         end
       end
@@ -581,7 +575,7 @@ describe Mongo::URI::SRVProtocol do
       end
 
       context 'replica set option provided' do
-        let(:rs_name) { TEST_SET }
+        let(:rs_name) { 'test-rs-name' }
         let(:options) { "replicaSet=#{rs_name}" }
 
         it 'sets the replica set option' do

data/spec/mongo/uri_option_parsing_spec.rb

@@ -129,6 +129,22 @@ describe Mongo::URI do
       expect(uri.uri_options[ruby_option]).to eq('foo')
     end
 
+    context 'it is escaped in URI' do
+      let(:string) { "mongodb://example.com/?#{uri_option}=foo%2f" }
+
+      it 'is unescaped' do
+        expect(uri.uri_options[ruby_option]).to eq('foo/')
+      end
+    end
+
+    context 'it is escaped twice in URI' do
+      let(:string) { "mongodb://example.com/?#{uri_option}=foo%252f" }
+
+      it 'is unescaped once' do
+        expect(uri.uri_options[ruby_option]).to eq('foo%2f')
+      end
+    end
+
     context 'value is a number' do
       let(:string) { "mongodb://example.com/?#{uri_option}=1" }
 
@@ -168,6 +184,17 @@ describe Mongo::URI do
         expect(uri.uri_options[:auth_mech]).to eq(:scram256)
       end
     end
+
+    context 'unrecognized value' do
+
+      let(:string) { 'mongodb://example.com/?authMechanism=foobar' }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is mapped to auth mechanism' do
+        expect(uri.uri_options[:auth_mech]).to eq('foobar')
+      end
+    end
   end
 
   context 'authMechanismProperties' do
@@ -182,6 +209,30 @@ describe Mongo::URI do
         canonicalize_host_name: true,
       ))
     end
+
+    context 'canonicalize host name is false' do
+
+      let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_REALM:foo,CANONICALIZE_HOST_NAME:false' }
+
+      it 'parses correctly' do
+        expect(uri.uri_options[:auth_mech_properties]).to eq(BSON::Document.new(
+          service_realm: 'foo',
+          canonicalize_host_name: false,
+        ))
+      end
+    end
+
+    context 'canonicalize host name is true in mixed case' do
+
+      let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_REALM:foo,CANONICALIZE_HOST_NAME:TrUe' }
+
+      it 'parses correctly' do
+        expect(uri.uri_options[:auth_mech_properties]).to eq(BSON::Document.new(
+          service_realm: 'foo',
+          canonicalize_host_name: true,
+        ))
+      end
+    end
   end
 
   context 'authSource' do
@@ -190,6 +241,22 @@ describe Mongo::URI do
     let(:ruby_option) { :auth_source }
 
     it_behaves_like 'a string option'
+
+    context '$external' do
+      let(:string) { "mongodb://example.com/?#{uri_option}=$external" }
+
+      it 'is converted to ;external' do
+        expect(uri.uri_options[ruby_option]).to eq(:external)
+      end
+    end
+
+    context 'empty' do
+      let(:string) { "mongodb://example.com/?#{uri_option}=" }
+
+      it 'is mapped to the empty string' do
+        expect(uri.uri_options[ruby_option]).to eq('')
+      end
+    end
   end
 
   context 'compressors' do
@@ -236,7 +303,7 @@ describe Mongo::URI do
     it_behaves_like 'parses successfully'
 
     it 'is a boolean' do
-      expect(uri.uri_options[:write]).to eq(BSON::Document.new(fsync: true))
+      expect(uri.uri_options[:write_concern]).to eq(BSON::Document.new(fsync: true))
     end
   end
 
@@ -255,7 +322,7 @@ describe Mongo::URI do
     it_behaves_like 'parses successfully'
 
     it 'is a boolean' do
-      expect(uri.uri_options[:write]).to eq(BSON::Document.new(j: true))
+      expect(uri.uri_options[:write_concern]).to eq(BSON::Document.new(j: true))
     end
   end
 
@@ -319,8 +386,8 @@ describe Mongo::URI do
 
     it_behaves_like 'parses successfully'
 
-    it 'is a string' do
-      expect(uri.uri_options[:read_concern]).to eq(BSON::Document.new(level: 'snapshot'))
+    it 'is a symbol' do
+      expect(uri.uri_options[:read_concern]).to eq(BSON::Document.new(level: :snapshot))
     end
   end
 
@@ -333,6 +400,15 @@ describe Mongo::URI do
     it 'is a string' do
       expect(uri.uri_options[:read]).to eq(BSON::Document.new(mode: :nearest))
     end
+
+    context 'an unknown value' do
+
+      let(:string) { "mongodb://example.com/?readPreference=foobar" }
+
+      it 'is unchanged' do
+        expect(uri.uri_options[:read]).to eq(BSON::Document.new(mode: 'foobar'))
+      end
+    end
   end
 
   context 'readPreferenceTags' do
@@ -345,6 +421,16 @@ describe Mongo::URI do
       expect(uri.uri_options[:read]).to eq(BSON::Document.new(
         tag_sets: [{'dc' => 'ny', 'rack' => '1'}]))
     end
+
+    context 'with double escaped keys and values' do
+
+      let(:string) { "mongodb://example.com/?readPreferenceTags=dc%252f:ny,rack:1%252f" }
+
+      it 'unescapes once' do
+        expect(uri.uri_options[:read]).to eq(BSON::Document.new(
+          tag_sets: [{'dc%2f' => 'ny', 'rack' => '1%2f'}]))
+      end
+    end
   end
 
   context 'replicaSet' do
@@ -451,7 +537,7 @@ describe Mongo::URI do
       it_behaves_like 'parses successfully'
 
       it 'is an integer' do
-        expect(uri.uri_options[:write]).to eq(BSON::Document.new(w: 1))
+        expect(uri.uri_options[:write_concern]).to eq(BSON::Document.new(w: 1))
       end
     end
 
@@ -461,7 +547,7 @@ describe Mongo::URI do
       it_behaves_like 'parses successfully'
 
       it 'is a string' do
-        expect(uri.uri_options[:write]).to eq(BSON::Document.new(w: 'foo'))
+        expect(uri.uri_options[:write_concern]).to eq(BSON::Document.new(w: 'foo'))
       end
     end
 
@@ -471,7 +557,7 @@ describe Mongo::URI do
       it_behaves_like 'parses successfully'
 
       it 'is a symbol' do
-        expect(uri.uri_options[:write]).to eq(BSON::Document.new(w: :majority))
+        expect(uri.uri_options[:write_concern]).to eq(BSON::Document.new(w: :majority))
       end
     end
   end
@@ -491,7 +577,7 @@ describe Mongo::URI do
     it_behaves_like 'parses successfully'
 
     it 'is a float' do
-      expect(uri.uri_options[:write]).to eq(BSON::Document.new(wtimeout: 100))
+      expect(uri.uri_options[:write_concern]).to eq(BSON::Document.new(wtimeout: 100))
     end
   end