mongo 2.20.0 → 2.21.0

data/spec/mongo/query_cache_spec.rb

@@ -138,12 +138,19 @@ describe Mongo::QueryCache do
   end
 
   describe '#get' do
-    let(:view) { double("Mongo::Collection::View") }
+    let(:view) do
+      double("Mongo::Collection::View").tap do |view|
+        allow(view).to receive(:client).and_return(client)
+        allow(view).to receive(:operation_timeouts).and_return({})
+      end
+    end
+
     let(:result) do
       double("Mongo::Operation::Result").tap do |result|
         allow(result).to receive(:is_a?).with(Mongo::Operation::Result).and_return(true)
       end
     end
+
     let(:server) { double("Mongo::Server") }
     let(:caching_cursor) { Mongo::CachingCursor.new(view, result, server) }
 
@@ -161,257 +168,268 @@ describe Mongo::QueryCache do
       allow(view).to receive(:limit) { nil }
     end
 
-    context 'when there is no entry in the cache' do
-      it 'returns nil' do
-        expect(Mongo::QueryCache.get(**options)).to be_nil
-      end
-    end
-
-    context 'when there is an entry in the cache' do
-      before do
-        Mongo::QueryCache.set(caching_cursor, **caching_cursor_options)
-      end
-
-      context 'when that entry has no limit' do
-        let(:caching_cursor_options) do
-          {
-            namespace: 'db.coll',
-            selector: { field: 'value' },
-          }
-        end
-
-        let(:query_options) do
-          caching_cursor_options.merge(limit: limit)
-        end
-
-        context 'when the query has a limit' do
-          let(:limit) { 5 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-
-        context 'when the query has a limit but negative' do
-          let(:limit) { -5 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-
-        context 'when the query has no limit' do
-          let(:limit) { nil }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-
-        context 'when the query has a 0 limit' do
-          let(:limit) { 0 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-      end
-
-      context 'when that entry has a 0 limit' do
-        let(:caching_cursor_options) do
-          {
-            namespace: 'db.coll',
-            selector: { field: 'value' },
-            limit: 0,
-          }
-        end
-
-        let(:query_options) do
-          caching_cursor_options.merge(limit: limit)
-        end
-
-        before do
-          allow(view).to receive(:limit) { 0 }
-        end
-
-        context 'when the query has a limit' do
-          let(:limit) { 5 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-
-        context 'when the query has a limit but negative' do
-          let(:limit) { -5 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-
-
-        context 'when the query has no limit' do
-          let(:limit) { nil }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-
-        context 'when the query has a 0 limit' do
-          let(:limit) { 0 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-      end
-
-      context 'when that entry has a limit' do
-        let(:caching_cursor_options) do
-          {
-            namespace: 'db.coll',
-            selector: { field: 'value' },
-            limit: 5,
-          }
-        end
-
-        let(:query_options) do
-          caching_cursor_options.merge(limit: limit)
-        end
-
+    [true, false].each do |load_balancer|
+      context "when load_balancer is #{load_balancer}" do
         before do
-          allow(view).to receive(:limit) { 5 }
-        end
-
-        context 'and the new query has a smaller limit' do
-          let(:limit) { 4 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-
-        context 'and the new query has a smaller limit but negative' do
-          let(:limit) { -4 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+          allow(server).to receive(:load_balancer?) { load_balancer }
+          if load_balancer
+            allow(result).to receive(:connection) { nil }
           end
         end
 
-        context 'and the new query has a larger limit' do
-          let(:limit) { 6 }
-
+        context 'when there is no entry in the cache' do
           it 'returns nil' do
-            expect(Mongo::QueryCache.get(**query_options)).to be_nil
+            expect(Mongo::QueryCache.get(**options)).to be_nil
           end
         end
 
-        context 'and the new query has a larger limit but negative' do
-          let(:limit) { -6 }
-
-          it 'returns nil' do
-            expect(Mongo::QueryCache.get(**query_options)).to be_nil
-          end
-        end
-
-        context 'and the new query has the same limit' do
-          let(:limit) { 5 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
-
-        context 'and the new query has the same limit but negative' do
-          let(:limit) { -5 }
-
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+        context 'when there is an entry in the cache' do
+          before do
+            Mongo::QueryCache.set(caching_cursor, **caching_cursor_options)
           end
-        end
-
-        context 'and the new query has no limit' do
-          let(:limit) { nil }
 
-          it 'returns nil' do
-            expect(Mongo::QueryCache.get(**query_options)).to be_nil
+          context 'when that entry has no limit' do
+            let(:caching_cursor_options) do
+              {
+                namespace: 'db.coll',
+                selector: { field: 'value' },
+              }
+            end
+
+            let(:query_options) do
+              caching_cursor_options.merge(limit: limit)
+            end
+
+            context 'when the query has a limit' do
+              let(:limit) { 5 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'when the query has a limit but negative' do
+              let(:limit) { -5 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'when the query has no limit' do
+              let(:limit) { nil }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'when the query has a 0 limit' do
+              let(:limit) { 0 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
           end
-        end
 
-        context 'and the new query has a 0 limit' do
-          let(:limit) { 0 }
+          context 'when that entry has a 0 limit' do
+            let(:caching_cursor_options) do
+              {
+                namespace: 'db.coll',
+                selector: { field: 'value' },
+                limit: 0,
+              }
+            end
 
-          it 'returns nil' do
-            expect(Mongo::QueryCache.get(**query_options)).to be_nil
-          end
-        end
-      end
-
-      context 'when that entry has a negative limit' do
-        let(:caching_cursor_options) do
-          {
-            namespace: 'db.coll',
-            selector: { field: 'value' },
-            limit: -5,
-          }
-        end
+            let(:query_options) do
+              caching_cursor_options.merge(limit: limit)
+            end
 
-        let(:query_options) do
-          caching_cursor_options.merge(limit: limit)
-        end
+            before do
+              allow(view).to receive(:limit) { 0 }
+            end
 
-        before do
-          allow(view).to receive(:limit) { -5 }
-        end
+            context 'when the query has a limit' do
+              let(:limit) { 5 }
 
-        context 'and the new query has a smaller limit' do
-          let(:limit) { 4 }
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
 
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
+            context 'when the query has a limit but negative' do
+              let(:limit) { -5 }
 
-        context 'and the new query has a larger limit' do
-          let(:limit) { 6 }
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
 
-          it 'returns nil' do
-            expect(Mongo::QueryCache.get(**query_options)).to be_nil
-          end
-        end
 
-        context 'and the new query has the same negative limit' do
-          let(:limit) { -5 }
+            context 'when the query has no limit' do
+              let(:limit) { nil }
 
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
-          end
-        end
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
 
-        context 'and the new query has the same positive limit' do
-          let(:limit) { 5 }
+            context 'when the query has a 0 limit' do
+              let(:limit) { 0 }
 
-          it 'returns the caching cursor' do
-            expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
           end
-        end
-
-        context 'and the new query has no limit' do
-          let(:limit) { nil }
 
-          it 'returns nil' do
-            expect(Mongo::QueryCache.get(**query_options)).to be_nil
+          context 'when that entry has a limit' do
+            let(:caching_cursor_options) do
+              {
+                namespace: 'db.coll',
+                selector: { field: 'value' },
+                limit: 5,
+              }
+            end
+
+            let(:query_options) do
+              caching_cursor_options.merge(limit: limit)
+            end
+
+            before do
+              allow(view).to receive(:limit) { 5 }
+            end
+
+            context 'and the new query has a smaller limit' do
+              let(:limit) { 4 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'and the new query has a smaller limit but negative' do
+              let(:limit) { -4 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'and the new query has a larger limit' do
+              let(:limit) { 6 }
+
+              it 'returns nil' do
+                expect(Mongo::QueryCache.get(**query_options)).to be_nil
+              end
+            end
+
+            context 'and the new query has a larger limit but negative' do
+              let(:limit) { -6 }
+
+              it 'returns nil' do
+                expect(Mongo::QueryCache.get(**query_options)).to be_nil
+              end
+            end
+
+            context 'and the new query has the same limit' do
+              let(:limit) { 5 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'and the new query has the same limit but negative' do
+              let(:limit) { -5 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'and the new query has no limit' do
+              let(:limit) { nil }
+
+              it 'returns nil' do
+                expect(Mongo::QueryCache.get(**query_options)).to be_nil
+              end
+            end
+
+            context 'and the new query has a 0 limit' do
+              let(:limit) { 0 }
+
+              it 'returns nil' do
+                expect(Mongo::QueryCache.get(**query_options)).to be_nil
+              end
+            end
           end
-        end
-
-        context 'and the new query has a 0 limit' do
-          let(:limit) { 0 }
 
-          it 'returns nil' do
-            expect(Mongo::QueryCache.get(**query_options)).to be_nil
+          context 'when that entry has a negative limit' do
+            let(:caching_cursor_options) do
+              {
+                namespace: 'db.coll',
+                selector: { field: 'value' },
+                limit: -5,
+              }
+            end
+
+            let(:query_options) do
+              caching_cursor_options.merge(limit: limit)
+            end
+
+            before do
+              allow(view).to receive(:limit) { -5 }
+            end
+
+            context 'and the new query has a smaller limit' do
+              let(:limit) { 4 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'and the new query has a larger limit' do
+              let(:limit) { 6 }
+
+              it 'returns nil' do
+                expect(Mongo::QueryCache.get(**query_options)).to be_nil
+              end
+            end
+
+            context 'and the new query has the same negative limit' do
+              let(:limit) { -5 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'and the new query has the same positive limit' do
+              let(:limit) { 5 }
+
+              it 'returns the caching cursor' do
+                expect(Mongo::QueryCache.get(**query_options)).to eq(caching_cursor)
+              end
+            end
+
+            context 'and the new query has no limit' do
+              let(:limit) { nil }
+
+              it 'returns nil' do
+                expect(Mongo::QueryCache.get(**query_options)).to be_nil
+              end
+            end
+
+            context 'and the new query has a 0 limit' do
+              let(:limit) { 0 }
+
+              it 'returns nil' do
+                expect(Mongo::QueryCache.get(**query_options)).to be_nil
+              end
+            end
           end
         end
       end

data/spec/mongo/retryable_spec.rb

@@ -76,6 +76,7 @@ class ModernRetryableTestConsumer < LegacyRetryableTestConsumer
       allow(session).to receive(:pinned_connection_global_id)
       allow(session).to receive(:starting_transaction?).and_return(false)
       allow(session).to receive(:materialize)
+      allow(session).to receive(:with_transaction_deadline).and_return(nil)
     end
   end
 

data/spec/mongo/server/connection_spec.rb

@@ -583,6 +583,28 @@ describe Mongo::Server::Connection do
       end
     end
 
+    context 'when the server returns unknown saslSupportedMechs' do
+      min_server_version '4.0'
+
+      let(:connection) do
+        described_class.new(server, server.options.merge(connection_pool: pool))
+      end
+
+      before do
+        expect_any_instance_of(Mongo::Server::PendingConnection).to receive(:get_handshake_response).and_wrap_original do |original_method, *args|
+          original_method.call(*args).tap do |result|
+            if result.documents.first.fetch('saslSupportedMechs', nil).is_a?(Array)
+              result.documents.first['saslSupportedMechs'].append('unknownMechanism')
+            end
+          end
+        end
+      end
+
+      it 'does not raise an error' do
+        expect { connection.connect! }.not_to raise_error
+      end
+    end
+
   end
 
   describe '#disconnect!' do

data/spec/mongo/server/round_trip_time_calculator_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+# rubocop:todo all
+
+require 'spec_helper'
+
+describe Mongo::Server::RoundTripTimeCalculator do
+  let(:calculator) { Mongo::Server::RoundTripTimeCalculator.new }
+
+  describe '#update_average_round_trip_time' do
+    context 'no existing average rtt' do
+      it 'updates average rtt' do
+        calculator.instance_variable_set('@last_round_trip_time', 5)
+        calculator.update_average_round_trip_time
+        expect(calculator.average_round_trip_time).to eq(5)
+      end
+    end
+
+    context 'with existing average rtt' do
+      it 'averages with existing average rtt' do
+        calculator.instance_variable_set('@last_round_trip_time', 5)
+        calculator.instance_variable_set('@average_round_trip_time', 10)
+        calculator.update_average_round_trip_time
+        expect(calculator.average_round_trip_time).to eq(9)
+      end
+    end
+  end
+
+  describe '#update_minimum_round_trip_time' do
+    context 'with no samples' do
+      it 'sets minimum_round_trip_time to zero' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(0)
+      end
+    end
+
+    context 'with one sample' do
+      before do
+        calculator.instance_variable_set('@last_round_trip_time', 5)
+      end
+
+      it 'sets minimum_round_trip_time to zero' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(0)
+      end
+    end
+
+    context 'with two samples' do
+      before do
+        calculator.instance_variable_set('@last_round_trip_time', 10)
+        calculator.instance_variable_set('@rtts', [5])
+      end
+
+      it 'sets minimum_round_trip_time to zero' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(0)
+      end
+    end
+
+    context 'with samples less than maximum' do
+      before do
+        calculator.instance_variable_set('@last_round_trip_time', 10)
+        calculator.instance_variable_set('@rtts', [5, 4, 120])
+      end
+
+      it 'properly sets minimum_round_trip_time' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(4)
+      end
+    end
+
+    context 'with more than maximum samples' do
+      before do
+        calculator.instance_variable_set('@last_round_trip_time', 2)
+        calculator.instance_variable_set('@rtts', [1, 20, 15, 4, 5, 6, 7, 39, 8, 4])
+      end
+
+      it 'properly sets minimum_round_trip_time' do
+        calculator.update_minimum_round_trip_time
+        expect(calculator.minimum_round_trip_time).to eq(2)
+      end
+    end
+
+  end
+
+  describe '#measure' do
+    context 'block does not raise' do
+      it 'updates average rtt' do
+        expect(calculator).to receive(:update_average_round_trip_time)
+        calculator.measure do
+        end
+      end
+
+      it 'updates minimum rtt' do
+        expect(calculator).to receive(:update_minimum_round_trip_time)
+        calculator.measure do
+        end
+      end
+    end
+
+    context 'block raises' do
+      it 'does not update average rtt' do
+        expect(calculator).not_to receive(:update_average_round_trip_time)
+        expect do
+          calculator.measure do
+            raise "Problem"
+          end
+        end.to raise_error(/Problem/)
+      end
+
+      it 'does not update minimum rtt' do
+        expect(calculator).not_to receive(:update_minimum_round_trip_time)
+        expect do
+          calculator.measure do
+            raise "Problem"
+          end
+        end.to raise_error(/Problem/)
+      end
+    end
+  end
+end

data/spec/mongo/socket/ssl_spec.rb

@@ -103,16 +103,6 @@ describe Mongo::Socket::SSL do
           expect(socket).to be_alive
         end
       end
-
-      context 'when connecting the tcp socket raises an exception' do
-
-        it 'raises an exception' do
-          expect_any_instance_of(::Socket).to receive(:connect).and_raise(Mongo::Error::SocketTimeoutError)
-          expect do
-            socket
-          end.to raise_error(Mongo::Error::SocketTimeoutError)
-        end
-      end
     end
 
     context 'when a certificate and key are provided as strings' do