mongo 2.5.0 → 2.5.1

data/spec/mongo/max_staleness_spec.rb

@@ -49,6 +49,7 @@ describe 'Max Staleness Spec' do
         spec.candidate_servers.collect do |server|
           features = double('features').tap do |feat|
             allow(feat).to receive(:max_staleness_enabled?).and_return(server['maxWireVersion'] && server['maxWireVersion'] >= 5)
+            allow(feat).to receive(:check_driver_support!).and_return(true)
           end
           address = Mongo::Address.new(server['address'])
           Mongo::Server.new(address, cluster, monitoring, listeners, options).tap do |s|

data/spec/mongo/retryable_writes_spec.rb

@@ -17,13 +17,7 @@ describe 'Retryable Writes' do
           end
 
           let(:client) do
-            authorized_client.with(heartbeat_frequency: 100, retry_writes: true).tap do |cl|
-              cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-            end
-          end
-
-          let(:subscriber) do
-            EventSubscriber.new
+            authorized_client_with_retry_writes
           end
 
           before do
@@ -348,7 +342,7 @@ describe 'Retryable Writes' do
     shared_examples_for 'an operation that does not support retryable writes' do
 
       let!(:client) do
-        authorized_client.with(retry_writes: true)
+        authorized_client_with_retry_writes
       end
 
       let!(:collection) do
@@ -375,7 +369,7 @@ describe 'Retryable Writes' do
       context 'when the client has retry_writes set to true' do
 
         let!(:client) do
-          authorized_client.with(retry_writes: true)
+          authorized_client_with_retry_writes
         end
 
         context 'when the collection has write concern acknowledged' do
@@ -452,6 +446,10 @@ describe 'Retryable Writes' do
           authorized_client.with(retry_writes: false)
         end
 
+        after do
+          client.close
+        end
+
         context 'when the collection has write concern acknowledged' do
 
           let!(:collection) do

data/spec/mongo/sdam_spec.rb

@@ -46,39 +46,57 @@ describe 'Server Discovery and Monitoring' do
             end
           end
 
-          let(:cluster_addresses) do
-            @client.cluster.instance_variable_get(:@servers).
-                collect(&:address).collect(&:to_s).uniq.sort
-          end
+          if phase.outcome.compatible?
 
-          let(:phase_addresses) do
-            phase.outcome.servers.keys.sort
-          end
+            let(:cluster_addresses) do
+              @client.cluster.instance_variable_get(:@servers).
+                  collect(&:address).collect(&:to_s).uniq.sort
+            end
 
-          it "sets the cluster topology to #{phase.outcome.topology_type}" do
-            expect(@client.cluster).to be_topology(phase.outcome.topology_type)
-          end
+            let(:phase_addresses) do
+              phase.outcome.servers.keys.sort
+            end
 
-          it "sets the cluster replica set name to #{phase.outcome.set_name.inspect}" do
-            expect(@client.cluster.replica_set_name).to eq(phase.outcome.set_name)
-          end
+            it "sets the cluster topology to #{phase.outcome.topology_type}" do
+              expect(@client.cluster).to be_topology(phase.outcome.topology_type)
+            end
 
-          it "sets the cluster logical session timeout minutes to #{phase.outcome.logical_session_timeout.inspect}" do
-            expect(@client.cluster.logical_session_timeout).to eq(phase.outcome.logical_session_timeout)
-          end
+            it "sets the cluster replica set name to #{phase.outcome.set_name.inspect}" do
+              expect(@client.cluster.replica_set_name).to eq(phase.outcome.set_name)
+            end
 
-          it "has the expected servers in the cluster" do
-            expect(cluster_addresses).to eq(phase_addresses)
-          end
+            it "sets the cluster logical session timeout minutes to #{phase.outcome.logical_session_timeout.inspect}" do
+              expect(@client.cluster.logical_session_timeout).to eq(phase.outcome.logical_session_timeout)
+            end
+
+            it "has the expected servers in the cluster" do
+              expect(cluster_addresses).to eq(phase_addresses)
+            end
+
+            phase.outcome.servers.each do |uri, server|
+
+              it "sets #{uri} to #{server['type']}" do
+                expect(find_server(@client, uri)).to be_server_type(server['type'])
+              end
 
-          phase.outcome.servers.each do |uri, server|
+              it "sets #{uri} replica set name to #{server['setName'].inspect}" do
+                expect(find_server(@client, uri).replica_set_name).to eq(server['setName'])
+              end
+            end
 
-            it "sets #{uri} to #{server['type']}" do
-              expect(find_server(@client, uri)).to be_server_type(server['type'])
+          else
+
+            before do
+              @client.cluster.servers.each do |server|
+                allow(server).to receive(:connectable?).and_return(true)
+              end
             end
 
-            it "sets #{uri} replica set name to #{server['setName'].inspect}" do
-              expect(find_server(@client, uri).replica_set_name).to eq(server['setName'])
+            it 'raises an UnsupportedFeatures error' do
+              expect {
+                Mongo::ServerSelector.get(mode: :primary).select_server(@client.cluster)
+                Mongo::ServerSelector.get(mode: :secondary).select_server(@client.cluster)
+              }.to raise_exception(Mongo::Error::UnsupportedFeatures)
             end
           end
         end

data/spec/mongo/server/description/features_spec.rb

@@ -27,7 +27,7 @@ describe Mongo::Server::Description::Features do
 
       it 'raises an exception' do
         expect {
-          features
+          features.check_driver_support!
         }.to raise_error(Mongo::Error::UnsupportedFeatures)
       end
     end
@@ -51,7 +51,7 @@ describe Mongo::Server::Description::Features do
 
       it 'raises an exception' do
         expect {
-          features
+          features.check_driver_support!
         }.to raise_error(Mongo::Error::UnsupportedFeatures)
       end
     end
@@ -214,7 +214,7 @@ describe Mongo::Server::Description::Features do
 
       it 'returns false' do
         expect {
-          features
+          features.check_driver_support!
         }.to raise_exception(Mongo::Error::UnsupportedFeatures)
       end
     end

data/spec/mongo/server_selection_spec.rb

@@ -42,6 +42,7 @@ describe 'Server Selection' do
             allow(s).to receive(:secondary?).and_return(server['type'] == 'RSSecondary')
             allow(s).to receive(:primary?).and_return(server['type'] == 'RSPrimary')
             allow(s).to receive(:connectable?).and_return(true)
+            allow(s).to receive(:check_driver_support!).and_return(true)
           end
         end
       end
@@ -53,6 +54,7 @@ describe 'Server Selection' do
             allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'] / 1000.0)
             allow(s).to receive(:tags).and_return(server['tags'])
             allow(s).to receive(:connectable?).and_return(true)
+            allow(s).to receive(:check_driver_support!).and_return(true)
           end
         end
       end

data/spec/mongo/server_selector_spec.rb

@@ -208,6 +208,7 @@ describe Mongo::ServerSelector do
         make_server(:secondary).tap do |s|
           allow(s).to receive(:connectable?).and_return(true)
           allow(s).to receive(:average_round_trip_time).and_return(100)
+          allow(s).to receive(:check_driver_support!).and_return(true)
         end
       end
 
@@ -215,6 +216,7 @@ describe Mongo::ServerSelector do
         make_server(:secondary).tap do |s|
           allow(s).to receive(:connectable?).and_return(true)
           allow(s).to receive(:average_round_trip_time).and_return(200)
+          allow(s).to receive(:check_driver_support!).and_return(true)
         end
       end
 

data/spec/mongo/session/session_pool_spec.rb

@@ -2,40 +2,40 @@ require 'spec_helper'
 
 describe Mongo::Session::SessionPool, if: test_sessions? do
 
-  describe '.create' do
+  let(:cluster) do
+    authorized_client.cluster
+  end
 
-    let(:client) do
-      authorized_client
-    end
+  describe '.create' do
 
     let!(:pool) do
-      described_class.create(client)
+      described_class.create(cluster)
     end
 
     it 'creates a session pool' do
       expect(pool).to be_a(Mongo::Session::SessionPool)
     end
 
-    it 'adds the pool as an instance variable on the client' do
-      expect(client.instance_variable_get(:@session_pool)).to eq(pool)
+    it 'adds the pool as an instance variable on the cluster' do
+      expect(cluster.session_pool).to eq(pool)
     end
   end
 
   describe '#initialize' do
 
     let(:pool) do
-      described_class.new(authorized_client)
+      described_class.new(cluster)
     end
 
-    it 'sets the client' do
-      expect(pool.instance_variable_get(:@client)).to be(authorized_client)
+    it 'sets the cluster' do
+      expect(pool.instance_variable_get(:@cluster)).to be(authorized_client.cluster)
     end
   end
 
   describe '#inspect' do
 
     let(:pool) do
-      described_class.new(authorized_client)
+      described_class.new(cluster)
     end
 
     before do
@@ -55,7 +55,7 @@ describe Mongo::Session::SessionPool, if: test_sessions? do
   describe 'checkout' do
 
     let(:pool) do
-      described_class.new(authorized_client)
+      described_class.new(cluster)
     end
 
     context 'when a session is checked out' do
@@ -138,7 +138,7 @@ describe Mongo::Session::SessionPool, if: test_sessions? do
   describe '#end_sessions' do
 
     let(:pool) do
-      described_class.create(client)
+      described_class.create(client.cluster)
     end
 
     let!(:session_a) do
@@ -150,13 +150,7 @@ describe Mongo::Session::SessionPool, if: test_sessions? do
     end
 
     let(:client) do
-      authorized_client.with(heartbeat_frequency: 100).tap do |cl|
-        cl.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-      end
-    end
-
-    let(:subscriber) do
-      EventSubscriber.new
+      subscribed_client
     end
 
     after do
@@ -177,7 +171,7 @@ describe Mongo::Session::SessionPool, if: test_sessions? do
 
       let(:end_sessions_command) do
         pool.end_sessions
-        subscriber.started_events.find { |c| c.command_name == :endSessions}
+        EventSubscriber.started_events.find { |c| c.command_name == :endSessions}
       end
 
       it 'sends the endSessions command with all the session ids' do
@@ -216,7 +210,7 @@ describe Mongo::Session::SessionPool, if: test_sessions? do
       end
 
       let(:end_sessions_commands) do
-        subscriber.started_events.select { |c| c.command_name == :endSessions}
+        EventSubscriber.started_events.select { |c| c.command_name == :endSessions}
       end
 
       it 'sends the command more than once' do

data/spec/mongo/session_spec.rb

@@ -28,8 +28,8 @@ describe Mongo::Session, if: test_sessions? do
       expect(session.cluster_time).to be(nil)
     end
 
-    it 'sets the client' do
-      expect(session.client).to be(authorized_client)
+    it 'sets the cluster' do
+      expect(session.cluster).to be(authorized_client.cluster)
     end
   end
 
@@ -50,7 +50,8 @@ describe Mongo::Session, if: test_sessions? do
       end
 
       it 'includes the options in the formatted string' do
-        expect(session.inspect).to include({ causal_consistency: true }.to_s)
+        expect(session.inspect).to include({ implicit: false,
+                                             causal_consistency: true }.to_s)
       end
     end
   end
@@ -188,13 +189,13 @@ describe Mongo::Session, if: test_sessions? do
       session.instance_variable_get(:@server_session)
     end
 
-    let(:client_session_pool) do
-      session.client.instance_variable_get(:@session_pool)
+    let(:cluster_session_pool) do
+      session.cluster.session_pool
     end
 
-    it 'returns the server session to the client session pool' do
+    it 'returns the server session to the cluster session pool' do
       session.end_session
-      expect(client_session_pool.instance_variable_get(:@queue)).to include(server_session)
+      expect(cluster_session_pool.instance_variable_get(:@queue)).to include(server_session)
     end
 
     context 'when #end_session is called multiple times' do
@@ -214,7 +215,7 @@ describe Mongo::Session, if: test_sessions? do
     context 'when the option is set to true' do
 
       let(:client) do
-        authorized_client.with(retry_writes: true)
+        authorized_client_with_retry_writes
       end
 
       it 'returns true' do
@@ -228,6 +229,10 @@ describe Mongo::Session, if: test_sessions? do
         authorized_client.with(retry_writes: false)
       end
 
+      after do
+        client.close
+      end
+
       it 'returns false' do
         expect(client.start_session.retry_writes?).to be(false)
       end

data/spec/mongo/uri/srv_protocol_spec.rb

@@ -200,733 +200,736 @@ describe Mongo::URI::SRVProtocol do
     end
   end
 
-  describe 'invalid query results' do
+  describe 'valid uris', if: test_connecting_externally? do
 
-    context 'when there are too many TXT records' do
+    describe 'invalid query results' do
 
-      let(:string) { "#{scheme}test6.test.build.10gen.cc/" }
+      context 'when there are too many TXT records' do
 
-      it 'raises an error' do
-        expect { uri }.to raise_exception(Mongo::Error::InvalidTXTRecord)
+        let(:string) { "#{scheme}test6.test.build.10gen.cc/" }
+
+        it 'raises an error' do
+          expect { uri }.to raise_exception(Mongo::Error::InvalidTXTRecord)
+        end
       end
-    end
 
-    context 'when the TXT has an invalid option' do
+      context 'when the TXT has an invalid option' do
 
-      let(:string) { "#{scheme}test10.test.build.10gen.cc" }
+        let(:string) { "#{scheme}test10.test.build.10gen.cc" }
 
-      it 'raises an error' do
-        expect { uri }.to raise_exception(Mongo::Error::InvalidTXTRecord)
+        it 'raises an error' do
+          expect { uri }.to raise_exception(Mongo::Error::InvalidTXTRecord)
+        end
       end
-    end
 
-    context 'when the SRV records domain does not match hostname used for the query' do
+      context 'when the SRV records domain does not match hostname used for the query' do
 
-      let(:string) { "#{scheme}test12.test.build.10gen.cc" }
+        let(:string) { "#{scheme}test12.test.build.10gen.cc" }
 
-      it 'raises an error' do
-        expect { uri }.to raise_exception(Mongo::Error::MismatchedDomain)
+        it 'raises an error' do
+          expect { uri }.to raise_exception(Mongo::Error::MismatchedDomain)
+        end
       end
-    end
 
-    context 'when the query returns no SRV records' do
+      context 'when the query returns no SRV records' do
 
-      let(:string) { "#{scheme}test4.test.build.10gen.cc" }
+        let(:string) { "#{scheme}test4.test.build.10gen.cc" }
 
-      it 'raises an error' do
-        expect { uri }.to raise_exception(Mongo::Error::NoSRVRecords)
+        it 'raises an error' do
+          expect { uri }.to raise_exception(Mongo::Error::NoSRVRecords)
+        end
       end
     end
-  end
 
-  describe '#servers' do
-    let(:string) { "#{scheme}#{servers}" }
+    describe '#servers' do
+      let(:string) { "#{scheme}#{servers}" }
 
-    context 'single server' do
-      let(:servers) { 'test5.test.build.10gen.cc' }
+      context 'single server' do
+        let(:servers) { 'test5.test.build.10gen.cc' }
 
-      it 'returns an array with the parsed server' do
-        expect(uri.servers).to eq(['localhost.test.build.10gen.cc:27017'])
+        it 'returns an array with the parsed server' do
+          expect(uri.servers).to eq(['localhost.test.build.10gen.cc:27017'])
+        end
       end
     end
-  end
 
-  describe '#client_options' do
+    describe '#client_options' do
 
-    let(:db)          { TEST_DB }
-    let(:servers)     { 'test5.test.build.10gen.cc' }
-    let(:string)      { "#{scheme}#{credentials}@#{servers}/#{db}" }
-    let(:user)        { 'tyler' }
-    let(:password)    { 's3kr4t' }
-    let(:credentials) { "#{user}:#{password}" }
+      let(:db)          { TEST_DB }
+      let(:servers)     { 'test5.test.build.10gen.cc' }
+      let(:string)      { "#{scheme}#{credentials}@#{servers}/#{db}" }
+      let(:user)        { 'tyler' }
+      let(:password)    { 's3kr4t' }
+      let(:credentials) { "#{user}:#{password}" }
 
-    let(:options) do
-      uri.client_options
-    end
+      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 database in the options' do
+        expect(options[:database]).to eq(TEST_DB)
+      end
 
-    it 'includes the user in the options' do
-      expect(options[:user]).to eq(user)
-    end
+      it 'includes the user in the options' do
+        expect(options[:user]).to eq(user)
+      end
 
-    it 'includes the password in the options' do
-      expect(options[:password]).to eq(password)
-    end
+      it 'includes the password in the options' do
+        expect(options[:password]).to eq(password)
+      end
 
-    it 'sets ssl to true' do
-      expect(options[:ssl]).to eq(true)
+      it 'sets ssl to true' do
+        expect(options[:ssl]).to eq(true)
+      end
     end
-  end
 
-  describe '#credentials' do
-    let(:servers)    { 'test5.test.build.10gen.cc' }
-    let(:string)   { "#{scheme}#{credentials}@#{servers}" }
-    let(:user)     { 'tyler' }
+    describe '#credentials' do
+      let(:servers)    { 'test5.test.build.10gen.cc' }
+      let(:string)   { "#{scheme}#{credentials}@#{servers}" }
+      let(:user)     { 'tyler' }
 
-    context 'username provided' do
-      let(:credentials) { "#{user}:" }
+      context 'username provided' do
+        let(:credentials) { "#{user}:" }
 
-      it 'returns the username' do
-        expect(uri.credentials[:user]).to eq(user)
+        it 'returns the username' do
+          expect(uri.credentials[:user]).to eq(user)
+        end
       end
-    end
 
-    context 'username and password provided' do
-      let(:password)    { 's3kr4t' }
-      let(:credentials) { "#{user}:#{password}" }
+      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 username' do
+          expect(uri.credentials[:user]).to eq(user)
+        end
 
-      it 'returns the password' do
-        expect(uri.credentials[:password]).to eq(password)
+        it 'returns the password' do
+          expect(uri.credentials[:password]).to eq(password)
+        end
       end
     end
-  end
 
-  describe '#database' do
-    let(:servers)  { 'test5.test.build.10gen.cc' }
-    let(:string) { "#{scheme}#{servers}/#{db}" }
-    let(:db)     { 'auth-db' }
+    describe '#database' do
+      let(:servers)  { 'test5.test.build.10gen.cc' }
+      let(:string) { "#{scheme}#{servers}/#{db}" }
+      let(:db)     { 'auth-db' }
 
-    context 'database provided' do
-      it 'returns the database name' do
-        expect(uri.database).to eq(db)
+      context 'database provided' do
+        it 'returns the database name' do
+          expect(uri.database).to eq(db)
+        end
       end
     end
-  end
 
-  describe '#uri_options' do
-    let(:servers)  { 'test5.test.build.10gen.cc' }
-    let(:string) { "#{scheme}#{servers}/?#{options}" }
+    describe '#uri_options' do
+      let(:servers)  { 'test5.test.build.10gen.cc' }
+      let(:string) { "#{scheme}#{servers}/?#{options}" }
 
-    context 'when no options were provided' do
-      let(:string) { "#{scheme}#{servers}" }
+      context 'when no options were provided' do
+        let(:string) { "#{scheme}#{servers}" }
 
-      it 'returns an empty hash' do
-        expect(uri.uri_options).to be_empty
+        it 'returns an empty hash' do
+          expect(uri.uri_options).to be_empty
+        end
       end
-    end
 
-    context 'write concern options provided' do
+      context 'write concern options provided' do
 
-      context 'numerical w value' do
-        let(:options) { 'w=1' }
-        let(:concern) { Mongo::Options::Redacted.new(:w => 1)}
+        context 'numerical w value' do
+          let(:options) { 'w=1' }
+          let(:concern) { Mongo::Options::Redacted.new(:w => 1)}
 
-        it 'sets the write concern options' do
-          expect(uri.uri_options[:write]).to eq(concern)
-        end
+          it 'sets the write concern options' do
+            expect(uri.uri_options[:write]).to eq(concern)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          end
         end
-      end
 
-      context 'w=majority' do
-        let(:options) { 'w=majority' }
-        let(:concern) { Mongo::Options::Redacted.new(:w => :majority) }
+        context 'w=majority' do
+          let(:options) { 'w=majority' }
+          let(:concern) { Mongo::Options::Redacted.new(:w => :majority) }
 
-        it 'sets the write concern options' do
-          expect(uri.uri_options[:write]).to eq(concern)
-        end
+          it 'sets the write concern options' do
+            expect(uri.uri_options[:write]).to eq(concern)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          end
         end
-      end
 
-      context 'journal' do
-        let(:options) { 'journal=true' }
-        let(:concern) { Mongo::Options::Redacted.new(:j => true) }
+        context 'journal' do
+          let(:options) { 'journal=true' }
+          let(:concern) { Mongo::Options::Redacted.new(:j => true) }
 
-        it 'sets the write concern options' do
-          expect(uri.uri_options[:write]).to eq(concern)
-        end
+          it 'sets the write concern options' do
+            expect(uri.uri_options[:write]).to eq(concern)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          end
         end
-      end
 
-      context 'fsync' do
-        let(:options) { 'fsync=true' }
-        let(:concern) { Mongo::Options::Redacted.new(:fsync => true) }
+        context 'fsync' do
+          let(:options) { 'fsync=true' }
+          let(:concern) { Mongo::Options::Redacted.new(:fsync => true) }
 
-        it 'sets the write concern options' do
-          expect(uri.uri_options[:write]).to eq(concern)
-        end
+          it 'sets the write concern options' do
+            expect(uri.uri_options[:write]).to eq(concern)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          end
         end
-      end
 
-      context 'wtimeoutMS' do
-        let(:timeout) { 1234 }
-        let(:options) { "w=2&wtimeoutMS=#{timeout}" }
-        let(:concern) { Mongo::Options::Redacted.new(:w => 2, :timeout => timeout) }
+        context 'wtimeoutMS' do
+          let(:timeout) { 1234 }
+          let(:options) { "w=2&wtimeoutMS=#{timeout}" }
+          let(:concern) { Mongo::Options::Redacted.new(:w => 2, :timeout => timeout) }
 
-        it 'sets the write concern options' do
-          expect(uri.uri_options[:write]).to eq(concern)
-        end
+          it 'sets the write concern options' do
+            expect(uri.uri_options[:write]).to eq(concern)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:write]).to eq(concern)
+          end
         end
       end
-    end
 
-    context 'read preference option provided' do
-      let(:options) { "readPreference=#{mode}" }
+      context 'read preference option provided' do
+        let(:options) { "readPreference=#{mode}" }
 
-      context 'primary' do
-        let(:mode) { 'primary' }
-        let(:read) { Mongo::Options::Redacted.new(:mode => :primary) }
+        context 'primary' do
+          let(:mode) { 'primary' }
+          let(:read) { Mongo::Options::Redacted.new(:mode => :primary) }
 
-        it 'sets the read preference' do
-          expect(uri.uri_options[:read]).to eq(read)
-        end
+          it 'sets the read preference' do
+            expect(uri.uri_options[:read]).to eq(read)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          end
         end
-      end
 
-      context 'primaryPreferred' do
-        let(:mode) { 'primaryPreferred' }
-        let(:read) { Mongo::Options::Redacted.new(:mode => :primary_preferred) }
+        context 'primaryPreferred' do
+          let(:mode) { 'primaryPreferred' }
+          let(:read) { Mongo::Options::Redacted.new(:mode => :primary_preferred) }
 
-        it 'sets the read preference' do
-          expect(uri.uri_options[:read]).to eq(read)
-        end
+          it 'sets the read preference' do
+            expect(uri.uri_options[:read]).to eq(read)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          end
         end
-      end
 
-      context 'secondary' do
-        let(:mode) { 'secondary' }
-        let(:read) { Mongo::Options::Redacted.new(:mode => :secondary) }
+        context 'secondary' do
+          let(:mode) { 'secondary' }
+          let(:read) { Mongo::Options::Redacted.new(:mode => :secondary) }
 
-        it 'sets the read preference' do
-          expect(uri.uri_options[:read]).to eq(read)
-        end
+          it 'sets the read preference' do
+            expect(uri.uri_options[:read]).to eq(read)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          end
         end
-      end
 
-      context 'secondaryPreferred' do
-        let(:mode) { 'secondaryPreferred' }
-        let(:read) { Mongo::Options::Redacted.new(:mode => :secondary_preferred) }
+        context 'secondaryPreferred' do
+          let(:mode) { 'secondaryPreferred' }
+          let(:read) { Mongo::Options::Redacted.new(:mode => :secondary_preferred) }
 
-        it 'sets the read preference' do
-          expect(uri.uri_options[:read]).to eq(read)
-        end
+          it 'sets the read preference' do
+            expect(uri.uri_options[:read]).to eq(read)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          end
         end
-      end
 
-      context 'nearest' do
-        let(:mode) { 'nearest' }
-        let(:read) { Mongo::Options::Redacted.new(:mode => :nearest) }
+        context 'nearest' do
+          let(:mode) { 'nearest' }
+          let(:read) { Mongo::Options::Redacted.new(:mode => :nearest) }
 
-        it 'sets the read preference' do
-          expect(uri.uri_options[:read]).to eq(read)
-        end
+          it 'sets the read preference' do
+            expect(uri.uri_options[:read]).to eq(read)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          end
         end
       end
-    end
 
-    context 'read preference tags provided' do
+      context 'read preference tags provided' do
 
-      context 'single read preference tag set' do
-        let(:options) do
-          'readPreferenceTags=dc:ny,rack:1'
-        end
+        context 'single read preference tag set' do
+          let(:options) do
+            'readPreferenceTags=dc:ny,rack:1'
+          end
 
-        let(:read) do
-          Mongo::Options::Redacted.new(:tag_sets => [{ 'dc' => 'ny', 'rack' => '1' }])
-        end
+          let(:read) do
+            Mongo::Options::Redacted.new(:tag_sets => [{ 'dc' => 'ny', 'rack' => '1' }])
+          end
 
-        it 'sets the read preference tag set' do
-          expect(uri.uri_options[:read]).to eq(read)
+          it 'sets the read preference tag set' do
+            expect(uri.uri_options[:read]).to eq(read)
+          end
+
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          end
         end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:read]).to eq(read)
+        context 'multiple read preference tag sets' do
+          let(:options) do
+            'readPreferenceTags=dc:ny&readPreferenceTags=dc:bos'
+          end
+
+          let(:read) do
+            Mongo::Options::Redacted.new(:tag_sets => [{ 'dc' => 'ny' }, { 'dc' => 'bos' }])
+          end
+
+          it 'sets the read preference tag sets' do
+            expect(uri.uri_options[:read]).to eq(read)
+          end
+
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:read]).to eq(read)
+          end
         end
       end
 
-      context 'multiple read preference tag sets' do
+      context 'read preference max staleness option provided' do
+
         let(:options) do
-          'readPreferenceTags=dc:ny&readPreferenceTags=dc:bos'
+          'readPreference=Secondary&maxStalenessSeconds=120'
         end
 
         let(:read) do
-          Mongo::Options::Redacted.new(:tag_sets => [{ 'dc' => 'ny' }, { 'dc' => 'bos' }])
+          Mongo::Options::Redacted.new(mode: :secondary, :max_staleness => 120)
         end
 
-        it 'sets the read preference tag sets' do
+        it 'sets the read preference max staleness in seconds' do
           expect(uri.uri_options[:read]).to eq(read)
         end
 
         it 'sets the options on a client created with the uri' do
           expect(Mongo::Client.new(string).options[:read]).to eq(read)
         end
-      end
-    end
 
-    context 'read preference max staleness option provided' do
+        context 'when the read preference and max staleness combination is invalid' do
 
-      let(:options) do
-        'readPreference=Secondary&maxStalenessSeconds=120'
-      end
-
-      let(:read) do
-        Mongo::Options::Redacted.new(mode: :secondary, :max_staleness => 120)
-      end
+          context 'when max staleness is combined with read preference mode primary' do
 
-      it 'sets the read preference max staleness in seconds' do
-        expect(uri.uri_options[:read]).to eq(read)
-      end
-
-      it 'sets the options on a client created with the uri' do
-        expect(Mongo::Client.new(string).options[:read]).to eq(read)
-      end
-
-      context 'when the read preference and max staleness combination is invalid' do
-
-        context 'when max staleness is combined with read preference mode primary' do
-
-          let(:options) do
-            'readPreference=primary&maxStalenessSeconds=120'
-          end
+            let(:options) do
+              'readPreference=primary&maxStalenessSeconds=120'
+            end
 
-          it 'raises an exception when read preference is accessed on the client' do
-            expect {
-              Mongo::Client.new(string).server_selector
-            }.to raise_exception(Mongo::Error::InvalidServerPreference)
+            it 'raises an exception when read preference is accessed on the client' do
+              expect {
+                Mongo::Client.new(string).server_selector
+              }.to raise_exception(Mongo::Error::InvalidServerPreference)
+            end
           end
-        end
 
-        context 'when the max staleness value is too small' do
+          context 'when the max staleness value is too small' do
 
-          let(:options) do
-            'readPreference=secondary&maxStalenessSeconds=89'
-          end
+            let(:options) do
+              'readPreference=secondary&maxStalenessSeconds=89'
+            end
 
-          it 'does not raise an exception until the read preference is used' do
-            expect(Mongo::Client.new(string).read_preference).to eq(BSON::Document.new(mode: :secondary, max_staleness: 89))
+            it 'does not raise an exception until the read preference is used' do
+              expect(Mongo::Client.new(string).read_preference).to eq(BSON::Document.new(mode: :secondary, max_staleness: 89))
+            end
           end
         end
       end
-    end
 
-    context 'replica set option provided' do
-      let(:rs_name) { TEST_SET }
-      let(:options) { "replicaSet=#{rs_name}" }
+      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.uri_options[:replica_set]).to eq(rs_name)
-      end
+        it 'sets the replica set option' do
+          expect(uri.uri_options[:replica_set]).to eq(rs_name)
+        end
 
-      it 'sets the options on a client created with the uri' do
-        expect(Mongo::Client.new(string).options[:replica_set]).to eq(rs_name)
+        it 'sets the options on a client created with the uri' do
+          expect(Mongo::Client.new(string).options[:replica_set]).to eq(rs_name)
+        end
       end
-    end
 
-    context 'auth mechanism provided' do
-      let(:options) { "authMechanism=#{mechanism}" }
+      context 'auth mechanism provided' do
+        let(:options) { "authMechanism=#{mechanism}" }
 
-      context 'plain' do
-        let(:mechanism) { 'PLAIN' }
-        let(:expected) { :plain }
+        context 'plain' do
+          let(:mechanism) { 'PLAIN' }
+          let(:expected) { :plain }
 
-        it 'sets the auth mechanism to :plain' do
-          expect(uri.uri_options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the auth mechanism to :plain' do
+            expect(uri.uri_options[:auth_mech]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
+          end
 
-        it 'is case-insensitive' do
-          expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          it 'is case-insensitive' do
+            expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          end
         end
-      end
 
-      context 'mongodb-cr' do
-        let(:mechanism) { 'MONGODB-CR' }
-        let(:expected) { :mongodb_cr }
+        context 'mongodb-cr' do
+          let(:mechanism) { 'MONGODB-CR' }
+          let(:expected) { :mongodb_cr }
 
-        it 'sets the auth mechanism to :mongodb_cr' do
-          expect(uri.uri_options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the auth mechanism to :mongodb_cr' do
+            expect(uri.uri_options[:auth_mech]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
+          end
 
-        it 'is case-insensitive' do
-          expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          it 'is case-insensitive' do
+            expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          end
         end
-      end
 
-      context 'gssapi' do
-        let(:mechanism) { 'GSSAPI' }
-        let(:expected) { :gssapi }
+        context 'gssapi' do
+          let(:mechanism) { 'GSSAPI' }
+          let(:expected) { :gssapi }
 
-        it 'sets the auth mechanism to :gssapi' do
-          expect(uri.uri_options[:auth_mech]).to eq(expected)
-        end
+          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
-          expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
+          end
 
-        it 'is case-insensitive' do
-          expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          it 'is case-insensitive' do
+            expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          end
         end
-      end
 
-      context 'scram-sha-1' do
-        let(:mechanism) { 'SCRAM-SHA-1' }
-        let(:expected) { :scram }
+        context 'scram-sha-1' do
+          let(:mechanism) { 'SCRAM-SHA-1' }
+          let(:expected) { :scram }
 
-        it 'sets the auth mechanism to :scram' do
-          expect(uri.uri_options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the auth mechanism to :scram' do
+            expect(uri.uri_options[:auth_mech]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
+          end
 
-        it 'is case-insensitive' do
-          expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          it 'is case-insensitive' do
+            expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          end
         end
-      end
 
-      context 'mongodb-x509' do
-        let(:mechanism) { 'MONGODB-X509' }
-        let(:expected) { :mongodb_x509 }
+        context 'mongodb-x509' do
+          let(:mechanism) { 'MONGODB-X509' }
+          let(:expected) { :mongodb_x509 }
 
-        it 'sets the auth mechanism to :mongodb_x509' do
-          expect(uri.uri_options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the auth mechanism to :mongodb_x509' do
+            expect(uri.uri_options[:auth_mech]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
-        end
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech]).to eq(expected)
+          end
 
-        it 'is case-insensitive' do
-          expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
-        end
+          it 'is case-insensitive' do
+            expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+          end
 
-        context 'when a username is not provided' do
+          context 'when a username is not provided' do
 
-          it 'recognizes the mechanism with no username' do
-            expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
-            expect(Mongo::Client.new(string.downcase).options[:user]).to be_nil
+            it 'recognizes the mechanism with no username' do
+              expect(Mongo::Client.new(string.downcase).options[:auth_mech]).to eq(expected)
+              expect(Mongo::Client.new(string.downcase).options[:user]).to be_nil
+            end
           end
         end
       end
-    end
 
-    context 'auth source provided' do
-      let(:options) { "authSource=#{source}" }
+      context 'auth source provided' do
+        let(:options) { "authSource=#{source}" }
 
-      context 'regular db' do
-        let(:source) { 'foo' }
+        context 'regular db' do
+          let(:source) { 'foo' }
 
-        it 'sets the auth source to the database' do
-          expect(uri.uri_options[:auth_source]).to eq(source)
-        end
+          it 'sets the auth source to the database' do
+            expect(uri.uri_options[:auth_source]).to eq(source)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_source]).to eq(source)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_source]).to eq(source)
+          end
         end
-      end
 
-      context '$external' do
-        let(:source) { '$external' }
-        let(:expected) { :external }
+        context '$external' do
+          let(:source) { '$external' }
+          let(:expected) { :external }
 
-        it 'sets the auth source to :external' do
-          expect(uri.uri_options[:auth_source]).to eq(expected)
-        end
+          it 'sets the auth source to :external' do
+            expect(uri.uri_options[:auth_source]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_source]).to eq(expected)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_source]).to eq(expected)
+          end
         end
       end
-    end
 
-    context 'auth mechanism properties provided' do
+      context 'auth mechanism properties provided' do
 
-      context 'service_name' do
-        let(:options) do
-          "authMechanismProperties=SERVICE_NAME:#{service_name}"
-        end
+        context 'service_name' do
+          let(:options) do
+            "authMechanismProperties=SERVICE_NAME:#{service_name}"
+          end
 
-        let(:service_name) { 'foo' }
-        let(:expected) { Mongo::Options::Redacted.new({ service_name: service_name }) }
+          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)
-        end
+          it 'sets the auth mechanism properties' do
+            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_mech_properties]).to eq(expected)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech_properties]).to eq(expected)
+          end
         end
-      end
 
-      context 'canonicalize_host_name' do
-        let(:options) do
-          "authMechanismProperties=CANONICALIZE_HOST_NAME:#{canonicalize_host_name}"
-        end
-        let(:canonicalize_host_name) { 'true' }
-        let(:expected) { Mongo::Options::Redacted.new({ canonicalize_host_name: true }) }
+        context 'canonicalize_host_name' do
+          let(:options) do
+            "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)
-        end
+          it 'sets the auth mechanism properties' do
+            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_mech_properties]).to eq(expected)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech_properties]).to eq(expected)
+          end
         end
-      end
 
-      context 'service_realm' do
-        let(:options) do
-          "authMechanismProperties=SERVICE_REALM:#{service_realm}"
-        end
+        context 'service_realm' do
+          let(:options) do
+            "authMechanismProperties=SERVICE_REALM:#{service_realm}"
+          end
 
-        let(:service_realm) { 'dumdum' }
-        let(:expected) { Mongo::Options::Redacted.new({ service_realm: service_realm }) }
+          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)
-        end
+          it 'sets the auth mechanism properties' do
+            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_mech_properties]).to eq(expected)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech_properties]).to eq(expected)
+          end
         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
+        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(: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 })
-        end
+          let(:expected) 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)
-        end
+          it 'sets the auth mechanism properties' do
+            expect(uri.uri_options[:auth_mech_properties]).to eq(expected)
+          end
 
-        it 'sets the options on a client created with the uri' do
-          expect(Mongo::Client.new(string).options[:auth_mech_properties]).to eq(expected)
+          it 'sets the options on a client created with the uri' do
+            expect(Mongo::Client.new(string).options[:auth_mech_properties]).to eq(expected)
+          end
         end
       end
-    end
 
-    context 'connectTimeoutMS' do
-      let(:options) { "connectTimeoutMS=4567" }
+      context 'connectTimeoutMS' do
+        let(:options) { "connectTimeoutMS=4567" }
 
-      it 'sets the the connect timeout' do
-        expect(uri.uri_options[:connect_timeout]).to eq(4.567)
+        it 'sets the the connect timeout' do
+          expect(uri.uri_options[:connect_timeout]).to eq(4.567)
+        end
       end
-    end
 
-    context 'socketTimeoutMS' do
-      let(:options) { "socketTimeoutMS=8910" }
+      context 'socketTimeoutMS' do
+        let(:options) { "socketTimeoutMS=8910" }
 
-      it 'sets the socket timeout' do
-        expect(uri.uri_options[:socket_timeout]).to eq(8.910)
+        it 'sets the socket timeout' do
+          expect(uri.uri_options[:socket_timeout]).to eq(8.910)
+        end
       end
-    end
 
-    context 'when providing serverSelectionTimeoutMS' do
+      context 'when providing serverSelectionTimeoutMS' do
 
-      let(:options) { "serverSelectionTimeoutMS=3561" }
+        let(:options) { "serverSelectionTimeoutMS=3561" }
 
-      it 'sets the the connect timeout' do
-        expect(uri.uri_options[:server_selection_timeout]).to eq(3.561)
+        it 'sets the the connect timeout' do
+          expect(uri.uri_options[:server_selection_timeout]).to eq(3.561)
+        end
       end
-    end
 
-    context 'when providing localThresholdMS' do
+      context 'when providing localThresholdMS' do
 
-      let(:options) { "localThresholdMS=3561" }
+        let(:options) { "localThresholdMS=3561" }
 
-      it 'sets the the connect timeout' do
-        expect(uri.uri_options[:local_threshold]).to eq(3.561)
+        it 'sets the the connect timeout' do
+          expect(uri.uri_options[:local_threshold]).to eq(3.561)
+        end
       end
-    end
 
-    context 'when providing maxPoolSize' do
+      context 'when providing maxPoolSize' do
 
-      let(:max_pool_size) { 10 }
-      let(:options) { "maxPoolSize=#{max_pool_size}" }
+        let(:max_pool_size) { 10 }
+        let(:options) { "maxPoolSize=#{max_pool_size}" }
 
-      it 'sets the max pool size option' do
-        expect(uri.uri_options[:max_pool_size]).to eq(max_pool_size)
+        it 'sets the max pool size option' do
+          expect(uri.uri_options[:max_pool_size]).to eq(max_pool_size)
+        end
       end
-    end
 
-    context 'when providing minPoolSize' do
+      context 'when providing minPoolSize' do
 
-      let(:min_pool_size) { 5 }
-      let(:options) { "minPoolSize=#{min_pool_size}" }
+        let(:min_pool_size) { 5 }
+        let(:options) { "minPoolSize=#{min_pool_size}" }
 
-      it 'sets the min pool size option' do
-        expect(uri.uri_options[:min_pool_size]).to eq(min_pool_size)
+        it 'sets the min pool size option' do
+          expect(uri.uri_options[:min_pool_size]).to eq(min_pool_size)
+        end
       end
-    end
 
-    context 'when providing waitQueueTimeoutMS' do
+      context 'when providing waitQueueTimeoutMS' do
 
-      let(:wait_queue_timeout) { 500 }
-      let(:options) { "waitQueueTimeoutMS=#{wait_queue_timeout}" }
+        let(:wait_queue_timeout) { 500 }
+        let(:options) { "waitQueueTimeoutMS=#{wait_queue_timeout}" }
 
-      it 'sets the wait queue timeout option' do
-        expect(uri.uri_options[:wait_queue_timeout]).to eq(0.5)
+        it 'sets the wait queue timeout option' do
+          expect(uri.uri_options[:wait_queue_timeout]).to eq(0.5)
+        end
       end
-    end
 
-    context 'ssl' do
-      let(:options) { "ssl=#{ssl}" }
+      context 'ssl' do
+        let(:options) { "ssl=#{ssl}" }
 
-      context 'true' do
-        let(:ssl) { true }
+        context 'true' do
+          let(:ssl) { true }
 
-        it 'sets the ssl option to true' do
-          expect(uri.uri_options[:ssl]).to be true
+          it 'sets the ssl option to true' do
+            expect(uri.uri_options[:ssl]).to be true
+          end
         end
-      end
 
-      context 'false' do
-        let(:ssl) { false }
+        context 'false' do
+          let(:ssl) { false }
 
-        it 'sets the ssl option to false' do
-          expect(uri.uri_options[:ssl]).to be false
+          it 'sets the ssl option to false' do
+            expect(uri.uri_options[:ssl]).to be false
+          end
         end
       end
-    end
 
-    context 'grouped and non-grouped options provided' do
-      let(:options) { 'w=1&ssl=true' }
+      context 'grouped and non-grouped options provided' do
+        let(:options) { 'w=1&ssl=true' }
 
-      it 'do not overshadow top level options' do
-        expect(uri.uri_options).not_to be_empty
+        it 'do not overshadow top level options' do
+          expect(uri.uri_options).not_to be_empty
+        end
       end
-    end
 
-    context 'when an invalid option is provided' do
+      context 'when an invalid option is provided' do
 
-      let(:options) { 'invalidOption=10' }
+        let(:options) { 'invalidOption=10' }
 
-      let(:uri_options) do
-        uri.uri_options
-      end
+        let(:uri_options) do
+          uri.uri_options
+        end
 
-      it 'does not raise an exception' do
-        expect(uri_options).to be_empty
-      end
+        it 'does not raise an exception' do
+          expect(uri_options).to be_empty
+        end
 
-      context 'when an invalid option is combined with valid options' do
+        context 'when an invalid option is combined with valid options' do
 
-        let(:options) { 'invalidOption=10&waitQueueTimeoutMS=500&ssl=true' }
+          let(:options) { 'invalidOption=10&waitQueueTimeoutMS=500&ssl=true' }
 
-        it 'does not raise an exception' do
-          expect(uri_options).not_to be_empty
-        end
+          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
+          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
 
-    context 'when an app name option is provided' do
-      let(:options) { "appname=reports" }
+      context 'when an app name option is provided' do
+        let(:options) { "appname=reports" }
 
-      it 'sets the app name on the client' do
-        expect(Mongo::Client.new(string).options[:app_name]).to eq(:reports)
+        it 'sets the app name on the client' do
+          expect(Mongo::Client.new(string).options[:app_name]).to eq(:reports)
+        end
       end
-    end
 
-    context 'when a supported compressors option is provided' do
-      let(:options) { "compressors=zlib" }
+      context 'when a supported compressors option is provided' do
+        let(:options) { "compressors=zlib" }
 
-      it 'sets the compressors as an array on the client' do
-        expect(Mongo::Client.new(string).options[:compressors]).to eq(['zlib'])
+        it 'sets the compressors as an array on the client' do
+          expect(Mongo::Client.new(string).options[:compressors]).to eq(['zlib'])
+        end
       end
-    end
 
-    context 'when a non-supported compressors option is provided' do
-      let(:options) { "compressors=snoopy" }
+      context 'when a non-supported compressors option is provided' do
+        let(:options) { "compressors=snoopy" }
 
-      let(:client) do
-        Mongo::Client.new(string)
-      end
+        let(:client) do
+          Mongo::Client.new(string)
+        end
 
-      it 'sets no compressors on the client and warns' do
-        expect(Mongo::Logger.logger).to receive(:warn)
-        expect(client.options[:compressors]).to be_nil
+        it 'sets no compressors on the client and warns' do
+          expect(Mongo::Logger.logger).to receive(:warn)
+          expect(client.options[:compressors]).to be_nil
+        end
       end
-    end
 
-    context 'when a zlibCompressionLevel option is provided' do
-      let(:options) { "zlibCompressionLevel=6" }
+      context 'when a zlibCompressionLevel option is provided' do
+        let(:options) { "zlibCompressionLevel=6" }
 
-      it 'sets the zlib compression level on the client' do
-        expect(Mongo::Client.new(string).options[:zlib_compression_level]).to eq(6)
+        it 'sets the zlib compression level on the client' do
+          expect(Mongo::Client.new(string).options[:zlib_compression_level]).to eq(6)
+        end
       end
     end
   end