mongo 2.1.0.beta → 2.2.0

data/spec/mongo/collection_spec.rb

@@ -4,6 +4,17 @@ describe Mongo::Collection do
 
   after do
     authorized_collection.delete_many
+    collection_with_validator.drop()
+  end
+
+  let(:collection_invalid_write_concern) do
+    authorized_collection.client.with(write: { w: (WRITE_CONCERN[:w] + 1) })[authorized_collection.name]
+  end
+  let(:collection_with_validator) do
+    authorized_client[:validating,
+                      :validator => { :a => { '$exists' => true } }].tap do |c|
+      c.create
+    end
   end
 
   describe '#==' do
@@ -86,6 +97,172 @@ describe Mongo::Collection do
     end
   end
 
+  describe '#with' do
+
+    let(:client) do
+      Mongo::Client.new(ADDRESSES)
+    end
+
+    let(:database) do
+      Mongo::Database.new(client, :test)
+    end
+
+    let(:collection) do
+      database.collection(:users)
+    end
+
+    let(:new_collection) do
+      collection.with(new_options)
+    end
+
+    context 'when new read options are provided' do
+
+      let(:new_options) do
+        { read: { mode: :secondary } }
+      end
+
+      it 'returns a new collection' do
+        expect(new_collection).not_to be(collection)
+      end
+
+      it 'sets the new read options on the new collection' do
+        expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+      end
+
+      context 'when the client has a server selection timeout setting' do
+
+        let(:client) do
+          Mongo::Client.new(ADDRESSES, server_selection_timeout: 2)
+        end
+
+        let(:server_selection_timeout) do
+          new_collection.read_preference.server_selection_timeout
+        end
+
+        it 'keeps the server_selection_timeout setting from client' do
+          expect(server_selection_timeout).to eq(client.options[:server_selection_timeout])
+        end
+      end
+
+      context 'when the client has a read preference set' do
+
+        let(:client) do
+          Mongo::Client.new(ADDRESSES, read: { mode: :primary_preferred })
+        end
+
+        it 'sets the new read options on the new collection' do
+          expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+        end
+      end
+
+      context 'when the client has a read preference and server selection timeout set' do
+
+        let(:client) do
+          Mongo::Client.new(ADDRESSES, read: { mode: :primary_preferred }, server_selection_timeout: 2)
+        end
+
+        let(:server_selection_timeout) do
+          new_collection.read_preference.server_selection_timeout
+        end
+
+        it 'sets the new read options on the new collection' do
+          expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+        end
+
+        it 'keeps the server_selection_timeout setting from client' do
+          expect(server_selection_timeout).to eq(client.options[:server_selection_timeout])
+        end
+      end
+    end
+
+    context 'when new write options are provided' do
+
+      let(:new_options) do
+        { write: { w: 5 } }
+      end
+
+      it 'returns a new collection' do
+        expect(new_collection).not_to be(collection)
+      end
+
+      it 'sets the new write options on the new collection' do
+        expect(new_collection.write_concern.options).to eq(Mongo::WriteConcern.get(new_options[:write]).options)
+      end
+
+      context 'when the client has a write concern set' do
+
+        let(:client) do
+          Mongo::Client.new(ADDRESSES, write: { w: 10 })
+        end
+
+        it 'sets the new write options on the new collection' do
+          expect(new_collection.write_concern.options).to eq(Mongo::WriteConcern.get(new_options[:write]).options)
+        end
+      end
+    end
+
+    context 'when new read and write options are provided' do
+
+      let(:new_options) do
+        {
+          read: { mode: :secondary },
+          write: { w: 4}
+        }
+      end
+
+      it 'returns a new collection' do
+        expect(new_collection).not_to be(collection)
+      end
+
+      it 'sets the new read options on the new collection' do
+        expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+      end
+
+      it 'sets the new write options on the new collection' do
+        expect(new_collection.write_concern.options).to eq(Mongo::WriteConcern.get(new_options[:write]).options)
+      end
+
+      context 'when the client has a server selection timeout setting' do
+
+        let(:client) do
+          Mongo::Client.new(ADDRESSES, server_selection_timeout: 2)
+        end
+
+        let(:server_selection_timeout) do
+          new_collection.read_preference.server_selection_timeout
+        end
+
+        it 'keeps the server_selection_timeout setting from client' do
+          expect(server_selection_timeout).to eq(client.options[:server_selection_timeout])
+        end
+      end
+
+      context 'when the client has a read preference set' do
+
+        let(:client) do
+          Mongo::Client.new(ADDRESSES, read: { mode: :primary_preferred })
+        end
+
+        it 'sets the new read options on the new collection' do
+          expect(new_collection.read_preference).to eq(Mongo::ServerSelector.get(new_options[:read]))
+        end
+      end
+    end
+
+    context 'when neither read nor write options are provided' do
+
+      let(:new_options) do
+        { some_option: 'invalid' }
+      end
+
+      it 'raises an error' do
+        expect {
+          new_collection
+        }.to raise_exception(Mongo::Error::UnchangeableCollectionOption)
+      end
+    end
+  end
+
   describe '#capped?' do
 
     let(:database) do
@@ -170,6 +347,10 @@ describe Mongo::Collection do
             collection.create
           end
 
+          let(:options) do
+            { :capped => true, :size => 1024 }
+          end
+
           after do
             collection.drop
           end
@@ -187,22 +368,62 @@ describe Mongo::Collection do
           end
         end
 
+        shared_examples 'a validated collection command' do
+
+          let!(:response) do
+            collection.create
+          end
+
+          let(:options) do
+            { :validator => { fieldName: { '$gte' =>  1024 } },
+              :validationLevel => 'strict' }
+          end
+
+          let(:collection_info) do
+            database.list_collections.find { |i| i['name'] == 'specs' }
+          end
+
+          after do
+            collection.drop
+          end
+
+          it 'executes the command' do
+            expect(response).to be_successful
+          end
+
+          it 'sets the collection with validators' do
+            expect(collection_info['options']['validator']).to eq({ 'fieldName' => { '$gte' => 1024 } })
+          end
+
+          it 'creates the collection in the database' do
+            expect(database.collection_names).to include('specs')
+          end
+        end
+
         context 'when instantiating a collection directly' do
 
           let(:collection) do
-            described_class.new(database, :specs, :capped => true, :size => 1024)
+            described_class.new(database, :specs, options)
           end
 
           it_behaves_like 'a capped collection command'
+
+          context 'when validators can be set', if: find_command_enabled? do
+            it_behaves_like 'a validated collection command'
+          end
         end
 
         context 'when instantiating a collection through the database' do
 
           let(:collection) do
-            authorized_client[:specs, :capped => true, :size => 1024]
+            authorized_client[:specs, options]
           end
 
           it_behaves_like 'a capped collection command'
+
+          context 'when validators can be set', if: find_command_enabled? do
+            it_behaves_like 'a validated collection command'
+          end
         end
       end
     end
@@ -244,29 +465,29 @@ describe Mongo::Collection do
 
   describe '#find' do
 
-    context 'when provided a selector' do
+    context 'when provided a filter' do
 
       let(:view) do
         authorized_collection.find(name: 1)
       end
 
-      it 'returns a authorized_collection view for the selector' do
-        expect(view.selector).to eq(name: 1)
+      it 'returns a authorized_collection view for the filter' do
+        expect(view.filter).to eq('name' => 1)
       end
     end
 
-    context 'when provided no selector' do
+    context 'when provided no filter' do
 
       let(:view) do
         authorized_collection.find
       end
 
-      it 'returns a authorized_collection view with an empty selector' do
-        expect(view.selector).to be_empty
+      it 'returns a authorized_collection view with an empty filter' do
+        expect(view.filter).to be_empty
       end
     end
 
-    context 'when providing a bad selector' do
+    context 'when providing a bad filter' do
 
       let(:view) do
         authorized_collection.find('$or' => [])
@@ -300,6 +521,50 @@ describe Mongo::Collection do
       end
     end
 
+    context 'when the user is not authorized', if: auth_enabled? do
+
+      let(:view) do
+        unauthorized_collection.find
+      end
+
+      it 'iterates over the documents' do
+        expect {
+          view.each{ |document| document }
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when documents contain potential error message fields' do
+
+      [ Mongo::Error::ERRMSG, Mongo::Error::ERROR, Mongo::Operation::Result::OK ].each do |field|
+
+        context "when the document contains a '#{field}' field" do
+
+          let(:value) do
+            'testing'
+          end
+
+          let(:view) do
+            authorized_collection.find
+          end
+
+          before do
+            authorized_collection.insert_one({ field => value })
+          end
+
+          after do
+            authorized_collection.delete_many
+          end
+
+          it 'iterates over the documents' do
+            view.each do |document|
+              expect(document[field]).to eq(value)
+            end
+          end
+        end
+      end
+    end
+
     context 'when provided options' do
 
       let(:view) do
@@ -324,7 +589,7 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :batch_size set' do
-          expect(view.options[:batch_size]).to be(options[:batch_size])
+          expect(view.options[:batch_size]).to eq(options[:batch_size])
         end
       end
 
@@ -335,7 +600,7 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :comment set' do
-          expect(view.options[:comment]).to be(options[:comment])
+          expect(view.modifiers[:$comment]).to eq(options[:comment])
         end
       end
 
@@ -346,10 +611,12 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :cursor_type set' do
-          expect(view.options[:cursor_type]).to be(options[:cursor_type])
+          expect(view.options[:cursor_type]).to eq(options[:cursor_type])
         end
       end
 
+      #limit
+
       context 'when provided :max_time_ms' do
 
         let(:options) do
@@ -357,18 +624,22 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :max_time_ms set' do
-          expect(view.options[:max_time_ms]).to be(options[:max_time_ms])
+          expect(view.modifiers[:$maxTimeMS]).to eq(options[:max_time_ms])
         end
       end
 
       context 'when provided :modifiers' do
 
         let(:options) do
-          { modifiers: { :$orderby => Mongo::Index::ASCENDING } }
+          { modifiers: { '$orderby' => Mongo::Index::ASCENDING } }
         end
 
         it 'returns a view with modifiers set' do
-          expect(view.options[:modifiers]).to be(options[:modifiers])
+          expect(view.modifiers).to eq(options[:modifiers])
+        end
+
+        it 'dups the modifiers hash' do
+          expect(view.modifiers).not_to be(options[:modifiers])
         end
       end
 
@@ -379,7 +650,7 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :no_cursor_timeout set' do
-          expect(view.options[:no_cursor_timeout]).to be(options[:no_cursor_timeout])
+          expect(view.options[:no_cursor_timeout]).to eq(options[:no_cursor_timeout])
         end
       end
 
@@ -390,7 +661,7 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :oplog_replay set' do
-          expect(view.options[:oplog_replay]).to be(options[:oplog_replay])
+          expect(view.options[:oplog_replay]).to eq(options[:oplog_replay])
         end
       end
 
@@ -401,7 +672,7 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :projection set' do
-          expect(view.options[:projection]).to be(options[:projection])
+          expect(view.options[:projection]).to eq(options[:projection])
         end
       end
 
@@ -412,7 +683,7 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :skip set' do
-          expect(view.options[:skip]).to be(options[:skip])
+          expect(view.options[:skip]).to eq(options[:skip])
         end
       end
 
@@ -423,7 +694,7 @@ describe Mongo::Collection do
         end
 
         it 'returns a view with :sort set' do
-          expect(view.options[:sort]).to be(options[:sort])
+          expect(view.modifiers[:$orderby]).to eq(options[:sort])
         end
       end
     end
@@ -433,6 +704,7 @@ describe Mongo::Collection do
 
     after do
       authorized_collection.delete_many
+      collection_with_validator.delete_many
     end
 
     let(:result) do
@@ -446,12 +718,112 @@ describe Mongo::Collection do
     it 'contains the ids in the result' do
       expect(result.inserted_ids.size).to eq(2)
     end
+
+    context 'when the client has a custom id generator' do
+
+      let(:generator) do
+        Class.new do
+          def generate
+            1
+          end
+        end.new
+      end
+
+      let(:custom_client) do
+        authorized_client.with(id_generator: generator)
+      end
+
+      let(:custom_collection) do
+        custom_client[TEST_COLL]
+      end
+
+      before do
+        custom_collection.insert_many([{ name: 'testing' }])
+      end
+
+      after do
+        custom_client.close
+      end
+
+      it 'inserts with the custom id' do
+        expect(custom_collection.find.first[:_id]).to eq(1)
+      end
+    end
+
+    context 'when the inserts fail' do
+
+      let(:result) do
+        authorized_collection.insert_many([{ _id: 1 }, { _id: 1 }])
+      end
+
+      it 'raises an BulkWriteError' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::BulkWriteError)
+      end
+    end
+
+    context "when the documents exceed the max bson size" do
+
+      let(:documents) do
+        [{ '_id' => 1, 'name' => '1'*17000000 }]
+      end
+
+      it 'raises a MaxBSONSize error' do
+        expect {
+          authorized_collection.insert_many(documents)
+        }.to raise_error(Mongo::Error::MaxBSONSize)
+      end
+    end
+
+    context 'when collection has a validator', if: find_command_enabled? do
+
+      context 'when the document is valid' do
+
+        let(:result) do
+          collection_with_validator.insert_many([{ a: 1 }, { a: 2 }])
+        end
+
+        it 'inserts successfully' do
+          expect(result.inserted_count).to eq(2)
+        end
+      end
+
+      context 'when the document is invalid' do
+
+        context 'when bypass_document_validation is not set' do
+
+          let(:result2) do
+            collection_with_validator.insert_many([{ x: 1 }, { x: 2 }])
+          end
+
+          it 'raises a BulkWriteError' do
+            expect {
+              result2
+            }.to raise_exception(Mongo::Error::BulkWriteError)
+          end
+        end
+
+        context 'when bypass_document_validation is true' do
+
+          let(:result3) do
+            collection_with_validator.insert_many(
+                [{ x: 1 }, { x: 2 }], :bypass_document_validation => true)
+          end
+
+          it 'inserts successfully' do
+            expect(result3.inserted_count).to eq(2)
+          end
+        end
+      end
+    end
   end
 
   describe '#insert_one' do
 
     after do
       authorized_collection.delete_many
+      collection_with_validator.delete_many
     end
 
     let(:result) do
@@ -469,6 +841,93 @@ describe Mongo::Collection do
     it 'contains the id in the result' do
       expect(result.inserted_id).to_not be_nil
     end
+
+    context 'when the insert fails' do
+
+      let(:result) do
+        authorized_collection.insert_one(_id: 1)
+        authorized_collection.insert_one(_id: 1)
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when the client has a custom id generator' do
+
+      let(:generator) do
+        Class.new do
+          def generate
+            1
+          end
+        end.new
+      end
+
+      let(:custom_client) do
+        authorized_client.with(id_generator: generator)
+      end
+
+      let(:custom_collection) do
+        custom_client[TEST_COLL]
+      end
+
+      before do
+        custom_collection.insert_one({ name: 'testing' })
+      end
+
+      after do
+        custom_client.close
+      end
+
+      it 'inserts with the custom id' do
+        expect(custom_collection.find.first[:_id]).to eq(1)
+      end
+    end
+
+    context 'when collection has a validator', if: find_command_enabled? do
+
+      context 'when the document is valid' do
+
+        let(:result) do
+          collection_with_validator.insert_one({ a: 1 })
+        end
+
+        it 'inserts successfully' do
+          expect(result.written_count).to eq(1)
+        end
+      end
+
+      context 'when the document is invalid' do
+
+        context 'when bypass_document_validation is not set' do
+
+          let(:result2) do
+            collection_with_validator.insert_one({ x: 1 })
+          end
+
+          it 'raises a OperationFailure' do
+            expect {
+              result2
+            }.to raise_exception(Mongo::Error::OperationFailure)
+          end
+        end
+
+        context 'when bypass_document_validation is true' do
+
+          let(:result3) do
+            collection_with_validator.insert_one(
+                { x: 1 }, :bypass_document_validation => true)
+          end
+
+          it 'inserts successfully' do
+            expect(result3.written_count).to eq(1)
+          end
+        end
+      end
+    end
   end
 
   describe '#inspect' do
@@ -525,7 +984,7 @@ describe Mongo::Collection do
     context 'when options are provided' do
 
       let(:options) do
-        { :allow_disk_use => true }
+        { :allow_disk_use => true, :bypass_document_validation => true }
       end
 
       it 'sets the options on the Aggregation object' do
@@ -575,7 +1034,7 @@ describe Mongo::Collection do
     end
 
     it 'returns the distinct values' do
-      expect(authorized_collection.distinct(:field)).to eq([ 'test1', 'test2', 'test3' ])
+      expect(authorized_collection.distinct(:field).sort).to eq([ 'test1', 'test2', 'test3' ])
     end
 
     context 'when a selector is provided' do
@@ -588,7 +1047,7 @@ describe Mongo::Collection do
     context 'when options are provided' do
 
       it 'passes the options to the distinct command' do
-        expect(authorized_collection.distinct(:field, {}, max_time_ms: 100)).to eq([ 'test1', 'test2', 'test3' ])
+        expect(authorized_collection.distinct(:field, {}, max_time_ms: 100).sort).to eq([ 'test1', 'test2', 'test3' ])
       end
     end
   end
@@ -636,6 +1095,19 @@ describe Mongo::Collection do
         expect(response.deleted_count).to eq(1)
       end
     end
+
+    context 'when the delete fails', if: standalone? do
+
+      let(:result) do
+        collection_invalid_write_concern.delete_one
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
   end
 
   describe '#delete_many' do
@@ -661,8 +1133,87 @@ describe Mongo::Collection do
 
     context 'when no selector was provided' do
 
-      it 'deletes all the documents in the collection' do
-        expect(authorized_collection.delete_many.deleted_count).to eq(2)
+      it 'deletes all the documents in the collection' do
+        expect(authorized_collection.delete_many.deleted_count).to eq(2)
+      end
+    end
+
+    context 'when the deletes fail', if: standalone?  do
+
+      let(:result) do
+        collection_invalid_write_concern.delete_many
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+
+  describe '#parallel_scan', unless: sharded? do
+
+    let(:documents) do
+      (1..200).map do |i|
+        { name: "testing-scan-#{i}" }
+      end
+    end
+
+    before do
+      authorized_collection.insert_many(documents)
+    end
+
+    let(:cursors) do
+      authorized_collection.parallel_scan(2)
+    end
+
+    it 'returns an array of cursors', if: write_command_enabled? do
+      cursors.each do |cursor|
+        expect(cursor.class).to be(Mongo::Cursor)
+      end
+    end
+
+    it 'returns the correct number of documents', if: write_command_enabled? do
+      expect(
+        cursors.reduce(0) { |total, cursor| total + cursor.to_a.size }
+      ).to eq(200)
+    end
+
+    it 'raises an error', unless: write_command_enabled? do
+      expect {
+        cursors
+      }.to raise_error(Mongo::Error::OperationFailure)
+    end
+
+    context 'when a read concern is provided', if: find_command_enabled? do
+
+      let(:result) do
+        authorized_collection.with(options).parallel_scan(2)
+      end
+
+      context 'when the read concern is valid' do
+
+        let(:options) do
+          { read_concern: { level: 'local' }}
+        end
+
+        it 'sends the read concern' do
+          expect { result }.to_not raise_error
+        end
+      end
+
+      context 'when the read concern is not valid' do
+
+        let(:options) do
+          { read_concern: { level: 'idontknow' }}
+        end
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
       end
     end
   end
@@ -760,6 +1311,69 @@ describe Mongo::Collection do
         expect(updated).to be_empty
       end
     end
+
+    context 'when the replace fails' do
+
+      let(:result) do
+        authorized_collection.replace_one(selector, { '$s' => 'test1' })
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when collection has a validator', if: find_command_enabled? do
+
+      before do
+        collection_with_validator.insert_one({ a: 1 })
+      end
+
+      after do
+        collection_with_validator.delete_many
+      end
+
+      context 'when the document is valid' do
+
+        let(:result) do
+          collection_with_validator.replace_one({ a: 1 }, { a: 5 })
+        end
+
+        it 'replaces successfully' do
+          expect(result.modified_count).to eq(1)
+        end
+      end
+
+      context 'when the document is invalid' do
+
+        context 'when bypass_document_validation is not set' do
+
+          let(:result2) do
+            collection_with_validator.replace_one({ a: 1 }, { x: 5 })
+          end
+
+          it 'raises OperationFailure' do
+            expect {
+              result2
+            }.to raise_exception(Mongo::Error::OperationFailure)
+          end
+        end
+
+        context 'when bypass_document_validation is true' do
+
+          let(:result3) do
+            collection_with_validator.replace_one(
+                { a: 1 }, { x: 1 }, :bypass_document_validation => true)
+          end
+
+          it 'replaces successfully' do
+            expect(result3.written_count).to eq(1)
+          end
+        end
+      end
+    end
   end
 
   describe '#update_many' do
@@ -853,6 +1467,72 @@ describe Mongo::Collection do
         expect(updated).to be_empty
       end
     end
+
+    context 'when the updates fail' do
+
+      let(:result) do
+        authorized_collection.update_many(selector, { '$s'=> { field: 'testing' } })
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when collection has a validator', if: find_command_enabled? do
+
+      before do
+        collection_with_validator.insert_many([{ a: 1 }, { a: 2 }])
+      end
+
+      after do
+        collection_with_validator.delete_many
+      end
+
+      context 'when the document is valid' do
+
+        let(:result) do
+          collection_with_validator.update_many(
+              { :a => { '$gt' => 0 } }, '$inc' => { :a => 1 } )
+        end
+
+        it 'updates successfully' do
+          expect(result.modified_count).to eq(2)
+        end
+      end
+
+      context 'when the document is invalid' do
+
+        context 'when bypass_document_validation is not set' do
+
+          let(:result2) do
+            collection_with_validator.update_many(
+                { :a => { '$gt' => 0 } }, '$unset' => { :a => '' })
+          end
+
+          it 'raises OperationFailure' do
+            expect {
+              result2
+            }.to raise_exception(Mongo::Error::OperationFailure)
+          end
+        end
+
+        context 'when bypass_document_validation is true' do
+
+          let(:result3) do
+            collection_with_validator.update_many(
+                { :a => { '$gt' => 0 } }, { '$unset' => { :a => '' } },
+                :bypass_document_validation => true)
+          end
+
+          it 'updates successfully' do
+            expect(result3.written_count).to eq(2)
+          end
+        end
+      end
+    end
   end
 
   describe '#update_one' do
@@ -942,6 +1622,72 @@ describe Mongo::Collection do
         expect(updated).to be_empty
       end
     end
+
+    context 'when the update fails' do
+
+      let(:result) do
+        authorized_collection.update_one(selector, { '$s'=> { field: 'testing' } })
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when collection has a validator', if: find_command_enabled? do
+
+      before do
+        collection_with_validator.insert_one({ a: 1 })
+      end
+
+      after do
+        collection_with_validator.delete_many
+      end
+
+      context 'when the document is valid' do
+
+        let(:result) do
+          collection_with_validator.update_one(
+              { :a => { '$gt' => 0 } }, '$inc' => { :a => 1 } )
+        end
+
+        it 'updates successfully' do
+          expect(result.modified_count).to eq(1)
+        end
+      end
+
+      context 'when the document is invalid' do
+
+        context 'when bypass_document_validation is not set' do
+
+          let(:result2) do
+            collection_with_validator.update_one(
+                { :a => { '$gt' => 0 } }, '$unset' => { :a => '' })
+          end
+
+          it 'raises OperationFailure' do
+            expect {
+              result2
+            }.to raise_exception(Mongo::Error::OperationFailure)
+          end
+        end
+
+        context 'when bypass_document_validation is true' do
+
+          let(:result3) do
+            collection_with_validator.update_one(
+                { :a => { '$gt' => 0 } }, { '$unset' => { :a => '' } },
+                :bypass_document_validation => true)
+          end
+
+          it 'updates successfully' do
+            expect(result3.written_count).to eq(1)
+          end
+        end
+      end
+    end
   end
 
   describe '#find_one_and_delete' do
@@ -950,11 +1696,11 @@ describe Mongo::Collection do
       authorized_collection.insert_many([{ field: 'test1' }])
     end
 
-    context 'when a matching document is found' do
+    let(:selector) do
+      { field: 'test1' }
+    end
 
-      let(:selector) do
-        { field: 'test1' }
-      end
+    context 'when a matching document is found' do
 
       context 'when no options are provided' do
 
@@ -1026,18 +1772,55 @@ describe Mongo::Collection do
         expect(document).to be_nil
       end
     end
-  end
 
-  describe '#find_one_and_update' do
+    context 'when the operation fails', if: write_command_enabled? do
 
-    before do
-      authorized_collection.insert_many([{ field: 'test1' }])
+      let(:result) do
+        authorized_collection.find_one_and_delete(selector, max_time_ms: 0.1)
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when write_concern is provided', if: find_command_enabled? && standalone? do
+
+      it 'uses the write concern' do
+        expect {
+          authorized_collection.find_one_and_delete(selector,
+                                                    write_concern: { w: 2 })
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when the collection has a write concern', if: find_command_enabled? && standalone? do
+
+      let(:collection) do
+        authorized_collection.with(write: { w: 2 })
+      end
+
+      it 'uses the write concern' do
+        expect {
+          collection.find_one_and_delete(selector,
+                                         write_concern: { w: 2 })
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
     end
+  end
+
+  describe '#find_one_and_update' do
 
     let(:selector) do
       { field: 'test1' }
     end
 
+    before do
+      authorized_collection.insert_many([{ field: 'test1' }])
+    end
+
     context 'when a matching document is found' do
 
       context 'when no options are provided' do
@@ -1167,6 +1950,99 @@ describe Mongo::Collection do
         end
       end
     end
+
+    context 'when the operation fails', if: write_command_enabled? do
+
+      let(:result) do
+        authorized_collection.find_one_and_update(selector, { '$set' => { field: 'testing' }}, max_time_ms: 0.1)
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when collection has a validator', if: find_command_enabled? do
+
+      before do
+        collection_with_validator.insert_one({ a: 1 })
+      end
+
+      after do
+        collection_with_validator.delete_many
+      end
+
+      context 'when the document is valid' do
+
+        let(:result) do
+          collection_with_validator.find_one_and_update(
+              { a: 1 }, { '$inc' => { :a => 1 } }, :return_document => :after)
+        end
+
+        it 'updates successfully' do
+          expect(result['a']).to eq(2)
+        end
+      end
+
+      context 'when the document is invalid' do
+
+        context 'when bypass_document_validation is not set' do
+
+          let(:result2) do
+            collection_with_validator.find_one_and_update(
+                { a: 1 }, { '$unset' => { :a => '' } }, :return_document => :after)
+          end
+
+          it 'raises OperationFailure' do
+            expect {
+              result2
+            }.to raise_exception(Mongo::Error::OperationFailure)
+          end
+        end
+
+        context 'when bypass_document_validation is true' do
+
+          let(:result3) do
+            collection_with_validator.find_one_and_update(
+                { a: 1 }, { '$unset' => { :a => '' } },
+                :bypass_document_validation => true,
+                :return_document => :after)
+          end
+
+          it 'updates successfully' do
+            expect(result3['a']).to be_nil
+          end
+        end
+      end
+    end
+
+    context 'when write_concern is provided', if: find_command_enabled? && standalone? do
+
+      it 'uses the write concern' do
+        expect {
+          authorized_collection.find_one_and_update(selector,
+                                         { '$set' => { field: 'testing' }},
+                                         write_concern: { w: 2 })
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when the collection has a write concern', if: find_command_enabled? && standalone? do
+
+      let(:collection) do
+        authorized_collection.with(write: { w: 2 })
+      end
+
+      it 'uses the write concern' do
+        expect {
+          collection.find_one_and_update(selector,
+                                         { '$set' => { field: 'testing' }},
+                                         write_concern: { w: 2 })
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
   end
 
   describe '#find_one_and_replace' do
@@ -1282,5 +2158,98 @@ describe Mongo::Collection do
         }.to raise_error(Mongo::Error::OperationFailure)
       end
     end
+
+    context 'when the operation fails', if: write_command_enabled? do
+
+      let(:result) do
+        authorized_collection.find_one_and_replace(selector, { field: 'testing' }, max_time_ms: 0.1)
+      end
+
+      it 'raises an OperationFailure' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when collection has a validator', if: find_command_enabled? do
+
+      before do
+        collection_with_validator.insert_one({ a: 1 })
+      end
+
+      after do
+        collection_with_validator.delete_many
+      end
+
+      context 'when the document is valid' do
+
+        let(:result) do
+          collection_with_validator.find_one_and_replace(
+              { a: 1 }, { a: 5 }, :return_document => :after)
+        end
+
+        it 'replaces successfully when document is valid' do
+          expect(result[:a]).to eq(5)
+        end
+      end
+
+      context 'when the document is invalid' do
+
+        context 'when bypass_document_validation is not set' do
+
+          let(:result2) do
+            collection_with_validator.find_one_and_replace(
+                { a: 1 }, { x: 5 }, :return_document => :after)
+          end
+
+          it 'raises OperationFailure' do
+            expect {
+              result2
+            }.to raise_exception(Mongo::Error::OperationFailure)
+          end
+        end
+
+        context 'when bypass_document_validation is true' do
+
+          let(:result3) do
+            collection_with_validator.find_one_and_replace(
+                { a: 1 }, { x: 1 }, :bypass_document_validation => true,
+                :return_document => :after)
+          end
+
+          it 'replaces successfully' do
+            expect(result3[:x]).to eq(1)
+            expect(result3[:a]).to be_nil
+          end
+        end
+      end
+    end
+
+    context 'when write_concern is provided', if: find_command_enabled? && standalone? do
+
+      it 'uses the write concern' do
+        expect {
+          authorized_collection.find_one_and_replace(selector,
+                                                     { field: 'testing' },
+                                                     write_concern: { w: 2 })
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+
+    context 'when the collection has a write concern', if: find_command_enabled? && standalone? do
+
+      let(:collection) do
+        authorized_collection.with(write: { w: 2 })
+      end
+
+      it 'uses the write concern' do
+        expect {
+          collection.find_one_and_replace(selector,
+                                          { field: 'testing' },
+                                          write_concern: { w: 2 })
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
   end
 end