mongo 2.1.0.beta → 2.2.0

data/spec/mongo/bulk_write_spec.rb

@@ -8,253 +8,477 @@ describe Mongo::BulkWrite do
 
   after do
     authorized_collection.delete_many
+    collection_with_validator.drop()
   end
 
-  let(:bulk) do
-    described_class.get(authorized_collection, operations, options)
+  let(:collection_with_validator) do
+    authorized_client[:validating,
+                      :validator => { :a => { '$exists' => true } }].tap do |c|
+      c.create
+    end
   end
 
-  describe '#get' do
+  describe '#execute' do
 
-    let(:operations) do
-      [{ insert_one: { _id: 0 } }]
-    end
+    shared_examples_for 'an executable bulk write' do
 
-    context 'When an ordered bulk write object is created' do
+      context 'when providing a bad operation' do
 
-      let(:options) do
-        { ordered: true }
-      end
+        let(:requests) do
+          [{ not_an_operation: { _id: 0 }}]
+        end
 
-      it 'returns an OrderedBulkWrite object' do
-        expect(bulk).to be_a(Mongo::BulkWrite::OrderedBulkWrite)
+        it 'raises an exception' do
+          expect {
+            bulk_write.execute
+          }.to raise_error(Mongo::Error::InvalidBulkOperationType)
+        end
       end
-    end
 
-    context 'When an unordered bulk write object is created' do
+      context 'when the operations do not need to be split' do
 
-      let(:options) do
-        { ordered: false }
-      end
+        context 'when a write error occurs' do
 
-      it 'returns an UnorderedBulkWrite object' do
-        expect(bulk).to be_a(Mongo::BulkWrite::UnorderedBulkWrite)
-      end
-    end
+          let(:requests) do
+            [
+              { insert_one: { _id: 0 }},
+              { insert_one: { _id: 1 }},
+              { insert_one: { _id: 0 }},
+              { insert_one: { _id: 1 }}
+            ]
+          end
 
-    context 'When ordered is not specified in options' do
+          let(:error) do
+            begin
+              bulk_write.execute
+            rescue => e
+              e
+            end
+          end
 
-      let(:options) do
-        { }
-      end
+          it 'raises an exception' do
+            expect {
+              bulk_write.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
 
-      it 'returns an OrderedBulkWrite object' do
-        expect(bulk).to be_a(Mongo::BulkWrite::OrderedBulkWrite)
-      end
-    end
-  end
+          it 'sets the document index on the error' do
+            expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(2)
+          end
+        end
 
-  describe 'Ordered bulk write' do
+        context 'when provided a single insert one' do
 
-    let(:options) do
-       { ordered: true }
-    end
+          let(:requests) do
+            [{ insert_one: { _id: 0 }}]
+          end
 
-    it_behaves_like 'a bulk write object'
+          let(:result) do
+            bulk_write.execute
+          end
+
+          it 'inserts the document' do
+            expect(result.inserted_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).count).to eq(1)
+          end
+        end
 
-    context 'when the batch requires splitting' do
+        context 'when provided multiple insert ones' do
 
-      context 'when the operations are the same type' do
+          let(:requests) do
+            [
+              { insert_one: { _id: 0 }},
+              { insert_one: { _id: 1 }},
+              { insert_one: { _id: 2 }}
+            ]
+          end
 
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
+          let(:result) do
+            bulk_write.execute
+          end
+
+          it 'inserts the documents' do
+            expect(result.inserted_count).to eq(3)
+            expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(3)
           end
         end
 
-        let(:operations) do
-          [].tap do |ops|
-            3000.times do |i|
-              ops << { insert_one: { _id: i } }
-            end
-            ops << { insert_one: { _id: 0 } }
-            ops << { insert_one: { _id: 3001 } }
+        context 'when provided a single delete one' do
+
+          let(:requests) do
+            [{ delete_one: { filter: { _id: 0 }}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'deletes the document' do
+            expect(result.deleted_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).count).to eq(0)
           end
         end
 
-        it 'raises a BulkWriteError' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        context 'when provided multiple delete ones' do
+
+          let(:requests) do
+            [
+              { delete_one: { filter: { _id: 0 }}},
+              { delete_one: { filter: { _id: 1 }}},
+              { delete_one: { filter: { _id: 2 }}}
+            ]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_many([
+              { _id: 0 }, { _id: 1 }, { _id: 2 }
+            ])
+          end
+
+          it 'deletes the documents' do
+            expect(result.deleted_count).to eq(3)
+            expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(0)
+          end
         end
 
-        it 'halts execution after first error and reports correct index' do
-          expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(3000)
-          expect(authorized_collection.find.count).to eq(3000)
+        context 'when provided a single delete many' do
+
+          let(:requests) do
+            [{ delete_many: { filter: { _id: 0 }}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'deletes the documents' do
+            expect(result.deleted_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).count).to eq(0)
+          end
         end
-      end
 
-      context 'when operations are mixed types' do
+        context 'when provided multiple delete many ops' do
 
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
+          let(:requests) do
+            [
+              { delete_many: { filter: { _id: 0 }}},
+              { delete_many: { filter: { _id: 1 }}},
+              { delete_many: { filter: { _id: 2 }}}
+            ]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_many([
+              { _id: 0 }, { _id: 1 }, { _id: 2 }
+            ])
+          end
+
+          it 'deletes the documents' do
+            expect(result.deleted_count).to eq(3)
+            expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(0)
           end
         end
 
-        let(:operations) do
-          [].tap do |ops|
-            2000.times do |i|
-              ops << { insert_one: { _id: i } }
-            end
-            ops << { delete_one: { _id: 0 } }
-            ops << { insert_one: { _id: 1 } }
-            ops << { insert_one: { _id: 2000 } }
+        context 'when providing a single replace one' do
+
+          let(:requests) do
+            [{ replace_one: { filter: { _id: 0 }, replacement: { name: 'test' }}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'replaces the document' do
+            expect(result.modified_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
           end
         end
 
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        context 'when providing a single update one' do
+
+          let(:requests) do
+            [{ update_one: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'updates the document' do
+            expect(result.modified_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+          end
         end
 
-        it 'halts execution after first error and reports correct index' do
-          expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(2001)
-          expect(authorized_collection.find.count).to eq(1999)
+        context 'when providing a single update many' do
+
+          let(:requests) do
+            [{ update_many: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'updates the documents' do
+            expect(result.modified_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+          end
         end
       end
 
-      context 'when the operations exceed the max bson size' do
+      context 'when the operations need to be split' do
 
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
+        context 'when a write error occurs' do
+
+          let(:requests) do
+            1001.times.map do |i|
+              { insert_one: { _id: i }}
+            end
+          end
+
+          let(:error) do
+            begin
+              bulk_write.execute
+            rescue => e
+              e
+            end
+          end
+
+          it 'raises an exception' do
+            expect {
+              requests.push({ insert_one: { _id: 5 }})
+              bulk_write.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
+
+          it 'sets the document index on the error' do
+            requests.push({ insert_one: { _id: 5 }})
+            expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(1001)
           end
         end
 
-        let(:operations) do
-          [].tap do |ops|
-            6.times do |i|
-              ops << { insert_one: { _id: i, x: 'y'*4000000 } }
+        context 'when no write errors occur' do
+
+          let(:requests) do
+            1001.times.map do |i|
+              { insert_one: { _id: i }}
             end
-            ops << { insert_one: { _id: 0 } }
-            ops << { insert_one: { _id: 100 } }
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          it 'inserts the documents' do
+            expect(result.inserted_count).to eq(1001)
+          end
+        end
+      end
+
+      context 'when an operation exceeds the max bson size' do
+
+        let(:requests) do
+          5.times.map do |i|
+            { insert_one: { _id: i, x: 'y' * 4000000 }}
           end
         end
 
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        let(:result) do
+          bulk_write.execute
         end
 
-        it 'splits messages into multiple messages' do
-          error
-          expect(authorized_collection.find.count).to eq(6)
+        it 'inserts the documents' do
+          expect(result.inserted_count).to eq(5)
         end
       end
     end
+
+    context 'when the bulk write is unordered' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests, ordered: false)
+      end
+
+      it_behaves_like 'an executable bulk write'
+    end
+
+    context 'when the bulk write is ordered' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests, ordered: true)
+      end
+
+      it_behaves_like 'an executable bulk write'
+    end
   end
 
-  describe 'Unordered bulk write' do
+  describe '#initialize' do
 
-    let(:options) do
-       { ordered: false }
+    let(:requests) do
+      [{ insert_one: { _id: 0 }}]
     end
 
-    it_behaves_like 'a bulk write object'
+    shared_examples_for 'a bulk write initializer' do
 
-    context 'when the operations exceed the max batch size' do
+      it 'sets the collection' do
+        expect(bulk_write.collection).to eq(authorized_collection)
+      end
 
-      context 'when operations are all the same type' do
+      it 'sets the requests' do
+        expect(bulk_write.requests).to eq(requests)
+      end
+    end
 
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
-        end
+    context 'when no options are provided' do
 
-        let(:operations) do
-          [].tap do |ops|
-            3000.times do |i|
-              ops << { insert_one: { _id: i } }
-            end
-            ops << { insert_one: { _id: 0 } }
-            ops << { insert_one: { _id: 3001 } }
-          end
-        end
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests)
+      end
 
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
-        end
+      it 'sets empty options' do
+        expect(bulk_write.options).to be_empty
+      end
 
-        it 'does not halt execution after first error' do
-          expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(3000)
-          expect(authorized_collection.find.count).to eq(3001)
-        end
+      it_behaves_like 'a bulk write initializer'
+    end
+
+    context 'when options are provided' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests, ordered: true)
       end
 
-      context 'when operations are mixed types' do
+      it 'sets the options' do
+        expect(bulk_write.options).to eq(ordered: true)
+      end
+    end
 
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
+    context 'when nil options are provided' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests, nil)
+      end
+
+      it 'sets empty options' do
+        expect(bulk_write.options).to be_empty
+      end
+    end
+  end
+
+  describe '#ordered?' do
+
+    context 'when no option provided' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, [])
+      end
+
+      it 'returns true' do
+        expect(bulk_write).to be_ordered
+      end
+    end
+
+    context 'when the option is provided' do
+
+      context 'when the option is true' do
+
+        let(:bulk_write) do
+          described_class.new(authorized_collection, [], ordered: true)
         end
 
-        let(:operations) do
-          [].tap do |ops|
-            2000.times do |i|
-              ops << { insert_one: { _id: i } }
-            end
-            ops << { delete_one: { _id: 0 } }
-            ops << { insert_one: { _id: 1 } }
-            ops << { insert_one: { _id: 2000 } }
-          end
+        it 'returns true' do
+          expect(bulk_write).to be_ordered
         end
+      end
+
+      context 'when the option is false' do
 
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        let(:bulk_write) do
+          described_class.new(authorized_collection, [], ordered: false)
         end
 
-        it 'does not halt execution after first error' do
-          expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(2001)
-          expect(authorized_collection.find.count).to eq(2000)
+        it 'returns false' do
+          expect(bulk_write).to_not be_ordered
         end
       end
+    end
+  end
 
-      context 'when the operations exceed the max bson size' do
+  describe 'when the collection has a validator', if: find_command_enabled? do
 
-        let(:error) do
-          begin
-            bulk.execute
-          rescue => ex
-            ex
-          end
+    before do
+      collection_with_validator.insert_many([{ :a => 1 }, { :a => 2 }])
+    end
+
+    after do
+      collection_with_validator.delete_many
+    end
+
+    context 'when the documents are invalid' do
+
+      let(:ops) do
+        [
+            { insert_one: { :x => 1 } },
+            { update_one: { filter: { :a => 1 },
+                            update: { '$unset' => { :a => '' } } } },
+            { replace_one: { filter: { :a => 2 },
+                             replacement: { :x => 2 } } }
+        ]
+      end
+
+      context 'when bypass_document_validation is not set' do
+
+        let(:result) do
+          collection_with_validator.bulk_write(ops)
         end
 
-        let(:operations) do
-          [].tap do |ops|
-            15.times do |i|
-              ops << { insert_one: { _id: i, x: 'y'*4000000 } }
-            end
-            ops << { insert_one: { _id: 0 } }
-            ops << { insert_one: { _id: 100 } }
-          end
+        it 'raises BulkWriteError' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::BulkWriteError)
         end
+      end
+
+      context 'when bypass_document_validation is true' do
 
-        it 'raises a BulkWriteError error' do
-          expect(error).to be_a(Mongo::Error::BulkWriteError)
+        let(:result2) do
+          collection_with_validator.bulk_write(
+              ops, :bypass_document_validation => true)
         end
 
-        it 'splits messages into multiple messages' do
-          error
-          expect(authorized_collection.find.count).to eq(16)
+        it 'executes successfully' do
+          expect(result2.modified_count).to eq(2)
+          expect(result2.inserted_count).to eq(1)
         end
       end
     end