mongo 2.3.1 → 2.4.0.rc0

data/spec/mongo/auth/ldap_spec.rb

@@ -14,8 +14,14 @@ describe Mongo::Auth::LDAP do
     Mongo::Event::Listeners.new
   end
 
+  let(:cluster) do
+    double('cluster').tap do |cl|
+      allow(cl).to receive(:app_metadata).and_return(app_metadata)
+    end
+  end
+
   let(:server) do
-    Mongo::Server.new(address, double('cluster'), monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
   end
 
   let(:connection) do

data/spec/mongo/auth/scram_spec.rb

@@ -14,8 +14,14 @@ describe Mongo::Auth::SCRAM do
     Mongo::Event::Listeners.new
   end
 
+  let(:cluster) do
+    double('cluster').tap do |cl|
+      allow(cl).to receive(:app_metadata).and_return(app_metadata)
+    end
+  end
+
   let(:server) do
-    Mongo::Server.new(address, double('cluster'), monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
   end
 
   let(:connection) do

data/spec/mongo/auth/x509_spec.rb

@@ -14,8 +14,14 @@ describe Mongo::Auth::X509 do
     Mongo::Event::Listeners.new
   end
 
+  let(:cluster) do
+    double('cluster').tap do |cl|
+      allow(cl).to receive(:app_metadata).and_return(app_metadata)
+    end
+  end
+
   let(:server) do
-    Mongo::Server.new(address, double('cluster'), monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
   end
 
   let(:connection) do

data/spec/mongo/bulk_write_spec.rb

@@ -12,6 +12,7 @@ describe Mongo::BulkWrite do
   end
 
   let(:collection_with_validator) do
+    begin; authorized_client[:validating].drop; rescue; end
     authorized_client[:validating,
                       :validator => { :a => { '$exists' => true } }].tap do |c|
       c.create
@@ -22,6 +23,10 @@ describe Mongo::BulkWrite do
     authorized_collection.client.with(write: { w: (WRITE_CONCERN[:w] + 1) })[authorized_collection.name]
   end
 
+  let(:collation) do
+    { locale: 'en_US', strength: 2 }
+  end
+
   describe '#execute' do
 
     shared_examples_for 'an executable bulk write' do
@@ -205,6 +210,64 @@ describe Mongo::BulkWrite do
                 }.to raise_error(Mongo::Error::OperationFailure)
               end
             end
+
+            context 'when the write has a collation specified' do
+
+              before do
+                authorized_collection.insert_one(name: 'bang')
+              end
+
+              let(:requests) do
+                [{ delete_one: { filter: { name: 'BANG' }, collation: collation } }]
+              end
+
+              context 'when the server selected supports collations', if: collation_enabled? do
+
+                let!(:result) do
+                  bulk_write.execute
+                end
+
+                it 'applies the collation' do
+                  expect(authorized_collection.find(name: 'bang').count).to eq(0)
+                end
+
+                it 'reports the deleted count' do
+                  expect(result.deleted_count).to eq(1)
+                end
+              end
+
+              context 'when the server selected does not support collations', unless: collation_enabled? do
+
+                it 'raises an exception' do
+                  expect {
+                    bulk_write.execute
+                  }.to raise_exception(Mongo::Error::UnsupportedCollation)
+                end
+              end
+            end
+
+            context 'when a collation is not specified' do
+
+              before do
+                authorized_collection.insert_one(name: 'bang')
+              end
+
+              let(:requests) do
+                [{ delete_one: { filter: { name: 'BANG' }}}]
+              end
+
+              let!(:result) do
+                bulk_write.execute
+              end
+
+              it 'does not apply the collation' do
+                expect(authorized_collection.find(name: 'bang').count).to eq(1)
+              end
+
+              it 'reports the deleted count' do
+                expect(result.deleted_count).to eq(0)
+              end
+            end
           end
 
           context 'when multiple documents match delete selector' do
@@ -273,6 +336,68 @@ describe Mongo::BulkWrite do
               end
             end
           end
+
+          context 'when the write has a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'doink')
+            end
+
+            let(:requests) do
+              [{ delete_one: { filter: { name: 'BANG' }, collation: collation }},
+               { delete_one: { filter: { name: 'DOINK' }, collation: collation }}]
+            end
+
+            context 'when the server selected supports collations', if: collation_enabled? do
+
+              let!(:result) do
+                bulk_write.execute
+              end
+
+              it 'applies the collation' do
+                expect(authorized_collection.find(name: { '$in' => ['bang', 'doink']}).count).to eq(0)
+              end
+
+              it 'reports the deleted count' do
+                expect(result.deleted_count).to eq(2)
+              end
+            end
+
+            context 'when the server selected does not support collations', unless: collation_enabled? do
+
+              it 'raises an exception' do
+                expect {
+                  bulk_write.execute
+                }.to raise_exception(Mongo::Error::UnsupportedCollation)
+              end
+            end
+          end
+
+          context 'when the write does not have a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'doink')
+            end
+
+            let(:requests) do
+              [{ delete_one: { filter: { name: 'BANG' }}},
+               { delete_one: { filter: { name: 'DOINK' }}}]
+            end
+
+            let!(:result) do
+              bulk_write.execute
+            end
+
+            it 'does not apply the collation' do
+              expect(authorized_collection.find(name: { '$in' => ['bang', 'doink']}).count).to eq(2)
+            end
+
+            it 'reports the deleted count' do
+              expect(result.deleted_count).to eq(0)
+            end
+          end
         end
 
         context 'when provided a single delete many' do
@@ -314,6 +439,66 @@ describe Mongo::BulkWrite do
               end
             end
           end
+
+          context 'when the write has a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'bang')
+            end
+
+            let(:requests) do
+              [{ delete_many: { filter: { name: 'BANG' }, collation: collation }}]
+            end
+
+            context 'when the server selected supports collations', if: collation_enabled? do
+
+              let!(:result) do
+                bulk_write.execute
+              end
+
+              it 'applies the collation' do
+                expect(authorized_collection.find(name: 'bang').count).to eq(0)
+              end
+
+              it 'reports the deleted count' do
+                expect(result.deleted_count).to eq(2)
+              end
+            end
+
+            context 'when the server selected does not support collations', unless: collation_enabled? do
+
+              it 'raises an exception' do
+                expect {
+                  bulk_write.execute
+                }.to raise_exception(Mongo::Error::UnsupportedCollation)
+              end
+            end
+          end
+
+          context 'when a collation is not specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'bang')
+            end
+
+            let(:requests) do
+              [{ delete_many: { filter: { name: 'BANG' }}}]
+            end
+
+            let!(:result) do
+              bulk_write.execute
+            end
+
+            it 'does not apply the collation' do
+              expect(authorized_collection.find(name: 'bang').count).to eq(2)
+            end
+
+            it 'reports the deleted count' do
+              expect(result.deleted_count).to eq(0)
+            end
+          end
         end
 
         context 'when provided multiple delete many ops' do
@@ -361,6 +546,70 @@ describe Mongo::BulkWrite do
               end
             end
           end
+
+          context 'when the write has a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'doink')
+            end
+
+            let(:requests) do
+              [{ delete_many: { filter: { name: 'BANG' },  collation: collation }},
+               { delete_many: { filter: { name: 'DOINK' },  collation: collation }}]
+            end
+
+            context 'when the server selected supports collations', if: collation_enabled? do
+
+              let!(:result) do
+                bulk_write.execute
+              end
+
+              it 'applies the collation' do
+                expect(authorized_collection.find(name: { '$in' => ['bang', 'doink'] }).count).to eq(0)
+              end
+
+              it 'reports the deleted count' do
+                expect(result.deleted_count).to eq(3)
+              end
+            end
+
+            context 'when the server selected does not support collations', unless: collation_enabled? do
+
+              it 'raises an exception' do
+                expect {
+                  bulk_write.execute
+                }.to raise_exception(Mongo::Error::UnsupportedCollation)
+              end
+            end
+          end
+
+          context 'when a collation is not specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'doink')
+            end
+
+            let(:requests) do
+              [{ delete_many: { filter: { name: 'BANG' }}},
+               { delete_many: { filter: { name: 'DOINK' }}}]
+            end
+
+            let!(:result) do
+              bulk_write.execute
+            end
+
+            it 'does not apply the collation' do
+              expect(authorized_collection.find(name: { '$in' => ['bang', 'doink'] }).count).to eq(3)
+            end
+
+            it 'reports the deleted count' do
+              expect(result.deleted_count).to eq(0)
+            end
+          end
         end
 
         context 'when providing a single replace one' do
@@ -402,6 +651,90 @@ describe Mongo::BulkWrite do
               end
             end
           end
+
+          context 'when the write has a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+            end
+
+            let(:requests) do
+              [{ replace_one: { filter: { name: 'BANG' },
+                                replacement: { other: 'pong' },
+                                collation: collation }}]
+            end
+
+            context 'when the server selected supports collations', if: collation_enabled? do
+
+              let!(:result) do
+                bulk_write.execute
+              end
+
+              it 'applies the collation' do
+                expect(authorized_collection.find(other: 'pong').count).to eq(1)
+              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
+            end
+
+            context 'when the server selected does not support collations', unless: collation_enabled? do
+
+              it 'raises an exception' do
+                expect {
+                  bulk_write.execute
+                }.to raise_exception(Mongo::Error::UnsupportedCollation)
+              end
+            end
+          end
+
+          context 'when the write does not have a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+            end
+
+            let(:requests) do
+              [{ replace_one: { filter: { name: 'BANG' }, replacement: { other: 'pong' }}}]
+            end
+
+            let!(:result) do
+              bulk_write.execute
+            end
+
+            it 'does not apply the collation' do
+              expect(authorized_collection.find(other: 'pong').count).to eq(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' do
+              expect(result.modified_count).to eq(0)
+            end
+
+            it 'reports the matched count' do
+              expect(result.matched_count).to eq(0)
+            end
+          end
         end
 
         context 'when providing a single update one' do
@@ -523,12 +856,12 @@ describe Mongo::BulkWrite do
               expect(result.upserted_count).to eq(1)
             end
 
-            it 'reports the matched count' do
+            it 'reports the modified_count count' do
               expect(result.modified_count).to eq(0)
             end
 
-            it 'reports the modified count' do
-              expect(result.modified_count).to eq(0)
+            it 'reports the matched count' do
+              expect(result.matched_count).to eq(0)
             end
 
             it 'reports the upserted id', if: write_command_enabled? do
@@ -556,10 +889,184 @@ describe Mongo::BulkWrite do
               end
             end
           end
+
+          context 'when the write has a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+            end
+
+            let(:requests) do
+              [{ update_one: { filter: { name: 'BANG' },
+                               update: { "$set" => { name: 'pong' }},
+                               collation: collation }}]
+            end
+
+            context 'when the server selected supports collations', if: collation_enabled? do
+
+              let!(:result) do
+                bulk_write.execute
+              end
+
+              it 'applies the collation' do
+                expect(authorized_collection.find(name: 'pong').count).to eq(1)
+              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
+            end
+
+            context 'when the server selected does not support collations', unless: collation_enabled? do
+
+              it 'raises an exception' do
+                expect {
+                  bulk_write.execute
+                }.to raise_exception(Mongo::Error::UnsupportedCollation)
+              end
+            end
+          end
+
+          context 'when the write does not have a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+            end
+
+            let(:requests) do
+              [{ update_one: { filter: { name: 'BANG' }, update: { "$set" => { name: 'pong' }}}}]
+            end
+
+            let!(:result) do
+              bulk_write.execute
+            end
+
+            it 'does not apply the collation' do
+              expect(authorized_collection.find(name: 'pong').count).to eq(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' do
+              expect(result.modified_count).to eq(0)
+            end
+
+            it 'reports the matched count' do
+              expect(result.matched_count).to eq(0)
+            end
+          end
         end
 
         context 'when providing multiple update ones' do
 
+          context 'when the write has a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'doink')
+            end
+
+            let(:requests) do
+              [{ update_one: { filter: { name: 'BANG' },
+                               update: { "$set" => { name: 'pong' }},
+                               collation: collation }},
+               { update_one: { filter: { name: 'DOINK' },
+                               update: { "$set" => { name: 'pong' }},
+                               collation: collation }}]
+            end
+
+            context 'when the server selected supports collations', if: collation_enabled? do
+
+              let!(:result) do
+                bulk_write.execute
+              end
+
+              it 'applies the collation' do
+                expect(authorized_collection.find(name: 'pong').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.matched_count).to eq(2)
+              end
+            end
+
+            context 'when the server selected does not support collations', unless: collation_enabled? do
+
+              it 'raises an exception' do
+                expect {
+                  bulk_write.execute
+                }.to raise_exception(Mongo::Error::UnsupportedCollation)
+              end
+            end
+          end
+
+          context 'when the write does not have a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'doink')
+            end
+
+            let(:requests) do
+              [{ update_one: { filter: { name: 'BANG' }, update: { "$set" => { name: 'pong' }}}},
+               { update_one: { filter: { name: 'DOINK' }, update: { "$set" => { name: 'pong' }}}}]
+            end
+
+            let!(:result) do
+              bulk_write.execute
+            end
+
+            it 'does not apply the collation' do
+              expect(authorized_collection.find(name: 'pong').count).to eq(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' do
+              expect(result.modified_count).to eq(0)
+            end
+
+            it 'reports the matched count' do
+              expect(result.matched_count).to eq(0)
+            end
+          end
+
           context 'when upsert is false' do
 
             let(:requests) do
@@ -593,7 +1100,7 @@ describe Mongo::BulkWrite do
             end
 
             it 'reports the matched count' do
-              expect(result.modified_count).to eq(2)
+              expect(result.matched_count).to eq(2)
             end
 
 
@@ -760,6 +1267,92 @@ describe Mongo::BulkWrite do
 
         context 'when providing a single update many' do
 
+          context 'when the write has a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'bang')
+            end
+
+            let(:requests) do
+              [{ update_many: { filter: { name: 'BANG' },
+                                update: { "$set" => { name: 'pong' }},
+                                collation: collation }}]
+            end
+
+            context 'when the server selected supports collations', if: collation_enabled? do
+
+              let!(:result) do
+                bulk_write.execute
+              end
+
+              it 'applies the collation' do
+                expect(authorized_collection.find(name: 'pong').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.matched_count).to eq(2)
+              end
+            end
+
+            context 'when the server selected does not support collations', unless: collation_enabled? do
+
+              it 'raises an exception' do
+                expect {
+                  bulk_write.execute
+                }.to raise_exception(Mongo::Error::UnsupportedCollation)
+              end
+            end
+          end
+
+          context 'when the write does not have a collation specified' do
+
+            before do
+              authorized_collection.insert_one(name: 'bang')
+              authorized_collection.insert_one(name: 'bang')
+            end
+
+            let(:requests) do
+              [{ update_many: { filter: { name: 'BANG' }, update: { "$set" => { name: 'pong' }}}}]
+            end
+
+            let!(:result) do
+              bulk_write.execute
+            end
+
+            it 'does not apply the collation' do
+              expect(authorized_collection.find(name: 'pong').count).to eq(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' do
+              expect(result.modified_count).to eq(0)
+            end
+
+            it 'reports the matched count' do
+              expect(result.matched_count).to eq(0)
+            end
+          end
+
           context 'when upsert is false' do
 
             let(:requests) do
@@ -791,7 +1384,7 @@ describe Mongo::BulkWrite do
             end
 
             it 'reports the matched count' do
-              expect(result.modified_count).to eq(2)
+              expect(result.matched_count).to eq(2)
             end
 
             context 'when there is a write concern error' do