mongo 2.0.6 → 2.1.0

data/spec/mongo/uri_spec.rb

@@ -4,6 +4,217 @@ describe Mongo::URI do
   let(:scheme) { 'mongodb://' }
   let(:uri) { described_class.new(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 'empty string' do
+
+      let(:string) { '' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongo://localhost:27017' do
+
+      let(:string) { 'mongo://localhost:27017' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://' do
+
+      let(:string) { 'mongodb://' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://localhost::27017' do
+
+      let(:string) { 'mongodb://localhost::27017' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://localhost::27017/' do
+
+      let(:string) { 'mongodb://localhost::27017/' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://::' do
+
+      let(:string) { 'mongodb://::' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://localhost,localhost::' do
+
+      let(:string) { 'mongodb://localhost,localhost::' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://localhost::27017,abc' do
+
+      let(:string) { 'mongodb://localhost::27017,abc' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://localhost:-1' do
+
+      let(:string) { 'mongodb://localhost:-1' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://localhost:0/' do
+
+      let(:string) { 'mongodb://localhost:0/' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://localhost:65536' do
+
+      let(:string) { 'mongodb://localhost:65536' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://localhost:foo' do
+
+      let(:string) { 'mongodb://localhost:foo' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://[::1]:-1' do
+
+      let(:string) { 'mongodb://[::1]:-1' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://[::1]:0/' do
+
+      let(:string) { 'mongodb://[::1]:0/' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://[::1]:65536' do
+
+      let(:string) { 'mongodb://[::1]:65536' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://[::1]:65536/' do
+
+      let(:string) { 'mongodb://[::1]:65536/' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://[::1]:foo' do
+
+      let(:string) { 'mongodb://[::1]:foo' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://example.com?w=1' do
+
+      let(:string) { 'mongodb://example.com?w=1' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://example.com/?w' do
+
+      let(:string) { 'mongodb://example.com/?w' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://alice:foo:bar@127.0.0.1' do
+
+      let(:string) { 'mongodb://alice:foo:bar@127.0.0.1' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://alice@@127.0.0.1' do
+
+      let(:string) { 'mongodb://alice@@127.0.0.1' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+    context 'mongodb://alice@foo:bar@127.0.0.1' do
+
+      let(:string) { 'mongodb://alice@foo:bar@127.0.0.1' }
+
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::Error::InvalidURI)
+      end
+    end
+
+  end
+
   describe '#initialize' do
     context 'string is not uri' do
       let(:string) { 'tyler' }
@@ -49,7 +260,7 @@ describe Mongo::URI do
     end
 
     context 'unix socket server' do
-      let(:servers) { '/tmp/mongodb-27017.sock' }
+      let(:servers) { '%2Ftmp%2Fmongodb-27017.sock' }
 
       it 'returns an array with the parsed server' do
         expect(uri.servers).to eq([servers])
@@ -129,16 +340,16 @@ describe Mongo::URI do
   describe '#database' do
     let(:servers)  { 'localhost' }
     let(:string) { "#{scheme}#{servers}/#{db}" }
-    let(:db)     { TEST_DB }
+    let(:db)     { 'auth-db' }
 
     context 'database provided' do
       it 'returns the database name' do
-        expect(uri.database).to eq(TEST_DB)
+        expect(uri.database).to eq(db)
       end
     end
   end
 
-  describe '#options' do
+  describe '#uri_options' do
     let(:servers)  { 'localhost' }
     let(:string) { "#{scheme}#{servers}/?#{options}" }
 
@@ -146,7 +357,7 @@ describe Mongo::URI do
       let(:string) { "#{scheme}#{servers}" }
 
       it 'returns an empty hash' do
-        expect(uri.options).to be_empty
+        expect(uri.uri_options).to be_empty
       end
     end
 
@@ -154,47 +365,47 @@ describe Mongo::URI do
 
       context 'numerical w value' do
         let(:options) { 'w=1' }
-        let(:concern) { { :w => 1 } }
+        let(:concern) { Mongo::Options::Redacted.new(:w => 1)}
 
         it 'sets the write concern options' do
-          expect(uri.options[:write]).to eq(concern)
+          expect(uri.uri_options[:write]).to eq(concern)
         end
       end
 
       context 'w=majority' do
         let(:options) { 'w=majority' }
-        let(:concern) { { :w => :majority } }
+        let(:concern) { Mongo::Options::Redacted.new(:w => :majority) }
 
         it 'sets the write concern options' do
-          expect(uri.options[:write]).to eq(concern)
+          expect(uri.uri_options[:write]).to eq(concern)
         end
       end
 
       context 'journal' do
-        let(:options) { 'j=true' }
-        let(:concern) { { :j => true } }
+        let(:options) { 'journal=true' }
+        let(:concern) { Mongo::Options::Redacted.new(:j => true) }
 
         it 'sets the write concern options' do
-          expect(uri.options[:write]).to eq(concern)
+          expect(uri.uri_options[:write]).to eq(concern)
         end
       end
 
       context 'fsync' do
         let(:options) { 'fsync=true' }
-        let(:concern) { { :fsync => true } }
+        let(:concern) { Mongo::Options::Redacted.new(:fsync => true) }
 
         it 'sets the write concern options' do
-          expect(uri.options[:write]).to eq(concern)
+          expect(uri.uri_options[:write]).to eq(concern)
         end
       end
 
       context 'wtimeoutMS' do
         let(:timeout) { 1234 }
         let(:options) { "w=2&wtimeoutMS=#{timeout}" }
-        let(:concern) { { :w => 2, :timeout => timeout } }
+        let(:concern) { Mongo::Options::Redacted.new(:w => 2, :timeout => timeout) }
 
         it 'sets the write concern options' do
-          expect(uri.options[:write]).to eq(concern)
+          expect(uri.uri_options[:write]).to eq(concern)
         end
       end
     end
@@ -204,51 +415,51 @@ describe Mongo::URI do
 
       context 'primary' do
         let(:mode) { 'primary' }
-        let(:read) { { :mode => :primary } }
+        let(:read) { Mongo::Options::Redacted.new(:mode => :primary) }
 
         it 'sets the read preference' do
-          expect(uri.options[:read]).to eq(read)
+          expect(uri.uri_options[:read]).to eq(read)
         end
       end
 
       context 'primaryPreferred' do
         let(:mode) { 'primaryPreferred' }
-        let(:read) { { :mode => :primary_preferred } }
+        let(:read) { Mongo::Options::Redacted.new(:mode => :primary_preferred) }
 
         it 'sets the read preference' do
-          expect(uri.options[:read]).to eq(read)
+          expect(uri.uri_options[:read]).to eq(read)
         end
       end
 
       context 'secondary' do
         let(:mode) { 'secondary' }
-        let(:read) { { :mode => :secondary } }
+        let(:read) { Mongo::Options::Redacted.new(:mode => :secondary) }
 
         it 'sets the read preference' do
-          expect(uri.options[:read]).to eq(read)
+          expect(uri.uri_options[:read]).to eq(read)
         end
       end
 
       context 'secondaryPreferred' do
         let(:mode) { 'secondaryPreferred' }
-        let(:read) { { :mode => :secondary_preferred } }
+        let(:read) { Mongo::Options::Redacted.new(:mode => :secondary_preferred) }
 
         it 'sets the read preference' do
-          expect(uri.options[:read]).to eq(read)
+          expect(uri.uri_options[:read]).to eq(read)
         end
       end
 
       context 'nearest' do
         let(:mode) { 'nearest' }
-        let(:read) { { :mode => :nearest } }
+        let(:read) { Mongo::Options::Redacted.new(:mode => :nearest) }
 
         it 'sets the read preference' do
-          expect(uri.options[:read]).to eq(read)
+          expect(uri.uri_options[:read]).to eq(read)
         end
       end
     end
 
-    context 'read preferece tags provided' do
+    context 'read preference tags provided' do
 
       context 'single read preference tag set' do
         let(:options) do
@@ -256,11 +467,11 @@ describe Mongo::URI do
         end
 
         let(:read) do
-          { :tag_sets => [{ :dc => 'ny', :rack => '1' }] }
+          Mongo::Options::Redacted.new(:tag_sets => [{ 'dc' => 'ny', 'rack' => '1' }])
         end
 
         it 'sets the read preference tag set' do
-          expect(uri.options[:read]).to eq(read)
+          expect(uri.uri_options[:read]).to eq(read)
         end
       end
 
@@ -270,11 +481,11 @@ describe Mongo::URI do
         end
 
         let(:read) do
-          { :tag_sets => [{ :dc => 'ny' }, { :dc => 'bos' }] }
+          Mongo::Options::Redacted.new(:tag_sets => [{ 'dc' => 'ny' }, { 'dc' => 'bos' }])
         end
 
         it 'sets the read preference tag sets' do
-          expect(uri.options[:read]).to eq(read)
+          expect(uri.uri_options[:read]).to eq(read)
         end
       end
     end
@@ -284,7 +495,7 @@ describe Mongo::URI do
       let(:options) { "replicaSet=#{rs_name}" }
 
       it 'sets the replica set option' do
-        expect(uri.options[:replica_set]).to eq(rs_name)
+        expect(uri.uri_options[:replica_set]).to eq(rs_name)
       end
     end
 
@@ -293,28 +504,29 @@ describe Mongo::URI do
 
       context 'plain' do
         let(:mechanism) { 'PLAIN' }
-        let(:auth) { { :mechanism => :plain } }
+        let(:expected) { :plain }
 
         it 'sets the auth mechanism to :plain' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth_mech]).to eq(expected)
         end
       end
 
       context 'mongodb-cr' do
         let(:mechanism) { 'MONGODB-CR' }
-        let(:auth) { { :mechanism => :mongodb_cr } }
+        let(:expected) { :mongodb_cr }
 
         it 'sets the auth mechanism to :mongodb_cr' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth_mech]).to eq(expected)
         end
       end
 
       context 'gssapi' do
         let(:mechanism) { 'GSSAPI' }
-        let(:auth) { { :mechanism => :gssapi } }
+        let(:expected) { :gssapi }
+
 
         it 'sets the auth mechanism to :gssapi' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth_mech]).to eq(expected)
         end
       end
     end
@@ -324,19 +536,19 @@ describe Mongo::URI do
 
       context 'regular db' do
         let(:source) { 'foo' }
-        let(:auth) { { :source => 'foo' } }
+        let(:auth) { Mongo::Options::Redacted.new(:source => 'foo') }
 
         it 'sets the auth source to the database' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth]).to eq(auth)
         end
       end
 
       context '$external' do
         let(:source) { '$external' }
-        let(:auth) { { :source => :external } }
+        let(:auth) { Mongo::Options::Redacted.new(:source => :external) }
 
         it 'sets the auth source to :external' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth]).to eq(auth)
         end
       end
     end
@@ -350,11 +562,11 @@ describe Mongo::URI do
 
         let(:service_name) { 'foo' }
         let(:auth) do
-          { auth_mech_properties: { service_name: service_name } }
+          Mongo::Options::Redacted.new(auth_mech_properties: { service_name: service_name })
         end
 
         it 'sets the auth mechanism properties' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth]).to eq(auth)
         end
       end
 
@@ -365,11 +577,11 @@ describe Mongo::URI do
 
         let(:canonicalize_host_name) { 'true' }
         let(:auth) do
-          { auth_mech_properties: { canonicalize_host_name: true } }
+          Mongo::Options::Redacted.new(auth_mech_properties: { canonicalize_host_name: true })
         end
 
         it 'sets the auth mechanism properties' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth]).to eq(auth)
         end
       end
 
@@ -380,11 +592,11 @@ describe Mongo::URI do
 
         let(:service_realm) { 'dumdum' }
         let(:auth) do
-          { auth_mech_properties: { service_realm: service_realm } }
+          Mongo::Options::Redacted.new(auth_mech_properties: { service_realm: service_realm })
         end
 
         it 'sets the auth mechanism properties' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth]).to eq(auth)
         end
       end
 
@@ -400,13 +612,13 @@ describe Mongo::URI do
         let(:service_realm) { 'dumdum' }
 
         let(:auth) do
-          { auth_mech_properties: { service_name: service_name,
-                                    canonicalize_host_name: true,
-                                    service_realm: service_realm } }
+          Mongo::Options::Redacted.new(auth_mech_properties: { service_name: service_name,
+                                                               canonicalize_host_name: true,
+                                                               service_realm: service_realm })
         end
 
         it 'sets the auth mechanism properties' do
-          expect(uri.options[:auth]).to eq(auth)
+          expect(uri.uri_options[:auth]).to eq(auth)
         end
       end
     end
@@ -415,7 +627,7 @@ describe Mongo::URI do
       let(:options) { "connectTimeoutMS=4567" }
 
       it 'sets the the connect timeout' do
-        expect(uri.options[:connect_timeout]).to eq(4.567)
+        expect(uri.uri_options[:connect_timeout]).to eq(4.567)
       end
     end
 
@@ -423,7 +635,7 @@ describe Mongo::URI do
       let(:options) { "socketTimeoutMS=8910" }
 
       it 'sets the socket timeout' do
-        expect(uri.options[:socket_timeout]).to eq(8.910)
+        expect(uri.uri_options[:socket_timeout]).to eq(8.910)
       end
     end
 
@@ -432,7 +644,7 @@ describe Mongo::URI do
       let(:options) { "serverSelectionTimeoutMS=3561" }
 
       it 'sets the the connect timeout' do
-        expect(uri.options[:server_selection_timeout]).to eq(3.561)
+        expect(uri.uri_options[:server_selection_timeout]).to eq(3.561)
       end
     end
 
@@ -441,7 +653,7 @@ describe Mongo::URI do
       let(:options) { "localThresholdMS=3561" }
 
       it 'sets the the connect timeout' do
-        expect(uri.options[:local_threshold]).to eq(3.561)
+        expect(uri.uri_options[:local_threshold]).to eq(3.561)
       end
     end
 
@@ -451,7 +663,7 @@ describe Mongo::URI do
       let(:options) { "maxPoolSize=#{max_pool_size}" }
 
       it 'sets the max pool size option' do
-        expect(uri.options[:max_pool_size]).to eq(max_pool_size)
+        expect(uri.uri_options[:max_pool_size]).to eq(max_pool_size)
       end
     end
 
@@ -461,7 +673,7 @@ describe Mongo::URI do
       let(:options) { "minPoolSize=#{min_pool_size}" }
 
       it 'sets the min pool size option' do
-        expect(uri.options[:min_pool_size]).to eq(min_pool_size)
+        expect(uri.uri_options[:min_pool_size]).to eq(min_pool_size)
       end
     end
 
@@ -471,7 +683,7 @@ describe Mongo::URI do
       let(:options) { "waitQueueTimeoutMS=#{wait_queue_timeout}" }
 
       it 'sets the wait queue timeout option' do
-        expect(uri.options[:wait_queue_timeout]).to eq(0.5)
+        expect(uri.uri_options[:wait_queue_timeout]).to eq(0.5)
       end
     end
 
@@ -482,7 +694,7 @@ describe Mongo::URI do
         let(:ssl) { true }
 
         it 'sets the ssl option to true' do
-          expect(uri.options[:ssl]).to be true
+          expect(uri.uri_options[:ssl]).to be true
         end
       end
 
@@ -490,7 +702,7 @@ describe Mongo::URI do
         let(:ssl) { false }
 
         it 'sets the ssl option to false' do
-          expect(uri.options[:ssl]).to be false
+          expect(uri.uri_options[:ssl]).to be false
         end
       end
     end
@@ -499,18 +711,34 @@ describe Mongo::URI do
       let(:options) { 'w=1&ssl=true' }
 
       it 'do not overshadow top level options' do
-        expect(uri.options).not_to be_empty
+        expect(uri.uri_options).not_to be_empty
       end
     end
 
     context 'when an invalid option is provided' do
 
-      let(:options) { 'iDontKnow=10' }
+      let(:options) { 'invalidOption=10' }
+
+      let(:uri_options) do
+        uri.uri_options
+      end
+
+      it 'does not raise an exception' do
+        expect(uri_options).to be_empty
+      end
 
-      it 'raises an exception' do
-        expect {
-          uri.options
-        }.to raise_error(Mongo::Error::InvalidURIOption)
+      context 'when an invalid option is combined with valid options' do
+
+        let(:options) { 'invalidOption=10&waitQueueTimeoutMS=500&ssl=true' }
+
+        it 'does not raise an exception' do
+          expect(uri_options).not_to be_empty
+        end
+
+        it 'sets the valid options' do
+          expect(uri_options[:wait_queue_timeout]).to eq(0.5)
+          expect(uri_options[:ssl]).to be true
+        end
       end
     end
   end