mongo 2.14.0 → 2.16.0

data/spec/integration/connection_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Connections' do
@@ -47,7 +50,7 @@ describe 'Connections' do
 
       context 'with sdam event subscription' do
 
-        let(:subscriber) { EventSubscriber.new }
+        let(:subscriber) { Mrss::EventSubscriber.new }
         let(:client) do
           ClientRegistry.instance.global_client('authorized').with(app_name: 'connection_integration').tap do |client|
             client.subscribe(Mongo::Monitoring::SERVER_OPENING, subscriber)
@@ -232,6 +235,8 @@ describe 'Connections' do
     end
 
     describe 'wire protocol version range update' do
+      require_no_required_api_version
+
       # 3.2 wire protocol is 4.
       # Wire protocol < 2 means only scram auth is available,
       # which is not supported by modern mongos.
@@ -241,48 +246,65 @@ describe 'Connections' do
 
       let(:client) { ClientRegistry.instance.global_client('authorized').with(app_name: 'wire_protocol_update') }
 
-      it 'updates on ismaster response from non-monitoring connections' do
-        # connect server
-        client['test'].insert_one(test: 1)
+      context 'non-lb' do
+        require_topology :single, :replica_set, :sharded
 
-        # kill background threads so that they are not interfering with
-        # our mocked ismaster response
-        client.cluster.servers.each do |server|
-          server.monitor.stop!
+        it 'updates on handshake response from non-monitoring connections' do
+          # connect server
+          client['test'].insert_one(test: 1)
+
+          # kill background threads so that they are not interfering with
+          # our mocked hello response
+          client.cluster.servers.each do |server|
+            server.monitor.stop!
+          end
+
+          server = client.cluster.servers.first
+          expect(server.features.server_wire_versions.max >= 4).to be true
+          max_version = server.features.server_wire_versions.max
+
+          # Depending on server version, handshake here may return a
+          # description that compares equal to the one we got from a
+          # monitoring connection (pre-4.2) or not (4.2+).
+          # Since we do run SDAM flow on handshake responses on
+          # non-monitoring connections, force descriptions to be different
+          # by setting the existing description here to unknown.
+          server.monitor.instance_variable_set('@description',
+            Mongo::Server::Description.new(server.address))
+
+          RSpec::Mocks.with_temporary_scope do
+            # now pretend a handshake returned a different range
+            features = Mongo::Server::Description::Features.new(0..3)
+            # One Features instantiation is for SDAM event publication, this
+            # one always happens. The second one happens on servers
+            # where we do not negotiate auth mechanism.
+            expect(Mongo::Server::Description::Features).to receive(:new).at_least(:once).and_return(features)
+
+            connection = Mongo::Server::Connection.new(server, server.options)
+            expect(connection.connect!).to be true
+
+            # hello response should update server description via sdam flow,
+            # which includes wire version range
+            expect(server.features.server_wire_versions.max).to eq(3)
+          end
         end
+      end
+
+      context 'lb' do
+        require_topology :load_balanced
+
+        it 'does not update on handshake response from non-monitoring connections since there are not any' do
+          # connect server
+          client['test'].insert_one(test: 1)
 
-        server = client.cluster.servers.first
-        expect(server.features.server_wire_versions.max >= 4).to be true
-        max_version = server.features.server_wire_versions.max
-
-        # Depending on server version, ismaster here may return a
-        # description that compares equal to the one we got from a
-        # monitoring connection (pre-4.2) or not (4.2+).
-        # Since we do run SDAM flow on ismaster responses on
-        # non-monitoring connections, force descriptions to be different
-        # by setting the existing description here to unknown.
-        server.monitor.instance_variable_set('@description',
-          Mongo::Server::Description.new(server.address))
-
-        RSpec::Mocks.with_temporary_scope do
-          # now pretend an ismaster returned a different range
-          features = Mongo::Server::Description::Features.new(0..3)
-          # One Features instantiation is for SDAM event publication, this
-          # one always happens. The second one happens on servers
-          # where we do not negotiate auth mechanism.
-          expect(Mongo::Server::Description::Features).to receive(:new).at_least(:once).and_return(features)
-
-          connection = Mongo::Server::Connection.new(server, server.options)
-          expect(connection.connect!).to be true
-
-          # ismaster response should update server description via sdam flow,
-          # which includes wire version range
-          expect(server.features.server_wire_versions.max).to eq(3)
+          server = client.cluster.servers.first
+          server.load_balancer?.should be true
+          server.features.server_wire_versions.max.should be 0
         end
       end
     end
 
-    describe 'SDAM flow triggered by ismaster on non-monitoring thread' do
+    describe 'SDAM flow triggered by hello on non-monitoring thread' do
       # replica sets can transition between having and not having a primary
       require_topology :replica_set
 

data/spec/integration/crud_spec.rb

@@ -1,7 +1,11 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'CRUD operations' do
-  let(:collection) { authorized_client['crud_integration'] }
+  let(:client) { authorized_client }
+  let(:collection) { client['crud_integration'] }
 
   before do
     collection.delete_many
@@ -33,6 +37,206 @@ describe 'CRUD operations' do
         end
       end
     end
+
+    context 'when using the legacy $query syntax' do
+      before do
+        collection.insert_one(_id: 1, test: 1)
+        collection.insert_one(_id: 2, test: 2)
+        collection.insert_one(_id: 3, test: 3)
+      end
+
+      context 'filter only' do
+        it 'passes the filter' do
+          collection.find(:'$query' => {test: 1}).first.should == {'_id' => 1, 'test' => 1}
+        end
+      end
+
+      context 'empty filter with order' do
+        it 'passes the filter' do
+          collection.find(:'$query' => {}, :'$orderby' => {test: 1}).first.should == {'_id' => 1, 'test' => 1}
+          collection.find(:'$query' => {}, :'$orderby' => {test: -1}).first.should == {'_id' => 3, 'test' => 3}
+        end
+      end
+
+      context 'filter with order' do
+        it 'passes both filter and order' do
+          collection.find(:'$query' => {test: {'$gt' => 1}}, '$orderby' => {test: 1}).first.should == {'_id' => 2, 'test' => 2}
+          collection.find(:'$query' => {test: {'$gt' => 1}}, '$orderby' => {test: -1}).first.should == {'_id' => 3, 'test' => 3}
+        end
+      end
+    end
+
+    context 'with read concern' do
+      # Read concern requires 3.2+ server.
+      min_server_fcv '3.2'
+
+      context 'with read concern specified on operation level' do
+
+        it 'passes the read concern' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client['foo'].find({}, read_concern: {level: :local}).to_a
+          end
+          event.command.fetch('readConcern').should == {'level' => 'local'}
+        end
+      end
+
+      context 'with read concern specified on collection level' do
+
+        it 'passes the read concern' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client['foo', read_concern: {level: :local}].find.to_a
+          end
+          event.command.fetch('readConcern').should == {'level' => 'local'}
+        end
+      end
+
+      context 'with read concern specified on client level' do
+
+        let(:client) { authorized_client.with(read_concern: {level: :local}) }
+
+        it 'passes the read concern' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client['foo'].find.to_a
+          end
+          event.command.fetch('readConcern').should == {'level' => 'local'}
+        end
+      end
+    end
+
+    context 'with oplog_replay option' do
+      let(:collection_name) { 'crud_integration_oplog_replay' }
+
+      let(:oplog_query) do
+        {ts: {'$gt' => 1}}
+      end
+
+      context 'passed to operation' do
+        it 'passes the option' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client[collection_name].find(oplog_query, oplog_replay: true).to_a
+          end
+          event.command.fetch('oplogReplay').should be true
+        end
+
+        it 'warns' do
+          client.should receive(:log_warn).with('The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later')
+          client[collection_name].find(oplog_query, oplog_replay: true).to_a
+        end
+      end
+
+      context 'set on collection' do
+        it 'passes the option' do
+          event = Utils.get_command_event(client, 'find') do |client|
+            client[collection_name, oplog_replay: true].find(oplog_query).to_a
+          end
+          event.command.fetch('oplogReplay').should be true
+        end
+
+        it 'warns' do
+          client.should receive(:log_warn).with('The :oplog_replay option is deprecated and ignored by MongoDB 4.4 and later')
+          client[collection_name, oplog_replay: true].find(oplog_query).to_a
+        end
+      end
+    end
+  end
+
+  describe 'explain' do
+    context 'with explicit session' do
+      min_server_fcv '3.6'
+
+      it 'passes the session' do
+        client.start_session do |session|
+          event = Utils.get_command_event(client, 'explain') do |client|
+            client['foo'].find({}, session: session).explain.should be_explain_output
+          end
+          event.command.fetch('lsid').should == session.session_id
+        end
+      end
+    end
+
+    context 'with read preference specified on operation level' do
+      require_topology :sharded
+
+      # RUBY-2706
+      min_server_fcv '3.6'
+
+      it 'passes the read preference' do
+        event = Utils.get_command_event(client, 'explain') do |client|
+          client['foo'].find({}, read: {mode: :secondary_preferred}).explain.should be_explain_output
+        end
+        event.command.fetch('$readPreference').should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+
+    context 'with read preference specified on collection level' do
+      require_topology :sharded
+
+      # RUBY-2706
+      min_server_fcv '3.6'
+
+      it 'passes the read preference' do
+        event = Utils.get_command_event(client, 'explain') do |client|
+          client['foo', read: {mode: :secondary_preferred}].find.explain.should be_explain_output
+        end
+        event.command.fetch('$readPreference').should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+
+    context 'with read preference specified on client level' do
+      require_topology :sharded
+
+      # RUBY-2706
+      min_server_fcv '3.6'
+
+      let(:client) { authorized_client.with(read: {mode: :secondary_preferred}) }
+
+      it 'passes the read preference' do
+        event = Utils.get_command_event(client, 'explain') do |client|
+          client['foo'].find.explain.should be_explain_output
+        end
+        event.command.fetch('$readPreference').should == {'mode' => 'secondaryPreferred'}
+      end
+    end
+
+    context 'with read concern' do
+      # Read concern requires 3.2+ server.
+      min_server_fcv '3.2'
+
+      context 'with read concern specifed on operation level' do
+
+        # Read concern is not allowed in explain command, driver drops it.
+        it 'drops the read concern' do
+          event = Utils.get_command_event(client, 'explain') do |client|
+            client['foo'].find({}, read_concern: {level: :local}).explain.should have_key('queryPlanner')
+          end
+          event.command.should_not have_key('readConcern')
+        end
+      end
+
+      context 'with read concern specifed on collection level' do
+
+        # Read concern is not allowed in explain command, driver drops it.
+        it 'drops the read concern' do
+          event = Utils.get_command_event(client, 'explain') do |client|
+            client['foo', read_concern: {level: :local}].find.explain.should have_key('queryPlanner')
+          end
+          event.command.should_not have_key('readConcern')
+        end
+      end
+
+      context 'with read concern specifed on client level' do
+
+        let(:client) { authorized_client.with(read_concern: {level: :local}) }
+
+        # Read concern is not allowed in explain command, driver drops it.
+        it 'drops the read concern' do
+          event = Utils.get_command_event(client, 'explain') do |client|
+            client['foo'].find.explain.should have_key('queryPlanner')
+          end
+          event.command.should_not have_key('readConcern')
+        end
+      end
+    end
   end
 
   describe 'insert' do

data/spec/integration/cursor_pinning_spec.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe 'Cursor pinning' do
+  let(:client) { authorized_client }
+  let(:collection_name) { 'cursor_pinning' }
+  let(:collection) { client[collection_name] }
+
+  before do
+    authorized_client[collection_name].insert_many([{test: 1}] * 200)
+  end
+
+  let(:server) { client.cluster.next_primary }
+
+  clean_slate
+
+  context 'non-lb' do
+    require_topology :single, :replica_set, :sharded
+    require_no_multi_mongos
+
+    # When not in load-balanced topology, iterating a cursor creates
+    # new connections as needed.
+
+    it 'creates new connections for iteration' do
+      server.pool.size.should == 0
+
+      # Use batch_size of 2 until RUBY-2727 is fixed.
+      enum = collection.find({}, batch_size: 2).to_enum
+      # Still zero because we haven't iterated
+      server.pool.size.should == 0
+
+      enum.next
+      enum.next
+      server.pool.size.should == 1
+
+      # Grab the connection that was used
+      server.with_connection do
+        # This requires a new connection
+        enum.next
+
+        server.pool.size.should == 2
+      end
+    end
+  end
+
+  context 'lb' do
+    require_topology :load_balanced
+
+    # In load-balanced topology, we cannot create new connections to a
+    # particular service.
+
+    context 'when no connection is available' do
+
+      it 'raises ConnectionCheckOutTimeout' do
+        server.pool.size.should == 0
+
+        enum = collection.find({}, batch_size: 1).to_enum
+        # Still zero because we haven't iterated
+        server.pool.size.should == 0
+
+        enum.next
+        server.pool.size.should == 1
+
+        # Grab the connection that was used
+        server.with_connection do
+          # This requires a new connection, but we cannot make one.
+          lambda do
+            enum.next
+          end.should raise_error(Mongo::Error::ConnectionCheckOutTimeout)
+
+          server.pool.size.should == 1
+        end
+      end
+    end
+
+    context 'when connection is available' do
+      require_multi_mongos
+
+      let(:client) { authorized_client.with(max_pool_size: 4) }
+
+      it 'uses the available connection' do
+        server.pool.size.should == 0
+
+        # Create 4 connections.
+
+        enums = []
+        connections = []
+        service_ids = []
+
+        4.times do
+          view = collection.find({}, batch_size: 1)
+          enum = view.to_enum
+
+          enum.next
+
+          enums << enum
+          service_ids << view.cursor.initial_result.connection_description.service_id
+          connections << server.pool.check_out
+        end
+
+        service_ids.uniq.length.should be > 1
+
+        server.pool.size.should == 4
+
+        connections.each do |c|
+          server.pool.check_in(c)
+        end
+
+        # At this point, in theory, all connections are equally likely to
+        # be chosen, but we have cursors referencing more than one
+        # distinct service.
+        # Iterate each cursor to ensure they all continue to work.
+        enums.each do |enum|
+          enum.next
+        end
+      end
+    end
+  end
+end

data/spec/integration/cursor_reaping_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Cursor reaping' do
@@ -5,6 +8,8 @@ describe 'Cursor reaping' do
   # in MRI, I don't currently know how to force GC to run in JRuby
   require_mri
 
+# Uncomment for debugging this test.
+=begin
   around(:all) do |example|
     saved_level = Mongo::Logger.logger.level
     Mongo::Logger.logger.level = Logger::DEBUG
@@ -14,8 +19,9 @@ describe 'Cursor reaping' do
       Mongo::Logger.logger.level = saved_level
     end
   end
+=end
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client) do
     authorized_client.tap do |client|
@@ -54,10 +60,11 @@ describe 'Cursor reaping' do
         10.times do
           scope = collection.find.batch_size(2).no_cursor_timeout
 
-          # there is no API for retrieving the cursor
+          # Begin iteration, creating the cursor
           scope.each.first
-          # and keep the first cursor
-          cursor_ids << scope.instance_variable_get('@cursor').id
+
+          scope.cursor.should_not be nil
+          cursor_ids << scope.cursor.id
         end
       end
     end

data/spec/integration/docs_examples_spec.rb

@@ -1,10 +1,20 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'aggregation examples in Ruby' do
   before(:all) do
     # In sharded clusters we need to ensure the database exists before running
     # the tests in this file.
-    ClientRegistry.instance.global_client('authorized')['_placeholder'].create
+    begin
+      ClientRegistry.instance.global_client('authorized')['_placeholder'].create
+    rescue Mongo::Error::OperationFailure => e
+      # Collection already exists
+      if e.code != 48
+        raise
+      end
+    end
   end
 
   let(:client) do

data/spec/integration/error_detection_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Error detection' do

data/spec/integration/fork_reconnect_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'fork reconnect' do
@@ -7,18 +10,17 @@ describe 'fork reconnect' do
   # On multi-shard sharded clusters a succeeding write request does not
   # guarantee that the next operation will succeed (since it could be sent to
   # another shard with a dead connection).
-  require_no_multi_shard
-
-  # On Ruby 2.3 $?.exitstatus is sometimes nil after Process.wait returns which
-  # is not supposed to happen.
-  ruby_version_gte '2.4'
+  require_no_multi_mongos
 
   let(:client) { authorized_client }
   let(:server) { client.cluster.next_primary }
 
   describe 'monitoring connection' do
     let(:monitor) do
-      Mongo::Server::Monitor.new(server, [], Mongo::Monitoring.new, server.options)
+      Mongo::Server::Monitor.new(server, [], Mongo::Monitoring.new, server.options.merge(
+        app_metadata: client.cluster.monitor_app_metadata,
+        push_monitor_app_metadata: client.cluster.push_monitor_app_metadata,
+      ))
     end
 
     it 'reconnects' do
@@ -131,7 +133,7 @@ describe 'fork reconnect' do
         status.exitstatus.should == 0
       else
         Utils.wrap_forked_child do
-          client.database.command(ismaster: 1).should be_a(Mongo::Operation::Result)
+          client.database.command(ping: 1).should be_a(Mongo::Operation::Result)
         end
       end
 

data/spec/integration/get_more_spec.rb

@@ -1,10 +1,13 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'getMore operation' do
   # https://jira.mongodb.org/browse/RUBY-1987
   min_server_fcv '3.2'
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client) do
     authorized_client.tap do |client|

data/spec/integration/grid_fs_bucket_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'GridFS bucket integration' do
@@ -30,7 +33,7 @@ describe 'GridFS bucket integration' do
 
     context 'in binary encoding' do
       let(:data_to_write) do
-        data.force_encoding('binary').freeze
+        data.dup.force_encoding('binary').freeze
       end
 
       it_behaves_like 'round-trips'

data/spec/integration/heartbeat_events_spec.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
 require 'spec_helper'
 
 describe 'Heartbeat events' do
@@ -8,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)
@@ -25,7 +28,7 @@ describe 'Heartbeat events' do
       server_selection_timeout: 0.1, connect: :direct)) }
 
   it 'notifies on successful heartbeats' do
-    client.database.command(ismaster: 1)
+    client.database.command(ping: 1)
 
     started_event = subscriber.started_events.first
     expect(started_event).not_to be nil
@@ -43,10 +46,10 @@ describe 'Heartbeat events' do
 
   it 'notifies on failed heartbeats' do
     exc = HeartbeatEventsSpecTestException.new
-    expect_any_instance_of(Mongo::Server::Monitor).to receive(:ismaster).at_least(:once).and_raise(exc)
+    expect_any_instance_of(Mongo::Server::Monitor).to receive(:check).at_least(:once).and_raise(exc)
 
     expect do
-      client.database.command(ismaster: 1)
+      client.database.command(ping: 1)
     end.to raise_error(Mongo::Error::NoServerAvailable)
 
     started_event = subscriber.started_events.first
@@ -72,7 +75,7 @@ describe 'Heartbeat events' do
 
     shared_examples_for 'does not notify on heartbeats' do
       it 'does not notify on heartbeats' do
-        client.database.command(ismaster: 1)
+        client.database.command(ping: 1)
 
         started_event = subscriber.started_events.first
         expect(started_event).to be nil