mongo 2.10.5 → 2.11.0.rc0

data/spec/mongo/srv/result_spec.rb

@@ -0,0 +1,54 @@
+require 'lite_spec_helper'
+
+describe Mongo::Srv::Result do
+  let(:result) do
+    described_class.new('bar.com')
+  end
+
+  describe '#add_record' do
+    context 'when incoming hostname is in mixed case' do
+      let(:record) do
+        double('record').tap do |record|
+          allow(record).to receive(:target).and_return('FOO.bar.COM')
+          allow(record).to receive(:port).and_return(42)
+          allow(record).to receive(:ttl).and_return(1)
+        end
+      end
+
+      it 'stores hostname in lower case' do
+        result.add_record(record)
+        expect(result.address_strs).to eq(['foo.bar.com:42'])
+      end
+    end
+  end
+
+  describe '#normalize_hostname' do
+    let(:actual) do
+      result.send(:normalize_hostname, hostname)
+    end
+
+    context 'when hostname is in mixed case' do
+      let(:hostname) { 'FOO.bar.COM' }
+
+      it 'converts to lower case' do
+        expect(actual).to eq('foo.bar.com')
+      end
+    end
+
+    context 'when hostname has one trailing dot' do
+      let(:hostname) { 'foo.' }
+
+      it 'removes the trailing dot' do
+        expect(actual).to eq('foo')
+      end
+    end
+
+    context 'when hostname has multiple trailing dots' do
+      let(:hostname) { 'foo..' }
+
+      it 'returns hostname unchanged' do
+        expect(actual).to eq('foo..')
+      end
+    end
+  end
+end

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -1,4 +1,4 @@
-require 'lite_spec_helper'
+require 'spec_helper'
 
 describe Mongo::URI::SRVProtocol do
   clean_slate_for_all
@@ -588,7 +588,11 @@ describe Mongo::URI::SRVProtocol do
       end
 
       context 'auth mechanism provided' do
-        let(:options) { "authMechanism=#{mechanism}" }
+        let(:options)     { "authMechanism=#{mechanism}" }
+        let(:string)      { "#{scheme}#{credentials}@#{servers}/?#{options}" }
+        let(:user)        { 'tyler' }
+        let(:password)    { 's3kr4t' }
+        let(:credentials) { "#{user}:#{password}" }
 
         context 'plain' do
           let(:mechanism) { 'PLAIN' }
@@ -603,7 +607,8 @@ describe Mongo::URI::SRVProtocol do
           end
 
           it 'is case-insensitive' do
-            expect(new_local_client(string.downcase).options[:auth_mech]).to eq(expected)
+            client = new_local_client_nmio(string.downcase)
+            expect(client.options[:auth_mech]).to eq(expected)
           end
         end
 
@@ -620,13 +625,17 @@ describe Mongo::URI::SRVProtocol do
           end
 
           it 'is case-insensitive' do
-            expect(new_local_client(string.downcase).options[:auth_mech]).to eq(expected)
+            client = new_local_client_nmio(string.downcase)
+            expect(client.options[:auth_mech]).to eq(expected)
           end
         end
 
         context 'gssapi' do
+          require_mongo_kerberos
+
           let(:mechanism) { 'GSSAPI' }
-          let(:expected) { :gssapi }
+          let(:expected)  { :gssapi }
+          let(:options)   { "authMechanism=#{mechanism}&authSource=$external" }
 
           it 'sets the auth mechanism to :gssapi' do
             expect(uri.uri_options[:auth_mech]).to eq(expected)
@@ -637,7 +646,8 @@ describe Mongo::URI::SRVProtocol do
           end
 
           it 'is case-insensitive' do
-            expect(new_local_client(string.downcase).options[:auth_mech]).to eq(expected)
+            client = new_local_client_nmio(string.downcase)
+            expect(client.options[:auth_mech]).to eq(expected)
           end
         end
 
@@ -654,13 +664,16 @@ describe Mongo::URI::SRVProtocol do
           end
 
           it 'is case-insensitive' do
-            expect(new_local_client(string.downcase).options[:auth_mech]).to eq(expected)
+            client = new_local_client_nmio(string.downcase)
+            expect(client.options[:auth_mech]).to eq(expected)
           end
         end
 
         context 'mongodb-x509' do
-          let(:mechanism) { 'MONGODB-X509' }
-          let(:expected) { :mongodb_x509 }
+          let(:options)     { "authMechanism=#{mechanism}&authSource=$external" }
+          let(:mechanism)   { 'MONGODB-X509' }
+          let(:expected)    { :mongodb_x509 }
+          let(:credentials) { user }
 
           it 'sets the auth mechanism to :mongodb_x509' do
             expect(uri.uri_options[:auth_mech]).to eq(expected)
@@ -671,14 +684,16 @@ describe Mongo::URI::SRVProtocol do
           end
 
           it 'is case-insensitive' do
-            expect(new_local_client(string.downcase).options[:auth_mech]).to eq(expected)
+              client = new_local_client_nmio(string.downcase)
+            expect(client.options[:auth_mech]).to eq(expected)
           end
 
           context 'when a username is not provided' do
-
+            let(:string) { "#{scheme}#{servers}/?#{options}" }
             it 'recognizes the mechanism with no username' do
-              expect(new_local_client(string.downcase).options[:auth_mech]).to eq(expected)
-              expect(new_local_client(string.downcase).options[:user]).to be_nil
+              client = new_local_client_nmio(string.downcase)
+              expect(client.options[:auth_mech]).to eq(expected)
+              expect(client.options[:user]).to be_nil
             end
           end
         end
@@ -947,7 +962,7 @@ describe Mongo::URI::SRVProtocol do
     end
   end
 
-  describe '#validate_hostname' do
+  describe '#validate_srv_hostname' do
     let(:valid_hostname) do
     end
 
@@ -956,7 +971,7 @@ describe Mongo::URI::SRVProtocol do
     end
 
     let(:validate) do
-      dummy_uri.send(:validate_hostname, hostname)
+      dummy_uri.send(:validate_srv_hostname, hostname)
     end
 
     context 'when the hostname is valid' do

data/spec/mongo/uri_spec.rb

@@ -352,7 +352,7 @@ describe Mongo::URI do
       let(:servers) { '%2Ftmp%2Fmongodb-27017.sock' }
 
       it 'returns an array with the parsed server' do
-        expect(uri.servers).to eq([URI::DEFAULT_PARSER.unescape(servers)])
+        expect(uri.servers).to eq([URI.unescape(servers)])
       end
     end
 
@@ -703,7 +703,11 @@ describe Mongo::URI do
     end
 
     context 'auth mechanism provided' do
-      let(:options) { "authMechanism=#{mechanism}" }
+      let(:string)      { "#{scheme}#{credentials}@#{servers}/?#{options}" }
+      let(:user)        { 'tyler' }
+      let(:password)    { 's3kr4t' }
+      let(:credentials) { "#{user}:#{password}" }
+      let(:options)     { "authMechanism=#{mechanism}" }
 
       context 'plain' do
         let(:mechanism) { 'PLAIN' }
@@ -722,6 +726,16 @@ describe Mongo::URI do
           client = new_local_client_nmio(string.downcase)
           expect(client.options[:auth_mech]).to eq(expected)
         end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=CANONICALIZE_HOST_NAME:true" }
+          
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /mechanism_properties are not supported/)
+          end
+        end
       end
 
       context 'mongodb-cr' do
@@ -741,9 +755,21 @@ describe Mongo::URI do
           client = new_local_client_nmio(string.downcase)
           expect(client.options[:auth_mech]).to eq(expected)
         end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=CANONICALIZE_HOST_NAME:true" }
+          
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /mechanism_properties are not supported/)
+          end
+        end
       end
 
       context 'gssapi' do
+        require_mongo_kerberos
+
         let(:mechanism) { 'GSSAPI' }
         let(:expected) { :gssapi }
 
@@ -760,6 +786,25 @@ describe Mongo::URI do
           client = new_local_client_nmio(string.downcase)
           expect(client.options[:auth_mech]).to eq(expected)
         end
+
+        context 'when auth source is invalid' do
+          let(:options) { "authMechanism=#{mechanism}&authSource=foo" }
+
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /invalid auth source/)
+          end
+        end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:other,CANONICALIZE_HOST_NAME:true" }
+          
+          it 'sets the options on a client created with the uri' do
+            client = new_local_client_nmio(string)
+            expect(client.options[:auth_mech_properties]).to eq({ 'canonicalize_host_name' => true, 'service_name' => 'other' })
+          end
+        end
       end
 
       context 'scram-sha-1' do
@@ -779,11 +824,22 @@ describe Mongo::URI do
           client = new_local_client_nmio(string.downcase)
           expect(client.options[:auth_mech]).to eq(expected)
         end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=CANONICALIZE_HOST_NAME:true" }
+          
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /mechanism_properties are not supported/)
+          end
+        end
       end
 
       context 'mongodb-x509' do
         let(:mechanism) { 'MONGODB-X509' }
-        let(:expected) { :mongodb_x509 }
+        let(:expected)  { :mongodb_x509 }
+        let(:credentials)  { user }
 
         it 'sets the auth mechanism to :mongodb_x509' do
           expect(uri.uri_options[:auth_mech]).to eq(expected)
@@ -799,7 +855,18 @@ describe Mongo::URI do
           expect(client.options[:auth_mech]).to eq(expected)
         end
 
+        context 'when auth source is invalid' do
+          let(:options) { "authMechanism=#{mechanism}&authSource=foo" }
+
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /invalid auth source/)
+          end
+        end
+
         context 'when a username is not provided' do
+          let(:string) { "#{scheme}#{servers}/?#{options}" }
 
           it 'recognizes the mechanism with no username' do
             client = new_local_client_nmio(string.downcase)
@@ -807,6 +874,61 @@ describe Mongo::URI do
             expect(client.options[:user]).to be_nil
           end
         end
+
+        context 'when a password is provided' do
+          let(:credentials) { "#{user}:#{password}"}
+          let(:password) { 's3kr4t' }
+          
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /password is not supported/)
+          end
+        end
+
+        context 'when mechanism_properties are provided' do
+          let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=CANONICALIZE_HOST_NAME:true" }
+          
+          it 'does not allow a client to be created' do
+            expect {
+              new_local_client_nmio(string)
+            }.to raise_error(Mongo::Auth::InvalidConfiguration, /mechanism_properties are not supported/)
+          end
+        end
+      end
+    end
+
+    context 'auth mechanism is not provided' do
+      let(:string) { "#{scheme}#{credentials}@#{servers}/" }
+
+      context 'with no credentials' do
+        let(:string) { "#{scheme}#{servers}/" }
+
+        it 'sets user and password as nil' do
+          expect(uri.credentials[:user]).to be_nil
+          expect(uri.credentials[:password]).to be_nil
+        end
+
+        it 'sets the options on a client created with the uri' do
+          client = new_local_client_nmio(string)
+          expect(client.options[:user]).to be_nil
+          expect(client.options[:password]).to be_nil
+        end
+      end
+
+      context 'with empty credentials' do
+        let(:credentials) { '' }
+
+        it 'sets user as an empty string and password as nil' do
+          expect(uri.credentials[:user]).to eq('')
+          expect(uri.credentials[:password]).to be_nil
+        end
+
+        it 'does not allow a client to be created with default auth mechanism' do
+          expect {
+            new_local_client_nmio(string)
+          }.to raise_error(Mongo::Auth::InvalidConfiguration, /empty username is not supported/)
+        end
       end
     end
 
@@ -847,7 +969,6 @@ describe Mongo::URI do
         let(:options) do
           "authMechanismProperties=SERVICE_NAME:#{service_name}"
         end
-
         let(:service_name) { 'foo' }
         let(:expected) { Mongo::Options::Redacted.new({ service_name: service_name }) }
 

data/spec/spec_helper.rb

@@ -12,6 +12,7 @@ require 'support/cluster_config'
 require 'support/cluster_tools'
 require 'rspec/retry'
 require 'support/monitoring_ext'
+require 'support/local_resource_registry'
 
 RSpec.configure do |config|
   config.include(Authorization)
@@ -22,6 +23,11 @@ RSpec.configure do |config|
       kill_all_server_sessions
     end
   end
+
+  config.after do
+    LocalResourceRegistry.instance.close_all
+    ClientRegistry.instance.close_local_clients
+  end
 end
 
 # require all shared examples

data/spec/spec_tests/auth_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe 'Auth' do
+  include Mongo::Auth
+
+  AUTH_TESTS.each do |file|
+    spec = Mongo::Auth::Spec.new(file)
+
+    context(spec.description) do
+      spec.tests.each_with_index do |test, index|
+        context test.description do
+          if test.description.downcase.include?("gssapi")
+            require_mongo_kerberos
+          end
+
+          context 'when the auth configuration is invalid', unless: test.valid? do
+            it 'raises an error' do
+              expect {
+                test.client
+            }.to raise_error(Mongo::Auth::InvalidConfiguration)
+            end
+          end
+
+          context 'when the auth configuration is valid' do
+            context 'with empty credentials', if: test.valid? && test.credential.nil? do
+              it 'creates a client with no credential information' do
+                expect(test.client).to have_blank_credentials
+              end
+            end
+
+            it 'creates a client with the correct credentials', if: test.valid? && test.credential do
+              expect(test.received_credential).to eq(test.expected_credential)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/spec_tests/cmap_spec.rb

@@ -1,6 +1,10 @@
-require 'lite_spec_helper'
+require 'spec_helper'
+
+# Temporary scopes in all of the tests are needed to exclude endSessions
+# commands being sent during cleanup from interfering with assertions.
 
 describe 'Cmap' do
+  clean_slate
 
   declare_topology_double
 
@@ -8,21 +12,58 @@ describe 'Cmap' do
     double('cluster').tap do |cl|
       allow(cl).to receive(:topology).and_return(topology)
       allow(cl).to receive(:options).and_return({})
+      allow(cl).to receive(:app_metadata).and_return(Mongo::Server::AppMetadata.new({}))
+      allow(cl).to receive(:run_sdam_flow)
+      allow(cl).to receive(:update_cluster_time)
+      allow(cl).to receive(:cluster_time).and_return(nil)
     end
   end
 
+  let(:options) do
+    SpecConfig.instance.ssl_options.merge(SpecConfig.instance.compressor_options)
+      .merge(SpecConfig.instance.retry_writes_options).merge(SpecConfig.instance.auth_options)
+      .merge(monitoring_io: false)
+  end
+
   CMAP_TESTS.each do |file|
     spec = Mongo::Cmap::Spec.new(file)
 
     context("#{spec.description} (#{file.sub(%r'.*/data/cmap/', '')})") do
+
       before do
-        spec.setup(cluster)
+        subscriber = EventSubscriber.new
+
+        monitoring = Mongo::Monitoring.new(monitoring: false)
+        monitoring.subscribe(Mongo::Monitoring::CONNECTION_POOL, subscriber)
+
+        @server = register_server(
+          Mongo::Server.new(
+            ClusterConfig.instance.primary_address,
+            cluster,
+            monitoring,
+            Mongo::Event::Listeners.new,
+            options.merge(spec.pool_options)
+          ).tap do |server|
+            allow(server).to receive(:description).and_return(ClusterConfig.instance.primary_description)
+          end
+        )
+        spec.setup(@server, subscriber)
+      end
+
+      after do
+        if @server && (pool = @server.instance_variable_get('@pool'))
+          begin
+            pool.disconnect!
+          rescue Mongo::Error::PoolClosedError
+          end
+        end
       end
 
       let!(:result) do
-        mock_socket = double('socket')
-        allow(mock_socket).to receive(:close)
-        allow_any_instance_of(Mongo::Server::Connection).to receive(:do_connect).and_return(mock_socket)
+        socket = double('fake socket')
+        allow(socket).to receive(:close)
+
+        allow_any_instance_of(Mongo::Server::Connection).to receive(:do_connect).and_return(socket)
         spec.run
       end
 
@@ -31,18 +72,24 @@ describe 'Cmap' do
       end
 
       it 'raises the correct error' do
-        expect(result['error']).to eq(spec.expected_error)
+        RSpec::Mocks.with_temporary_scope do
+          expect(result['error']).to eq(spec.expected_error)
+        end
       end
 
       let(:actual_events) { result['events'].freeze }
 
       it 'emits the correct number of events' do
-        expect(actual_events.length).to eq(spec.expected_events.length)
+        RSpec::Mocks.with_temporary_scope do
+          expect(actual_events.length).to eq(spec.expected_events.length)
+        end
       end
 
       spec.expected_events.each_with_index do |expected_event, index|
         it "emits correct event #{index+1}" do
-          verifier.verify_hashes(actual_events[index], expected_event)
+          RSpec::Mocks.with_temporary_scope do
+            verifier.verify_hashes(actual_events[index], expected_event)
+          end
         end
       end
     end