mongo 2.17.2 → 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
 

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

data/spec/mongo/server/connection_pool_spec.rb

@@ -83,11 +83,21 @@ describe Mongo::Server::ConnectionPool do
 
     context 'when min size exceeds default max size' do
       let (:options) do
-        { min_pool_size: 10 }
+        { min_pool_size: 50 }
       end
 
       it 'sets max size to equal provided min size' do
-        expect(pool.max_size).to eq(10)
+        expect(pool.max_size).to eq(50)
+      end
+    end
+
+    context 'when min size is provided and max size is zero (unlimited)' do
+      let (:options) do
+        { min_size: 10, max_size: 0 }
+      end
+
+      it 'sets max size to zero (unlimited)' do
+        expect(pool.max_size).to eq(0)
       end
     end
 
@@ -155,7 +165,7 @@ describe Mongo::Server::ConnectionPool do
 
     context 'when no pool size option is provided' do
       it 'returns the default size' do
-        expect(pool.max_size).to eq(5)
+        expect(pool.max_size).to eq(20)
       end
     end
 
@@ -165,7 +175,7 @@ describe Mongo::Server::ConnectionPool do
       end
 
       it 'returns max size' do
-        expect(pool.max_size).to eq(5)
+        expect(pool.max_size).to eq(20)
       end
     end
   end
@@ -316,16 +326,22 @@ describe Mongo::Server::ConnectionPool do
       end
     end
 
-    context 'connection of the same generation as pool' do
-      # These tests are also applicable to load balancers, but
-      # require different setup and assertions because load balancers
-      # do not have a single global generation.
-      require_topology :single, :replica_set, :sharded
-
-      before do
-        expect(pool.generation).to eq(connection.generation)
+    shared_examples 'does not add connection to pool' do
+      it 'disconnects connection and does not add connection to pool' do
+        # connection was checked out
+        expect(pool.available_count).to eq(0)
+        expect(pool.size).to eq(1)
+        expect(connection).to receive(:disconnect!)
+        pool.check_in(connection)
+        # connection is not added to the pool, and no replacement
+        # connection has been created at this point
+        expect(pool.available_count).to eq(0)
+        expect(pool.size).to eq(0)
+        expect(pool.check_out).not_to eq(connection)
       end
+    end
 
+    shared_examples 'adds connection to the pool' do
       it 'adds the connection to the pool' do
         # connection is checked out
         expect(pool.available_count).to eq(0)
@@ -338,19 +354,17 @@ describe Mongo::Server::ConnectionPool do
       end
     end
 
-    shared_examples 'does not add connection to pool' do
-      it 'disconnects connection and does not add connection to pool' do
-        # connection was checked out
-        expect(pool.available_count).to eq(0)
-        expect(pool.size).to eq(1)
-        expect(connection).to receive(:disconnect!)
-        pool.check_in(connection)
-        # connection is not added to the pool, and no replacement
-        # connection has been created at this point
-        expect(pool.available_count).to eq(0)
-        expect(pool.size).to eq(0)
-        expect(pool.check_out).not_to eq(connection)
+    context 'connection of the same generation as pool' do
+      # These tests are also applicable to load balancers, but
+      # require different setup and assertions because load balancers
+      # do not have a single global generation.
+      require_topology :single, :replica_set, :sharded
+
+      before do
+        expect(pool.generation).to eq(connection.generation)
       end
+
+      it_behaves_like 'adds connection to the pool'
     end
 
     context 'connection of earlier generation than pool' do
@@ -359,18 +373,37 @@ describe Mongo::Server::ConnectionPool do
       # do not have a single global generation.
       require_topology :single, :replica_set, :sharded
 
-      let(:connection) do
-        pool.check_out.tap do |connection|
-          expect(connection).to receive(:generation).at_least(:once).and_return(0)
-          expect(connection).not_to receive(:record_checkin!)
+      context 'when connection is not pinned' do
+        let(:connection) do
+          pool.check_out.tap do |connection|
+            expect(connection).to receive(:generation).at_least(:once).and_return(0)
+            expect(connection).not_to receive(:record_checkin!)
+          end
         end
+
+        before do
+          expect(connection.generation).to be < pool.generation
+        end
+
+        it_behaves_like 'does not add connection to pool'
       end
 
-      before do
-        expect(connection.generation).to be < pool.generation
+      context 'when connection is pinned' do
+        let(:connection) do
+          pool.check_out.tap do |connection|
+            allow(connection).to receive(:pinned?).and_return(true)
+            expect(connection).to receive(:generation).at_least(:once).and_return(0)
+            expect(connection).to receive(:record_checkin!)
+          end
+        end
+
+        before do
+          expect(connection.generation).to be < pool.generation
+        end
+
+        it_behaves_like 'adds connection to the pool'
       end
 
-      it_behaves_like 'does not add connection to pool'
     end
 
     context 'connection of later generation than pool' do
@@ -437,6 +470,18 @@ describe Mongo::Server::ConnectionPool do
       server.pool
     end
 
+    context 'when max_size is zero (unlimited)' do
+      let(:options) do
+        { max_size: 0 }
+      end
+
+      it 'checks out a connection' do
+        expect do
+          pool.check_out
+        end.not_to raise_error
+      end
+    end
+
     context 'when a connection is checked out on a different thread' do
 
       let!(:connection) do
@@ -473,23 +518,45 @@ describe Mongo::Server::ConnectionPool do
         { max_pool_size: 2, max_idle_time: 0.1 }
       end
 
-      let(:connection) do
-        pool.check_out.tap do |connection|
-          allow(connection).to receive(:generation).and_return(pool.generation)
-          allow(connection).to receive(:record_checkin!).and_return(connection)
-          expect(connection).to receive(:last_checkin).at_least(:once).and_return(Time.now - 10)
+      context 'when connection is not pinned' do
+        let(:connection) do
+          pool.check_out.tap do |connection|
+            allow(connection).to receive(:generation).and_return(pool.generation)
+            allow(connection).to receive(:record_checkin!).and_return(connection)
+            expect(connection).to receive(:last_checkin).at_least(:once).and_return(Time.now - 10)
+          end
         end
-      end
 
-      before do
-        pool.check_in(connection)
+        before do
+          pool.check_in(connection)
+        end
+
+        it 'closes stale connection and creates a new one' do
+          expect(connection).to receive(:disconnect!)
+          expect(Mongo::Server::Connection).to receive(:new).and_call_original
+          pool.check_out
+        end
       end
 
-      it 'closes stale connection and creates a new one' do
-        expect(connection).to receive(:disconnect!)
-        expect(Mongo::Server::Connection).to receive(:new).and_call_original
-        pool.check_out
+      context 'when connection is pinned' do
+        let(:connection) do
+          pool.check_out.tap do |connection|
+            allow(connection).to receive(:generation).and_return(pool.generation)
+            allow(connection).to receive(:record_checkin!).and_return(connection)
+            expect(connection).to receive(:pinned?).and_return(true)
+          end
+        end
+
+        before do
+          pool.check_in(connection)
+        end
+
+        it 'does not close stale connection' do
+          expect(connection).not_to receive(:disconnect!)
+          pool.check_out
+        end
       end
+
     end
 
     context 'when there are no available connections' do
@@ -520,24 +587,24 @@ describe Mongo::Server::ConnectionPool do
           end
         end
 
-        context 'with service_id' do
+        context 'with connection_global_id' do
           require_topology :load_balanced
 
-          let(:service_id) do
+          let(:connection_global_id) do
             pool.with_connection do |connection|
-              connection.service_id.should_not be nil
-              connection.service_id
+              connection.global_id.should_not be nil
+              connection.global_id
             end
           end
 
           it 'raises a timeout error' do
             expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
-            service_id
+            connection_global_id
 
-            pool.check_out(service_id: service_id)
+            pool.check_out(connection_global_id: connection_global_id)
 
             expect {
-              pool.check_out(service_id: service_id)
+              pool.check_out(connection_global_id: connection_global_id)
             }.to raise_error(Mongo::Error::ConnectionCheckOutTimeout)
 
             expect(pool.size).to eq(1)
@@ -545,13 +612,13 @@ describe Mongo::Server::ConnectionPool do
 
           it 'waits for the timeout' do
             expect(Mongo::Server::Connection).to receive(:new).once.and_call_original
-            service_id
+            connection_global_id
 
-            pool.check_out(service_id: service_id)
+            pool.check_out(connection_global_id: connection_global_id)
 
             start_time = Mongo::Utils.monotonic_time
             expect {
-              pool.check_out(service_id: service_id)
+              pool.check_out(connection_global_id: connection_global_id)
             }.to raise_error(Mongo::Error::ConnectionCheckOutTimeout)
             elapsed_time = Mongo::Utils.monotonic_time - start_time