mongo 2.17.1 → 2.18.1

data/spec/mongo/operation/update_spec.rb

@@ -231,34 +231,5 @@ describe Mongo::Operation::Update do
         end
       end
     end
-
-    context 'when write concern { w: 0 } is used' do
-      max_server_version '3.4'
-
-      let(:update) do
-        described_class.new({
-                                updates: [ document ],
-                                db_name: SpecConfig.instance.test_db,
-                                coll_name: TEST_COLL,
-                                write_concern: Mongo::WriteConcern.get(:w => 0)
-                            })
-      end
-
-      let(:document) do
-        { 'q' => { name: 'test' }, 'u' => { '$set' => { field: 'blah' }}, limit: 1 }
-      end
-
-      let(:result) do
-        update.execute(authorized_primary, context: context)
-      end
-
-      before do
-        expect(Mongo::Operation::Update::Legacy).to receive(:new).and_call_original
-      end
-
-      it 'uses op codes instead of write commands' do
-        expect(result.written_count).to eq(0)
-      end
-    end
   end
 end

data/spec/mongo/protocol/caching_hash_spec.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Protocol::CachingHash do
+
+  let(:hash) { described_class.new(x:1) }
+  let(:bson_reg) { {x:1}.to_bson }
+
+  describe "#to_bson" do
+
+    context "when serializing to bson" do
+      it "caches the results" do
+        hash.to_bson
+        expect(hash.instance_variable_get("@bytes")).to eq(bson_reg.to_s)
+      end
+    end
+
+    context "when giving a non empty buffer to_bson" do
+
+      let!(:buffer) { {z: 1}.to_bson }
+      let!(:bytes) { buffer.to_s }
+
+      it "updates the given buffer" do
+        hash.to_bson(buffer)
+        expect(buffer.to_s).to eq(bytes + bson_reg.to_s)
+      end
+
+      it "given buffer is not included in the cached bytes" do
+        hash.to_bson(buffer)
+        expect(hash.instance_variable_get("@bytes")).to eq(bson_reg.to_s)
+        expect(hash.to_bson.to_s).to eq(bson_reg.to_s)
+      end
+    end
+  end
+
+  describe "#needs_validation?" do
+
+    before do
+      hash.to_bson(BSON::ByteBuffer.new, validation)
+    end
+
+    let(:needs_validation?) do
+      hash.send(:needs_validation?, validating_keys)
+    end
+
+    context "when calling to_bson without validation" do
+      let(:validation) { false }
+
+      context "validating_keys is true" do
+        let(:validating_keys) { true }
+
+        it "is true" do
+          expect(needs_validation?).to be true
+        end
+      end
+
+      context "validating_keys is false" do
+        let(:validating_keys) { false }
+
+        it "is false" do
+          expect(needs_validation?).to be false
+        end
+      end
+    end
+
+    context "when calling to_bson with validation" do
+      let(:validation) { true }
+
+      [true, false].each do |b|
+        context "validating_keys is #{b}" do
+          let(:validating_keys) { b }
+
+          it "is false" do
+            expect(needs_validation?).to be false
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/protocol/msg_spec.rb

@@ -525,4 +525,45 @@ describe Mongo::Protocol::Msg do
       end
     end
   end
+
+  describe '#number_returned' do
+
+    let(:batch) do
+      (1..2).map{ |i| { field: "test#{i}" }}
+    end
+
+    context 'when the msg contains a find document' do
+
+      let(:find_document) { { "cursor" => { "firstBatch" => batch } } }
+
+      let(:find_message) do
+        described_class.new(flags, options, find_document, *sequences)
+      end
+
+      it 'returns the correct number_returned' do
+        expect(find_message.number_returned).to eq(2)
+      end
+    end
+
+    context 'when the msg contains a getmore document' do
+      let(:next_document) { { "cursor" => { "nextBatch" => batch } } }
+
+      let(:next_message) do
+        described_class.new(flags, options, next_document, *sequences)
+      end
+
+      it 'returns the correct number_returned' do
+        expect(next_message.number_returned).to eq(2)
+      end
+    end
+
+    context 'when the msg contains a document without first/nextBatch' do
+
+      it 'raises NotImplementedError' do
+        lambda do
+          message.number_returned
+        end.should raise_error(NotImplementedError, /number_returned is only defined for cursor replies/)
+      end
+    end
+  end
 end

data/spec/mongo/query_cache_spec.rb

@@ -157,6 +157,7 @@ describe Mongo::QueryCache do
     before do
       allow(result).to receive(:cursor_id) { 0 }
       allow(result).to receive(:namespace) { 'db.coll' }
+      allow(result).to receive(:connection_global_id) { 1 }
       allow(view).to receive(:limit) { nil }
     end
 
@@ -191,6 +192,14 @@ describe Mongo::QueryCache do
           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 }
 
@@ -198,6 +207,65 @@ describe Mongo::QueryCache 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
@@ -225,6 +293,14 @@ describe Mongo::QueryCache do
           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 }
 
@@ -233,6 +309,14 @@ describe Mongo::QueryCache do
           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 }
 
@@ -241,6 +325,80 @@ describe Mongo::QueryCache do
           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
+
+      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 }
 
@@ -248,6 +406,14 @@ describe Mongo::QueryCache 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

@@ -39,7 +39,8 @@ class RetryableTestConsumer
   def write
     # This passes a nil session and therefore triggers
     # legacy_write_with_retry code path
-    write_with_retry(session, write_concern) do
+    context = Mongo::Operation::Context.new(client: @client, session: session)
+    write_with_retry(write_concern, context: context) do
       operation.execute
     end
   end
@@ -65,13 +66,16 @@ class ModernRetryableTestConsumer < LegacyRetryableTestConsumer
   def session
     double('session').tap do |session|
       expect(session).to receive(:retry_writes?).and_return(true)
+      allow(session).to receive(:materialize_if_needed)
 
       # mock everything else that is in the way
       i = 1
       allow(session).to receive(:next_txn_num) { i += 1 }
       allow(session).to receive(:in_transaction?).and_return(false)
       allow(session).to receive(:pinned_server)
+      allow(session).to receive(:pinned_connection_global_id)
       allow(session).to receive(:starting_transaction?).and_return(false)
+      allow(session).to receive(:materialize)
     end
   end
 
@@ -92,7 +96,15 @@ describe Mongo::Retryable do
     double('operation')
   end
 
-  let(:server) { double('server') }
+  let(:connection) do
+    double('connection')
+  end
+
+  let(:server) do
+    double('server').tap do |server|
+      allow(server).to receive('with_connection').and_yield(connection)
+    end
+  end
 
   let(:max_read_retries) { 1 }
   let(:max_write_retries) { 1 }
@@ -120,6 +132,17 @@ describe Mongo::Retryable do
     LegacyRetryableTestConsumer.new(operation, cluster, client)
   end
 
+  let(:session) do
+    double('session').tap do |session|
+      allow(session).to receive(:pinned_connection_global_id).and_return(nil)
+      allow(session).to receive(:materialize_if_needed)
+    end
+  end
+
+  let(:context) do
+    Mongo::Operation::Context.new(client: client, session: session)
+  end
+
   before do
     # Retryable reads perform server selection
     allow_any_instance_of(Mongo::ServerSelector::Primary).to receive(:select_server).and_return(server)
@@ -141,9 +164,15 @@ describe Mongo::Retryable do
     context 'when ending_transaction is true' do
       let(:retryable) { RetryableTestConsumer.new(operation, cluster, client) }
 
+      let(:context) do
+        Mongo::Operation::Context.new(client: client, session: nil)
+      end
+
       it 'raises ArgumentError' do
         expect do
-          retryable.write_with_retry(nil, nil, true)
+          retryable.write_with_retry(nil, ending_transaction: true, context: context) do
+            fail 'Expected not to get here'
+          end
         end.to raise_error(ArgumentError, 'Cannot end a transaction without a session')
       end
     end

data/spec/mongo/server/connection_auth_spec.rb

@@ -4,7 +4,9 @@
 require 'spec_helper'
 
 # these tests fail intermittently in evergreen
-describe Mongo::Server::Connection, retry: 3 do
+describe Mongo::Server::Connection do
+  retry_test
+
   let(:address) do
     Mongo::Address.new(SpecConfig.instance.addresses.first)
   end

data/spec/mongo/server/connection_common_spec.rb

@@ -47,8 +47,10 @@ describe Mongo::Server::ConnectionCommon do
 
   describe '#handshake_command' do
     let(:document) do
-      subject.handshake_document(metadata)
+      subject.handshake_document(metadata, load_balancer: load_balancer)
     end
+    
+    let(:load_balancer) { false }
 
     context 'with api version' do
       let(:metadata) do
@@ -63,6 +65,16 @@ describe Mongo::Server::ConnectionCommon do
         ).to be_a(Mongo::Protocol::Msg)
       end
     end
+    
+    context 'with loadBalanced=true' do
+      let(:load_balancer) { true }
+
+      it 'returns OP_MSG command' do
+        expect(
+          subject.handshake_command(document)
+        ).to be_a(Mongo::Protocol::Msg)
+      end
+    end
 
     context 'without api version' do
       it 'returns OP_QUERY command' do