mongo 2.12.4 → 2.14.0.rc1

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

@@ -239,12 +239,16 @@ describe Mongo::Collection::View::MapReduce do
             Mongo::Collection::View.new(client[TEST_COLL], selector, view_options)
           end
 
+          let(:subscriber) { EventSubscriber.new }
+
           let(:client) do
-            subscribed_client
+            authorized_client.tap do |client|
+              client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+            end
           end
 
           let(:find_command) do
-            EventSubscriber.started_events[-1].command
+            subscriber.started_events[-1].command
           end
 
           before do
@@ -577,6 +581,7 @@ describe Mongo::Collection::View::MapReduce do
 
       context 'when the server is not valid for writing' do
         clean_slate
+        require_warning_clean
 
         before do
           stop_monitoring(authorized_client)
@@ -657,6 +662,7 @@ describe Mongo::Collection::View::MapReduce do
 
       context 'when the server is a valid for writing' do
         clean_slate
+        require_warning_clean
 
         before do
           stop_monitoring(authorized_client)

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

@@ -68,6 +68,20 @@ describe Mongo::Collection::View::Readable do
     end
   end
 
+  describe '#allow_disk_use' do
+    let(:new_view) do
+      view.allow_disk_use
+    end
+
+    it 'sets the flag' do
+      expect(new_view.options[:allow_disk_use]).to be true
+    end
+
+    it 'returns the new View' do
+      expect(new_view).not_to be(view)
+    end
+  end
+
   describe '#aggregate' do
 
      let(:documents) do
@@ -192,7 +206,7 @@ describe Mongo::Collection::View::Readable do
 
       let(:command) do
         operation
-        EventSubscriber.started_events.find { |cmd| cmd.command_name == 'mapReduce' }.command
+        subscriber.started_events.find { |cmd| cmd.command_name == 'mapReduce' }.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'

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

@@ -10,8 +10,12 @@ describe Mongo::Collection::View::Writable do
     {}
   end
 
+  let(:view_collection) do
+    authorized_collection
+  end
+
   let(:view) do
-    Mongo::Collection::View.new(authorized_collection, selector, options)
+    Mongo::Collection::View.new(view_collection, selector, options)
   end
 
   before do
@@ -24,6 +28,32 @@ describe Mongo::Collection::View::Writable do
       authorized_collection.insert_many([{ field: 'test1' }])
     end
 
+    context 'when hint option is provided' do
+      # Functionality on more recent servers is sufficiently covered by spec tests.
+      context 'on server versions < 4.2' do
+        max_server_fcv '4.0'
+
+        it 'raises a client-side exception' do
+          expect do
+            view.find_one_and_delete(hint: '_id_')
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+        end
+      end
+
+      context 'when the write concern is unacknowledged' do
+        let(:view_collection) do
+          client = authorized_client.with(write_concern: { w: 0 })
+          client[authorized_collection.name]
+        end
+
+        it 'raises a client-side error' do
+          expect do
+            view.find_one_and_delete(hint: '_id_')
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+        end
+      end
+    end
+
     context 'when a matching document is found' do
 
       let(:selector) do
@@ -218,6 +248,32 @@ describe Mongo::Collection::View::Writable do
       authorized_collection.insert_many([{ field: 'test1', other: 'sth' }])
     end
 
+    context 'when hint option is provided' do
+      # Functionality on more recent servers is sufficiently covered by spec tests.
+      context 'on server versions < 4.2' do
+        max_server_fcv '4.0'
+
+        it 'raises a client-side exception' do
+          expect do
+            view.find_one_and_replace({ field: 'testing' }, { hint: '_id_' })
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+        end
+      end
+
+      context 'when the write concern is unacknowledged' do
+        let(:view_collection) do
+          client = authorized_client.with(write_concern: { w: 0 })
+          client[authorized_collection.name]
+        end
+
+        it 'raises a client-side error' do
+          expect do
+            view.find_one_and_replace({ field: 'testing' }, { hint: '_id_' })
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+        end
+      end
+    end
+
     context 'when a matching document is found' do
 
       let(:selector) do
@@ -435,6 +491,32 @@ describe Mongo::Collection::View::Writable do
       authorized_collection.insert_many([{ field: 'test1' }])
     end
 
+    context 'when hint option is provided' do
+      # Functionality on more recent servers is sufficiently covered by spec tests.
+      context 'on server versions < 4.2' do
+        max_server_fcv '4.0'
+
+        it 'raises a client-side exception' do
+          expect do
+            view.find_one_and_update({ '$set' => { field: 'testing' } }, { hint: '_id_' })
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+        end
+      end
+
+      context 'when the write concern is unacknowledged' do
+        let(:view_collection) do
+          client = authorized_client.with(write_concern: { w: 0 })
+          client[authorized_collection.name]
+        end
+
+        it 'raises a client-side error' do
+          expect do
+            view.find_one_and_update({ '$set' => { field: 'testing' } }, { hint: '_id_' })
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+        end
+      end
+    end
+
     context 'when a matching document is found' do
 
       let(:selector) do
@@ -625,6 +707,31 @@ describe Mongo::Collection::View::Writable do
   end
 
   describe '#delete_many' do
+    context 'when a hint option is provided' do
+      # Functionality on more recent servers is sufficiently covered by spec tests.
+      context 'on server versions < 3.4' do
+        max_server_fcv '3.2'
+
+        it 'raises a client-side exception' do
+          expect do
+            view.delete_many(hint: '_id_')
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+        end
+      end
+
+      context 'when the write concern is unacknowledged' do
+        let(:view_collection) do
+          client = authorized_client.with(write_concern: { w: 0 })
+          client[authorized_collection.name]
+        end
+
+        it 'raises a client-side error' do
+          expect do
+            view.delete_many(hint: '_id_')
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+        end
+      end
+    end
 
     context 'when a selector was provided' do
 
@@ -787,6 +894,31 @@ describe Mongo::Collection::View::Writable do
   end
 
   describe '#delete_one' do
+    context 'when a hint option is provided' do
+      # Functionality on more recent servers is sufficiently covered by spec tests.
+      context 'on server versions < 3.4' do
+        max_server_fcv '3.2'
+
+        it 'raises a client-side exception' do
+          expect do
+            view.delete_one(hint: '_id_')
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+        end
+      end
+
+      context 'when the write concern is unacknowledged' do
+        let(:view_collection) do
+          client = authorized_client.with(write_concern: { w: 0 })
+          client[authorized_collection.name]
+        end
+
+        it 'raises a client-side error' do
+          expect do
+            view.delete_many(hint: '_id_')
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+        end
+      end
+    end
 
     context 'when a selector was provided' do
 
@@ -950,6 +1082,31 @@ describe Mongo::Collection::View::Writable do
   end
 
   describe '#replace_one' do
+    context 'when a hint option is provided' do
+      # Functionality on more recent servers is sufficiently covered by spec tests.
+      context 'on server versions < 3.4' do
+        max_server_fcv '3.2'
+
+        it 'raises a client-side exception' do
+          expect do
+            view.replace_one({ field: 'testing' }, { hint: '_id_' })
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+        end
+      end
+
+      context 'when the write concern is unacknowledged' do
+        let(:view_collection) do
+          client = authorized_client.with(write_concern: { w: 0 })
+          client[authorized_collection.name]
+        end
+
+        it 'raises a client-side error' do
+          expect do
+            view.delete_many(hint: '_id_')
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+        end
+      end
+    end
 
     context 'when a selector was provided' do
 
@@ -1182,6 +1339,31 @@ describe Mongo::Collection::View::Writable do
   end
 
   describe '#update_many' do
+    context 'when a hint option is provided' do
+      # Functionality on more recent servers is sufficiently covered by spec tests.
+      context 'on server versions < 3.4' do
+        max_server_fcv '3.2'
+
+        it 'raises a client-side exception' do
+          expect do
+            view.update_many({ '$set' => { field: 'testing' } }, { hint: '_id_' })
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+        end
+      end
+
+      context 'when the write concern is unacknowledged' do
+        let(:view_collection) do
+          client = authorized_client.with(write_concern: { w: 0 })
+          client[authorized_collection.name]
+        end
+
+        it 'raises a client-side error' do
+          expect do
+            view.delete_many(hint: '_id_')
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+        end
+      end
+    end
 
     context 'when a selector was provided' do
 
@@ -1420,6 +1602,31 @@ describe Mongo::Collection::View::Writable do
   end
 
   describe '#update_one' do
+    context 'when a hint option is provided' do
+      # Functionality on more recent servers is sufficiently covered by spec tests.
+      context 'on server versions < 3.4' do
+        max_server_fcv '3.2'
+
+        it 'raises a client-side exception' do
+          expect do
+            view.update_one({ '$set' => { field: 'testing' } }, { hint: '_id_' })
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The MongoDB server handling this request does not support the hint option on this command./)
+        end
+      end
+
+      context 'when the write concern is unacknowledged' do
+        let(:view_collection) do
+          client = authorized_client.with(write_concern: { w: 0 })
+          client[authorized_collection.name]
+        end
+
+        it 'raises a client-side error' do
+          expect do
+            view.update_one({ '$set' => { field: 'testing' } }, { hint: '_id_' })
+          end.to raise_error(Mongo::Error::UnsupportedOption, /The hint option cannot be specified on an unacknowledged write operation/)
+        end
+      end
+    end
 
     context 'when a selector was provided' do
 

data/spec/mongo/collection_spec.rb

@@ -2,8 +2,18 @@ require 'spec_helper'
 
 describe Mongo::Collection do
 
+  let(:subscriber) { EventSubscriber.new }
+
+  let(:client) do
+    authorized_client.tap do |client|
+      client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
+    end
+  end
+
+  let(:authorized_collection) { client['collection_spec'] }
+
   before do
-    authorized_collection.drop
+    authorized_client['collection_spec'].drop
   end
 
   let(:collection_invalid_write_concern) do
@@ -14,10 +24,6 @@ describe Mongo::Collection do
     authorized_client[:validating]
   end
 
-  let(:client) do
-    authorized_client
-  end
-
   describe '#==' do
 
     let(:database) do
@@ -246,6 +252,7 @@ describe Mongo::Collection do
           authorized_client.with(client_options).tap do |client|
             expect(client.options[:read]).to eq(Mongo::Options::Redacted.new(
               mode: :primary_preferred))
+            client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
           end
         end
 
@@ -278,12 +285,6 @@ describe Mongo::Collection do
             {read: { mode: :primary_preferred }}
           end
 
-          let(:subscriber) { EventSubscriber.new }
-
-          before do
-            client.subscribe(Mongo::Monitoring::COMMAND, subscriber)
-          end
-
           shared_examples_for "uses collection's read preference when reading" do
             it "uses collection's read preference when reading" do
               expect do
@@ -820,6 +821,38 @@ describe Mongo::Collection do
           end
         end
 
+        context 'when write concern passed in as an option' do
+          min_server_fcv '3.4'
+          require_topology :replica_set
+
+          before do
+            database['collection_spec'].drop
+          end
+
+          let(:events) do
+            subscriber.command_started_events('create')
+          end
+
+          let(:options) do
+            { write_concern: {w: 1} }
+          end
+
+          let!(:collection) do
+            authorized_collection.with(options)
+          end
+
+          let!(:command) do
+            Utils.get_command_event(authorized_client, 'create') do |client|
+              collection.create({ write_concern: {w: 2} })
+            end.command
+          end
+
+          it 'applies the write concern passed in as an option' do
+            expect(events.length).to eq(1)
+            expect(command[:writeConcern][:w]).to eq(2)
+          end
+        end
+
         context 'when the server does not support write concern on the create command' do
           max_server_version '3.2'
 
@@ -1058,6 +1091,34 @@ describe Mongo::Collection do
           end
         end
 
+        context 'when write concern passed in as an option' do
+          min_server_fcv '3.4'
+          require_set_write_concern
+
+          let(:events) do
+            subscriber.command_started_events('drop')
+          end
+
+          let(:options) do
+            { write_concern: {w: 1} }
+          end
+
+          let!(:collection) do
+            authorized_collection.with(options)
+          end
+
+          let!(:command) do
+            Utils.get_command_event(authorized_client, 'drop') do |client|
+              collection.drop({ write_concern: {w: 0} })
+            end.command
+          end
+
+          it 'applies the write concern passed in as an option' do
+            expect(events.length).to eq(1)
+            expect(command[:writeConcern][:w]).to eq(0)
+          end
+        end
+
         context 'when the server does not support write concern on the drop command' do
           max_server_version '3.2'
 
@@ -1230,10 +1291,6 @@ describe Mongo::Collection do
           { session: session }
         end
 
-        let(:client) do
-          subscribed_client
-        end
-
         let(:session) do
           client.start_session
         end
@@ -1244,7 +1301,7 @@ describe Mongo::Collection do
 
         let(:command) do
           client[TEST_COLL].find({}, session: session).explain
-          EventSubscriber.started_events.find { |c| c.command_name == 'explain' }.command
+          subscriber.started_events.find { |c| c.command_name == 'explain' }.command
         end
 
         it 'sends the session id' do
@@ -1261,7 +1318,7 @@ describe Mongo::Collection do
 
         let(:command) do
           operation
-          EventSubscriber.started_events.find { |cmd| cmd.command_name == 'find' }.command
+          subscriber.started_events.find { |cmd| cmd.command_name == 'find' }.command
         end
 
         it_behaves_like 'an operation supporting causally consistent reads'
@@ -1461,7 +1518,7 @@ describe Mongo::Collection do
     context 'when unacknowledged writes is used with an implicit session' do
 
       let(:collection_with_unacknowledged_write_concern) do
-        subscribed_client.with(write: { w: 0 })[TEST_COLL]
+        client.with(write: { w: 0 })[TEST_COLL]
       end
 
       let(:operation) do
@@ -1543,20 +1600,16 @@ describe Mongo::Collection do
     context 'when the documents are sent with OP_MSG' do
       min_server_fcv '3.6'
 
-      let(:client) do
-        subscribed_client
-      end
-
       let(:documents) do
         [{ '_id' => 1, 'name' => '1'*16777191 }, { '_id' => 'y' }]
       end
 
       before do
-        client[TEST_COLL].insert_many(documents)
+        authorized_collection.insert_many(documents)
       end
 
       let(:insert_events) do
-        EventSubscriber.started_events.select { |e| e.command_name == 'insert' }
+        subscriber.started_events.select { |e| e.command_name == 'insert' }
       end
 
       it 'sends the documents in one OP_MSG' do
@@ -1632,6 +1685,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
@@ -1704,7 +1791,7 @@ describe Mongo::Collection do
     context 'when unacknowledged writes is used with an implicit session' do
 
       let(:collection_with_unacknowledged_write_concern) do
-        subscribed_client.with(write: { w: 0 })[TEST_COLL]
+        client.with(write: { w: 0 })[TEST_COLL]
       end
 
       let(:operation) do
@@ -1714,6 +1801,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
@@ -1822,6 +1940,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
@@ -1914,7 +2078,7 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        EventSubscriber.started_events.find { |cmd| cmd.command_name == 'aggregate' }.command
+        subscriber.started_events.find { |cmd| cmd.command_name == 'aggregate' }.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'
@@ -2031,6 +2195,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
@@ -2119,7 +2316,7 @@ describe Mongo::Collection do
 
         let(:command) do
           operation
-          EventSubscriber.started_events.find { |cmd| cmd.command_name == 'count' }.command
+          subscriber.started_events.find { |cmd| cmd.command_name == 'count' }.command
         end
 
         it_behaves_like 'an operation supporting causally consistent reads'
@@ -2237,7 +2434,7 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        EventSubscriber.started_events.find { |cmd| cmd.command_name == 'distinct' }.command
+        subscriber.started_events.find { |cmd| cmd.command_name == 'distinct' }.command
       end
 
       it_behaves_like 'an operation supporting causally consistent reads'
@@ -2399,7 +2596,7 @@ describe Mongo::Collection do
     context 'when unacknowledged writes is used with an implicit session' do
 
       let(:collection_with_unacknowledged_write_concern) do
-        subscribed_client.with(write: { w: 0 })[TEST_COLL]
+        client.with(write: { w: 0 })[TEST_COLL]
       end
 
       let(:operation) do
@@ -2509,6 +2706,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
@@ -2571,7 +2810,7 @@ describe Mongo::Collection do
       it_behaves_like 'a failed operation using a session'
     end
 
-    context 'when unacknowledged writes is used with an explicit session' do
+    context 'when unacknowledged writes are used with an explicit session' do
 
       let(:collection_with_unacknowledged_write_concern) do
         authorized_collection.with(write: { w: 0 })
@@ -2584,10 +2823,10 @@ describe Mongo::Collection do
       it_behaves_like 'an explicit session with an unacknowledged write'
     end
 
-    context 'when unacknowledged writes is used with an implicit session' do
+    context 'when unacknowledged writes are used with an implicit session' do
 
       let(:collection_with_unacknowledged_write_concern) do
-        subscribed_client.with(write: { w: 0 })[TEST_COLL]
+        client.with(write: { w: 0 })[TEST_COLL]
       end
 
       let(:operation) do
@@ -2699,6 +2938,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
@@ -2755,7 +3036,6 @@ describe Mongo::Collection do
     end
 
     context 'when a session is not provided' do
-      let(:client) { subscribed_client }
       let(:collection) { client['test'] }
 
       let(:cursors) do
@@ -2772,7 +3052,7 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        event = EventSubscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }
+        event = subscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }
         expect(event).not_to be_nil
         event.command
       end
@@ -2794,7 +3074,7 @@ describe Mongo::Collection do
 
       let(:command) do
         operation
-        event = EventSubscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }
+        event = subscriber.started_events.find { |cmd| cmd.command_name == 'parallelCollectionScan' }
         expect(event).not_to be_nil
         event.command
       end
@@ -3197,7 +3477,7 @@ describe Mongo::Collection do
     context 'when unacknowledged writes is used with an implicit session' do
 
       let(:collection_with_unacknowledged_write_concern) do
-        subscribed_client.with(write: { w: 0 })[TEST_COLL]
+        client.with(write: { w: 0 })[TEST_COLL]
       end
 
       let(:operation) do
@@ -3206,6 +3486,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
@@ -3619,7 +3944,7 @@ describe Mongo::Collection do
     context 'when unacknowledged writes is used with an implicit session' do
 
       let(:collection_with_unacknowledged_write_concern) do
-        subscribed_client.with(write: { w: 0 })[TEST_COLL]
+        client.with(write: { w: 0 })[TEST_COLL]
       end
 
       let(:operation) do
@@ -3628,6 +3953,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
@@ -3977,10 +4341,6 @@ describe Mongo::Collection do
     context 'when the documents are sent with OP_MSG' do
       min_server_fcv '3.6'
 
-      let(:client) do
-        subscribed_client
-      end
-
       let(:documents) do
         [{ '_id' => 1, 'name' => '1'*16777191 }, { '_id' => 'y' }]
       end
@@ -3991,7 +4351,7 @@ describe Mongo::Collection do
       end
 
       let(:update_events) do
-        EventSubscriber.started_events.select { |e| e.command_name == 'update' }
+        subscriber.started_events.select { |e| e.command_name == 'update' }
       end
 
       it 'sends the documents in one OP_MSG' do
@@ -4041,7 +4401,7 @@ describe Mongo::Collection do
     context 'when unacknowledged writes is used with an implicit session' do
 
       let(:collection_with_unacknowledged_write_concern) do
-        subscribed_client.with(write: { w: 0 })[TEST_COLL]
+        client.with(write: { w: 0 })[TEST_COLL]
       end
 
       let(:operation) do
@@ -4050,6 +4410,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
@@ -4267,6 +4668,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
@@ -4688,6 +5129,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
@@ -5001,6 +5487,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