mongo 2.16.3 → 2.17.0

data/spec/integration/sdam_events_spec.rb

@@ -135,44 +135,4 @@ describe 'SDAM events' do
       end
     end
   end
-
-  describe 'server description changed' do
-    require_topology :single
-
-    let(:sdam_proc) do
-      Proc.new do |client|
-        client.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED, subscriber)
-      end
-    end
-
-    let(:client) do
-      new_local_client(SpecConfig.instance.addresses,
-        # Heartbeat interval is bound by 500 ms
-        SpecConfig.instance.test_options.merge(client_options).merge(
-          heartbeat_frequency: 0.5,
-          sdam_proc: sdam_proc,
-        ),
-      )
-    end
-
-    let(:client_options) do
-      {}
-    end
-
-    it 'is not published when there are no changes in server state' do
-      client
-      sleep 6
-      client.close
-
-      events = subscriber.select_succeeded_events(Mongo::Monitoring::Event::ServerDescriptionChanged)
-
-      # In 6 seconds we should have about 10 or 12 heartbeats.
-      # We expect 1 or 2 description changes:
-      # The first one from unknown to known,
-      # The second one because server changes the fields it returns based on
-      # driver server check payload (e.g. ismaster/isWritablePrimary).
-      events.length.should >= 1
-      events.length.should <= 2
-    end
-  end
 end

data/spec/lite_spec_helper.rb

@@ -157,13 +157,6 @@ RSpec.configure do |config|
 end
 
 if SpecConfig.instance.active_support?
-  require "active_support/version"
-  if ActiveSupport.version >= Gem::Version.new(7)
-    # ActiveSupport wants us to require ALL of it all of the time.
-    # See: https://github.com/rails/rails/issues/43851,
-    # https://github.com/rails/rails/issues/43889, etc.
-    require 'active_support'
-  end
   require "active_support/time"
   require 'mongo/active_support'
 end

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,20 +878,4 @@ 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/collection/view/readable_spec.rb

@@ -1186,62 +1186,6 @@ describe Mongo::Collection::View::Readable do
     it 'returns a new View' do
       expect(new_view).not_to be(view)
     end
-
-    context 'when sending to server' do
-      let(:subscriber) { Mrss::EventSubscriber.new }
-
-      before do
-        authorized_collection.client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-      end
-
-      let(:event) do
-        subscriber.single_command_started_event('find')
-      end
-
-      it 'is sent to server' do
-        new_view.to_a
-        event.command.slice('noCursorTimeout').should == {'noCursorTimeout' => true}
-      end
-    end
-
-    context 'integration test' do
-      require_topology :single
-
-      # The number of open cursors with the option set to prevent timeout.
-      def current_no_timeout_count
-        root_authorized_client
-          .command(serverStatus: 1)
-          .documents
-          .first
-          .fetch('metrics')
-          .fetch('cursor')
-          .fetch('open')
-          .fetch('noTimeout')
-      end
-
-      it 'is applied on the server' do
-        # Initialize collection with two documents.
-        new_view.collection.insert_many([{}, {}])
-
-        expect(new_view.count).to be == 2
-
-        # Initial "noTimeout" count should be zero.
-        states = [current_no_timeout_count]
-
-        # The "noTimeout" count should be one while iterating.
-        new_view.batch_size(1).each { states << current_no_timeout_count }
-
-        # Final "noTimeout" count should be back to zero.
-        states << current_no_timeout_count
-
-        # This succeeds on:
-        #   commit aab776ebdfb15ddb9765039f7300e15796de0c5c
-        #
-        # This starts failing with [0, 0, 0, 0] from:
-        #   commit 2d9f0217ec904a1952a1ada2136502eefbca562e
-        expect(states).to be == [0, 1, 1, 0]
-      end
-    end
   end
 
   describe '#projection' 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/query_cache_spec.rb

@@ -191,14 +191,6 @@ 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 }
 
@@ -206,65 +198,6 @@ 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
@@ -292,14 +225,6 @@ 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 }
 
@@ -308,14 +233,6 @@ 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 }
 
@@ -324,80 +241,6 @@ 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 }
 
@@ -405,14 +248,6 @@ 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