mongo 1.12.5 → 2.0.0.beta

data/spec/mongo/server_selector/secondary_spec.rb

@@ -0,0 +1,196 @@
+require 'spec_helper'
+
+describe Mongo::ServerSelector::Secondary do
+
+  include_context 'server selector'
+
+  it_behaves_like 'a read preference mode' do
+    let(:name) { :secondary }
+    let(:slave_ok) { true }
+  end
+
+  it_behaves_like 'a read preference mode accepting tag sets'
+
+  describe '#to_mongos' do
+
+    it 'returns read preference formatted for mongos' do
+      expect(read_pref.to_mongos).to eq(
+        { :mode => 'secondary' }
+      )
+    end
+
+    context 'tag sets provided' do
+      let(:tag_sets) { [tag_set] }
+
+      it 'returns read preference formatted for mongos with tag sets' do
+        expect(read_pref.to_mongos).to eq(
+          { :mode => 'secondary', :tags => tag_sets}
+        )
+      end
+    end
+  end
+
+  describe '#select' do
+
+    context 'no candidates' do
+      let(:candidates) { [] }
+
+      it 'returns an empty array' do
+        expect(read_pref.send(:select, candidates)).to be_empty
+      end
+    end
+
+    context 'single primary candidate' do
+      let(:candidates) { [primary] }
+
+      it 'returns an empty array' do
+        expect(read_pref.send(:select, candidates)).to be_empty
+      end
+    end
+
+    context 'single secondary candidate' do
+      let(:candidates) { [secondary] }
+
+      it 'returns array with secondary' do
+        expect(read_pref.send(:select, candidates)).to eq([secondary])
+      end
+    end
+
+    context 'primary and secondary candidates' do
+      let(:candidates) { [primary, secondary] }
+
+      it 'returns array with secondary' do
+        expect(read_pref.send(:select, candidates)).to eq([secondary])
+      end
+    end
+
+    context 'multiple secondary candidates' do
+      let(:candidates) { [secondary, secondary, primary] }
+
+      it 'returns array with all secondaries' do
+        expect(read_pref.send(:select, candidates)).to eq([secondary, secondary])
+      end
+    end
+
+    context 'tag sets provided' do
+      let(:tag_sets) { [tag_set] }
+      let(:matching_secondary) { server(:secondary, :tags => server_tags) }
+
+      context 'single candidate' do
+
+        context 'primary' do
+          let(:candidates) { [primary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'secondary' do
+          let(:candidates) { [secondary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'matching secondary' do
+          let(:candidates) { [matching_secondary] }
+
+          it 'returns an array with matching secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_secondary])
+          end
+        end
+      end
+
+      context 'multiple candidates' do
+
+        context 'no matching candidates' do
+          let(:candidates) { [primary, secondary, secondary] }
+
+          it 'returns an emtpy array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'one matching secondary' do
+          let(:candidates) { [secondary, matching_secondary]}
+
+          it 'returns array with matching secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_secondary])
+          end
+        end
+
+        context 'two matching secondaries' do
+          let(:candidates) { [matching_secondary, matching_secondary] }
+
+          it 'returns an array with both matching secondaries' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_secondary, matching_secondary])
+          end
+        end
+      end
+    end
+
+    context 'high latency servers' do
+      let(:far_primary) { server(:primary, :average_round_trip_time => 100) }
+      let(:far_secondary) { server(:secondary, :average_round_trip_time => 113) }
+
+      context 'single candidate' do
+
+        context 'far primary' do
+          let(:candidates) { [far_primary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'far secondary' do
+          let(:candidates) { [far_secondary] }
+
+          it 'returns an array with the secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([far_secondary])
+          end
+        end
+      end
+
+      context 'multiple candidates' do
+
+        context 'local primary, far secondary' do
+          let(:candidates) { [primary, far_secondary] }
+
+          it 'returns an array with the secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([far_secondary])
+          end
+        end
+
+        context 'far primary, far secondary' do
+          let(:candidates) { [far_primary, far_secondary] }
+
+          it 'returns an array with the secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([far_secondary])
+          end
+        end
+
+        context 'two near servers, one far server' do
+
+          context 'near primary, near and far secondaries' do
+            let(:candidates) { [primary, secondary, far_secondary] }
+
+            it 'returns an array with near secondary' do
+              expect(read_pref.send(:select, candidates)).to eq([secondary])
+            end
+          end
+
+          context 'far primary and two near secondaries' do
+            let(:candidates) { [far_primary, secondary, secondary] }
+
+            it 'returns an array with two secondaries' do
+              expect(read_pref.send(:select, candidates)).to eq([secondary, secondary])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/server_selector_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe Mongo::ServerSelector do
+
+  include_context 'server selector'
+
+  describe '.get' do
+
+    let(:read_pref) do
+      described_class.get({ :mode => name })
+    end
+
+    let(:name) { :secondary }
+    let(:tag_sets) { [{ 'test' => 'tag' }] }
+
+    context 'when the mode is primary' do
+      let(:name) { :primary }
+
+      it 'returns a read preference of class Primary' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::Primary)
+      end
+    end
+
+    context 'when the mode is primary_preferred' do
+      let(:name) { :primary_preferred }
+
+      it 'returns a read preference of class PrimaryPreferred' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::PrimaryPreferred)
+      end
+    end
+
+    context 'when the mode is secondary' do
+      let(:name) { :secondary }
+
+      it 'returns a read preference of class Secondary' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::Secondary)
+      end
+    end
+
+    context 'when the mode is secondary_preferred' do
+      let(:name) { :secondary_preferred }
+
+      it 'returns a read preference of class SecondaryPreferred' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::SecondaryPreferred)
+      end
+    end
+
+    context 'when the mode is nearest' do
+      let(:name) { :nearest }
+
+      it 'returns a read preference of class Nearest' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::Nearest)
+      end
+    end
+
+    context 'when a mode is not provided' do
+      let(:read_pref) { described_class.get }
+
+      it 'returns a read preference of class Primary' do
+        expect(read_pref).to be_a(Mongo::ServerSelector::Primary)
+      end
+    end
+
+    context 'when tag sets provided' do
+      let(:read_pref) { described_class.get(:mode => name, :tag_sets => tag_sets) }
+
+      it 'sets tag sets on the read preference object' do
+        expect(read_pref.tag_sets).to eq(tag_sets)
+      end
+    end
+  end
+
+  describe "#select_server" do
+
+    context 'when #select returns a list of nils' do
+
+      let(:servers) { [ server(:primary) ] }
+
+      let(:cluster) do
+        double('cluster').tap do |c|
+          allow(c).to receive(:servers).and_return(servers)
+          allow(c).to receive(:standalone?).and_return(false)
+          allow(c).to receive(:sharded?).and_return(false)
+          allow(c).to receive(:scan!).and_return(true)
+        end
+      end
+
+      let(:read_pref) do
+        described_class.get({ mode: :primary }, server_selection_timeout: 1).tap do |pref|
+          allow(pref).to receive(:select).and_return([ nil, nil ])
+        end
+      end
+
+      it 'raises a NoServerAvailable error' do
+        expect do
+          read_pref.select_server(cluster)
+        end.to raise_exception(Mongo::ServerSelector::NoServerAvailable)
+      end
+    end
+  end
+end

data/spec/mongo/server_spec.rb

@@ -0,0 +1,131 @@
+require 'spec_helper'
+
+describe Mongo::Server do
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  let(:address) do
+    Mongo::Address.new('127.0.0.1:27017')
+  end
+
+  describe '#==' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    context 'when the other is not a server' do
+
+      let(:other) do
+        false
+      end
+
+      it 'returns false' do
+        expect(server).to_not eq(other)
+      end
+    end
+
+    context 'when the other is a server' do
+
+      context 'when the addresses match' do
+
+        let(:other) do
+          described_class.new(address, listeners)
+        end
+
+        it 'returns true' do
+          expect(server).to eq(other)
+        end
+      end
+
+      context 'when the addresses dont match' do
+
+        let(:other_address) do
+          Mongo::Address.new('127.0.0.1:27018')
+        end
+
+        let(:other) do
+          described_class.new(other_address, listeners)
+        end
+
+        it 'returns false' do
+          expect(server).to_not eq(other)
+        end
+      end
+    end
+  end
+
+  describe '#context' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    let(:context) do
+      server.context
+    end
+
+    it 'returns a new server context' do
+      expect(context.server).to eq(server)
+    end
+  end
+
+  describe '#disconnect!' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    it 'stops the monitor instance' do
+      expect(server.instance_variable_get(:@monitor)).to receive(:stop!).and_return(true)
+      server.disconnect!
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:server) do
+      described_class.new(address, listeners, :heartbeat_frequency => 5)
+    end
+
+    it 'sets the address host' do
+      expect(server.address.host).to eq('127.0.0.1')
+    end
+
+    it 'sets the address port' do
+      expect(server.address.port).to eq(27017)
+    end
+
+    it 'sets the options' do
+      expect(server.options).to eq(:heartbeat_frequency => 5)
+    end
+  end
+
+  describe '#pool' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    let(:pool) do
+      server.pool
+    end
+
+    it 'returns the connection pool for the server' do
+      expect(pool).to be_a(Mongo::Server::ConnectionPool)
+    end
+  end
+
+  describe '#scan!' do
+
+    let(:server) do
+      described_class.new(address, listeners)
+    end
+
+    it 'forces a scan on the monitor' do
+      expect(server.scan!).to eq(server.description)
+    end
+  end
+end

data/spec/mongo/uri_spec.rb

@@ -0,0 +1,517 @@
+require 'spec_helper'
+
+describe Mongo::URI do
+  let(:scheme) { 'mongodb://' }
+  let(:uri) { described_class.new(string) }
+
+  describe '#initialize' do
+    context 'string is not uri' do
+      let(:string) { 'tyler' }
+      it 'raises an error' do
+        expect { uri }.to raise_error(Mongo::URI::Invalid)
+      end
+    end
+  end
+
+  describe '#servers' do
+    let(:string) { "#{scheme}#{servers}" }
+
+    context 'single server' do
+      let(:servers) { 'localhost' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'single server with port' do
+      let(:servers) { 'localhost:27017' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'numerical ipv4 server' do
+      let(:servers) { '127.0.0.1' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'numerical ipv6 server' do
+      let(:servers) { '[::1]:27107' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'unix socket server' do
+      let(:servers) { '/tmp/mongodb-27017.sock' }
+
+      it 'returns an array with the parsed server' do
+        expect(uri.servers).to eq([servers])
+      end
+    end
+
+    context 'multiple servers' do
+      let(:servers) { 'localhost,127.0.0.1' }
+
+      it 'returns an array with the parsed servers' do
+        expect(uri.servers).to eq(servers.split(','))
+      end
+    end
+
+    context 'multiple servers with ports' do
+      let(:servers) { '127.0.0.1:27107,localhost:27018' }
+
+      it 'returns an array with the parsed servers' do
+        expect(uri.servers).to eq(servers.split(','))
+      end
+    end
+  end
+
+  describe '#client_options' do
+
+    let(:db)          { TEST_DB }
+    let(:servers)     { 'localhost' }
+    let(:string)      { "#{scheme}#{credentials}@#{servers}/#{db}" }
+    let(:user)        { 'tyler' }
+    let(:password)    { 's3kr4t' }
+    let(:credentials) { "#{user}:#{password}" }
+
+    let(:options) do
+      uri.client_options
+    end
+
+    it 'includes the database in the options' do
+      expect(options[:database]).to eq(TEST_DB)
+    end
+
+    it 'includes the credentials in the options' do
+      expect(options[:user]).to eq(user)
+    end
+
+    it 'includes the options in the options' do
+      expect(options[:password]).to eq(password)
+    end
+  end
+
+  describe '#credentials' do
+    let(:servers)    { 'localhost' }
+    let(:string)   { "#{scheme}#{credentials}@#{servers}" }
+    let(:user)     { 'tyler' }
+
+    context 'username provided' do
+      let(:credentials) { "#{user}:" }
+
+      it 'returns the username' do
+        expect(uri.credentials[:user]).to eq(user)
+      end
+    end
+
+    context 'username and password provided' do
+      let(:password)    { 's3kr4t' }
+      let(:credentials) { "#{user}:#{password}" }
+
+      it 'returns the username' do
+        expect(uri.credentials[:user]).to eq(user)
+      end
+
+      it 'returns the password' do
+        expect(uri.credentials[:password]).to eq(password)
+      end
+    end
+  end
+
+  describe '#database' do
+    let(:servers)  { 'localhost' }
+    let(:string) { "#{scheme}#{servers}/#{db}" }
+    let(:db)     { TEST_DB }
+
+    context 'database provided' do
+      it 'returns the database name' do
+        expect(uri.database).to eq(TEST_DB)
+      end
+    end
+  end
+
+  describe '#options' do
+    let(:servers)  { 'localhost' }
+    let(:string) { "#{scheme}#{servers}/?#{options}" }
+
+    context 'when no options were provided' do
+      let(:string) { "#{scheme}#{servers}" }
+
+      it 'returns an empty hash' do
+        expect(uri.options).to be_empty
+      end
+    end
+
+    context 'write concern options provided' do
+
+      context 'numerical w value' do
+        let(:options) { 'w=1' }
+        let(:concern) { { :w => 1 } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+
+      context 'w=majority' do
+        let(:options) { 'w=majority' }
+        let(:concern) { { :w => :majority } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+
+      context 'journal' do
+        let(:options) { 'j=true' }
+        let(:concern) { { :j => true } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+
+      context 'fsync' do
+        let(:options) { 'fsync=true' }
+        let(:concern) { { :fsync => true } }
+
+        it 'sets the write concern options' do
+          expect(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 } }
+
+        it 'sets the write concern options' do
+          expect(uri.options[:write]).to eq(concern)
+        end
+      end
+    end
+
+    context 'read preference option provided' do
+      let(:options) { "readPreference=#{mode}" }
+
+      context 'primary' do
+        let(:mode) { 'primary' }
+        let(:read) { { :mode => :primary } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'primaryPreferred' do
+        let(:mode) { 'primaryPreferred' }
+        let(:read) { { :mode => :primary_preferred } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'secondary' do
+        let(:mode) { 'secondary' }
+        let(:read) { { :mode => :secondary } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'secondaryPreferred' do
+        let(:mode) { 'secondaryPreferred' }
+        let(:read) { { :mode => :secondary_preferred } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'nearest' do
+        let(:mode) { 'nearest' }
+        let(:read) { { :mode => :nearest } }
+
+        it 'sets the read preference' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+    end
+
+    context 'read preferece tags provided' do
+
+      context 'single read preference tag set' do
+        let(:options) do
+          'readPreferenceTags=dc:ny,rack:1'
+        end
+
+        let(:read) do
+          { :tag_sets => [{ :dc => 'ny', :rack => '1' }] }
+        end
+
+        it 'sets the read preference tag set' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+
+      context 'multiple read preference tag sets' do
+        let(:options) do
+          'readPreferenceTags=dc:ny&readPreferenceTags=dc:bos'
+        end
+
+        let(:read) do
+          { :tag_sets => [{ :dc => 'ny' }, { :dc => 'bos' }] }
+        end
+
+        it 'sets the read preference tag sets' do
+          expect(uri.options[:read]).to eq(read)
+        end
+      end
+    end
+
+    context 'replica set option provided' do
+      let(:rs_name) { TEST_SET }
+      let(:options) { "replicaSet=#{rs_name}" }
+
+      it 'sets the replica set option' do
+        expect(uri.options[:replica_set]).to eq(rs_name)
+      end
+    end
+
+    context 'auth mechanism provided' do
+      let(:options) { "authMechanism=#{mechanism}" }
+
+      context 'plain' do
+        let(:mechanism) { 'PLAIN' }
+        let(:auth) { { :mechanism => :plain } }
+
+        it 'sets the auth mechanism to :plain' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'mongodb-cr' do
+        let(:mechanism) { 'MONGODB-CR' }
+        let(:auth) { { :mechanism => :mongodb_cr } }
+
+        it 'sets the auth mechanism to :mongodb_cr' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'gssapi' do
+        let(:mechanism) { 'GSSAPI' }
+        let(:auth) { { :mechanism => :gssapi } }
+
+        it 'sets the auth mechanism to :gssapi' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+    end
+
+    context 'auth source provided' do
+      let(:options) { "authSource=#{source}" }
+
+      context 'regular db' do
+        let(:source) { 'foo' }
+        let(:auth) { { :source => 'foo' } }
+
+        it 'sets the auth source to the database' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context '$external' do
+        let(:source) { '$external' }
+        let(:auth) { { :source => :external } }
+
+        it 'sets the auth source to :external' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+    end
+
+    context 'auth mechanism properties provided' do
+
+      context 'service_name' do
+        let(:options) do
+          "authMechanismProperties=SERVICE_NAME:#{service_name}"
+        end
+
+        let(:service_name) { 'foo' }
+        let(:auth) do
+          { auth_mech_properties: { service_name: service_name } }
+        end
+
+        it 'sets the auth mechanism properties' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'canonicalize_host_name' do
+        let(:options) do
+          "authMechanismProperties=CANONICALIZE_HOST_NAME:#{canonicalize_host_name}"
+        end
+
+        let(:canonicalize_host_name) { 'true' }
+        let(:auth) do
+          { auth_mech_properties: { canonicalize_host_name: true } }
+        end
+
+        it 'sets the auth mechanism properties' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'service_realm' do
+        let(:options) do
+          "authMechanismProperties=SERVICE_REALM:#{service_realm}"
+        end
+
+        let(:service_realm) { 'dumdum' }
+        let(:auth) do
+          { auth_mech_properties: { service_realm: service_realm } }
+        end
+
+        it 'sets the auth mechanism properties' do
+          expect(uri.options[:auth]).to eq(auth)
+        end
+      end
+
+      context 'multiple properties' do
+        let(:options) do
+          "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(:auth) do
+          { 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)
+        end
+      end
+    end
+
+    context 'connectTimeoutMS' do
+      let(:options) { "connectTimeoutMS=4567" }
+
+      it 'sets the the connect timeout' do
+        expect(uri.options[:connect_timeout]).to eq(4.567)
+      end
+    end
+
+    context 'socketTimeoutMS' do
+      let(:options) { "socketTimeoutMS=8910" }
+
+      it 'sets the socket timeout' do
+        expect(uri.options[:socket_timeout]).to eq(8.910)
+      end
+    end
+
+    context 'when providing serverSelectionTimeoutMS' do
+
+      let(:options) { "serverSelectionTimeoutMS=3561" }
+
+      it 'sets the the connect timeout' do
+        expect(uri.options[:server_selection_timeout]).to eq(3.561)
+      end
+    end
+
+    context 'when providing localThresholdMS' do
+
+      let(:options) { "localThresholdMS=3561" }
+
+      it 'sets the the connect timeout' do
+        expect(uri.options[:local_threshold]).to eq(3.561)
+      end
+    end
+
+    context 'when providing maxPoolSize' do
+
+      let(:max_pool_size) { 10 }
+      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)
+      end
+    end
+
+    context 'when providing minPoolSize' do
+
+      let(:min_pool_size) { 5 }
+      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)
+      end
+    end
+
+    context 'when providing waitQueueTimeoutMS' do
+
+      let(:wait_queue_timeout) { 500 }
+      let(:options) { "waitQueueTimeoutMS=#{wait_queue_timeout}" }
+
+      it 'sets the wait queue timeout option' do
+        expect(uri.options[:wait_queue_timeout]).to eq(0.5)
+      end
+    end
+
+    context 'ssl' do
+      let(:options) { "ssl=#{ssl}" }
+
+      context 'true' do
+        let(:ssl) { true }
+
+        it 'sets the ssl option to true' do
+          expect(uri.options[:ssl]).to be true
+        end
+      end
+
+      context 'false' do
+        let(:ssl) { false }
+
+        it 'sets the ssl option to false' do
+          expect(uri.options[:ssl]).to be false
+        end
+      end
+    end
+
+    context 'grouped and non-grouped options provided' do
+      let(:options) { 'w=1&ssl=true' }
+
+      it 'do not overshadow top level options' do
+        expect(uri.options).not_to be_empty
+      end
+    end
+
+    context 'when an invalid option is provided' do
+
+      let(:options) { 'iDontKnow=10' }
+
+      it 'raises an exception' do
+        expect {
+          uri.options
+        }.to raise_error(Mongo::URI::InvalidOption)
+      end
+    end
+  end
+end