mongo 2.13.0.beta1 → 2.13.0.rc1

data/spec/mongo/client_spec.rb

@@ -595,6 +595,21 @@ describe Mongo::Client do
     end
 
     context 'when name_only is true' do
+      min_server_fcv '3.6'
+
+      let(:command) do
+        Utils.get_command_event(root_authorized_client, 'listDatabases') do |client|
+          client.list_databases({}, true)
+        end.command
+      end
+
+      it 'sends the command with the nameOnly flag set to true' do
+        expect(command[:nameOnly]).to be(true)
+      end
+    end
+
+    context 'when authorized_databases is provided' do
+      min_server_fcv '4.0'
 
       let(:client_options) do
         root_authorized_client.options.merge(heartbeat_frequency: 100, monitoring: true)
@@ -614,12 +629,32 @@ describe Mongo::Client do
         subscriber.started_events.find { |c| c.command_name == 'listDatabases' }.command
       end
 
+      let(:authDb) do
+        { authorized_databases: true }
+      end
+
+      let(:noAuthDb) do
+        { authorized_databases: false }
+      end
+
       before do
-        client.list_databases({}, true)
+        client.list_databases({}, true, authDb)
+        client.list_databases({}, true, noAuthDb)
       end
 
-      it 'sends the command with the nameOnly flag set to true' do
-        expect(command[:nameOnly]).to be(true)
+      let(:events) do
+        subscriber.command_started_events('listDatabases')
+      end
+
+      it 'sends the command with the authorizedDatabases flag set to true' do
+        expect(events.length).to eq(2)
+        command = events.first.command
+        expect(command[:authorizedDatabases]).to be(true)
+      end
+
+      it 'sends the command with the authorizedDatabases flag set to nil' do
+        command = events.last.command
+        expect(command[:authorizedDatabases]).to be_nil
       end
     end
   end

data/spec/mongo/cluster/topology/replica_set_spec.rb

@@ -150,7 +150,13 @@ describe Mongo::Cluster::Topology::ReplicaSetNoPrimary do
     end
 
     let(:cluster) do
-      double('cluster', servers: servers, single?: false, sharded?: false, unknown?: false)
+      double('cluster',
+        servers: servers,
+        single?: false,
+        replica_set?: true,
+        sharded?: false,
+        unknown?: false,
+      )
     end
 
     context 'when the read preference is primary' do
@@ -162,7 +168,11 @@ describe Mongo::Cluster::Topology::ReplicaSetNoPrimary do
       context 'when a primary exists' do
 
         let(:servers) do
-          [ double('server', primary?: true) ]
+          [ double('server',
+            primary?: true,
+            # for runs with linting enabled
+            average_round_trip_time: 42,
+          ) ]
         end
 
         it 'returns true' do
@@ -191,7 +201,12 @@ describe Mongo::Cluster::Topology::ReplicaSetNoPrimary do
       context 'when a primary exists' do
 
         let(:servers) do
-          [ double('server', primary?: true, secondary?: false) ]
+          [ double('server',
+            primary?: true,
+            secondary?: false,
+            # for runs with linting enabled
+            average_round_trip_time: 42,
+          ) ]
         end
 
         it 'returns true' do
@@ -260,7 +275,12 @@ describe Mongo::Cluster::Topology::ReplicaSetNoPrimary do
       context 'when a secondary does not exist' do
 
         let(:servers) do
-          [ double('server', secondary?: false, primary?: true) ]
+          [ double('server',
+            secondary?: false,
+            primary?: true,
+            # for runs with linting enabled
+            average_round_trip_time: 42,
+          ) ]
         end
 
         it 'returns true' do
@@ -289,7 +309,12 @@ describe Mongo::Cluster::Topology::ReplicaSetNoPrimary do
       context 'when a primary exists' do
 
         let(:servers) do
-          [ double('server', primary?: true, secondary?: false) ]
+          [ double('server',
+            primary?: true,
+            secondary?: false,
+            # for runs with linting enabled
+            average_round_trip_time: 42,
+          ) ]
         end
 
         it 'returns true' do
@@ -319,15 +344,28 @@ describe Mongo::Cluster::Topology::ReplicaSetNoPrimary do
     context 'when a primary server exists' do
 
       let(:primary) do
-        double('server', :primary? => true)
+        double('server',
+          :primary? => true,
+          # for runs with linting enabled
+          average_round_trip_time: 42,
+        )
       end
 
       let(:secondary) do
-        double('server', :primary? => false)
+        double('server',
+          :primary? => false,
+          # for runs with linting enabled
+          average_round_trip_time: 42,
+        )
       end
 
       let(:cluster) do
-        double('cluster', servers: [ primary, secondary ])
+        double('cluster',
+          single?: false,
+          replica_set?: true,
+          sharded?: false,
+          servers: [ primary, secondary ],
+        )
       end
 
       it 'returns true' do
@@ -342,7 +380,12 @@ describe Mongo::Cluster::Topology::ReplicaSetNoPrimary do
       end
 
       let(:cluster) do
-        double('cluster', servers: [ server ])
+        double('cluster',
+          single?: false,
+          replica_set?: true,
+          sharded?: false,
+          servers: [ server ],
+        )
       end
 
       it 'returns false' do

data/spec/mongo/cluster/topology/single_spec.rb

@@ -87,8 +87,10 @@ describe Mongo::Cluster::Topology::Single do
       topology.servers([ mongos, standalone, standalone_two, replica_set ])
     end
 
-    it 'returns only the first standalone server' do
-      expect(servers).to eq([ standalone ])
+    it 'returns all data-bearing non-unknown servers' do
+      # mongos and replica_set do not have ok: 1 in their descriptions,
+      # and are considered unknown.
+      expect(servers).to eq([ standalone, standalone_two ])
     end
   end
 

data/spec/mongo/cluster_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'runners/sdam_monitoring'
 
 describe Mongo::Cluster do
 
@@ -344,13 +343,13 @@ describe Mongo::Cluster do
       end
 
       let(:monitoring) { Mongo::Monitoring.new }
-      let(:subscriber) { Mongo::SDAMMonitoring::TestSubscriber.new }
+      let(:subscriber) { EventSubscriber.new }
 
       it 'publishes server closed event once' do
         monitoring.subscribe(Mongo::Monitoring::SERVER_CLOSED, subscriber)
         expect(cluster.disconnect!).to be(true)
         expect(subscriber.first_event('server_closed_event')).not_to be nil
-        subscriber.events.clear
+        subscriber.succeeded_events.clear
         expect(cluster.disconnect!).to be(true)
         expect(subscriber.first_event('server_closed_event')).to be nil
       end
@@ -595,7 +594,23 @@ describe Mongo::Cluster do
     end
   end
 
-  describe '#sessions_supported?' do
+  describe '#validate_session_support!' do
+    shared_examples 'supports sessions' do
+      it 'supports sessions' do
+        lambda do
+          cluster.validate_session_support!
+        end.should_not raise_error
+      end
+    end
+
+    shared_examples 'does not support sessions' do
+      it 'does not support sessions' do
+        lambda do
+          cluster.validate_session_support!
+        end.should raise_error(Mongo::Error::SessionsNotSupported)
+      end
+    end
+
     context 'when client has not contacted any servers' do
 
       let(:cluster) do
@@ -604,9 +619,7 @@ describe Mongo::Cluster do
             monitoring_io: false, server_selection_timeout: 0.183))
       end
 
-      it 'is false' do
-        expect(cluster.send(:sessions_supported?)).to be false
-      end
+      it_behaves_like 'does not support sessions'
     end
 
     context 'when client has contacted servers and then disconnected' do
@@ -629,22 +642,20 @@ describe Mongo::Cluster do
         cluster.servers_list.map(&:unknown!)
       end
 
-      it 'is true' do
-        expect(cluster.send(:sessions_supported?)).to be true
-      end
+      it_behaves_like 'supports sessions'
     end
 
     context 'in server < 3.6' do
       max_server_version '3.4'
 
+      let(:cluster) { client.cluster }
+
       context 'in single topology' do
         require_topology :single
 
         let(:client) { ClientRegistry.instance.global_client('authorized') }
 
-        it 'is false' do
-          expect(client.cluster.send(:sessions_supported?)).to be false
-        end
+        it_behaves_like 'does not support sessions'
       end
 
       context 'in single topology with replica set name set' do
@@ -656,9 +667,7 @@ describe Mongo::Cluster do
               connect: :direct, replica_set: ClusterConfig.instance.replica_set_name))
         end
 
-        it 'is false' do
-          expect(client.cluster.send(:sessions_supported?)).to be false
-        end
+        it_behaves_like 'does not support sessions'
       end
 
       context 'in replica set topology' do
@@ -666,9 +675,7 @@ describe Mongo::Cluster do
 
         let(:client) { ClientRegistry.instance.global_client('authorized') }
 
-        it 'is false' do
-          expect(client.cluster.send(:sessions_supported?)).to be false
-        end
+        it_behaves_like 'does not support sessions'
       end
 
       context 'in sharded topology' do
@@ -676,15 +683,15 @@ describe Mongo::Cluster do
 
         let(:client) { ClientRegistry.instance.global_client('authorized') }
 
-        it 'is false' do
-          expect(client.cluster.send(:sessions_supported?)).to be false
-        end
+        it_behaves_like 'does not support sessions'
       end
     end
 
     context 'in server 3.6+' do
       min_server_fcv '3.6'
 
+      let(:cluster) { client.cluster }
+
       context 'in single topology' do
         require_topology :single
 
@@ -692,10 +699,8 @@ describe Mongo::Cluster do
 
         # Contrary to the session spec, 3.6 and 4.0 standalone servers
         # report a logical session timeout and thus are considered to
-        # support sessions
-        it 'is true' do
-          expect(client.cluster.send(:sessions_supported?)).to be true
-        end
+        # support sessions.
+        it_behaves_like 'supports sessions'
       end
 
       context 'in single topology with replica set name set' do
@@ -707,9 +712,7 @@ describe Mongo::Cluster do
               connect: :direct, replica_set: ClusterConfig.instance.replica_set_name))
         end
 
-        it 'is true' do
-          expect(client.cluster.send(:sessions_supported?)).to be true
-        end
+        it_behaves_like 'supports sessions'
       end
 
       context 'in replica set topology' do
@@ -717,9 +720,7 @@ describe Mongo::Cluster do
 
         let(:client) { ClientRegistry.instance.global_client('authorized') }
 
-        it 'is true' do
-          expect(client.cluster.send(:sessions_supported?)).to be true
-        end
+        it_behaves_like 'supports sessions'
       end
 
       context 'in sharded topology' do
@@ -727,9 +728,7 @@ describe Mongo::Cluster do
 
         let(:client) { ClientRegistry.instance.global_client('authorized') }
 
-        it 'is true' do
-          expect(client.cluster.send(:sessions_supported?)).to be true
-        end
+        it_behaves_like 'supports sessions'
       end
     end
   end

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

@@ -196,7 +196,7 @@ describe Mongo::Collection::View::ChangeStream do
         change_stream.to_enum
       end
 
-      it 'propagates cursor not found error' do
+      it 'resumes on a cursor not found error' do
         original_cursor_id = cursor.id
 
         client.use(:admin).command({
@@ -204,9 +204,9 @@ describe Mongo::Collection::View::ChangeStream do
           cursors: [cursor.id]
         })
 
-        lambda do
+        expect do
           enum.next
-        end.should raise_error(Mongo::Error::OperationFailure, /cursor.*not found/)
+        end.not_to raise_error
       end
     end
 
@@ -218,7 +218,7 @@ describe Mongo::Collection::View::ChangeStream do
         collection.insert_one(a:2)
       end
 
-      it 'propagates cursor not found error' do
+      it 'resumes on a cursor not found error' do
         original_cursor_id = cursor.id
 
         client.use(:admin).command({
@@ -226,9 +226,9 @@ describe Mongo::Collection::View::ChangeStream do
           cursors: [cursor.id]
         })
 
-        lambda do
+        expect do
           change_stream.try_next
-        end.should raise_error(Mongo::Error::OperationFailure, /cursor.*not found/)
+        end.not_to raise_error
       end
     end
   end

data/spec/mongo/collection_spec.rb

@@ -941,6 +941,30 @@ describe Mongo::Collection do
         it_behaves_like 'a failed operation using a session'
       end
     end
+
+    context 'when collation has a strength' do
+      min_server_fcv '3.4'
+
+      let(:band_collection) do
+        described_class.new(database, :bands)
+      end
+
+      before do
+        band_collection.delete_many
+        band_collection.insert_many([{ name: "Depeche Mode" }, { name: "New Order" }])
+      end
+
+      let(:options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+      let(:band_result) do
+        band_collection.find({ name: 'DEPECHE MODE' }, options)
+      end
+
+      it 'finds Capitalize from UPPER CASE' do
+        expect(band_result.count_documents).to eq(1)
+      end
+    end
   end
 
   describe '#drop' do
@@ -1601,6 +1625,40 @@ describe Mongo::Collection do
         expect(result.inserted_count).to be(0)
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('insert')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'insert') do |client|
+          collection.insert_many([{ name: 'test1' }, { name: 'test2' }], session: session,
+            write_concern: {w: 1}, bypass_document_validation: true)
+        end.command
+      end
+
+      it 'inserts many successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:bypassDocumentValidation]).to be(true)
+      end
+    end
   end
 
   describe '#insert_one' do
@@ -1683,6 +1741,37 @@ describe Mongo::Collection do
       it_behaves_like 'an implicit session with an unacknowledged write'
     end
 
+    context 'when various options passed in' do
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('insert')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 3})
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'insert') do |client|
+          collection.insert_one({name: 'test1'}, session: session, write_concern: {w: 1},
+            bypass_document_validation: true)
+        end.command
+      end
+
+      it 'inserts one successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:bypassDocumentValidation]).to be(true)
+      end
+    end
+
     context 'when the document contains invalid keys' do
 
       let(:doc) do
@@ -1791,6 +1880,52 @@ describe Mongo::Collection do
     end
   end
 
+  describe '#bulk_write' do
+
+    context 'when various options passed in' do
+      min_server_fcv '3.2'
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      let(:requests) do
+        [
+          { insert_one: { name: "anne" }},
+          { insert_one: { name: "bob" }},
+          { insert_one: { name: "charlie" }}
+        ]
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'insert') do |client|
+          collection.bulk_write(requests, session: session, write_concern: {w: 1},
+            bypass_document_validation: true)
+        end.command
+      end
+
+      let(:events) do
+        subscriber.command_started_events('insert')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      it 'inserts successfully with correct options sent to server' do
+        expect(collection.count).to eq(3)
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:bypassDocumentValidation]).to eq(true)
+      end
+    end
+  end
+
   describe '#inspect' do
 
     it 'includes the object id' do
@@ -2000,6 +2135,39 @@ describe Mongo::Collection do
   end
 
   describe '#count_documents' do
+
+    before do
+      authorized_collection.delete_many
+    end
+
+    context 'no argument provided' do
+
+      context 'when collection is empty' do
+        it 'returns 0 matching documents' do
+          expect(authorized_collection.count_documents).to eq(0)
+        end
+      end
+
+      context 'when collection is not empty' do
+
+        let(:documents) do
+          documents = []
+          1.upto(10) do |index|
+            documents << { key: 'a', _id: "in#{index}" }
+          end
+          documents
+        end
+
+        before do
+          authorized_collection.insert_many(documents)
+        end
+
+        it 'returns 10 matching documents' do
+          expect(authorized_collection.count_documents).to eq(10)
+        end
+      end
+    end
+
     context 'when transactions are enabled' do
       require_wired_tiger
       require_transaction_support
@@ -2478,6 +2646,48 @@ describe Mongo::Collection do
         expect(authorized_collection.find(name: 'bang').count).to eq(1)
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        authorized_collection.insert_many([{ name: 'test1' }, { name: 'test2' }])
+      end
+
+      let(:selector) do
+        {name: 'test2'}
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('delete')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'delete') do |client|
+          collection.delete_one(selector, session: session, write_concern: {w: 1},
+            bypass_document_validation: true)
+        end.command
+      end
+
+      it 'deletes one successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:bypassDocumentValidation]).to eq(true)
+      end
+    end
   end
 
   describe '#delete_many' do
@@ -2668,6 +2878,48 @@ describe Mongo::Collection do
         expect(authorized_collection.find(name: 'bang').count).to eq(2)
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        collection.insert_many([{ name: 'test1' }, { name: 'test2' }, { name: 'test3'}])
+      end
+
+      let(:selector) do
+        {name: 'test1'}
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('delete')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 1})
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'delete') do |client|
+          collection.delete_many(selector, session: session, write_concern: {w: 2},
+            bypass_document_validation: true)
+        end.command
+      end
+
+      it 'deletes many successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(command[:bypassDocumentValidation]).to be(true)
+      end
+    end
   end
 
   describe '#parallel_scan' do
@@ -3174,6 +3426,51 @@ describe Mongo::Collection do
 
       it_behaves_like 'an implicit session with an unacknowledged write'
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        authorized_collection.insert_one({field: 'test1'})
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('update')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 3})
+      end
+
+      let(:updated) do
+        collection.find(field: 'test4').first
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'update') do |client|
+          collection.replace_one(selector, { field: 'test4'},
+            session: session, :return_document => :after, write_concern: {w: 2},
+            upsert: true, bypass_document_validation: true)
+       end.command
+      end
+
+      it 'replaced one successfully with correct options sent to server' do
+        expect(updated[:field]).to eq('test4')
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(command[:bypassDocumentValidation]).to be(true)
+        expect(command[:updates][0][:upsert]).to be(true)
+      end
+    end
   end
 
   describe '#update_many' do
@@ -3596,6 +3893,45 @@ describe Mongo::Collection do
 
       it_behaves_like 'an implicit session with an unacknowledged write'
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        collection.insert_many([{ field: 'test' }, { field: 'test2' }], session: session)
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 1})
+      end
+
+      let(:events) do
+        subscriber.command_started_events('update')
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'update') do |client|
+          collection.update_many(selector, {'$set'=> { field: 'testing' }}, session: session,
+            write_concern: {w: 2}, bypass_document_validation: true, upsert: true)
+        end.command
+      end
+
+      it 'updates many successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(collection.options[:write_concern]).to eq(w: 1)
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(command[:bypassDocumentValidation]).to be(true)
+        expect(command[:updates][0][:upsert]).to be(true)
+      end
+    end
   end
 
   describe '#update_one' do
@@ -4014,6 +4350,47 @@ describe Mongo::Collection do
 
       it_behaves_like 'an implicit session with an unacknowledged write'
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        collection.insert_many([{ field: 'test1' }, { field: 'test2' }], session: session)
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 1})
+      end
+
+      let(:events) do
+        subscriber.command_started_events('update')
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'update') do |client|
+          collection.update_one(selector, { '$set'=> { field: 'testing' } }, session: session,
+            write_concern: {w: 2}, bypass_document_validation: true, :return_document => :after,
+            upsert: true)
+        end.command
+      end
+
+      it 'updates one successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(collection.options[:write_concern]).to eq(w:1)
+        expect(command[:bypassDocumentValidation]).to be(true)
+        expect(command[:updates][0][:upsert]).to be(true)
+      end
+    end
   end
 
   describe '#find_one_and_delete' do
@@ -4231,6 +4608,46 @@ describe Mongo::Collection do
         expect(result).to be_nil
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        authorized_collection.delete_many
+        authorized_collection.insert_many([{ name: 'test1' }, { name: 'test2' }])
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'findAndModify') do |client|
+          collection.find_one_and_delete(selector, session: session, write_concern: {w: 2},
+            bypass_document_validation: true, max_time_ms: 300)
+        end.command
+      end
+
+      let(:events) do
+        subscriber.command_started_events('findAndModify')
+      end
+
+      it 'finds and deletes successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(2)
+        expect(command[:bypassDocumentValidation]).to eq(true)
+        expect(command[:maxTimeMS]).to eq(300)
+      end
+    end
   end
 
   describe '#find_one_and_update' do
@@ -4652,6 +5069,51 @@ describe Mongo::Collection do
         end
       end
     end
+
+    context 'when various options passed in' do
+      # w: 2 requires a replica set
+      require_topology :replica_set
+
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('findAndModify')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: {w: 2})
+      end
+
+      let(:selector) do
+        {field: 'test1'}
+      end
+
+      before do
+        collection.insert_one({field: 'test1'}, session: session)
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'findAndModify') do |client|
+          collection.find_one_and_update(selector, { '$set' => {field: 'testing'}},
+            :return_document => :after, write_concern: {w: 1}, upsert: true,
+            bypass_document_validation: true, max_time_ms: 100, session: session)
+        end.command
+      end
+
+      it 'find and updates successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:upsert]).to eq(true)
+        expect(command[:bypassDocumentValidation]).to be(true)
+        expect(command[:maxTimeMS]).to eq(100)
+      end
+    end
   end
 
   describe '#find_one_and_replace' do
@@ -4965,6 +5427,44 @@ describe Mongo::Collection do
         expect(result).to be_nil
       end
     end
+
+    context 'when various options passed in' do
+      # https://jira.mongodb.org/browse/RUBY-2306
+      min_server_fcv '3.6'
+
+      before do
+        authorized_collection.insert_one({field: 'test1'})
+      end
+
+      let(:session) do
+        authorized_client.start_session
+      end
+
+      let(:events) do
+        subscriber.command_started_events('findAndModify')
+      end
+
+      let(:collection) do
+        authorized_collection.with(write_concern: { w: 2 })
+      end
+
+      let!(:command) do
+        Utils.get_command_event(authorized_client, 'findAndModify') do |client|
+          collection.find_one_and_replace(selector, { '$set' => {field: 'test5'}},
+            :return_document => :after, write_concern: {w: 1}, session: session,
+            upsert: true, bypass_document_validation: false, max_time_ms: 200)
+        end.command
+      end
+
+      it 'find and replaces successfully with correct options sent to server' do
+        expect(events.length).to eq(1)
+        expect(command[:writeConcern]).to_not be_nil
+        expect(command[:writeConcern][:w]).to eq(1)
+        expect(command[:upsert]).to be(true)
+        expect(command[:bypassDocumentValidation]).to be_nil
+        expect(command[:maxTimeMS]).to eq(200)
+      end
+    end
   end
 
   describe '#watch' do