mongo 2.4.3 → 2.5.0.beta

data/spec/mongo/client_spec.rb

@@ -218,6 +218,119 @@ describe Mongo::Client do
 
     context 'when providing options' do
 
+      context 'when compressors are provided' do
+
+        let(:client) do
+          described_class.new([default_address.seed], authorized_client.options.merge(options))
+        end
+
+        after do
+          client.close
+        end
+
+        context 'when the compressor is supported' do
+
+          let(:options) do
+            { compressors: ['zlib'] }
+          end
+
+          it 'sets the compressor' do
+            expect(client.options['compressors']).to eq(options[:compressors])
+          end
+
+          it 'sends the compressor in the compression key of the handshake document' do
+            expect(client.cluster.app_metadata.send(:document)[:compression]).to eq(options[:compressors])
+          end
+
+          it 'uses compression for messages', if: testing_compression? do
+            expect(Mongo::Protocol::Compressed).to receive(:new).and_call_original
+            client[TEST_COLL].find({}, limit: 1).first
+          end
+
+          it 'does not use compression for authentication messages' do
+            expect(Mongo::Protocol::Compressed).not_to receive(:new)
+            client.cluster.next_primary.send(:with_connection) do |conn|
+              conn.send(:authenticate!)
+            end
+          end
+        end
+
+        context 'when the compressor is not supported by the driver' do
+
+          let(:options) do
+            { compressors: ['snoopy'] }
+          end
+
+          it 'does not set the compressor and warns' do
+            expect(Mongo::Logger.logger).to receive(:warn)
+            expect(client.options['compressors']).to be_nil
+          end
+
+          it 'sets the compression key of the handshake document to an empty array' do
+            expect(client.cluster.app_metadata.send(:document)[:compression]).to eq([])
+          end
+
+          context 'when one supported compressor and one unsupported compressor are provided', if: compression_enabled? do
+
+            let(:options) do
+              { compressors: ['zlib', 'snoopy'] }
+            end
+
+            it 'does not set the unsupported compressor and warns' do
+              expect(Mongo::Logger.logger).to receive(:warn).at_least(:once)
+              expect(client.options['compressors']).to eq(['zlib'])
+            end
+
+            it 'sets the compression key of the handshake document to the list of supported compressors' do
+              expect(client.cluster.app_metadata.send(:document)[:compression]).to eq(['zlib'])
+            end
+          end
+        end
+
+        context 'when the compressor is not supported by the server', unless: collation_enabled? do
+
+          let(:options) do
+            { compressors: ['zlib'] }
+          end
+
+          it 'does not set the compressor and warns' do
+            expect(Mongo::Logger.logger).to receive(:warn).at_least(:once)
+            expect(client.cluster.next_primary.monitor.compressor).to be_nil
+          end
+        end
+      end
+
+      context 'when compressors are not provided', unless: compression_enabled? do
+
+        let(:client) do
+          authorized_client
+        end
+
+        it 'does not set the compressor' do
+          expect(client.options['compressors']).to be_nil
+        end
+
+        it 'sets the compression key of the handshake document to an empty array' do
+          expect(client.cluster.app_metadata.send(:document)[:compression]).to eq([])
+        end
+
+        it 'does not use compression for messages' do
+          client[TEST_COLL].find({}, limit: 1).first
+          expect(Mongo::Protocol::Compressed).not_to receive(:new)
+        end
+      end
+
+      context 'when a zlib_compression_level option is provided', if: testing_compression? do
+
+        let(:client) do
+          described_class.new([default_address.seed], TEST_OPTIONS.merge(zlib_compression_level: 1))
+        end
+
+        it 'sets the option on the client' do
+          expect(client.options[:zlib_compression_level]).to eq(1)
+        end
+      end
+
       context 'when ssl options are provided' do
 
         let(:options) do
@@ -444,6 +557,25 @@ describe Mongo::Client do
         end
       end
 
+      context 'when max_pool_size and min_pool_size are both nil' do
+
+        let(:client) do
+          described_class.new(['127.0.0.1:27017'], options)
+        end
+
+        let(:options) do
+          {
+              :min_pool_size => nil,
+              :max_pool_size => nil
+          }
+        end
+
+        it 'does not set either option' do
+          expect(client.options[:max_pool_size]).to be_nil
+          expect(client.options[:min_pool_size]).to be_nil
+        end
+      end
+
       context 'when platform details are specified' do
 
         let(:app_metadata) do
@@ -690,6 +822,122 @@ describe Mongo::Client do
     end
   end
 
+  describe '#server_selector' do
+
+    context 'when there is a read preference set' do
+
+      let(:client) do
+        described_class.new(['127.0.0.1:27017'],
+                            :database => TEST_DB,
+                            :read => mode,
+                            :server_selection_timeout => 2)
+      end
+
+      let(:server_selector) do
+        client.server_selector
+      end
+
+      context 'when mode is primary' do
+
+        let(:mode) do
+          { :mode => :primary }
+        end
+
+        it 'returns a primary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::Primary)
+        end
+
+        it 'passes the options to the cluster' do
+          expect(client.cluster.options[:server_selection_timeout]).to eq(2)
+        end
+      end
+
+      context 'when mode is primary_preferred' do
+
+        let(:mode) do
+          { :mode => :primary_preferred }
+        end
+
+        it 'returns a primary preferred server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::PrimaryPreferred)
+        end
+      end
+
+      context 'when mode is secondary' do
+
+        let(:mode) do
+          { :mode => :secondary }
+        end
+
+        it 'uses a Secondary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::Secondary)
+        end
+      end
+
+      context 'when mode is secondary preferred' do
+
+        let(:mode) do
+          { :mode => :secondary_preferred }
+        end
+
+        it 'uses a Secondary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::SecondaryPreferred)
+        end
+      end
+
+      context 'when mode is nearest' do
+
+        let(:mode) do
+          { :mode => :nearest }
+        end
+
+        it 'uses a Secondary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::Nearest)
+        end
+      end
+
+      context 'when no mode provided' do
+
+        let(:client) do
+          described_class.new(['127.0.0.1:27017'],
+                              :database => TEST_DB,
+                              :server_selection_timeout => 2)
+        end
+
+        it 'returns a primary server selector' do
+          expect(server_selector).to be_a(Mongo::ServerSelector::Primary)
+        end
+      end
+
+      context 'when the read preference is printed' do
+
+        let(:client) do
+          described_class.new([ default_address.to_s ], options)
+        end
+
+        let(:options) do
+          { user: 'Emily', password: 'sensitive_data', server_selection_timeout: 0.1 }
+        end
+
+        before do
+          allow(client.database.cluster).to receive(:single?).and_return(false)
+        end
+
+        let(:error) do
+          begin
+            client.database.command(ping: 1)
+          rescue => e
+            e
+          end
+        end
+
+        it 'redacts sensitive client options' do
+          expect(error.message).not_to match(options[:password])
+        end
+      end
+    end
+  end
+
   describe '#read_preference' do
 
     let(:client) do
@@ -710,11 +958,7 @@ describe Mongo::Client do
       end
 
       it 'returns a primary read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::Primary)
-      end
-
-      it 'passes the options to the cluster' do
-        expect(client.cluster.options[:server_selection_timeout]).to eq(2)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
@@ -725,7 +969,7 @@ describe Mongo::Client do
       end
 
       it 'returns a primary preferred read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::PrimaryPreferred)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
@@ -736,7 +980,7 @@ describe Mongo::Client do
       end
 
       it 'returns a secondary read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::Secondary)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
@@ -747,7 +991,7 @@ describe Mongo::Client do
       end
 
       it 'returns a secondary preferred read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::SecondaryPreferred)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
@@ -758,45 +1002,20 @@ describe Mongo::Client do
       end
 
       it 'returns a nearest read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::Nearest)
+        expect(preference).to eq(BSON::Document.new(mode))
       end
     end
 
     context 'when no mode provided' do
 
-      let(:mode) do
-        {}
-      end
-
-      it 'returns a primary read preference' do
-        expect(preference).to be_a(Mongo::ServerSelector::Primary)
-      end
-    end
-
-    context 'when the read preference is printed' do
-
       let(:client) do
-        described_class.new([ default_address.to_s ], options)
+        described_class.new(['127.0.0.1:27017'],
+                            :database => TEST_DB,
+                            :server_selection_timeout => 2)
       end
 
-      let(:options) do
-        { user: 'Emily', password: 'sensitive_data', server_selection_timeout: 0.1 }
-      end
-
-      before do
-        allow(client.database.cluster).to receive(:single?).and_return(false)
-      end
-
-      let(:error) do
-        begin
-          client.database.command(ping: 1)
-        rescue => e
-          e
-        end
-      end
-
-      it 'redacts sensitive client options' do
-        expect(error.message).not_to match(options[:password])
+      it 'returns nil' do
+        expect(preference).to be_nil
       end
     end
   end
@@ -1133,4 +1352,102 @@ describe Mongo::Client do
       expect(authorized_client.collections).to all(be_a(Mongo::Collection))
     end
   end
+
+  describe '#start_session' do
+
+    let(:session) do
+      authorized_client.start_session
+    end
+
+    context 'when sessions are supported', if: sessions_enabled? do
+
+      it 'creates a session' do
+        expect(session).to be_a(Mongo::Session)
+      end
+
+      it 'sets the last use field to the current time' do
+        expect(session.instance_variable_get(:@server_session).last_use).to be_within(0.2).of(Time.now)
+      end
+
+      context 'when options are provided' do
+
+        let(:options) do
+          { causally_consistent: true }
+        end
+
+        let(:session) do
+          authorized_client.start_session(options)
+        end
+
+        it 'sets the options on the session' do
+          expect(session.options).to eq(options)
+        end
+      end
+
+      context 'when options are not provided' do
+
+        it 'does not set options on the session' do
+          expect(session.options).to be_empty
+        end
+      end
+
+      context 'when a session is checked out and checked back in' do
+
+        let!(:session_a) do
+          authorized_client.start_session
+        end
+
+        let!(:session_b) do
+          authorized_client.start_session
+        end
+
+        let!(:session_a_server_session) do
+          session_a.instance_variable_get(:@server_session)
+        end
+
+        let!(:session_b_server_session) do
+          session_b.instance_variable_get(:@server_session)
+        end
+
+        before do
+          session_a.end_session
+          session_b.end_session
+        end
+
+        it 'is returned to the front of the queue' do
+          expect(authorized_client.start_session.instance_variable_get(:@server_session)).to be(session_b_server_session)
+          expect(authorized_client.start_session.instance_variable_get(:@server_session)).to be(session_a_server_session)
+        end
+      end
+
+      context 'when an implicit session is used' do
+
+        before do
+          authorized_client.database.command(ping: 1)
+        end
+
+        let(:pool) do
+          authorized_client.instance_variable_get(:@session_pool)
+        end
+
+        let!(:before_last_use) do
+          pool.instance_variable_get(:@queue)[0].last_use
+        end
+
+        it 'uses the session and updates the last use time' do
+          authorized_client.database.command(ping: 1)
+          expect(before_last_use).to be < (pool.instance_variable_get(:@queue)[0].last_use)
+        end
+      end
+    end
+
+    context 'when sessions are not supported', unless: sessions_enabled? do
+
+      it 'raises an exception' do
+        expect {
+          session
+        }.to raise_exception(Mongo::Error::InvalidSession)
+      end
+    end
+  end
 end