mongo 2.15.0 → 2.18.1

data/spec/integration/grid_fs_bucket_spec.rb

@@ -26,8 +26,8 @@ describe 'GridFS bucket integration' do
           actual = stream.read
         end
 
-        actual.encoding.name.should == 'ASCII-8BIT'
-        actual.should == data.dup.force_encoding('binary')
+        actual.encoding.should == Encoding::BINARY
+        actual.should == data.b
       end
     end
 
@@ -41,7 +41,7 @@ describe 'GridFS bucket integration' do
 
     context 'in UTF-8 encoding' do
       let(:data_to_write) do
-        data.encoding.name.should == 'UTF-8'
+        data.encoding.should == Encoding::UTF_8
         data.freeze
       end
 

data/spec/integration/heartbeat_events_spec.rb

@@ -11,7 +11,7 @@ describe 'Heartbeat events' do
 
   clean_slate_for_all
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   before do
     Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_HEARTBEAT, subscriber)

data/spec/integration/map_reduce_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Map-reduce operations' do
+  let(:client) { authorized_client }
+  let(:collection) { client['mr_integration'] }
+
+  let(:subscriber) { Mrss::EventSubscriber.new }
+
+  let(:find_options) { {} }
+
+  let(:operation) do
+    collection.find({}, find_options).map_reduce('function(){}', 'function(){}')
+  end
+
+  before do
+    collection.insert_one(test: 1)
+    client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+  end
+
+  let(:event) { subscriber.single_command_started_event('mapReduce') }
+
+  context 'read preference' do
+    require_topology :sharded
+
+    context 'specified on client' do
+      let(:client) { authorized_client.with(read: {mode: :secondary_preferred }) }
+
+      # RUBY-2706: read preference is not sent on pre-3.6 servers
+      min_server_fcv '3.6'
+
+      it 'is sent' do
+        operation.to_a
+
+        event.command['$readPreference'].should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+
+    context 'specified on collection' do
+      let(:collection) { client['mr_integration', read: {mode: :secondary_preferred }] }
+
+      # RUBY-2706: read preference is not sent on pre-3.6 servers
+      min_server_fcv '3.6'
+
+      it 'is sent' do
+        operation.to_a
+
+        event.command['$readPreference'].should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+
+    context 'specified on operation' do
+      let(:find_options) { {read: {mode: :secondary_preferred }} }
+
+      # RUBY-2706: read preference is not sent on pre-3.6 servers
+      min_server_fcv '3.6'
+
+      it 'is sent' do
+        operation.to_a
+
+        event.command['$readPreference'].should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+  end
+
+  context 'session' do
+    min_server_fcv '3.6'
+
+    it 'is sent' do
+      operation.to_a
+
+      event.command['lsid'].should_not be nil
+    end
+  end
+end

data/spec/integration/ocsp_verifier_spec.rb

@@ -7,6 +7,7 @@ require 'webrick'
 describe Mongo::Socket::OcspVerifier do
   require_ocsp_verifier
   with_openssl_debug
+  retry_test sleep: 5
 
   shared_examples 'verifies' do
     context 'mri' do
@@ -334,6 +335,8 @@ describe Mongo::Socket::OcspVerifier do
     # have a path in the OCSP URI (which the test also asserts).
     # Note that these certificates expire in 3 months and need to be replaced
     # with a more permanent solution.
+    # Use the spec/support/certificates/retrieve-atlas-cert script to retrieve
+    # current certificates from Atlas.
     let(:cert_path) { File.join(File.dirname(__FILE__), '../support/certificates/atlas-ocsp.crt') }
     let(:ca_cert_path) { File.join(File.dirname(__FILE__), '../support/certificates/atlas-ocsp-ca.crt') }
     let(:cert_store) do

data/spec/integration/query_cache_spec.rb

@@ -21,14 +21,14 @@ describe 'QueryCache' do
     # these tests.
     #
     # Other session leaks will be detected and addressed as part of RUBY-2391.
-    SessionRegistry.instance.clear_registry
+    Mrss::SessionRegistry.instance.clear_registry
   end
 
   after do
-    SessionRegistry.instance.verify_sessions_ended!
+    Mrss::SessionRegistry.instance.verify_sessions_ended!
   end
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client) do
     authorized_client.tap do |client|
@@ -345,18 +345,69 @@ describe 'QueryCache' do
 
         it 'uses the cache' do
           results_limit_5 = authorized_collection.find.limit(5).to_a
+          results_limit_negative_5 = authorized_collection.find.limit(-5).to_a
           results_limit_3 = authorized_collection.find.limit(3).to_a
+          results_limit_negative_3 = authorized_collection.find.limit(-3).to_a
           results_no_limit = authorized_collection.find.to_a
+          results_limit_0 = authorized_collection.find.limit(0).to_a
+
+
+          expect(results_limit_5.length).to eq(5)
+          expect(results_limit_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+          expect(results_limit_negative_5.length).to eq(5)
+          expect(results_limit_negative_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+          expect(results_limit_3.length).to eq(3)
+          expect(results_limit_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+          expect(results_limit_negative_3.length).to eq(3)
+          expect(results_limit_negative_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+          expect(results_no_limit.length).to eq(10)
+          expect(results_no_limit.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+          expect(results_limit_0.length).to eq(10)
+          expect(results_limit_0.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
+          expect(events.length).to eq(1)
+        end
+      end
+
+      context 'when the first query has a 0 limit' do
+        before do
+          authorized_collection.find.limit(0).to_a
+        end
+
+        it 'uses the cache' do
+          results_limit_5 = authorized_collection.find.limit(5).to_a
+          results_limit_negative_5 = authorized_collection.find.limit(-5).to_a
+          results_limit_3 = authorized_collection.find.limit(3).to_a
+          results_limit_negative_3 = authorized_collection.find.limit(-3).to_a
+          results_no_limit = authorized_collection.find.to_a
+          results_limit_0 = authorized_collection.find.limit(0).to_a
 
           expect(results_limit_5.length).to eq(5)
           expect(results_limit_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
 
+          expect(results_limit_negative_5.length).to eq(5)
+          expect(results_limit_negative_5.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4])
+
+
           expect(results_limit_3.length).to eq(3)
           expect(results_limit_3.map { |r| r["test"] }).to eq([0, 1, 2])
 
+          expect(results_limit_negative_3.length).to eq(3)
+          expect(results_limit_negative_3.map { |r| r["test"] }).to eq([0, 1, 2])
+
+
           expect(results_no_limit.length).to eq(10)
           expect(results_no_limit.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
 
+
+          expect(results_limit_0.length).to eq(10)
+          expect(results_limit_0.map { |r| r["test"] }).to eq([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+
           expect(events.length).to eq(1)
         end
       end
@@ -391,6 +442,21 @@ describe 'QueryCache' do
           end
         end
 
+        context 'and two queries are performed with a larger negative limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(-3).to_a
+            results2 = authorized_collection.find.limit(-3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
         context 'and the second query has a smaller limit' do
           let(:results) { authorized_collection.find.limit(1).to_a }
 
@@ -401,6 +467,99 @@ describe 'QueryCache' do
           end
         end
 
+        context 'and the second query has a smaller negative limit' do
+          let(:results) { authorized_collection.find.limit(-1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
+        context 'and the second query has no limit' do
+          it 'queries again' do
+            expect(authorized_collection.find.to_a.count).to eq(10)
+            expect(events.length).to eq(2)
+          end
+        end
+      end
+
+      context 'when the first query has a negative limit' do
+        before do
+          authorized_collection.find.limit(-2).to_a
+        end
+
+        context 'and the second query has a larger limit' do
+          let(:results) { authorized_collection.find.limit(3).to_a }
+
+          it 'queries again' do
+            expect(results.length).to eq(3)
+            expect(results.map { |result| result["test"] }).to eq([0, 1, 2])
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and the second query has a larger negative limit' do
+          let(:results) { authorized_collection.find.limit(-3).to_a }
+
+          it 'queries again' do
+            expect(results.length).to eq(3)
+            expect(results.map { |result| result["test"] }).to eq([0, 1, 2])
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and two queries are performed with a larger limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(3).to_a
+            results2 = authorized_collection.find.limit(3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and two queries are performed with a larger negative limit' do
+          it 'uses the query cache for the third query' do
+            results1 = authorized_collection.find.limit(-3).to_a
+            results2 = authorized_collection.find.limit(-3).to_a
+
+            expect(results1.length).to eq(3)
+            expect(results1.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(results2.length).to eq(3)
+            expect(results2.map { |r| r["test"] }).to eq([0, 1, 2])
+
+            expect(events.length).to eq(2)
+          end
+        end
+
+        context 'and the second query has a smaller limit' do
+          let(:results) { authorized_collection.find.limit(1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
+        context 'and the second query has a smaller negative limit' do
+          let(:results) { authorized_collection.find.limit(-1).to_a }
+
+          it 'uses the cached query' do
+            expect(results.count).to eq(1)
+            expect(results.first["test"]).to eq(0)
+            expect(events.length).to eq(1)
+          end
+        end
+
         context 'and the second query has no limit' do
           it 'queries again' do
             expect(authorized_collection.find.to_a.count).to eq(10)
@@ -534,7 +693,7 @@ describe 'QueryCache' do
     end
 
     [:find_one_and_delete, :find_one_and_replace, :find_one_and_update,
-      :update_one, :replace_one].each do |method|
+      :replace_one].each do |method|
       context "when updating with #{method}" do
         context 'when updating and querying from same collection' do
           before do
@@ -562,28 +721,30 @@ describe 'QueryCache' do
       end
     end
 
-    context 'when updating with #update_many' do
-      context 'when updating and querying from same collection' do
-        before do
-          authorized_collection.find.to_a
-          authorized_collection.update_many({ field: 'value' }, { "$inc" => { :field =>  1 } })
-        end
+    [:update_one, :update_many].each do |method|
+      context "when updating with ##{method}" do
+        context 'when updating and querying from same collection' do
+          before do
+            authorized_collection.find.to_a
+            authorized_collection.send(method, { field: 'value' }, { "$inc" => { :field =>  1 } })
+          end
 
-        it 'queries again' do
-          authorized_collection.find.to_a
-          expect(events.length).to eq(2)
+          it 'queries again' do
+            authorized_collection.find.to_a
+            expect(events.length).to eq(2)
+          end
         end
-      end
 
-      context 'when updating and querying from different collections' do
-        before do
-          authorized_collection.find.to_a
-          authorized_client['different_collection'].update_many({ field: 'value' }, { "$inc" => { :field =>  1 } })
-        end
+        context 'when updating and querying from different collections' do
+          before do
+            authorized_collection.find.to_a
+            authorized_client['different_collection'].send(method, { field: 'value' }, { "$inc" => { :field =>  1 } })
+          end
 
-        it 'uses the cached query' do
-          authorized_collection.find.to_a
-          expect(events.length).to eq(1)
+          it 'uses the cached query' do
+            authorized_collection.find.to_a
+            expect(events.length).to eq(1)
+          end
         end
       end
     end
@@ -913,7 +1074,7 @@ describe 'QueryCache' do
     end
 
     [:find_one_and_delete, :find_one_and_replace, :find_one_and_update,
-      :update_one, :replace_one].each do |method|
+      :replace_one].each do |method|
       context "when #{method} is performed on another collection" do
         before do
           aggregation.to_a
@@ -927,15 +1088,17 @@ describe 'QueryCache' do
       end
     end
 
-    context 'when update_many is performed on another collection' do
-      before do
-        aggregation.to_a
-        authorized_client['different_collection'].update_many({ field: 'value' }, { "$inc" => { :field =>  1 } })
-        aggregation.to_a
-      end
+    [:update_one, :update_many].each do |method|
+      context 'when update_many is performed on another collection' do
+        before do
+          aggregation.to_a
+          authorized_client['different_collection'].send(method, { field: 'value' }, { "$inc" => { :field =>  1 } })
+          aggregation.to_a
+        end
 
-      it 'queries again' do
-        expect(events.length).to eq(2)
+        it 'queries again' do
+          expect(events.length).to eq(2)
+        end
       end
     end
 
@@ -969,7 +1132,7 @@ describe 'QueryCache' do
 
   context 'when find command fails and retries' do
     require_fail_command
-    require_no_multi_shard
+    require_no_multi_mongos
     require_warning_clean
 
     before do
@@ -1045,4 +1208,49 @@ describe 'QueryCache' do
       expect(events.length).to eq(2)
     end
   end
+
+  context 'when result set has multiple documents and cursor is iterated partially' do
+
+    before do
+      Mongo::QueryCache.enabled = false
+      5.times do
+        authorized_collection.insert_one({ name: 'testing' })
+      end
+    end
+
+    shared_examples 'retrieves full result set on second iteration' do
+      it 'retrieves full result set on second iteration' do
+        Mongo::QueryCache.clear
+        Mongo::QueryCache.enabled = true
+
+        partial_first_iteration
+
+        authorized_collection.find.to_a.length.should == 5
+      end
+
+    end
+
+    context 'using each & break' do
+      let(:partial_first_iteration) do
+        called = false
+        authorized_collection.find.each do
+          called = true
+          break
+        end
+        called.should be true
+      end
+
+      include_examples 'retrieves full result set on second iteration'
+    end
+
+    context 'using next' do
+      let(:partial_first_iteration) do
+        # #next is executed in its own fiber, and query cache is disabled
+        # for that operation.
+        authorized_collection.find.to_enum.next
+      end
+
+      include_examples 'retrieves full result set on second iteration'
+    end
+  end
 end

data/spec/integration/query_cache_transactions_spec.rb

@@ -23,7 +23,7 @@ describe 'QueryCache with transactions' do
   # leak sessions independently of the query cache. This will be resolved by
   # RUBY-2391.
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client) do
     authorized_client.tap do |client|

data/spec/integration/read_concern_spec.rb

@@ -7,7 +7,7 @@ describe 'read concern' do
   min_server_version '3.2'
 
   let(:subscriber) do
-    EventSubscriber.new
+    Mrss::EventSubscriber.new
   end
 
   let(:specified_read_concern) do

data/spec/integration/read_preference_spec.rb

@@ -16,7 +16,7 @@ describe 'Read preference' do
     authorized_client.with(client_options)
   end
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   before do
     client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
@@ -45,16 +45,6 @@ describe 'Read preference' do
     {}
   end
 
-  shared_examples_for 'sends expected read preference when reading' do
-    it 'sends expected read preference when reading' do
-      read_operation
-
-      event = subscriber.single_command_started_event('find')
-      actual_preference = event.command['$readPreference']
-      expect(actual_preference).to eq(expected_read_preference)
-    end
-  end
-
   shared_examples_for 'does not send read preference when reading' do
     it 'does not send read preference when reading' do
       read_operation
@@ -95,7 +85,17 @@ describe 'Read preference' do
       context 'server supporting OP_MSG' do
         min_server_fcv '3.6'
 
-        it_behaves_like 'sends expected read preference when reading'
+        it 'sends expected read preference when reading' do
+          read_operation
+
+          event = subscriber.single_command_started_event('find')
+          actual_preference = event.command['$readPreference']
+          if expected_read_preference&.[]("mode") == "primary"
+            expect(actual_preference).to be_nil
+          else
+            expect(actual_preference).to eq(expected_read_preference)
+          end
+        end
       end
     end
 
@@ -307,7 +307,11 @@ describe 'Read preference' do
 
           event = subscriber.single_command_started_event('find')
           actual_preference = event.command['$readPreference']
-          expect(actual_preference).to eq(expected_read_preference)
+          if expected_read_preference&.[]("mode") == "primary"
+            expect(actual_preference).to be_nil
+          else
+            expect(actual_preference).to eq(expected_read_preference)
+          end
         end
       end
     end

data/spec/integration/reconnect_spec.rb

@@ -16,20 +16,38 @@ describe 'Client after reconnect' do
     expect(doc['testk']).to eq('testv')
   end
 
-  it 'recreates monitor thread' do
-    thread = client.cluster.servers.first.monitor.instance_variable_get('@thread')
-    expect(thread).to be_alive
+  context 'non-lb' do
+    require_topology :single, :replica_set, :sharded
 
-    thread.kill
-    # context switch to let the thread get killed
-    sleep 0.1
-    expect(thread).not_to be_alive
+    it 'recreates monitor thread' do
+      thread = client.cluster.servers.first.monitor.instance_variable_get('@thread')
+      expect(thread).to be_alive
 
-    client.reconnect
+      thread.kill
+      # context switch to let the thread get killed
+      sleep 0.1
+      expect(thread).not_to be_alive
+
+      client.reconnect
+
+      new_thread = client.cluster.servers.first.monitor.instance_variable_get('@thread')
+      expect(new_thread).not_to eq(thread)
+      expect(new_thread).to be_alive
+    end
+  end
+
+  context 'lb' do
+    require_topology :load_balanced
 
-    new_thread = client.cluster.servers.first.monitor.instance_variable_get('@thread')
-    expect(new_thread).not_to eq(thread)
-    expect(new_thread).to be_alive
+    it 'does not recreate monitor thread' do
+      thread = client.cluster.servers.first.monitor.instance_variable_get('@thread')
+      expect(thread).to be nil
+
+      client.reconnect
+
+      new_thread = client.cluster.servers.first.monitor.instance_variable_get('@thread')
+      expect(new_thread).to be nil
+    end
   end
 
   context 'with min_pool_size > 0' do
@@ -55,6 +73,7 @@ describe 'Client after reconnect' do
   end
 
   context 'SRV monitor thread' do
+    require_external_connectivity
 
     let(:uri) do
       "mongodb+srv://test1.test.build.10gen.cc/?tls=#{SpecConfig.instance.ssl?}"
@@ -114,7 +133,7 @@ describe 'Client after reconnect' do
     context 'in sharded topology' do
       require_topology :sharded
       require_default_port_deployment
-      require_multi_shard
+      require_multi_mongos
 
       let(:expected_topology_cls) { Mongo::Cluster::Topology::Sharded }
 
@@ -122,6 +141,7 @@ describe 'Client after reconnect' do
     end
 
     context 'in unknown topology' do
+      require_external_connectivity
 
       # JRuby apparently does not implement non-blocking UDP I/O which is used
       # by RubyDNS:

data/spec/integration/retryable_errors_spec.rb

@@ -7,7 +7,7 @@ describe 'Failing retryable operations' do
   # Requirement for fail point
   min_server_fcv '4.0'
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client_options) do
     {}

data/spec/integration/retryable_writes/retryable_writes_36_and_older_spec.rb

@@ -20,7 +20,7 @@ describe 'Retryable writes integration tests' do
 
   # These tests override server selector, which fails if there are multiple
   # eligible servers as would be the case in a multi-shard sharded cluster
-  require_no_multi_shard
+  require_no_multi_mongos
 
   # Note: these tests are deprecated in favor of the tests in the file
   # spec/integration/retryable_writes/retryable_writes_40_and_newer_spec.rb
@@ -731,7 +731,7 @@ describe 'Retryable writes integration tests' do
     end
 
     let(:operation) do
-      collection.bulk_write([{ update_many: { filter: { a: 0 }, update: { a: 1 } } }])
+      collection.bulk_write([{ update_many: { filter: { a: 0 }, update: { "$set" => { a: 1 } } } }])
     end
 
     let(:expectation) do

data/spec/integration/retryable_writes/retryable_writes_40_and_newer_spec.rb

@@ -10,7 +10,7 @@ require_relative './shared/does_not_support_retries'
 describe 'Retryable Writes' do
   require_fail_command
   require_wired_tiger
-  require_no_multi_shard
+  require_no_multi_mongos
   require_warning_clean
 
   let(:client) do