mongo 2.19.1 → 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/write_worker_spec.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe Mongo::Retryable::WriteWorker do
+  describe '#nro_write_with_retry' do
+    context 'when session is nil' do
+      let(:retryable) do
+        authorized_client['write_worker_test']
+      end
+
+      let(:write_concern) do
+        Mongo::WriteConcern.get(w: 0)
+      end
+
+      let(:write_worker) do
+        described_class.new(retryable)
+      end
+
+      let(:context) do
+        instance_double(Mongo::Operation::Context).tap do |context|
+          allow(context).to receive(:session).and_return(nil)
+        end
+      end
+
+      before do
+        # We avoid actual execution of the operation to speed up and simplify
+        # the spec.
+        allow(write_worker).to receive(:legacy_write_with_retry).and_return(nil)
+      end
+
+      it 'does not raise' do
+        expect do
+          write_worker.nro_write_with_retry(write_concern, context: context)
+        end.not_to raise_error
+      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