mongo 2.16.0 → 2.17.1

data/spec/mongo/collection/view/aggregation_spec.rb

@@ -29,8 +29,16 @@ describe Mongo::Collection::View::Aggregation do
     described_class.new(view, pipeline, options)
   end
 
+  let(:server) do
+    double('server')
+  end
+
+  let(:session) do
+    double('session')
+  end
+
   let(:aggregation_spec) do
-    aggregation.send(:aggregate_spec, double('session'))
+    aggregation.send(:aggregate_spec, server, session, nil)
   end
 
   before do
@@ -351,15 +359,15 @@ describe Mongo::Collection::View::Aggregation do
 
   describe '#aggregate_spec' do
 
-    context 'when the collection has a read preference' do
+    context 'when a read preference is given' do
 
       let(:read_preference) do
-        {mode: :secondary}
+        BSON::Document.new({mode: :secondary})
       end
 
       it 'includes the read preference in the spec' do
-        allow(authorized_collection).to receive(:read_preference).and_return(read_preference)
-        expect(aggregation_spec[:read]).to eq(read_preference)
+        spec = aggregation.send(:aggregate_spec, server, session, read_preference)
+        expect(spec[:read]).to eq(read_preference)
       end
     end
 
@@ -570,109 +578,77 @@ describe Mongo::Collection::View::Aggregation do
   end
 
   context 'when $out is in the pipeline' do
-
-    let(:pipeline) do
-      [{
-           "$group" => {
-               "_id" => "$city",
-               "totalpop" => { "$sum" => "$pop" }
+    [['$out', 'string'], [:$out, 'symbol']].each do |op, type|
+      context "when #{op} is a #{type}" do
+        let(:pipeline) do
+          [{
+               "$group" => {
+                   "_id" => "$city",
+                   "totalpop" => { "$sum" => "$pop" }
+               }
+           },
+           {
+               op => 'output_collection'
            }
-       },
-       {
-           '$out' => 'output_collection'
-       }
-      ]
-    end
-
-    before do
-      authorized_client['output_collection'].delete_many
-    end
-
-    context 'when $out is a string' do
-
-      it 'does not allow the operation on a secondary' do
-        expect(aggregation.send(:secondary_ok?)).to be(false)
-      end
-    end
-
-    context 'when $out is a symbol' do
-
-      let(:pipeline) do
-        [{
-             "$group" => {
-                 "_id" => "$city",
-                 "totalpop" => { "$sum" => "$pop" }
-             }
-         },
-         {
-             :$out => 'output_collection'
-         }
-        ]
-      end
-
-      it 'does not allow the operation on a secondary' do
-        expect(aggregation.send(:secondary_ok?)).to be(false)
-      end
-    end
+          ]
+        end
 
+        before do
+          authorized_client['output_collection'].delete_many
+        end
 
-    context 'when the server is not a valid for writing' do
+        let(:features) do
+          double()
+        end
 
-     it 'reroutes the operation to a primary' do
-       allow(aggregation).to receive(:valid_server?).and_return(false)
-       expect(Mongo::Logger.logger).to receive(:warn).and_call_original
-       aggregation.to_a
-     end
-    end
+        let(:server) do
+          double().tap do |server|
+            allow(server).to receive(:features).and_return(features)
+          end
+        end
 
-    context 'when the server is a valid for writing' do
+        context 'when the view has a write concern' do
 
-     it 'does not reroute the operation to a primary' do
-       expect(Mongo::Logger.logger).not_to receive(:warn)
-       aggregation.to_a
-     end
+          let(:collection) do
+            authorized_collection.with(write: INVALID_WRITE_CONCERN)
+          end
 
-     context 'when the view has a write concern' do
+          let(:view) do
+            Mongo::Collection::View.new(collection, selector, view_options)
+          end
 
-       let(:collection) do
-         authorized_collection.with(write: INVALID_WRITE_CONCERN)
-       end
+          context 'when the server supports write concern on the aggregate command' do
+            min_server_fcv '3.4'
 
-       let(:view) do
-         Mongo::Collection::View.new(collection, selector, view_options)
-       end
+            it 'uses the write concern' do
+              expect {
+                aggregation.to_a
+              }.to raise_exception(Mongo::Error::OperationFailure)
+            end
+          end
 
-       context 'when the server supports write concern on the aggregate command' do
-        min_server_fcv '3.4'
+          context 'when the server does not support write concern on the aggregation command' do
+            max_server_version '3.2'
 
-         it 'uses the write concern' do
-           expect {
-             aggregation.to_a
-           }.to raise_exception(Mongo::Error::OperationFailure)
-         end
-       end
+            let(:documents) do
+              [
+                { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
+                { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
+                { city: "New York", pop: 40270, neighborhood: "Brooklyn" }
+              ]
+            end
 
-       context 'when the server does not support write concern on the aggregation command' do
-        max_server_version '3.2'
+            before do
+              authorized_collection.insert_many(documents)
+              aggregation.to_a
+            end
 
-         let(:documents) do
-           [
-             { city: "Berlin", pop: 18913, neighborhood: "Kreuzberg" },
-             { city: "Berlin", pop: 84143, neighborhood: "Mitte" },
-             { city: "New York", pop: 40270, neighborhood: "Brooklyn" }
-           ]
-         end
-
-         before do
-           authorized_collection.insert_many(documents)
-           aggregation.to_a
-         end
-
-         it 'does not apply the write concern' do
-           expect(authorized_client['output_collection'].find.count).to eq(2)
-         end
-       end
-     end
+            it 'does not apply the write concern' do
+              expect(authorized_client['output_collection'].find.count).to eq(2)
+            end
+          end
+        end
+      end
     end
   end
 end

data/spec/mongo/collection/view/change_stream_spec.rb

@@ -56,7 +56,7 @@ describe Mongo::Collection::View::ChangeStream do
 
   let(:command_spec) do
     change_stream.send(:instance_variable_set, '@resuming', false)
-    change_stream.send(:aggregate_spec, double('session'))
+    change_stream.send(:aggregate_spec, double('server'), double('session'), nil)
   end
 
   let(:cursor) do

data/spec/mongo/collection/view/map_reduce_spec.rb

@@ -60,6 +60,14 @@ describe Mongo::Collection::View::MapReduce do
     described_class.new(view, map, reduce, options)
   end
 
+  describe '#initialize' do
+    it 'warns of deprecation' do
+      Mongo::Logger.logger.should receive(:warn).with('MONGODB | The map_reduce operation is deprecated, please use the aggregation pipeline instead')
+
+      map_reduce
+    end
+  end
+
   describe '#map_function' do
 
     it 'returns the map function' do
@@ -672,7 +680,12 @@ describe Mongo::Collection::View::MapReduce do
         end
 
         it 'does not reroute the operation to a primary' do
-          expect(Mongo::Logger.logger).not_to receive(:warn)
+          # We produce a deprecation warning, but there shouldn't be
+          # the reroute warning.
+          expect(Mongo::Logger.logger).to receive(:warn).once do |msg|
+            expect(msg).not_to include('Rerouting the MapReduce operation to the primary server')
+          end
+
           map_reduce.to_a
         end
       end
@@ -865,4 +878,20 @@ describe Mongo::Collection::View::MapReduce do
       end
     end
   end
+
+  describe '#map_reduce_spec' do
+    context 'when read preference is given' do
+      let(:view_options) do
+        { read: {mode: :secondary} }
+      end
+
+      context 'selector' do
+        # For compatibility with released versions of Mongoid, this method
+        # must return read preference under the :read key.
+        it 'contains read preference' do
+          map_reduce_spec[:selector][:read].should == {'mode' => :secondary}
+        end
+      end
+    end
+  end
 end

data/spec/mongo/cursor_spec.rb

@@ -331,8 +331,9 @@ describe Mongo::Cursor do
 
       before do
         authorized_collection.insert_many(documents)
-        cluster.schedule_kill_cursor(cursor.kill_spec,
-                                     cursor.instance_variable_get(:@server))
+        cluster.schedule_kill_cursor(
+          cursor.kill_spec(cursor.instance_variable_get(:@server))
+        )
       end
 
       let(:view) do

data/spec/mongo/operation/read_preference_op_msg_spec.rb

@@ -99,6 +99,29 @@ describe Mongo::Operation::SessionsSupported do
       end
     end
 
+    shared_examples_for 'sends read preference correctly for replica set' do
+      context "when read preference mode is primary" do
+        let(:mode) { :primary}
+
+        it_behaves_like 'does not modify selector'
+      end
+      %i(primary_preferred secondary secondary_preferred nearest).each do |_mode|
+        active_mode = _mode
+
+        context "when read preference mode is #{active_mode}" do
+          let(:mode) { active_mode }
+
+          let(:expected) do
+            selector.merge(:$readPreference => expected_read_preference)
+          end
+
+          it 'adds read preference' do
+            expect(actual).to eq(expected)
+          end
+        end
+      end
+    end
+
     shared_examples_for 'sends user-specified read preference' do
       %i(primary primary_preferred secondary secondary_preferred nearest).each do |_mode|
         active_mode = _mode
@@ -302,7 +325,7 @@ describe Mongo::Operation::SessionsSupported do
         let(:standalone?) { false }
         let(:mongos?) { false }
 
-        it_behaves_like 'sends user-specified read preference'
+        it_behaves_like 'sends read preference correctly for replica set'
       end
     end
   end

data/spec/mongo/server/monitor/connection_spec.rb

@@ -136,6 +136,28 @@ describe Mongo::Server::Monitor::Connection do
     end
   end
 
+  describe '#connect!' do
+
+    let(:options) do
+      SpecConfig.instance.test_options.merge(
+        app_metadata: monitor_app_metadata,
+      )
+    end
+
+    context 'when address resolution fails' do
+      let(:connection) { described_class.new(server.address, options) }
+
+      it 'propagates the exception' do
+        connection
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          connection.connect!
+        end.should raise_error(SocketError, 'Test exception')
+      end
+    end
+  end
+
   describe '#check_document' do
     context 'with API version' do
       let(:meta) do

data/spec/mongo/server/push_monitor_spec.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Mongo::Server::PushMonitor do
+  before(:all) do
+    ClientRegistry.instance.close_all_clients
+  end
+
+  let(:address) do
+    default_address
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  let(:monitor_options) do
+    {}
+  end
+
+  let(:monitor_app_metadata) do
+    Mongo::Server::Monitor::AppMetadata.new(
+      server_api: SpecConfig.instance.ruby_options[:server_api],
+    )
+  end
+
+  let(:cluster) do
+    double('cluster').tap do |cluster|
+      allow(cluster).to receive(:run_sdam_flow)
+      allow(cluster).to receive(:heartbeat_interval).and_return(1000)
+    end
+  end
+
+  let(:server) do
+    Mongo::Server.new(address, cluster, Mongo::Monitoring.new, listeners,
+      monitoring_io: false)
+  end
+
+  let(:monitor) do
+    register_background_thread_object(
+      Mongo::Server::Monitor.new(server, listeners, Mongo::Monitoring.new,
+        SpecConfig.instance.test_options.merge(cluster: cluster).merge(monitor_options).update(
+          app_metadata: monitor_app_metadata,
+          push_monitor_app_metadata: monitor_app_metadata))
+    )
+  end
+
+  let(:topology_version) do
+    Mongo::TopologyVersion.new('processId' => BSON::ObjectId.new, 'counter' => 1)
+  end
+
+  let(:check_document) do
+    {hello: 1}
+  end
+
+  let(:push_monitor) do
+    described_class.new(monitor, topology_version, monitor.monitoring,
+      **monitor.options.merge(check_document: check_document))
+  end
+
+  describe '#do_work' do
+    it 'works' do
+      lambda do
+        push_monitor.do_work
+      end.should_not raise_error
+    end
+
+    context 'network error during check' do
+      it 'does not propagate the exception' do
+        push_monitor
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+      end
+
+      it 'throttles checks' do
+        push_monitor
+
+        start = Mongo::Utils.monotonic_time
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        expect(Socket).to receive(:getaddrinfo).and_raise(SocketError.new('Test exception'))
+        lambda do
+          push_monitor.do_work
+        end.should_not raise_error
+
+        elapsed = Mongo::Utils.monotonic_time - start
+        elapsed.should > 0.5
+      end
+    end
+  end
+
+end

data/spec/mongo/server_selector_spec.rb

@@ -202,12 +202,7 @@ describe Mongo::ServerSelector do
   describe "#select_server" do
     require_no_linting
 
-    context 'when #select_in_replica_set returns a list of nils' do
-
-      let(:servers) do
-        [ make_server(:primary) ]
-      end
-
+    context 'replica set topology' do
       let(:cluster) do
         double('cluster').tap do |c|
           allow(c).to receive(:connected?).and_return(true)
@@ -223,19 +218,141 @@ describe Mongo::ServerSelector do
           allow(c).to receive(:scan!).and_return(true)
           allow(c).to receive(:options).and_return(server_selection_timeout: 0.1)
           allow(c).to receive(:server_selection_semaphore).and_return(nil)
+          allow(topology).to receive(:compatible?).and_return(true)
         end
       end
 
-      let(:read_pref) do
-        described_class.get(mode: :primary).tap do |pref|
-          allow(pref).to receive(:select_in_replica_set).and_return([ nil, nil ])
+      let(:primary) do
+        make_server(:primary).tap do |server|
+          allow(server).to receive(:features).and_return(double("primary features"))
         end
       end
 
-      it 'raises a NoServerAvailable error' do
-        expect do
-          read_pref.select_server(cluster)
-        end.to raise_exception(Mongo::Error::NoServerAvailable)
+      let(:secondary) do
+        make_server(:secondary).tap do |server|
+          allow(server).to receive(:features).and_return(double("secondary features"))
+        end
+      end
+
+      context "when #select_in_replica_set returns a list of nils" do
+        let(:servers) do
+          [ primary ]
+        end
+
+        let(:read_pref) do
+          described_class.get(mode: :primary).tap do |pref|
+            allow(pref).to receive(:select_in_replica_set).and_return([ nil, nil ])
+          end
+        end
+
+        it 'raises a NoServerAvailable error' do
+          expect do
+            read_pref.select_server(cluster)
+          end.to raise_exception(Mongo::Error::NoServerAvailable)
+        end
+      end
+
+      context "write_aggregation is true" do
+
+        before do
+          # It does not matter for this context whether primary supports secondary wites or not,
+          # but we need to mock out this call.
+          allow(primary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+        end
+
+        context "read preference is primary" do
+          let(:selector) { Mongo::ServerSelector::Primary.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          [true, false].each do |secondary_support_writes|
+            context "secondary #{secondary_support_writes ? 'supports' : 'does not support' } writes" do
+              it "selects a primary" do
+                allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(secondary_support_writes)
+
+                expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+              end
+            end
+          end
+        end
+
+        context "read preference is primary preferred" do
+          let(:selector) { Mongo::ServerSelector::PrimaryPreferred.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          [true, false].each do |secondary_support_writes|
+            context "secondary #{secondary_support_writes ? 'supports' : 'does not support' } writes" do
+              it "selects a primary" do
+                allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(secondary_support_writes)
+
+                expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+              end
+            end
+          end
+        end
+
+        context "read preference is secondary preferred" do
+          let(:selector) { Mongo::ServerSelector::SecondaryPreferred.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          context "secondary supports writes" do
+            it "selects a secondary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(true)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(secondary)
+            end
+          end
+
+          context "secondary does not support writes" do
+            it "selects a primary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+        end
+
+        context "read preference is secondary" do
+          let(:selector) { Mongo::ServerSelector::Secondary.new }
+
+          let(:servers) do
+            [ primary, secondary ]
+          end
+
+          context "secondary supports writes" do
+            it "selects a secondary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(true)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(secondary)
+            end
+          end
+
+          context "secondary does not support writes" do
+            it "selects a primary" do
+              allow(secondary.features).to receive(:merge_out_on_secondary_enabled?).and_return(false)
+
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+
+          context "no secondaries in cluster" do
+            let(:servers) do
+              [ primary ]
+            end
+
+            it "selects a primary" do
+              expect(selector.select_server(cluster, write_aggregation: true)).to eq(primary)
+            end
+          end
+        end
       end
     end
 
@@ -381,8 +498,12 @@ describe Mongo::ServerSelector do
         let(:servers) { [unknown, mongos] }
         let(:selector) { described_class.primary }
 
-        it 'returns the mongos' do
-          expect(selector.select_server(cluster)).to eq(mongos)
+        [true, false].each do |write_aggregation|
+          context "write_aggregation is #{write_aggregation}" do
+            it 'returns the mongos' do
+              expect(selector.select_server(cluster, write_aggregation: write_aggregation)).to eq(mongos)
+            end
+          end
         end
       end
     end