mongo 2.10.5 → 2.15.1

data/spec/mongo/srv/monitor_spec.rb

@@ -0,0 +1,233 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'lite_spec_helper'
+
+describe Mongo::Srv::Monitor do
+  describe '#scan!' do
+    let(:hostname) do
+      'test1.test.build.10gen.cc'
+    end
+
+    let(:hosts) do
+      [
+        'localhost.test.build.10gen.cc:27017',
+        'localhost.test.build.10gen.cc:27018',
+      ]
+    end
+
+    let(:result) do
+      double('result').tap do |result|
+        allow(result).to receive(:hostname).and_return(hostname)
+        allow(result).to receive(:address_strs).and_return(hosts)
+        allow(result).to receive(:empty?).and_return(false)
+        allow(result).to receive(:min_ttl).and_return(nil)
+      end
+    end
+
+    let(:uri_resolver) do
+      double('uri resolver').tap do |resolver|
+        expect(resolver).to receive(:get_records).and_return(result)
+      end
+    end
+
+    let(:srv_uri) do
+      Mongo::URI.get("mongodb+srv://this.is.not.used")
+    end
+
+    let(:cluster) do
+      Mongo::Cluster.new(hosts, Mongo::Monitoring.new, monitoring_io: false)
+    end
+
+    let(:monitor) do
+      described_class.new(cluster, srv_uri: srv_uri)
+    end
+
+    before do
+      # monitor instantiation triggers cluster instantiation which
+      # performs real SRV lookups for the hostname.
+      # The next lookup (the one performed when cluster is already set up)
+      # is using our doubles.
+      RSpec::Mocks.with_temporary_scope do
+        allow(uri_resolver).to receive(:get_txt_options_string)
+        expect(Mongo::Srv::Resolver).to receive(:new).ordered.and_return(uri_resolver)
+        allow(resolver).to receive(:get_txt_options_string)
+        expect(Mongo::Srv::Resolver).to receive(:new).ordered.and_return(resolver)
+        monitor.send(:scan!)
+      end
+    end
+
+    context 'when a new DNS record is added' do
+      let(:new_hosts) do
+        hosts + ['localhost.test.build.10gen.cc:27019']
+      end
+
+      let(:new_result) do
+        double('result').tap do |result|
+          allow(result).to receive(:hostname).and_return(hostname)
+          allow(result).to receive(:address_strs).and_return(new_hosts)
+          allow(result).to receive(:empty?).and_return(false)
+          allow(result).to receive(:min_ttl).and_return(nil)
+        end
+      end
+
+      let(:resolver) do
+        double('monitor resolver').tap do |resolver|
+          expect(resolver).to receive(:get_records).and_return(new_result)
+        end
+      end
+
+      it 'adds the new host to the cluster' do
+        expect(cluster.servers_list.map(&:address).map(&:to_s).sort).to eq(new_hosts.sort)
+      end
+    end
+
+    context 'when a DNS record is removed' do
+      let(:new_hosts) do
+        hosts - ['test1.test.build.10gen.cc:27018']
+      end
+
+      let(:new_result) do
+        double('result').tap do |result|
+          allow(result).to receive(:hostname).and_return(hostname)
+          allow(result).to receive(:address_strs).and_return(new_hosts)
+          allow(result).to receive(:empty?).and_return(false)
+          allow(result).to receive(:min_ttl).and_return(nil)
+        end
+      end
+
+      let(:resolver) do
+        double('resolver').tap do |resolver|
+          allow(resolver).to receive(:get_records).and_return(new_result)
+        end
+      end
+
+      it 'adds the new host to the cluster' do
+        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
+      end
+    end
+
+    context 'when a single DNS record is replaced' do
+      let(:new_hosts) do
+        hosts - ['test1.test.build.10gen.cc:27018'] +  ['test1.test.build.10gen.cc:27019']
+      end
+
+      let(:new_result) do
+        double('result').tap do |result|
+          allow(result).to receive(:hostname).and_return(hostname)
+          allow(result).to receive(:address_strs).and_return(new_hosts)
+          allow(result).to receive(:empty?).and_return(false)
+          allow(result).to receive(:min_ttl).and_return(nil)
+        end
+      end
+
+      let(:resolver) do
+        double('resolver').tap do |resolver|
+          allow(resolver).to receive(:get_records).and_return(new_result)
+        end
+      end
+
+      it 'adds the new host to the cluster' do
+        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
+      end
+    end
+
+    context 'when all DNS result are replaced with a single record' do
+      let(:new_hosts) do
+        ['test1.test.build.10gen.cc:27019']
+      end
+
+      let(:new_result) do
+        double('result').tap do |result|
+          allow(result).to receive(:hostname).and_return(hostname)
+          allow(result).to receive(:address_strs).and_return(new_hosts)
+          allow(result).to receive(:empty?).and_return(false)
+          allow(result).to receive(:min_ttl).and_return(nil)
+        end
+      end
+
+      let(:resolver) do
+        double('resolver').tap do |resolver|
+          expect(resolver).to receive(:get_records).and_return(new_result)
+        end
+      end
+
+      it 'adds the new host to the cluster' do
+        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
+      end
+    end
+
+    context 'when all DNS result are replaced with multiple result' do
+      let(:new_hosts) do
+        [
+          'test1.test.build.10gen.cc:27019',
+          'test1.test.build.10gen.cc:27020',
+        ]
+      end
+
+      let(:new_result) do
+        double('result').tap do |result|
+          allow(result).to receive(:hostname).and_return(hostname)
+          allow(result).to receive(:address_strs).and_return(new_hosts)
+          allow(result).to receive(:empty?).and_return(false)
+          allow(result).to receive(:min_ttl).and_return(nil)
+        end
+      end
+
+      let(:resolver) do
+        double('resolver').tap do |resolver|
+          allow(resolver).to receive(:get_records).and_return(new_result)
+        end
+      end
+
+      it 'adds the new host to the cluster' do
+        expect(cluster.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
+      end
+    end
+
+    context 'when the DNS lookup times out' do
+      let(:resolver) do
+        double('resolver').tap do |resolver|
+          expect(resolver).to receive(:get_records).and_raise(Resolv::ResolvTimeout)
+        end
+      end
+
+      it 'does not add or remove any hosts from the cluster' do
+        expect(cluster.addresses.map(&:to_s).sort).to eq(hosts.sort)
+      end
+    end
+
+    context 'when the DNS lookup is unable to resolve the hostname' do
+     let(:resolver) do
+        double('resolver').tap do |resolver|
+          allow(resolver).to receive(:get_records).and_raise(Resolv::ResolvError)
+        end
+      end
+
+      it 'does not add or remove any hosts from the cluster' do
+        expect(cluster.addresses.map(&:to_s).sort).to eq(hosts.sort)
+      end
+    end
+
+    context 'when no DNS result are returned' do
+      let(:new_result) do
+        double('result').tap do |result|
+          allow(result).to receive(:hostname).and_return(hostname)
+          allow(result).to receive(:address_strs).and_return([])
+          allow(result).to receive(:empty?).and_return(true)
+          allow(result).to receive(:min_ttl).and_return(nil)
+        end
+      end
+
+      let(:resolver) do
+        double('resolver').tap do |resolver|
+          allow(resolver).to receive(:get_records).and_return(new_result)
+        end
+      end
+
+      it 'does not add or remove any hosts from the cluster' do
+        expect(cluster.addresses.map(&:to_s).sort).to eq(hosts.sort)
+      end
+    end
+  end
+end

data/spec/mongo/srv/result_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+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/timeout_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'lite_spec_helper'
+
+describe Mongo::Timeout do
+  describe '#timeout' do
+    let(:default_error_message) { 'execution expired' }
+    let(:custom_error_class) { Mongo::Error::SocketTimeoutError }
+    let(:custom_error_message) { 'socket timed out' }
+
+    context 'with time argument' do
+      it 'raises StandardError' do
+        expect do
+          Mongo::Timeout.timeout(0.1) do
+            sleep 1
+          end
+        end.to raise_error(::Timeout::Error, default_error_message)
+      end
+    end
+
+    context 'with time and class arguments' do
+      it 'raises the specified error class' do
+        expect do
+          Mongo::Timeout.timeout(0.1, custom_error_class) do
+            sleep 1
+          end
+        end.to raise_error(custom_error_class, default_error_message)
+      end
+    end
+
+    context 'with time, class, and message arguments' do
+      it 'raises the specified error class with message' do
+        expect do
+          Mongo::Timeout.timeout(0.1, custom_error_class, custom_error_message) do
+            sleep 1
+          end
+        end.to raise_error(custom_error_class, custom_error_message)
+      end
+    end
+  end
+end

data/spec/mongo/tls_context_hooks_spec.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo do
+  before do
+    Mongo.tls_context_hooks.clear
+  end
+
+  describe '#tls_context_hooks' do
+    it 'returns an array' do
+      expect(Mongo.tls_context_hooks).to eq([])
+    end
+  end
+
+  describe '#tls_context_hooks=' do
+    context 'when argument is not an array' do
+      it 'raises an ArgumentError' do
+        expect do
+          Mongo.tls_context_hooks = "Hello"
+        end.to raise_error(ArgumentError, /TLS context hooks must be an array of Procs/)
+      end
+    end
+
+    context 'when argument is an array not containing procs' do
+      it 'raises an ArgumentError' do
+        expect do
+          Mongo.tls_context_hooks = [1, 2, 3]
+        end.to raise_error(ArgumentError, /TLS context hooks must be an array of Procs/)
+      end
+    end
+
+    it 'saves the provided hooks' do
+      Mongo.tls_context_hooks = [ Proc.new { |x| x ** 2 } ]
+      expect(Mongo.tls_context_hooks.length).to eq(1)
+      expect(Mongo.tls_context_hooks.first).to be_a(Proc)
+    end
+  end
+end

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'lite_spec_helper'
 
 describe Mongo::URI::SRVProtocol do
-  clean_slate_for_all
+  require_external_connectivity
+  clean_slate_for_all_if_possible
 
   let(:scheme) { 'mongodb+srv://' }
   let(:uri) { described_class.new(string) }
@@ -567,8 +571,8 @@ describe Mongo::URI::SRVProtocol do
               'readPreference=secondary&maxStalenessSeconds=89'
             end
 
-            it 'does not raise an exception until the read preference is used' do
-              expect(client.read_preference).to eq(BSON::Document.new(mode: :secondary, max_staleness: 89))
+            it 'does not raise an exception and is omitted' do
+              expect(client.read_preference).to eq(BSON::Document.new(mode: :secondary))
             end
           end
         end
@@ -588,7 +592,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 +611,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 +629,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 +650,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 +668,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 +688,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
@@ -698,98 +717,116 @@ describe Mongo::URI::SRVProtocol do
             expect(client.options[:auth_source]).to eq(source)
           end
         end
+      end
 
-        context '$external' do
-          let(:source) { '$external' }
-          let(:expected) { :external }
+      # This context exactly duplicates the same one in uri_spec.rb
+      context 'auth mechanism properties provided' do
 
-          it 'sets the auth source to :external' do
-            expect(uri.uri_options[:auth_source]).to eq(expected)
+        shared_examples 'sets options in the expected manner' do
+          it 'preserves case in auth mechanism properties returned from URI' do
+            expect(uri.uri_options[:auth_mech_properties]).to eq(expected_uri_options)
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_source]).to eq(expected)
+          it 'downcases auth mechanism properties keys in client options' do
+            client = new_local_client_nmio(string)
+            expect(client.options[:auth_mech_properties]).to eq(expected_client_options)
           end
         end
-      end
-
-      context 'auth mechanism properties provided' do
 
         context 'service_name' do
           let(:options) do
-            "authMechanismProperties=SERVICE_NAME:#{service_name}"
+            "authMechanismProperties=SERVICE_name:#{service_name}"
           end
 
           let(:service_name) { 'foo' }
-          let(:expected) { Mongo::Options::Redacted.new({ service_name: service_name }) }
 
-          it 'sets the auth mechanism properties' do
-            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          let(:expected_uri_options) do
+            Mongo::Options::Redacted.new(
+              SERVICE_name: service_name,
+            )
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_mech_properties]).to eq(expected)
+          let(:expected_client_options) do
+            Mongo::Options::Redacted.new(
+              service_name: service_name,
+            )
           end
+
+          include_examples 'sets options in the expected manner'
         end
 
         context 'canonicalize_host_name' do
           let(:options) do
-            "authMechanismProperties=CANONICALIZE_HOST_NAME:#{canonicalize_host_name}"
+            "authMechanismProperties=CANONICALIZE_HOST_name:#{canonicalize_host_name}"
           end
+
           let(:canonicalize_host_name) { 'true' }
-          let(:expected) { Mongo::Options::Redacted.new({ canonicalize_host_name: true }) }
 
-          it 'sets the auth mechanism properties' do
-            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          let(:expected_uri_options) do
+            Mongo::Options::Redacted.new(
+              CANONICALIZE_HOST_name: true,
+            )
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_mech_properties]).to eq(expected)
+          let(:expected_client_options) do
+            Mongo::Options::Redacted.new(
+              canonicalize_host_name: true,
+            )
           end
+
+          include_examples 'sets options in the expected manner'
         end
 
         context 'service_realm' do
           let(:options) do
-            "authMechanismProperties=SERVICE_REALM:#{service_realm}"
+            "authMechanismProperties=SERVICE_realm:#{service_realm}"
           end
 
           let(:service_realm) { 'dumdum' }
-          let(:expected) { Mongo::Options::Redacted.new({ service_realm: service_realm }) }
-
 
-          it 'sets the auth mechanism properties' do
-            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          let(:expected_uri_options) do
+            Mongo::Options::Redacted.new(
+              SERVICE_realm: service_realm,
+            )
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_mech_properties]).to eq(expected)
+          let(:expected_client_options) do
+            Mongo::Options::Redacted.new(
+              service_realm: service_realm,
+            )
           end
+
+          include_examples 'sets options in the expected manner'
         end
 
         context 'multiple properties' do
           let(:options) do
-            "authMechanismProperties=SERVICE_REALM:#{service_realm}," +
-                "CANONICALIZE_HOST_NAME:#{canonicalize_host_name}," +
-                "SERVICE_NAME:#{service_name}"
+            "authMechanismProperties=SERVICE_realm:#{service_realm}," +
+              "CANONICALIZE_HOST_name:#{canonicalize_host_name}," +
+              "SERVICE_name:#{service_name}"
           end
 
           let(:service_name) { 'foo' }
           let(:canonicalize_host_name) { 'true' }
           let(:service_realm) { 'dumdum' }
 
-          let(:expected) do
-            Mongo::Options::Redacted.new({ service_name: service_name,
-                                           canonicalize_host_name: true,
-                                           service_realm: service_realm })
+          let(:expected_uri_options) do
+            Mongo::Options::Redacted.new(
+              SERVICE_name: service_name,
+              CANONICALIZE_HOST_name: true,
+              SERVICE_realm: service_realm,
+            )
           end
 
-          it 'sets the auth mechanism properties' do
-            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          let(:expected_client_options) do
+            Mongo::Options::Redacted.new(
+              service_name: service_name,
+              canonicalize_host_name: true,
+              service_realm: service_realm,
+            )
           end
 
-          it 'sets the options on a client created with the uri' do
-            expect(client.options[:auth_mech_properties]).to eq(expected)
-          end
+          include_examples 'sets options in the expected manner'
         end
       end
 
@@ -947,7 +984,7 @@ describe Mongo::URI::SRVProtocol do
     end
   end
 
-  describe '#validate_hostname' do
+  describe '#validate_srv_hostname' do
     let(:valid_hostname) do
     end
 
@@ -956,7 +993,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