mongo 2.17.0 → 2.17.3

data/spec/mongo/cluster/cursor_reaper_spec.rb

@@ -41,12 +41,12 @@ describe Mongo::Cluster::CursorReaper do
     let(:cursor_id) { 1 }
     let(:cursor_kill_spec_1) do
       Mongo::Cursor::KillSpec.new(
-        cursor_id: cursor_id, coll_name: 'c', db_name: 'd', service_id: nil,
+        cursor_id: cursor_id, coll_name: 'c', db_name: 'd', service_id: nil, server_address: address
       )
     end
     let(:cursor_kill_spec_2) do
       Mongo::Cursor::KillSpec.new(
-        cursor_id: cursor_id, coll_name: 'c', db_name: 'q', service_id: nil,
+        cursor_id: cursor_id, coll_name: 'c', db_name: 'q', service_id: nil, server_address: address
       )
     end
     let(:to_kill) { reaper.instance_variable_get(:@to_kill)}
@@ -60,36 +60,40 @@ describe Mongo::Cluster::CursorReaper do
       context 'when there is not a list already for the server' do
 
         before do
-          reaper.schedule_kill_cursor(cursor_kill_spec_1, server)
+          reaper.schedule_kill_cursor(cursor_kill_spec_1)
+          reaper.read_scheduled_kill_specs
         end
 
         it 'initializes the list of op specs to a set' do
-          expect(to_kill.keys).to eq([ address.seed ])
-          expect(to_kill[address.seed]).to eq(Set.new([cursor_kill_spec_1]))
+          expect(to_kill.keys).to eq([ address ])
+          expect(to_kill[address]).to contain_exactly(cursor_kill_spec_1)
         end
       end
 
       context 'when there is a list of ops already for the server' do
 
         before do
-          reaper.schedule_kill_cursor(cursor_kill_spec_1, server)
-          reaper.schedule_kill_cursor(cursor_kill_spec_2, server)
+          reaper.schedule_kill_cursor(cursor_kill_spec_1)
+          reaper.read_scheduled_kill_specs
+          reaper.schedule_kill_cursor(cursor_kill_spec_2)
+          reaper.read_scheduled_kill_specs
         end
 
         it 'adds the op to the server list' do
-          expect(to_kill.keys).to eq([ address.seed ])
-          expect(to_kill[address.seed]).to contain_exactly(cursor_kill_spec_1, cursor_kill_spec_2)
+          expect(to_kill.keys).to eq([ address ])
+          expect(to_kill[address]).to contain_exactly(cursor_kill_spec_1, cursor_kill_spec_2)
         end
 
         context 'when the same op is added more than once' do
 
           before do
-            reaper.schedule_kill_cursor(cursor_kill_spec_2, server)
+            reaper.schedule_kill_cursor(cursor_kill_spec_2)
+            reaper.read_scheduled_kill_specs
           end
 
           it 'does not allow duplicates ops for a server' do
-            expect(to_kill.keys).to eq([ address.seed ])
-            expect(to_kill[address.seed]).to contain_exactly(cursor_kill_spec_1, cursor_kill_spec_2)
+            expect(to_kill.keys).to eq([ address ])
+            expect(to_kill[address]).to contain_exactly(cursor_kill_spec_1, cursor_kill_spec_2)
           end
         end
       end
@@ -98,7 +102,7 @@ describe Mongo::Cluster::CursorReaper do
     context 'when the cursor is not on the list of active cursors' do
 
       before do
-        reaper.schedule_kill_cursor(cursor_kill_spec_1, server)
+        reaper.schedule_kill_cursor(cursor_kill_spec_1)
       end
 
       it 'does not add the kill cursors op spec to the list' do
@@ -189,8 +193,11 @@ describe Mongo::Cluster::CursorReaper do
     around do |example|
       authorized_collection.insert_many(docs)
       periodic_executor.stop!
-      cluster.schedule_kill_cursor(cursor.kill_spec,
-                                   cursor.instance_variable_get(:@server))
+      cluster.schedule_kill_cursor(
+        cursor.kill_spec(
+          cursor.instance_variable_get(:@server)
+        )
+      )
       periodic_executor.flush
       example.run
       periodic_executor.run!

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

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

@@ -1186,6 +1186,62 @@ 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/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
@@ -697,4 +698,54 @@ describe Mongo::Cursor do
       end
     end
   end
+
+  describe '#batch_size' do
+    let(:subscriber) { Mrss::EventSubscriber.new }
+
+    let(:subscribed_client) do
+      authorized_client.tap do |client|
+        client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+      end
+    end
+
+    let(:collection) do
+      subscribed_client[TEST_COLL]
+    end
+
+    let(:view) do
+      collection.find({}, limit: limit)
+    end
+
+    before do
+      collection.drop
+      collection.insert_many([].fill({ "bar": "baz" }, 0, 102))
+    end
+
+    context 'when limit is 0 and batch_size is not set' do
+      let(:limit) do
+        0
+      end
+
+      it 'does not set batch_size' do
+        view.to_a
+        get_more_commands = subscriber.started_events.select { |e| e.command_name == 'getMore' }
+        expect(get_more_commands.length).to eq(1)
+        expect(get_more_commands.first.command.keys).not_to include('batchSize')
+      end
+    end
+
+    context 'when limit is not zero and batch_size is not set' do
+      let(:limit) do
+        1000
+      end
+
+      it 'sets batch_size' do
+        view.to_a
+        get_more_commands = subscriber.started_events.select { |e| e.command_name == 'getMore' }
+
+        expect(get_more_commands.length).to eq(1)
+        expect(get_more_commands.first.command.keys).to include('batchSize')
+      end
+    end
+  end
 end

data/spec/mongo/query_cache_spec.rb

@@ -191,6 +191,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 +206,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 +292,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 +308,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 +324,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 +405,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/runners/auth.rb

@@ -48,7 +48,7 @@ module Mongo
       attr_reader :tests
 
       def initialize(test_path)
-        @spec = YAML.load(File.read(test_path))
+        @spec = ::Utils.load_spec_yaml_file(test_path)
         @description = File.basename(test_path)
       end
 

data/spec/runners/change_streams/spec.rb

@@ -32,7 +32,7 @@ module Mongo
       #
       # @since 2.6.0
       def initialize(test_path)
-        @spec = YAML.load(File.read(test_path))
+        @spec = ::Utils.load_spec_yaml_file(test_path)
         @description = File.basename(test_path)
         @spec_tests = @spec['tests']
         @collection_name = @spec['collection_name']

data/spec/runners/cmap.rb

@@ -40,7 +40,7 @@ module Mongo
       #
       # @param [ String ] test_path The path to the file.
       def initialize(test_path)
-        @test = YAML.load(File.read(test_path))
+        @test = ::Utils.load_spec_yaml_file(test_path)
 
         @description = @test['description']
         @pool_options = ::Utils.snakeize_hash(process_options(@test['poolOptions']))

data/spec/runners/command_monitoring.rb

@@ -204,7 +204,7 @@ module Mongo
       #
       # @since 2.1.0
       def initialize(test_path)
-        @spec = YAML.load(File.read(test_path))
+        @spec = ::Utils.load_spec_yaml_file(test_path)
         @data = @spec['data']
         @tests = @spec['tests']
       end

data/spec/runners/connection_string.rb

@@ -100,7 +100,7 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(test_path)
-        @spec = YAML.load(File.read(test_path))
+        @spec = ::Utils.load_spec_yaml_file(test_path)
         @description = File.basename(test_path)
       end
 

data/spec/runners/crud/spec.rb

@@ -12,9 +12,7 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(test_path)
-        contents = File.read(test_path)
-
-        @spec = YAML.load(contents)
+        @spec = ::Utils.load_spec_yaml_file(test_path)
         @description = File.basename(test_path)
         @data = BSON::ExtJSON.parse_obj(@spec['data'])
         @tests = @spec['tests']

data/spec/runners/gridfs.rb

@@ -100,7 +100,7 @@ module Mongo
       #
       # @since 2.1.0
       def initialize(test_path)
-        @spec = YAML.load(File.read(test_path))
+        @spec = ::Utils.load_spec_yaml_file(test_path)
         @description = File.basename(test_path)
         @data = @spec['data']
       end

data/spec/runners/read_write_concern_document.rb

@@ -13,7 +13,7 @@ module ReadWriteConcernDocument
     #
     # @since 2.0.0
     def initialize(test_path)
-      @spec = YAML.load(File.read(test_path))
+      @spec = ::Utils.load_spec_yaml_file(test_path)
       @description = File.basename(test_path)
     end
 

data/spec/runners/sdam.rb

@@ -77,7 +77,7 @@ module Mongo
       #
       # @since 2.0.0
       def initialize(test_path)
-        @test = YAML.load(File.read(test_path))
+        @test = ::Utils.load_spec_yaml_file(test_path)
         @description = @test['description']
         @uri_string = @test['uri']
         @uri = URI.new(uri_string)

data/spec/runners/server_selection.rb

@@ -64,7 +64,7 @@ module Mongo
         #
         # @since 2.0.0
         def initialize(test_path)
-          @test = YAML.load(File.read(test_path))
+          @test = ::Utils.load_spec_yaml_file(test_path)
           @description = "#{@test['topology_description']['type']}: #{File.basename(test_path)}"
           @heartbeat_frequency = @test['heartbeatFrequencyMS'] / 1000 if @test['heartbeatFrequencyMS']
           @read_preference = @test['read_preference']

data/spec/runners/server_selection_rtt.rb

@@ -28,7 +28,7 @@ module Mongo
         #
         # @since 2.0.0
         def initialize(test_path)
-          @test = YAML.load(File.read(test_path))
+          @test = ::Utils.load_spec_yaml_file(test_path)
           @description = "#{File.basename(test_path)}: avg_rtt_ms: #{@test['avg_rtt_ms']}, new_rtt_ms: #{@test['new_rtt_ms']}," +
                            " new_avg_rtt: #{@test['new_avg_rtt']}"
           @average_rtt = @test['avg_rtt_ms'] == 'NULL' ? nil : @test['avg_rtt_ms'].to_f / 1000

data/spec/runners/unified/test_group.rb

@@ -6,7 +6,7 @@ module Unified
   class TestGroup
     def initialize(path, **opts)
       if String === path
-        data = YAML.load(File.read(path))
+        data = ::Utils.load_spec_yaml_file(path)
       else
         data = path
       end

data/spec/shared/share/Dockerfile.erb

@@ -233,13 +233,13 @@ CFG
   # Current virtualenv fails with
   # https://github.com/pypa/virtualenv/issues/1630
   <% if distro =~ /ubuntu2004/ %>
-    RUN python3 -m pip install 'virtualenv<20' 'mtools-legacy[mlaunch]'
+    RUN python3 -m pip install 'virtualenv<20' 'mtools-legacy[mlaunch]==1.5.5'
   <% else %>
-    RUN python2 -m pip install 'virtualenv<20' 'mtools-legacy[mlaunch]'
+    RUN python2 -m pip install 'virtualenv<20' 'mtools-legacy[mlaunch]==1.5.5'
   <% end %>
 
   RUN pip --version && \
-    pip install mtools-legacy[mlaunch]
+    pip install 'mtools-legacy[mlaunch]==1.5.5'
 
   <% if @env.fetch('MONGODB_VERSION') >= '4.4' %>
     # ubuntu1604 installs MarkupSafe 0.0.0 here instead of 2.0.0+

data/spec/shared/shlib/server.sh

@@ -71,7 +71,7 @@ install_mlaunch_virtualenv() {
     venvpath="$MONGO_ORCHESTRATION_HOME"/venv
     python2 -m virtualenv -p python2 $venvpath
     . $venvpath/bin/activate
-    pip install 'mtools-legacy[mlaunch]'
+    pip install 'mtools-legacy[mlaunch]==1.5.5'
   fi
 }
 

data/spec/spec_tests/seed_list_discovery_spec.rb

@@ -15,7 +15,7 @@ describe 'DNS Seedlist Discovery' do
 
   SEED_LIST_DISCOVERY_TESTS.each do |test_path|
 
-    spec = YAML.load(File.read(test_path))
+    spec = ::Utils.load_spec_yaml_file(test_path)
 
     test = Mongo::ConnectionString::Test.new(spec)