mongo 2.11.2 → 2.13.0.beta1

data/spec/mongo/socket/tcp_spec.rb

@@ -1,22 +1,14 @@
 require 'spec_helper'
 
 describe Mongo::Socket::TCP do
-  require_no_tls
-
-  let(:address) { default_address }
-
-  let!(:resolver) do
-    address.send(:create_resolver, {})
-  end
-
   let(:socket) do
-    resolver.socket(5, {})
+    described_class.new('127.0.0.1', SpecConfig.instance.any_port, 5, Socket::AF_INET)
   end
 
-  describe '#address' do
+  describe '#human_address' do
     it 'returns the address and tls indicator' do
       addr = socket.send(:socket).remote_address
-      expect(socket.send(:address)).to eq("#{addr.ip_address}:#{addr.ip_port} (no TLS)")
+      expect(socket.send(:human_address)).to eq("#{addr.ip_address}:#{addr.ip_port} (no TLS)")
     end
   end
 end

data/spec/mongo/socket/unix_spec.rb

@@ -8,9 +8,9 @@ describe Mongo::Socket::Unix do
     described_class.new(path, 5)
   end
 
-  describe '#address' do
+  describe '#human_address' do
     it 'returns the path' do
-      expect(socket.send(:address)).to eq(path)
+      expect(socket.send(:human_address)).to eq(path)
     end
   end
 

data/spec/mongo/socket_spec.rb

@@ -3,25 +3,25 @@ require 'spec_helper'
 describe Mongo::Socket do
 
   let(:socket) do
-    described_class.new(Socket::PF_INET)
+    described_class.new(0, {})
   end
 
-  describe '#address' do
+  describe '#human_address' do
     it 'raises NotImplementedError' do
       expect do
-        socket.send(:address)
+        socket.send(:human_address)
       end.to raise_error(NotImplementedError)
     end
   end
 
-  describe '#handle_errors' do
+  describe '#map_exceptions' do
     before do
-      expect(socket).to receive(:address).and_return('fake-address')
+      expect(socket).to receive(:human_address).and_return('fake-address')
     end
 
     it 'maps timeout exception' do
       expect do
-        socket.send(:handle_errors) do
+        socket.send(:map_exceptions) do
           raise Errno::ETIMEDOUT
         end
       end.to raise_error(Mongo::Error::SocketTimeoutError)
@@ -29,7 +29,7 @@ describe Mongo::Socket do
 
     it 'maps SystemCallError and preserves message' do
       expect do
-        socket.send(:handle_errors) do
+        socket.send(:map_exceptions) do
           raise SystemCallError.new('Test error', Errno::ENFILE::Errno)
         end
       end.to raise_error(Mongo::Error::SocketError, 'Errno::ENFILE: Too many open files in system - Test error (for fake-address)')
@@ -37,7 +37,7 @@ describe Mongo::Socket do
 
     it 'maps IOError and preserves message' do
       expect do
-        socket.send(:handle_errors) do
+        socket.send(:map_exceptions) do
           raise IOError.new('Test error')
         end
       end.to raise_error(Mongo::Error::SocketError, 'IOError: Test error (for fake-address)')
@@ -45,7 +45,7 @@ describe Mongo::Socket do
 
     it 'maps SSLError and preserves message' do
       expect do
-        socket.send(:handle_errors) do
+        socket.send(:map_exceptions) do
           raise OpenSSL::SSL::SSLError.new('Test error')
         end
       end.to raise_error(Mongo::Error::SocketError, 'OpenSSL::SSL::SSLError: Test error (for fake-address) (MongoDB may not be configured with SSL support)')

data/spec/mongo/srv/monitor_spec.rb

@@ -1,82 +1,101 @@
 require 'lite_spec_helper'
 
-describe Mongo::SRV::Monitor do
+describe Mongo::Srv::Monitor do
   describe '#scan!' do
     let(:hostname) do
-      'test1.test.build.10gen.cc.'
+      'test1.test.build.10gen.cc'
     end
 
     let(:hosts) do
       [
-        'localhost.test.build.10gen.cc.:27017',
-        'localhost.test.build.10gen.cc.:27018',
+        'localhost.test.build.10gen.cc:27017',
+        'localhost.test.build.10gen.cc:27018',
       ]
     end
 
-    let(:records) do
-      double('records').tap do |records|
-        allow(records).to receive(:hostname).and_return(hostname)
-        allow(records).to receive(:hosts).and_return(hosts)
-        allow(records).to receive(:empty?).and_return(false)
-        allow(records).to receive(:min_ttl).and_return(nil)
+    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(records.hosts, Mongo::Monitoring.new, { monitoring_io: false })
+      Mongo::Cluster.new(hosts, Mongo::Monitoring.new, monitoring_io: false)
     end
 
-    let(:monitoring) do
-      described_class.new(cluster, resolver, records)
+    let(:monitor) do
+      described_class.new(cluster, srv_uri: srv_uri)
     end
 
     before do
-      monitoring.scan!
+      # 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 + ['test1.test.build.10gen.cc.:27019']
+        hosts + ['localhost.test.build.10gen.cc:27019']
       end
 
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
+      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_records)
+        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.addresses.map(&:to_s).sort).to eq(new_hosts.sort)
+        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']
+        hosts - ['test1.test.build.10gen.cc:27018']
       end
 
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
+      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_records)
+          allow(resolver).to receive(:get_records).and_return(new_result)
         end
       end
 
@@ -87,21 +106,21 @@ describe Mongo::SRV::Monitor do
 
     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']
+        hosts - ['test1.test.build.10gen.cc:27018'] +  ['test1.test.build.10gen.cc:27019']
       end
 
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
+      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_records)
+          allow(resolver).to receive(:get_records).and_return(new_result)
         end
       end
 
@@ -110,23 +129,23 @@ describe Mongo::SRV::Monitor do
       end
     end
 
-    context 'when all DNS records are replaced with a single record' do
+    context 'when all DNS result are replaced with a single record' do
       let(:new_hosts) do
-        ['test1.test.build.10gen.cc.:27019']
+        ['test1.test.build.10gen.cc:27019']
       end
 
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
+      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_records)
+          expect(resolver).to receive(:get_records).and_return(new_result)
         end
       end
 
@@ -135,26 +154,26 @@ describe Mongo::SRV::Monitor do
       end
     end
 
-    context 'when all DNS records are replaced with multiple records' do
+    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',
+          'test1.test.build.10gen.cc:27019',
+          'test1.test.build.10gen.cc:27020',
         ]
       end
 
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return(new_hosts)
-          allow(records).to receive(:empty?).and_return(false)
-          allow(records).to receive(:min_ttl).and_return(nil)
+      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_records)
+          allow(resolver).to receive(:get_records).and_return(new_result)
         end
       end
 
@@ -166,7 +185,7 @@ describe Mongo::SRV::Monitor do
     context 'when the DNS lookup times out' do
       let(:resolver) do
         double('resolver').tap do |resolver|
-          allow(resolver).to receive(:get_records).and_raise(Resolv::ResolvTimeout)
+          expect(resolver).to receive(:get_records).and_raise(Resolv::ResolvTimeout)
         end
       end
 
@@ -187,19 +206,19 @@ describe Mongo::SRV::Monitor do
       end
     end
 
-    context 'when no DNS records are returned' do
-      let(:new_records) do
-        double('records').tap do |records|
-          allow(records).to receive(:hostname).and_return(hostname)
-          allow(records).to receive(:hosts).and_return([])
-          allow(records).to receive(:empty?).and_return(true)
-          allow(records).to receive(:min_ttl).and_return(nil)
+    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_records)
+          allow(resolver).to receive(:get_records).and_return(new_result)
         end
       end
 
@@ -208,4 +227,4 @@ describe Mongo::SRV::Monitor do
       end
     end
   end
-end
+end

data/spec/mongo/timeout_spec.rb

@@ -0,0 +1,39 @@
+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/uri/srv_protocol_spec.rb

@@ -1,7 +1,7 @@
-require 'spec_helper'
+require 'lite_spec_helper'
 
 describe Mongo::URI::SRVProtocol do
-  clean_slate_for_all
+  clean_slate_for_all_if_possible
 
   let(:scheme) { 'mongodb+srv://' }
   let(:uri) { described_class.new(string) }

data/spec/mongo/uri_spec.rb

@@ -6,6 +6,40 @@ describe Mongo::URI do
 
     let(:uri) { described_class.get(string) }
 
+    describe 'invalid uris' do
+
+      context 'string is not uri' do
+
+        let(:string) { 'tyler' }
+
+        it 'raises an error' do
+          expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+        end
+      end
+
+      context 'nil' do
+
+        let(:string) { nil }
+
+        it 'raises an error' do
+          expect do
+            uri
+          end.to raise_error(Mongo::Error::InvalidURI, /URI must be a string, not nil/)
+        end
+      end
+
+      context 'empty string' do
+
+        let(:string) { '' }
+
+        it 'raises an error' do
+          expect do
+            uri
+          end.to raise_error(Mongo::Error::InvalidURI, /Cannot parse an empty URI/)
+        end
+      end
+    end
+
     context 'when the scheme is mongodb://' do
 
       let(:string) do
@@ -55,12 +89,25 @@ describe Mongo::URI do
       end
     end
 
+    context 'nil' do
+
+      let(:string) { nil }
+
+      it 'raises an error' do
+        expect do
+          uri
+        end.to raise_error(Mongo::Error::InvalidURI, /URI must be a string, not nil/)
+      end
+    end
+
     context 'empty string' do
 
       let(:string) { '' }
 
       it 'raises an error' do
-        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+        expect do
+          uri
+        end.to raise_error(Mongo::Error::InvalidURI, /Cannot parse an empty URI/)
       end
     end
 
@@ -228,10 +275,10 @@ describe Mongo::URI do
 
     context 'equal sign in option value' do
 
-      let(:string) { 'mongodb://example.com/?w=a=b' }
+      let(:string) { 'mongodb://example.com/?authmechanismproperties=foo:a=b&appname=test' }
 
-      it 'raises an error' do
-        expect { uri }.to raise_error(Mongo::Error::InvalidURI, %r,Value for option w contains the key/value delimiter \(=\): a=b,)
+      it 'is allowed' do
+        expect(uri.uri_options[:auth_mech_properties]).to eq('foo' => 'a=b')
       end
     end
 
@@ -352,7 +399,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.unescape(servers)])
+        expect(uri.servers).to eq([URI::DEFAULT_PARSER.unescape(servers)])
       end
     end
 
@@ -772,13 +819,13 @@ describe Mongo::URI do
 
         let(:mechanism) { 'GSSAPI' }
         let(:expected) { :gssapi }
+        let(:client) { new_local_client_nmio(string) }
 
         it 'sets the auth mechanism to :gssapi' do
           expect(uri.uri_options[:auth_mech]).to eq(expected)
         end
 
         it 'sets the options on a client created with the uri' do
-          client = new_local_client_nmio(string)
           expect(client.options[:auth_mech]).to eq(expected)
         end
 
@@ -792,7 +839,7 @@ describe Mongo::URI do
 
           it 'does not allow a client to be created' do
             expect {
-              new_local_client_nmio(string)
+              client
             }.to raise_error(Mongo::Auth::InvalidConfiguration, /invalid auth source/)
           end
         end
@@ -801,9 +848,24 @@ describe Mongo::URI 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
+
+          context 'when a mapping value is missing' do
+            let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:,CANONICALIZE_HOST_NAME:" }
+
+            it 'sets the options on a client created with the uri' do
+              expect(client.options[:auth_mech_properties]).to eq({ 'canonicalize_host_name' => nil, 'service_name' => nil })
+            end
+          end
+
+          context 'when a mapping value is missing but another is present' do
+            let(:options) { "authMechanism=#{mechanism}&authMechanismProperties=SERVICE_NAME:foo,CANONICALIZE_HOST_NAME:" }
+
+            it 'sets the options on a client created with the uri' do
+              expect(client.options[:auth_mech_properties]).to eq({ 'canonicalize_host_name' => nil, 'service_name' => 'foo' })
+            end
+          end
         end
       end
 
@@ -880,9 +942,9 @@ describe Mongo::URI do
           let(:password) { 's3kr4t' }
 
           it 'does not allow a client to be created' do
-            expect {
+            expect do
               new_local_client_nmio(string)
-            }.to raise_error(Mongo::Auth::InvalidConfiguration, /password is not supported/)
+            end.to raise_error(Mongo::Auth::InvalidConfiguration, /Password is not supported/)
           end
         end
 
@@ -925,9 +987,9 @@ describe Mongo::URI do
         end
 
         it 'does not allow a client to be created with default auth mechanism' do
-          expect {
+          expect do
             new_local_client_nmio(string)
-          }.to raise_error(Mongo::Auth::InvalidConfiguration, /empty username is not supported/)
+          end.to raise_error(Mongo::Auth::InvalidConfiguration, /Empty username is not supported/)
         end
       end
     end