mongo 2.2.2 → 2.2.3

data/lib/mongo/version.rb

@@ -17,5 +17,5 @@ module Mongo
   # The current version of the driver.
   #
   # @since 2.0.0
-  VERSION = '2.2.2'.freeze
+  VERSION = '2.2.3'.freeze
 end

data/spec/mongo/bulk_write_spec.rb

@@ -8,7 +8,7 @@ describe Mongo::BulkWrite do
 
   after do
     authorized_collection.delete_many
-    collection_with_validator.drop()
+    collection_with_validator.drop
   end
 
   let(:collection_with_validator) do
@@ -18,6 +18,10 @@ describe Mongo::BulkWrite do
     end
   end
 
+  let(:collection_invalid_write_concern) do
+    authorized_collection.client.with(write: { w: (WRITE_CONCERN[:w] + 1) })[authorized_collection.name]
+  end
+
   describe '#execute' do
 
     shared_examples_for 'an executable bulk write' do
@@ -81,6 +85,32 @@ describe Mongo::BulkWrite do
             expect(result.inserted_count).to eq(1)
             expect(authorized_collection.find(_id: 0).count).to eq(1)
           end
+
+          it 'only inserts that document' do
+            result
+            expect(authorized_collection.find.first['_id']).to eq(0)
+          end
+
+          context 'when there is a write concern error' do
+
+            context 'when the server version is < 2.6' do
+
+              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::BulkWriteError)
+              end
+            end
+
+            context 'when the server version has write commands enabled' do
+
+              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
+              end
+            end
+          end
         end
 
         context 'when provided multiple insert ones' do
@@ -101,6 +131,40 @@ describe Mongo::BulkWrite do
             expect(result.inserted_count).to eq(3)
             expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(3)
           end
+
+          context 'when there is a write failure' do
+
+            let(:requests) do
+              [{ insert_one: { _id: 1 }}, { insert_one: { _id: 1 }}]
+            end
+
+            it 'raises a BulkWriteError' do
+              expect {
+                bulk_write.execute
+              }.to raise_error(Mongo::Error::BulkWriteError)
+            end
+          end
+
+          context 'when there is a write concern error' do
+
+            context 'when the server version is < 2.6' do
+
+              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::BulkWriteError)
+              end
+            end
+
+            context 'when the server version has write commands enabled' do
+
+              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
+              end
+            end
+          end
         end
 
         context 'when provided a single delete one' do
@@ -121,6 +185,47 @@ describe Mongo::BulkWrite do
             expect(result.deleted_count).to eq(1)
             expect(authorized_collection.find(_id: 0).count).to eq(0)
           end
+
+          context 'when there is a write concern error' do
+
+            context 'when the server version is < 2.6' do
+
+              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::BulkWriteError)
+              end
+            end
+
+            context 'when the server version has write commands enabled' do
+
+              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
+              end
+            end
+          end
+
+          context 'when multiple documents match delete selector' do
+
+            before do
+              authorized_collection.insert_many([{ a: 1 }, { a: 1 }])
+            end
+
+            let(:requests) do
+              [{ delete_one: { filter: { a: 1 }}}]
+            end
+
+            it 'reports n_removed correctly' do
+              expect(bulk_write.execute.deleted_count).to eq(1)
+            end
+
+            it 'deletes only matching documents' do
+              bulk_write.execute
+              expect(authorized_collection.find(a: 1).count).to eq(1)
+            end
+          end
         end
 
         context 'when provided multiple delete ones' do
@@ -147,6 +252,27 @@ describe Mongo::BulkWrite do
             expect(result.deleted_count).to eq(3)
             expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(0)
           end
+
+          context 'when there is a write concern error' do
+
+            context 'when the server version is < 2.6' do
+
+              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::BulkWriteError)
+              end
+            end
+
+            context 'when the server version has write commands enabled' do
+
+              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
+              end
+            end
+          end
         end
 
         context 'when provided a single delete many' do
@@ -167,6 +293,27 @@ describe Mongo::BulkWrite do
             expect(result.deleted_count).to eq(1)
             expect(authorized_collection.find(_id: 0).count).to eq(0)
           end
+
+          context 'when there is a write concern error' do
+
+            context 'when the server version is < 2.6' do
+
+              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::BulkWriteError)
+              end
+            end
+
+            context 'when the server version has write commands enabled' do
+
+              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
+              end
+            end
+          end
         end
 
         context 'when provided multiple delete many ops' do
@@ -193,6 +340,27 @@ describe Mongo::BulkWrite do
             expect(result.deleted_count).to eq(3)
             expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(0)
           end
+
+          context 'when there is a write concern error' do
+
+            context 'when the server version is < 2.6' do
+
+              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::BulkWriteError)
+              end
+            end
+
+            context 'when the server version has write commands enabled' do
+
+              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
+              end
+            end
+          end
         end
 
         context 'when providing a single replace one' do
@@ -213,45 +381,492 @@ describe Mongo::BulkWrite do
             expect(result.modified_count).to eq(1)
             expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
           end
+
+          context 'when there is a write concern error' do
+
+            context 'when the server version is < 2.6' do
+
+              it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::BulkWriteError)
+              end
+            end
+
+            context 'when the server version has write commands enabled' do
+
+              it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                expect {
+                  bulk_write_invalid_write_concern.execute
+                }.to raise_error(Mongo::Error::OperationFailure)
+              end
+            end
+          end
         end
 
         context 'when providing a single update one' do
 
-          let(:requests) do
-            [{ update_one: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}}}]
+          context 'when upsert is false' 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
+              result
+              expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+            end
+
+            it 'reports the upserted id' do
+              expect(result.upserted_ids).to eq([])
+            end
+
+            it 'reports the upserted count' do
+              expect(result.upserted_count).to eq(0)
+            end
+
+            it 'reports the modified count' do
+              expect(result.modified_count).to eq(1)
+            end
+
+            it 'reports the matched count' do
+              expect(result.matched_count).to eq(1)
+            end
+
+            context 'when documents match but are not modified' do
+
+              before do
+                authorized_collection.insert_one({ a: 0 })
+              end
+
+              let(:requests) do
+                [{ update_one: { filter: { a: 0 }, update: { "$set" => { a: 0 }}}}]
+              end
+
+              it 'reports the upserted id' do
+                expect(result.upserted_ids).to eq([])
+              end
+
+              it 'reports the upserted count' do
+                expect(result.upserted_count).to eq(0)
+              end
+
+              it 'reports the modified count', if: write_command_enabled? do
+                expect(result.modified_count).to eq(0)
+              end
+
+              it 'reports the matched count' do
+                expect(result.matched_count).to eq(1)
+              end
+            end
+
+            context 'when the number of updates exceeds the max batch size', if: write_command_enabled? do
+
+              let(:requests) do
+                1001.times.collect do |i|
+                  { update_one: { filter: { a: i }, update: { "$set" => { a: i, b: 3 }}, upsert: true }}
+                end
+              end
+
+              it 'updates the documents and reports the correct number of upserted ids' do
+                expect(result.upserted_ids.size).to eq(1001)
+                expect(authorized_collection.find(b: 3).count).to eq(1001)
+              end
+            end
+
+            context 'when there is a write concern error' do
+
+              context 'when the server version is < 2.6' do
+
+                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::BulkWriteError)
+                end
+              end
+
+              context 'when the server version has write commands enabled' do
+
+                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::OperationFailure)
+                end
+              end
+            end
           end
 
-          let(:result) do
-            bulk_write.execute
+          context 'when upsert is true' do
+
+            let(:requests) do
+              [{ update_one: { filter: { _id: 0 }, update: { "$set" => { name: 'test' } }, upsert: true }}]
+            end
+
+            let(:result) do
+              bulk_write.execute
+            end
+
+            it 'updates the document' do
+              result
+              expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+            end
+
+            it 'reports the upserted count' do
+              expect(result.upserted_count).to eq(1)
+            end
+
+            it 'reports the matched count' do
+              expect(result.modified_count).to eq(0)
+            end
+
+            it 'reports the modified count' do
+              expect(result.modified_count).to eq(0)
+            end
+
+            it 'reports the upserted id', if: write_command_enabled? do
+              expect(result.upserted_ids).to eq([0])
+            end
+
+            context 'when there is a write concern error' do
+
+              context 'when the server version is < 2.6' do
+
+                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::BulkWriteError)
+                end
+              end
+
+              context 'when the server version has write commands enabled' do
+
+                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::OperationFailure)
+                end
+              end
+            end
           end
+        end
 
-          before do
-            authorized_collection.insert_one({ _id: 0 })
+        context 'when providing multiple update ones' do
+
+          context 'when upsert is false' do
+
+            let(:requests) do
+              [{ update_one: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}}},
+               { update_one: { filter: { _id: 1 }, update: { "$set" => { name: 'test' }}}}]
+            end
+
+            let(:result) do
+              bulk_write.execute
+            end
+
+            before do
+              authorized_collection.insert_many([{ _id: 0 }, { _id: 1 }])
+            end
+
+            it 'updates the document' do
+              result
+              expect(authorized_collection.find(name: 'test').count).to eq(2)
+            end
+
+            it 'reports the upserted id' do
+              expect(result.upserted_ids).to eq([])
+            end
+
+            it 'reports the upserted count' do
+              expect(result.upserted_count).to eq(0)
+            end
+
+            it 'reports the modified count' do
+              expect(result.modified_count).to eq(2)
+            end
+
+            it 'reports the matched count' do
+              expect(result.modified_count).to eq(2)
+            end
+
+
+            context 'when there is a mix of updates and matched without an update' do
+
+              let(:requests) do
+                [{ update_one: { filter: { a: 0 }, update: { "$set" => { a: 1 }}}},
+                 { update_one: { filter: { a: 2 }, update: { "$set" => { a: 2 }}}}]
+              end
+
+              let(:result) do
+                bulk_write.execute
+              end
+
+              before do
+                authorized_collection.insert_many([{ a: 0 }, { a: 2 }])
+              end
+
+              it 'updates the document' do
+                result
+                expect(authorized_collection.find(a: { '$lt' => 3 }).count).to eq(2)
+              end
+
+              it 'reports the upserted id' do
+                expect(result.upserted_ids).to eq([])
+              end
+
+              it 'reports the upserted count' do
+                expect(result.upserted_count).to eq(0)
+              end
+
+              it 'reports the modified count', if: write_command_enabled? do
+                expect(result.modified_count).to eq(1)
+              end
+
+              it 'reports the modified count', unless: write_command_enabled? do
+                expect(result.modified_count).to eq(2)
+              end
+
+              it 'reports the matched count' do
+                expect(result.matched_count).to eq(2)
+              end
+            end
+
+            context 'when there is a write concern error' do
+
+              context 'when the server version is < 2.6' do
+
+                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::BulkWriteError)
+                end
+              end
+
+              context 'when the server version has write commands enabled' do
+
+                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::OperationFailure)
+                end
+              end
+            end
           end
 
-          it 'updates the document' do
-            expect(result.modified_count).to eq(1)
-            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+          context 'when upsert is true' do
+
+            let(:requests) do
+              [{ update_one: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}, upsert: true }},
+               { update_one: { filter: { _id: 1 }, update: { "$set" => { name: 'test1' }}, upsert: true }}]
+            end
+
+            let(:result) do
+              bulk_write.execute
+            end
+
+            it 'updates the document' do
+              expect(result.modified_count).to eq(0)
+              expect(authorized_collection.find(name: { '$in' => ['test', 'test1'] }).count).to eq(2)
+            end
+
+            it 'reports the upserted count' do
+              expect(result.upserted_count).to eq(2)
+            end
+
+            it 'reports the modified count' do
+              expect(result.modified_count).to eq(0)
+            end
+
+            it 'reports the matched count' do
+              expect(result.matched_count).to eq(0)
+            end
+
+            it 'reports the upserted id', if: write_command_enabled? do
+              expect(result.upserted_ids).to eq([0, 1])
+            end
+
+            context 'when there is a mix of updates, upsert, and matched without an update' do
+
+              let(:requests) do
+                [{ update_one: { filter: { a: 0 }, update: { "$set" => { a: 1 }}}},
+                 { update_one: { filter: { a: 2 }, update: { "$set" => { a: 2 }}}},
+                 { update_one: { filter: { _id: 3 }, update: { "$set" => { a: 4 }}, upsert: true }}]
+              end
+
+              let(:result) do
+                bulk_write.execute
+              end
+
+              before do
+                authorized_collection.insert_many([{ a: 0 }, { a: 2 }])
+              end
+
+              it 'updates the documents' do
+                result
+                expect(authorized_collection.find(a: { '$lt' => 3 }).count).to eq(2)
+                expect(authorized_collection.find(a: 4).count).to eq(1)
+              end
+
+              it 'reports the upserted id', if: write_command_enabled? do
+                expect(result.upserted_ids).to eq([3])
+              end
+
+              it 'reports the upserted count' do
+                expect(result.upserted_count).to eq(1)
+              end
+
+              it 'reports the modified count', if: write_command_enabled? do
+                expect(result.modified_count).to eq(1)
+              end
+
+              it 'reports the modified count', unless: write_command_enabled? do
+                expect(result.modified_count).to eq(2)
+              end
+
+              it 'reports the matched count' do
+                expect(result.matched_count).to eq(2)
+              end
+            end
+
+            context 'when there is a write concern error' do
+
+              context 'when the server version is < 2.6' do
+
+                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::BulkWriteError)
+                end
+              end
+
+              context 'when the server version has write commands enabled' do
+
+                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::OperationFailure)
+                end
+              end
+            end
           end
         end
 
         context 'when providing a single update many' do
 
-          let(:requests) do
-            [{ update_many: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}}}]
-          end
+          context 'when upsert is false' do
 
-          let(:result) do
-            bulk_write.execute
-          end
+            let(:requests) do
+              [{ update_many: { filter: { a: 0 }, update: { "$set" => { name: 'test' }}}}]
+            end
 
-          before do
-            authorized_collection.insert_one({ _id: 0 })
+            let(:result) do
+              bulk_write.execute
+            end
+
+            before do
+              authorized_collection.insert_many([{ a: 0 }, { a: 0 }])
+            end
+
+            it 'updates the documents' do
+              expect(authorized_collection.find(a: 0).count).to eq(2)
+            end
+
+            it 'reports the upserted ids' do
+              expect(result.upserted_ids).to eq([])
+            end
+
+            it 'reports the upserted count' do
+              expect(result.upserted_count).to eq(0)
+            end
+
+            it 'reports the modified count' do
+              expect(result.modified_count).to eq(2)
+            end
+
+            it 'reports the matched count' do
+              expect(result.modified_count).to eq(2)
+            end
+
+            context 'when there is a write concern error' do
+
+              context 'when the server version is < 2.6' do
+
+                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::BulkWriteError)
+                end
+              end
+
+              context 'when the server version has write commands enabled' do
+
+                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::OperationFailure)
+                end
+              end
+            end
           end
 
-          it 'updates the documents' do
-            expect(result.modified_count).to eq(1)
-            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+          context 'when upsert is true' do
+
+            let(:requests) do
+              [{ update_many: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}, upsert: true }}]
+            end
+
+            let(:result) do
+              bulk_write.execute
+            end
+
+            it 'updates the document' do
+              result
+              expect(authorized_collection.find(name: 'test').count).to eq(1)
+            end
+
+            it 'reports the upserted count' do
+              expect(result.upserted_count).to eq(1)
+            end
+
+            it 'reports the matched count' do
+              expect(result.matched_count).to eq(0)
+            end
+
+            it 'reports the modified count' do
+              expect(result.modified_count).to eq(0)
+            end
+
+            it 'reports the upserted id', if: write_command_enabled? do
+              expect(result.upserted_ids).to eq([0])
+            end
+
+            context 'when there is a write concern error' do
+
+              context 'when the server version is < 2.6' do
+
+                it 'raises a BulkWriteError', if: !write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::BulkWriteError)
+                end
+              end
+
+              context 'when the server version has write commands enabled' do
+
+                it 'raises an OperationFailure', if: write_command_enabled? && standalone? do
+                  expect {
+                    bulk_write_invalid_write_concern.execute
+                  }.to raise_error(Mongo::Error::OperationFailure)
+                end
+              end
+            end
           end
         end
       end
@@ -302,6 +917,10 @@ describe Mongo::BulkWrite do
           it 'inserts the documents' do
             expect(result.inserted_count).to eq(1001)
           end
+
+          it 'combines the inserted ids' do
+            expect(result.inserted_ids.size).to eq(1001)
+          end
         end
       end
 
@@ -329,6 +948,10 @@ describe Mongo::BulkWrite do
         described_class.new(authorized_collection, requests, ordered: false)
       end
 
+      let(:bulk_write_invalid_write_concern) do
+        described_class.new(collection_invalid_write_concern, requests, ordered: false)
+      end
+
       it_behaves_like 'an executable bulk write'
     end
 
@@ -338,6 +961,10 @@ describe Mongo::BulkWrite do
         described_class.new(authorized_collection, requests, ordered: true)
       end
 
+      let(:bulk_write_invalid_write_concern) do
+        described_class.new(collection_invalid_write_concern, requests, ordered: true)
+      end
+
       it_behaves_like 'an executable bulk write'
     end
   end