mongo 2.15.0 → 2.18.1

data/spec/integration/client_side_encryption/unique_index_on_key_alt_names_prose_spec.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+require "spec_helper"
+
+describe "Decryption events" do
+  require_enterprise
+  min_server_fcv "4.2"
+  require_libmongocrypt
+  include_context "define shared FLE helpers"
+
+  let(:client) do
+    ClientRegistry.instance.new_local_client(
+      SpecConfig.instance.addresses,
+      SpecConfig.instance.test_options.merge(
+        database: SpecConfig.instance.test_db,
+      )
+    )
+  end
+
+  let(:client_encryption) do
+    Mongo::ClientEncryption.new(
+      client,
+      key_vault_namespace: "#{key_vault_db}.#{key_vault_coll}",
+      kms_providers: local_kms_providers
+    )
+  end
+
+  let(:existing_key_alt_name) do
+    'def'
+  end
+
+  let(:existing_key_id) do
+    client_encryption.create_data_key('local', key_alt_names: [existing_key_alt_name])
+  end
+
+  before(:each) do
+    client.use(key_vault_db)[key_vault_coll].drop
+    client.use(key_vault_db).command({
+      createIndexes: key_vault_coll,
+      indexes: [
+        {
+          name: "keyAltNames_1",
+          key: { "keyAltNames": 1 },
+          unique: true,
+          partialFilterExpression: { keyAltNames: { "$exists" => true } },
+        },
+      ],
+      writeConcern: { w: "majority" },
+    })
+    # Force key creation
+    existing_key_id
+  end
+
+  it 'tests create_data_key' do
+    expect do
+      client_encryption.create_data_key('local', key_alt_names: ['abc'])
+    end.not_to raise_error
+
+    expect do
+      client_encryption.create_data_key('local', key_alt_names: [existing_key_alt_name])
+    end.to raise_error(Mongo::Error::OperationFailure, /E11000/) # duplicate key error
+  end
+
+  it 'tests add_key_alt_name' do
+    key_id = client_encryption.create_data_key('local')
+    expect do
+      client_encryption.add_key_alt_name(key_id, 'abc')
+    end.not_to raise_error
+
+    expect do
+      key_document = client_encryption.add_key_alt_name(key_id, 'abc')
+      expect(key_document['keyAltNames']).to include('abc')
+    end.not_to raise_error
+
+    expect do
+      client_encryption.add_key_alt_name(key_id, existing_key_alt_name)
+    end.to raise_error(Mongo::Error::OperationFailure, /E11000/) # duplicate key error
+
+    expect do
+      key_document = client_encryption.add_key_alt_name(existing_key_id, existing_key_alt_name)
+      expect(key_document['keyAltNames']).to include(existing_key_alt_name)
+    end.not_to raise_error
+  end
+end

data/spec/integration/client_side_encryption/views_spec.rb

@@ -24,7 +24,7 @@ describe 'Client-Side Encryption' do
         SpecConfig.instance.test_options.merge(
           auto_encryption_options: {
             kms_providers: local_kms_providers,
-            key_vault_namespace: 'admin.datakeys',
+            key_vault_namespace: 'keyvault.datakeys',
             # Spawn mongocryptd on non-default port for sharded cluster tests
             extra_options: extra_options,
           },

data/spec/integration/client_spec.rb

@@ -21,6 +21,8 @@ describe 'Client' do
     end
 
     context 'after all servers are marked unknown' do
+      require_topology :single, :replica_set, :sharded
+
       before do
         client.cluster.servers.each do |server|
           server.unknown!

data/spec/integration/client_update_spec.rb

@@ -15,8 +15,8 @@ describe Mongo::Client do
     include_context 'with local kms_providers'
 
     before do
-      authorized_client.use(:admin)[:datakeys].drop
-      authorized_client.use(:admin)[:datakeys].insert_one(data_key)
+      authorized_client.use(:keyvault)[:datakeys].drop
+      authorized_client.use(:keyvault)[:datakeys].insert_one(data_key)
       authorized_client.use(:auto_encryption)[:users].drop
       authorized_client.use(:auto_encryption)[:users,
         {

data/spec/integration/command_monitoring_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 
 describe 'Command monitoring' do
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   let(:client) do
     authorized_client.with(app_name: 'command monitoring spec').tap do |client|

data/spec/integration/command_spec.rb

@@ -5,7 +5,7 @@ require 'spec_helper'
 
 describe 'Command' do
 
-  let(:subscriber) { EventSubscriber.new }
+  let(:subscriber) { Mrss::EventSubscriber.new }
 
   describe 'payload' do
     let(:server) { authorized_client.cluster.next_primary }

data/spec/integration/connection_spec.rb

@@ -50,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)
@@ -246,43 +246,60 @@ describe 'Connections' do
 
       let(:client) { ClientRegistry.instance.global_client('authorized').with(app_name: 'wire_protocol_update') }
 
-      it 'updates on hello 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 hello 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, hello 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 hello 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 hello 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)
+          server = client.cluster.servers.first
+          server.load_balancer?.should be true
+          server.features.server_wire_versions.max.should be 0
         end
       end
     end

data/spec/integration/crud_spec.rb

@@ -4,7 +4,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
@@ -64,9 +65,193 @@ describe 'CRUD operations' do
         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
+    context 'user documents' do
+      let(:doc) do
+        IceNine.deep_freeze(test: 42)
+      end
+
+      it 'does not mutate user documents' do
+        lambda do
+          collection.insert_one(doc)
+        end.should_not raise_error
+      end
+    end
+
     context 'inserting a BSON::Int64' do
       before do
         collection.insert_one(int64: BSON::Int64.new(42))

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 = []
+        connection_ids = []
+
+        4.times do
+          view = collection.find({}, batch_size: 1)
+          enum = view.to_enum
+
+          enum.next
+
+          enums << enum
+          connection_ids << view.cursor.initial_result.connection_global_id
+          connections << server.pool.check_out
+        end
+
+        connection_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

@@ -8,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
@@ -17,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|
@@ -57,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/fork_reconnect_spec.rb

@@ -10,11 +10,7 @@ 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 }
@@ -155,32 +151,37 @@ describe 'fork reconnect' do
     #   * In the child, create a ClientSession and assert its lsid is different.
     describe 'session pool' do
       it 'is cleared after fork' do
-        session = client.get_session
+        session = client.get_session.materialize_if_needed
         parent_lsid = session.session_id
         session.end_session
+
         if pid = fork
           pid, status = Process.wait2(pid)
           status.exitstatus.should == 0
         else
           Utils.wrap_forked_child do
             client.reconnect
-            child_session = client.get_session
+            child_session = client.get_session.materialize_if_needed
             child_lsid = child_session.session_id
             expect(child_lsid).not_to eq(parent_lsid)
           end
         end
 
-        expect(client.get_session.session_id).to eq(parent_lsid)
+        session = client.get_session.materialize_if_needed
+        session_id = session.session_id
+        expect(session_id).to eq(parent_lsid)
       end
 
       # Test from Driver Sessions Spec
       #   * Create ClientSession
       #   * Record its lsid
       #   * Fork
-      #   * In the parent, return the ClientSession to the pool, create a new ClientSession, and assert its lsid is the same.
-      #   * In the child, return the ClientSession to the pool, create a new ClientSession, and assert its lsid is different.
+      #   * In the parent, return the ClientSession to the pool, create a new
+      #     ClientSession, and assert its lsid is the same.
+      #   * In the child, return the ClientSession to the pool, create a new
+      #     ClientSession, and assert its lsid is different.
       it 'does not return parent process sessions to child process pool' do
-        session = client.get_session
+        session = client.get_session.materialize_if_needed
         parent_lsid = session.session_id
 
         if pid = fork
@@ -190,14 +191,16 @@ describe 'fork reconnect' do
           Utils.wrap_forked_child do
             client.reconnect
             session.end_session
-            child_session = client.get_session
+            child_session = client.get_session.materialize_if_needed
+
             child_lsid = child_session.session_id
             expect(child_lsid).not_to eq(parent_lsid)
           end
         end
 
         session.end_session
-        expect(client.get_session.session_id).to eq(parent_lsid)
+        session_id = client.get_session.materialize_if_needed.session_id
+        expect(session_id).to eq(parent_lsid)
       end
     end
   end

data/spec/integration/get_more_spec.rb

@@ -7,7 +7,7 @@ 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|