mongo 2.8.0 → 2.9.0.rc0

data/spec/mongo/server/connection_spec.rb

@@ -559,14 +559,34 @@ describe Mongo::Server::Connection, retry: 3 do
           /Got response for request ID \d+ but expected response for request ID \d+/)
       end
 
-      it 'does not affect subsequent requests' do
-        expect {
-          connection.dispatch([ query_alice ])
-        }.to raise_error(Mongo::Error::UnexpectedResponse)
+      context 'linting' do
+        require_linting
+
+        it 'marks the connection no longer usable' do
+          expect {
+            connection.dispatch([ query_alice ])
+          }.to raise_error(Mongo::Error::UnexpectedResponse)
 
-        docs = connection.dispatch([ query_alice ]).documents
-        expect(docs).to_not be_empty
-        expect(docs.first['name']).to eq('alice')
+          expect do
+            connection.dispatch([ query_alice ]).documents
+          end.to raise_error(Mongo::Error::LintError, 'Reconnecting closed connections is no longer supported')
+        end
+      end
+
+      context 'not linting' do
+        skip_if_linting
+
+        it 'does not affect subsequent requests but warns' do
+          expect(Mongo::Logger.logger).to receive(:warn).once.and_call_original
+
+          expect {
+            connection.dispatch([ query_alice ])
+          }.to raise_error(Mongo::Error::UnexpectedResponse)
+
+          docs = connection.dispatch([ query_alice ]).documents
+          expect(docs).to_not be_empty
+          expect(docs.first['name']).to eq('alice')
+        end
       end
     end
 
@@ -831,6 +851,34 @@ describe Mongo::Server::Connection, retry: 3 do
         expect(connection.address).to eq(server.address)
       end
 
+      it 'sets id' do
+        expect(connection.id).to eq(1)
+      end
+
+      context 'multiple connections' do
+        it 'use incrementing ids' do
+          expect(connection.id).to eq(1)
+
+          second_connection = described_class.new(server, server.options)
+          expect(second_connection.id).to eq(2)
+        end
+      end
+
+      context 'two pools for different servers' do
+        let(:server2) do
+          Mongo::Server.new(address, cluster, monitoring, listeners, server_options)
+        end
+
+        it 'ids do not share namespace' do
+          server.pool.with_connection do |conn|
+            expect(conn.id).to eq(1)
+          end
+          server2.pool.with_connection do |conn|
+            expect(conn.id).to eq(1)
+          end
+        end
+      end
+
       it 'sets the socket to nil' do
         expect(connection.send(:socket)).to be_nil
       end

data/spec/mongo/server_spec.rb

@@ -91,6 +91,11 @@ describe Mongo::Server do
       expect(server).to receive(:pool).and_return(pool)
       server.disconnect!
     end
+
+    it 'disconnects the connection pool' do
+      expect(server.pool).to receive(:disconnect!).once.and_call_original
+      server.disconnect!
+    end
   end
 
   describe '#initialize' do

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -48,6 +48,17 @@ describe Mongo::URI::SRVProtocol do
       end
     end
 
+    context 'when the {tld} is empty' do
+
+      let(:string) { "#{scheme}#{hosts}" }
+      let(:hosts) { '10gen.cc./' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+
     context 'string is not uri' do
 
       let(:string) { 'tyler' }
@@ -403,7 +414,7 @@ describe Mongo::URI::SRVProtocol do
         context 'wtimeoutMS' do
           let(:timeout) { 1234 }
           let(:options) { "w=2&wtimeoutMS=#{timeout}" }
-          let(:concern) { Mongo::Options::Redacted.new(:w => 2, :timeout => timeout) }
+          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)
@@ -911,7 +922,7 @@ describe Mongo::URI::SRVProtocol do
         let(:options) { "appname=srv_test" }
 
         it 'sets the app name on the client' do
-          expect(client.options[:app_name]).to eq(:srv_test)
+          expect(client.options[:app_name]).to eq('srv_test')
         end
       end
 
@@ -941,4 +952,126 @@ describe Mongo::URI::SRVProtocol do
       end
     end
   end
+
+  describe '#validate_hostname' do
+    let(:valid_hostname) do
+    end
+
+    let(:dummy_uri) do
+      Mongo::URI::SRVProtocol.new("mongodb+srv://test1.test.build.10gen.cc/")
+    end
+
+    let(:validate) do
+      dummy_uri.send(:validate_hostname, hostname)
+    end
+
+    context 'when the hostname is valid' do
+      let(:hostname) do
+        'a.b.c'
+      end
+
+      it 'does not raise an error' do
+        expect { validate }.not_to raise_error
+      end
+    end
+
+    context 'when the hostname has a trailing dot' do
+      let(:hostname) do
+        "a.b.c."
+      end
+
+      it 'raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI, /Hostname cannot end with a dot: a\.b\.c\./)
+      end
+    end
+
+    context 'when the hostname is empty' do
+      let(:hostname) do
+        ''
+      end
+
+      it 'raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'when the hostname has only one part' do
+      let(:hostname) do
+        'a'
+      end
+
+      it 'raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+
+    context 'when the hostname has only two parts' do
+      let(:hostname) do
+        'a.b'
+      end
+
+      it 'raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'when the hostname has an empty last part' do
+      let(:hostname) do
+        'a.b.'
+      end
+
+      it 'it raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'when multiple hostnames are specified' do
+      it 'raises an error' do
+        expect do
+          Mongo::URI::SRVProtocol.new("mongodb+srv://a.b.c,d.e.f/")
+        end.to raise_error(Mongo::Error::InvalidURI, /One and only one host is required/)
+      end
+    end
+
+    context 'when the hostname contains a colon' do
+      let(:hostname) do
+        'a.b.c:27017'
+      end
+
+      it 'raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'when the hostname starts with a dot' do
+      let(:hostname) do
+        '.a.b.c'
+      end
+
+      it 'raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'when the hostname ends with consecutive dots' do
+      let(:hostname) do
+        'a.b.c..'
+      end
+
+      it 'raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'when the hostname contains consecutive dots in the middle' do
+      let(:hostname) do
+        'a..b.c'
+      end
+
+      it 'raises an error' do
+        expect { validate }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+  end
 end

data/spec/mongo/uri_option_parsing_spec.rb

@@ -0,0 +1,511 @@
+require 'lite_spec_helper'
+
+describe Mongo::URI do
+
+  let(:uri) { described_class.new(string) }
+
+  shared_examples_for 'parses successfully' do
+    it 'returns a Mongo::URI object' do
+      expect(uri).to be_a(Mongo::URI)
+    end
+  end
+
+  shared_examples_for 'raises parse error' do
+    it 'raises InvalidURI' do
+      expect do
+        uri
+      end.to raise_error(Mongo::Error::InvalidURI)
+    end
+  end
+
+  shared_examples_for 'a millisecond option' do
+
+    let(:string) { "mongodb://example.com/?#{uri_option}=123" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a float' do
+      expect(uri.uri_options[ruby_option]).to eq(0.123)
+    end
+
+    context 'a multiple of 1 second' do
+      let(:string) { "mongodb://example.com/?#{uri_option}=123000" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is a float' do
+        expect(uri.uri_options[ruby_option]).to be_a(Float)
+        expect(uri.uri_options[ruby_option]).to eq(123)
+      end
+    end
+  end
+
+  shared_examples_for 'an integer option' do
+
+    let(:string) { "mongodb://example.com/?#{uri_option}=123" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is an integer' do
+      expect(uri.uri_options[ruby_option]).to eq(123)
+    end
+
+    context 'URL encoded value' do
+      let(:string) { "mongodb://example.com/?#{uri_option}=%31%32%33" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is an integer' do
+        expect(uri.uri_options[ruby_option]).to eq(123)
+      end
+    end
+  end
+
+  shared_examples_for 'a boolean option' do
+
+    context 'is true' do
+
+      let(:string) { "mongodb://example.com/?#{uri_option}=true" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is a boolean' do
+        expect(uri.uri_options[ruby_option]).to be true
+      end
+    end
+
+    context 'is TRUE' do
+
+      let(:string) { "mongodb://example.com/?#{uri_option}=TRUE" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is a boolean' do
+        expect(uri.uri_options[ruby_option]).to be true
+      end
+    end
+
+    context 'is false' do
+
+      let(:string) { "mongodb://example.com/?#{uri_option}=false" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is a boolean' do
+        expect(uri.uri_options[ruby_option]).to be false
+      end
+    end
+
+    context 'is FALSE' do
+
+      let(:string) { "mongodb://example.com/?#{uri_option}=FALSE" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is a boolean' do
+        expect(uri.uri_options[ruby_option]).to be false
+      end
+    end
+  end
+
+  shared_examples_for 'an inverted boolean option' do
+
+    let(:string) { "mongodb://example.com/?#{uri_option}=true" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a boolean' do
+      expect(uri.uri_options[ruby_option]).to be false
+    end
+  end
+
+  shared_examples_for 'a string option' do
+
+    let(:string) { "mongodb://example.com/?#{uri_option}=foo" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a string' do
+      expect(uri.uri_options[ruby_option]).to eq('foo')
+    end
+
+    context 'value is a number' do
+      let(:string) { "mongodb://example.com/?#{uri_option}=1" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is a string' do
+        expect(uri.uri_options[ruby_option]).to eq('1')
+      end
+    end
+  end
+
+  context 'appName' do
+
+    let(:uri_option) { 'appName' }
+    let(:ruby_option) { :app_name }
+
+    it_behaves_like 'a string option'
+  end
+
+  context 'authMechanism' do
+
+    let(:string) { 'mongodb://example.com/?authMechanism=SCRAM-SHA-256' }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a symbol' do
+      expect(uri.uri_options[:auth_mech]).to eq(:scram256)
+    end
+
+    context 'lowercase value' do
+
+      let(:string) { 'mongodb://example.com/?authMechanism=scram-sha-256' }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is mapped to auth mechanism' do
+        expect(uri.uri_options[:auth_mech]).to eq(:scram256)
+      end
+    end
+  end
+
+  context 'authMechanismProperties' do
+
+    let(:string) { 'mongodb://example.com/?authmechanismproperties=SERVICE_REALM:foo,CANONICALIZE_HOST_NAME:TRUE' }
+
+    it_behaves_like 'parses successfully'
+
+    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
+
+  context 'authSource' do
+
+    let(:uri_option) { 'authSource' }
+    let(:ruby_option) { :auth_source }
+
+    it_behaves_like 'a string option'
+  end
+
+  context 'compressors' do
+
+    let(:string) { 'mongodb://example.com/?compressors=snappy,zlib' }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is an array of strings string' do
+      expect(uri.uri_options[:compressors]).to eq(['snappy', 'zlib'])
+    end
+  end
+
+  context 'connect' do
+
+    let(:string) { 'mongodb://example.com/?connect=sharded' }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a symbol' do
+      expect(uri.uri_options[:connect]).to eq(:sharded)
+    end
+
+    context 'invalid value' do
+      let(:string) { 'mongodb://example.com/?connect=bogus' }
+
+      # should raise an error
+      it_behaves_like 'parses successfully'
+    end
+  end
+
+  context 'connectTimeoutMS' do
+
+    let(:uri_option) { 'connectTimeoutMS' }
+    let(:ruby_option) { :connect_timeout }
+
+    it_behaves_like 'a millisecond option'
+  end
+
+  context 'fsync' do
+
+    let(:string) { 'mongodb://example.com/?fsync=true' }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a boolean' do
+      expect(uri.uri_options[:write]).to eq(BSON::Document.new(fsync: true))
+    end
+  end
+
+  context 'heartbeatFrequencyMS' do
+
+    let(:uri_option) { 'heartbeatFrequencyMS' }
+    let(:ruby_option) { :heartbeat_frequency }
+
+    it_behaves_like 'a millisecond option'
+  end
+
+  context 'journal' do
+
+    let(:string) { 'mongodb://example.com/?journal=true' }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a boolean' do
+      expect(uri.uri_options[:write]).to eq(BSON::Document.new(j: true))
+    end
+  end
+
+  context 'localThresholdMS' do
+
+    let(:uri_option) { 'localThresholdMS' }
+    let(:ruby_option) { :local_threshold }
+
+    it_behaves_like 'a millisecond option'
+  end
+
+  context 'maxIdleTimeMS' do
+
+    let(:uri_option) { 'maxIdleTimeMS' }
+    let(:ruby_option) { :max_idle_time }
+
+    it_behaves_like 'a millisecond option'
+  end
+
+  context 'maxStalenessSeconds' do
+
+    let(:string) { "mongodb://example.com/?maxStalenessSeconds=123" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is an integer' do
+      expect(uri.uri_options[:read][:max_staleness]).to be_a(Integer)
+      expect(uri.uri_options[:read][:max_staleness]).to eq(123)
+    end
+
+    context '-1 as value' do
+      let(:string) { "mongodb://example.com/?maxStalenessSeconds=-1" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is converted to nil' do
+        expect(uri.uri_options[:read]).to eq(BSON::Document.new(max_staleness: nil))
+      end
+    end
+  end
+
+  context 'maxPoolSize' do
+
+    let(:uri_option) { 'maxPoolSize' }
+    let(:ruby_option) { :max_pool_size }
+
+    it_behaves_like 'an integer option'
+  end
+
+  context 'minPoolSize' do
+
+    let(:uri_option) { 'minPoolSize' }
+    let(:ruby_option) { :min_pool_size }
+
+    it_behaves_like 'an integer option'
+  end
+
+  context 'readConcernLevel' do
+
+    let(:string) { 'mongodb://example.com/?readConcernLevel=snapshot' }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a string' do
+      expect(uri.uri_options[:read_concern]).to eq(BSON::Document.new(level: 'snapshot'))
+    end
+  end
+
+  context 'readPreference' do
+
+    let(:string) { "mongodb://example.com/?readPreference=nearest" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a string' do
+      expect(uri.uri_options[:read]).to eq(BSON::Document.new(mode: :nearest))
+    end
+  end
+
+  context 'readPreferenceTags' do
+
+    let(:string) { "mongodb://example.com/?readPreferenceTags=dc:ny,rack:1" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'parses correctly' do
+      expect(uri.uri_options[:read]).to eq(BSON::Document.new(
+        tag_sets: [{'dc' => 'ny', 'rack' => '1'}]))
+    end
+  end
+
+  context 'replicaSet' do
+
+    let(:uri_option) { 'replicaSet' }
+    let(:ruby_option) { :replica_set }
+
+    it_behaves_like 'a string option'
+  end
+
+  context 'retryWrites' do
+
+    let(:uri_option) { 'retryWrites' }
+    let(:ruby_option) { :retry_writes }
+
+    it_behaves_like 'a boolean option'
+  end
+
+  context 'serverSelectionTimeoutMS' do
+
+    let(:uri_option) { 'serverSelectionTimeoutMS' }
+    let(:ruby_option) { :server_selection_timeout }
+
+    it_behaves_like 'a millisecond option'
+  end
+
+  context 'socketTimeoutMS' do
+
+    let(:uri_option) { 'socketTimeoutMS' }
+    let(:ruby_option) { :socket_timeout }
+
+    it_behaves_like 'a millisecond option'
+  end
+
+  context 'ssl' do
+
+    let(:uri_option) { 'ssl' }
+    let(:ruby_option) { :ssl }
+
+    it_behaves_like 'a boolean option'
+  end
+
+  context 'tls' do
+
+    let(:uri_option) { 'tls' }
+    let(:ruby_option) { :ssl }
+
+    it_behaves_like 'a boolean option'
+  end
+
+  context 'tlsAllowInvalidCertificates' do
+
+    let(:uri_option) { 'tlsAllowInvalidCertificates' }
+    let(:ruby_option) { :ssl_verify_certificate }
+
+    it_behaves_like 'an inverted boolean option'
+  end
+
+  context 'tlsAllowInvalidHostnames' do
+
+    let(:uri_option) { 'tlsAllowInvalidHostnames' }
+    let(:ruby_option) { :ssl_verify_hostname }
+
+    it_behaves_like 'an inverted boolean option'
+  end
+
+  context 'tlsCAFile' do
+
+    let(:uri_option) { 'tlsCAFile' }
+    let(:ruby_option) { :ssl_ca_cert }
+
+    it_behaves_like 'a string option'
+  end
+
+  context 'tlsCertificateKeyFile' do
+
+    let(:uri_option) { 'tlsCertificateKeyFile' }
+    let(:ruby_option) { :ssl_cert }
+
+    it_behaves_like 'a string option'
+  end
+
+  context 'tlsCertificateKeyFilePassword' do
+
+    let(:uri_option) { 'tlsCertificateKeyFilePassword' }
+    let(:ruby_option) { :ssl_key_pass_phrase }
+
+    it_behaves_like 'a string option'
+  end
+
+  context 'tlsInsecure' do
+
+    let(:uri_option) { 'tlsInsecure' }
+    let(:ruby_option) { :ssl_verify }
+
+    it_behaves_like 'an inverted boolean option'
+  end
+
+  context 'w' do
+
+    context 'integer value' do
+      let(:string) { "mongodb://example.com/?w=1" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is an integer' do
+        expect(uri.uri_options[:write]).to eq(BSON::Document.new(w: 1))
+      end
+    end
+
+    context 'string value' do
+      let(:string) { "mongodb://example.com/?w=foo" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is a string' do
+        expect(uri.uri_options[:write]).to eq(BSON::Document.new(w: 'foo'))
+      end
+    end
+
+    context 'majority' do
+      let(:string) { "mongodb://example.com/?w=majority" }
+
+      it_behaves_like 'parses successfully'
+
+      it 'is a symbol' do
+        expect(uri.uri_options[:write]).to eq(BSON::Document.new(w: :majority))
+      end
+    end
+  end
+
+  context 'waitQueueTimeoutMS' do
+
+    let(:uri_option) { 'waitQueueTimeoutMS' }
+    let(:ruby_option) { :wait_queue_timeout }
+
+    it_behaves_like 'a millisecond option'
+  end
+
+  context 'wtimeoutMS' do
+
+    let(:string) { "mongodb://example.com/?wtimeoutMS=100" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is a float' do
+      expect(uri.uri_options[:write]).to eq(BSON::Document.new(wtimeout: 100))
+    end
+  end
+
+  context 'zlibCompressionLevel' do
+
+    let(:uri_option) { 'zlibCompressionLevel' }
+    let(:ruby_option) { :zlib_compression_level }
+
+    let(:string) { "mongodb://example.com/?#{uri_option}=7" }
+
+    it_behaves_like 'parses successfully'
+
+    it 'is an integer' do
+      expect(uri.uri_options[ruby_option]).to eq(7)
+    end
+  end
+end