mongo 2.4.0 → 2.4.1

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

@@ -133,6 +133,23 @@ describe Mongo::Collection::View::MapReduce do
         it 'fetches the results from the collection' do
           expect(new_map_reduce.count).to eq(2)
         end
+
+        context 'when another db is specified', if: (!auth_enabled? && list_command_enabled?) do
+
+          let(:new_map_reduce) do
+            map_reduce.out(db: 'another-db', replace: 'output_collection')
+          end
+
+          it 'iterates over the documents in the result' do
+            new_map_reduce.each do |document|
+              expect(document[:value]).to_not be_nil
+            end
+          end
+
+          it 'fetches the results from the collection' do
+            expect(new_map_reduce.count).to eq(2)
+          end
+        end
       end
 
       context 'when the option is to merge' do
@@ -150,6 +167,23 @@ describe Mongo::Collection::View::MapReduce do
         it 'fetches the results from the collection' do
           expect(new_map_reduce.count).to eq(2)
         end
+
+        context 'when another db is specified', if: (!auth_enabled? && list_command_enabled?) do
+
+          let(:new_map_reduce) do
+            map_reduce.out(db: 'another-db', merge: 'output_collection')
+          end
+
+          it 'iterates over the documents in the result' do
+            new_map_reduce.each do |document|
+              expect(document[:value]).to_not be_nil
+            end
+          end
+
+          it 'fetches the results from the collection' do
+            expect(new_map_reduce.count).to eq(2)
+          end
+        end
       end
 
       context 'when the option is to reduce' do
@@ -167,6 +201,23 @@ describe Mongo::Collection::View::MapReduce do
         it 'fetches the results from the collection' do
           expect(new_map_reduce.count).to eq(2)
         end
+
+        context 'when another db is specified', if: (!auth_enabled? && list_command_enabled?) do
+
+          let(:new_map_reduce) do
+            map_reduce.out(db: 'another-db', reduce: 'output_collection')
+          end
+
+          it 'iterates over the documents in the result' do
+            new_map_reduce.each do |document|
+              expect(document[:value]).to_not be_nil
+            end
+          end
+
+          it 'fetches the results from the collection' do
+            expect(new_map_reduce.count).to eq(2)
+          end
+        end
       end
 
       context 'when the option is a collection name' do
@@ -506,33 +557,67 @@ describe Mongo::Collection::View::MapReduce do
       authorized_collection.insert_many([ { name: 'bang' }, { name: 'bang' }])
     end
 
-    let(:options) do
-      { collation: { locale: 'en_US', strength: 2 } }
-    end
-
     let(:selector) do
       { name: 'BANG' }
     end
 
     context 'when the server selected supports collations', if: collation_enabled? do
 
-      it 'applies the collation' do
-        expect(map_reduce.first['value']).to eq(2)
+      context 'when the collation key is a String' do
+
+        let(:options) do
+          { 'collation' => { locale: 'en_US', strength: 2 } }
+        end
+
+        it 'applies the collation' do
+          expect(map_reduce.first['value']).to eq(2)
+        end
+      end
+
+      context 'when the collation key is a Symbol' do
+
+        let(:options) do
+          { collation: { locale: 'en_US', strength: 2 } }
+        end
+
+        it 'applies the collation' do
+          expect(map_reduce.first['value']).to eq(2)
+        end
       end
     end
 
     context 'when the server selected does not support collations', unless: collation_enabled? do
 
-      it 'raises an exception' do
-        expect {
-          map_reduce.to_a
-        }.to raise_exception(Mongo::Error::UnsupportedCollation)
+      context 'when the map reduce has collation specified in its options' do
+
+        let(:options) do
+          { collation: { locale: 'en_US', strength: 2 } }
+        end
+
+        it 'raises an exception' do
+          expect {
+            map_reduce.to_a
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              map_reduce.to_a
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
       end
 
-      context 'when a String key is used' do
+      context 'when the view has collation specified in its options' do
 
-        let(:options) do
-          { 'collation' => { locale: 'en_US', strength: 2 } }
+        let(:view_options) do
+          { collation: { locale: 'en_US', strength: 2 } }
         end
 
         it 'raises an exception' do
@@ -540,6 +625,19 @@ describe Mongo::Collection::View::MapReduce do
             map_reduce.to_a
           }.to raise_exception(Mongo::Error::UnsupportedCollation)
         end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              map_reduce.to_a
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
       end
     end
   end

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

@@ -309,6 +309,40 @@ describe Mongo::Collection::View::Readable do
       expect(view.count(read: { mode: :secondary })).to eq(10)
     end
 
+    context 'when a read preference is set on the view', unless: sharded? do
+
+      let(:client) do
+        # Set a timeout otherwise, the test will hang for 30 seconds.
+        authorized_client.with(server_selection_timeout: 1)
+      end
+
+      let(:collection) do
+        client[authorized_collection.name]
+      end
+
+      before do
+        allow(client.cluster).to receive(:single?).and_return(false)
+      end
+
+      let(:view) do
+        Mongo::Collection::View.new(collection, selector, options)
+      end
+
+      let(:view_with_read_pref) do
+        view.read(:mode => :secondary, :tag_sets => [{ 'non' => 'existent' }])
+      end
+
+      let(:result) do
+        view_with_read_pref.count
+      end
+
+      it 'uses the read preference setting on the view' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::NoServerAvailable)
+      end
+    end
+
     context 'when the collection has a read preference set' do
 
       after do
@@ -344,6 +378,21 @@ describe Mongo::Collection::View::Readable do
         end
       end
 
+      context 'when a read preference is set on the view' do
+
+        let(:view_with_read_pref) do
+          view.read(mode: :primary)
+        end
+
+        let(:result) do
+          view_with_read_pref.count
+        end
+
+        it 'uses the read preference of the view' do
+          expect(result).to eq(10)
+        end
+      end
+
       context 'when no read preference argument is provided', unless: sharded? do
 
         before do
@@ -394,6 +443,21 @@ describe Mongo::Collection::View::Readable do
           }.to raise_exception(Mongo::Error::NoServerAvailable)
         end
       end
+
+      context 'when a read preference is set on the view' do
+
+        let(:view_with_read_pref) do
+          view.read(:mode => :primary)
+        end
+
+        let(:result) do
+          view_with_read_pref.count
+        end
+
+        it 'uses the read preference passed to the method' do
+          expect(result).to eq(10)
+        end
+      end
     end
 
     it 'takes a max_time_ms option', if: write_command_enabled? do
@@ -412,6 +476,54 @@ describe Mongo::Collection::View::Readable do
         { name: 'BANG' }
       end
 
+      let(:result) do
+        view.count
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+      end
+
+      let(:options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+
+      context 'when the server selected supports collations', if: collation_enabled? do
+
+        it 'applies the collation to the count' do
+          expect(result).to eq(1)
+        end
+      end
+
+      context 'when the server selected does not support collations', unless: collation_enabled? do
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
+      end
+    end
+
+    context 'when a collation is specified in the method options' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
       let(:result) do
         view.count(count_options)
       end
@@ -569,6 +681,40 @@ describe Mongo::Collection::View::Readable do
       end
     end
 
+    context 'when a read preference is set on the view', unless: sharded? do
+
+      let(:client) do
+        # Set a timeout otherwise, the test will hang for 30 seconds.
+        authorized_client.with(server_selection_timeout: 1)
+      end
+
+      let(:collection) do
+        client[authorized_collection.name]
+      end
+
+      before do
+        allow(client.cluster).to receive(:single?).and_return(false)
+      end
+
+      let(:view) do
+        Mongo::Collection::View.new(collection, selector, options)
+      end
+
+      let(:view_with_read_pref) do
+        view.read(:mode => :secondary, :tag_sets => [{ 'non' => 'existent' }])
+      end
+
+      let(:result) do
+        view_with_read_pref.distinct(:field)
+      end
+
+      it 'uses the read preference setting on the view' do
+        expect {
+          result
+        }.to raise_exception(Mongo::Error::NoServerAvailable)
+      end
+    end
+
     context 'when the collection has a read preference set' do
 
       let(:documents) do
@@ -667,6 +813,21 @@ describe Mongo::Collection::View::Readable do
           }.to raise_exception(Mongo::Error::NoServerAvailable)
         end
       end
+
+      context 'when a read preference is set on the view' do
+
+        let(:view_with_read_pref) do
+          view.read(:mode => :secondary, :tag_sets => [{ 'non' => 'existent' }])
+        end
+
+        let(:distinct) do
+          view_with_read_pref.distinct(:field, read: { mode: :primary })
+        end
+
+        it 'uses the read preference passed to the method' do
+          expect(distinct.sort).to eq([ 'test1', 'test2', 'test3' ])
+        end
+      end
     end
 
     context 'when a max_time_ms is specified', if: write_command_enabled? do
@@ -697,7 +858,52 @@ describe Mongo::Collection::View::Readable do
       end
     end
 
-    context 'when a collation is specified' do
+    context 'when a collation is specified on the view' do
+
+      let(:result) do
+        view.distinct(:name)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+        authorized_collection.insert_one(name: 'BANG')
+      end
+
+      let(:options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+
+      context 'when the server selected supports collations', if: collation_enabled? do
+
+        it 'applies the collation to the distinct' do
+          expect(result).to eq(['bang'])
+        end
+      end
+
+      context 'when the server selected does not support collations', unless: collation_enabled? do
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
+      end
+    end
+
+    context 'when a collation is specified in the method options' do
 
       let(:result) do
         view.distinct(:name, distinct_options)

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

@@ -142,6 +142,54 @@ describe Mongo::Collection::View::Writable do
           expect(result).to be_nil
         end
       end
+
+      context 'when collation is specified as a method option' do
+
+        let(:selector) do
+          { name: 'BANG' }
+        end
+
+        let(:result) do
+          view.find_one_and_delete(method_options)
+        end
+
+        before do
+          authorized_collection.insert_one(name: 'bang')
+        end
+
+        let(:method_options) do
+          { collation: { locale: 'en_US', strength: 2 } }
+        end
+
+        context 'when the server selected supports collations', if: collation_enabled? do
+
+          it 'applies the collation' do
+            expect(result['name']).to eq('bang')
+          end
+        end
+
+        context 'when the server selected does not support collations', unless: collation_enabled? do
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+
+          context 'when a String key is used' do
+
+            let(:method_options) do
+              { 'collation' => { locale: 'en_US', strength: 2 } }
+            end
+
+            it 'raises an exception' do
+              expect {
+                result
+              }.to raise_exception(Mongo::Error::UnsupportedCollation)
+            end
+          end
+        end
+      end
     end
 
     context 'when no matching document is found' do
@@ -270,6 +318,55 @@ describe Mongo::Collection::View::Writable do
         end
       end
 
+      context 'when collation is provided as a method option' do
+
+        let(:selector) do
+          { name: 'BANG' }
+        end
+
+        let(:result) do
+          view.find_one_and_replace({ name: 'doink' }, method_options)
+        end
+
+        before do
+          authorized_collection.insert_one(name: 'bang')
+        end
+
+        let(:method_options) do
+          { collation: { locale: 'en_US', strength: 2 } }
+        end
+
+        context 'when the server selected supports collations', if: collation_enabled? do
+
+          it 'applies the collation' do
+            expect(result['name']).to eq('bang')
+            expect(authorized_collection.find({ name: 'doink' }, limit: -1).first['name']).to eq('doink')
+          end
+        end
+
+        context 'when the server selected does not support collations', unless: collation_enabled? do
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+
+          context 'when a String key is used' do
+
+            let(:method_options) do
+              { 'collation' => { locale: 'en_US', strength: 2 } }
+            end
+
+            it 'raises an exception' do
+              expect {
+                result
+              }.to raise_exception(Mongo::Error::UnsupportedCollation)
+            end
+          end
+        end
+      end
+
       context 'when collation is not provided' do
 
         let(:selector) do
@@ -431,6 +528,55 @@ describe Mongo::Collection::View::Writable do
       end
     end
 
+    context 'when a collation is specified as a method option' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      let(:result) do
+        view.find_one_and_update({ '$set' => { other: 'doink' } }, method_options)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+      end
+
+      let(:method_options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+
+      context 'when the server selected supports collations', if: collation_enabled? do
+
+        it 'applies the collation' do
+          expect(result['name']).to eq('bang')
+          expect(authorized_collection.find({ name: 'bang' }, limit: -1).first['other']).to eq('doink')
+        end
+      end
+
+      context 'when the server selected does not support collations', unless: collation_enabled? do
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:method_options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
+      end
+    end
+
     context 'when no collation is specified' do
 
       let(:selector) do
@@ -509,7 +655,7 @@ describe Mongo::Collection::View::Writable do
       end
 
       let(:result) do
-        view.delete_many(options)
+        view.delete_many
       end
 
       before do
@@ -552,6 +698,56 @@ describe Mongo::Collection::View::Writable do
       end
     end
 
+    context 'when a collation is specified as a method option' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      let(:result) do
+        view.delete_many(method_options)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+        authorized_collection.insert_one(name: 'bang')
+      end
+
+      let(:method_options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+
+      context 'when the server selected supports collations', if: collation_enabled? do
+
+        it 'applies the collation' do
+          expect(result.written_count).to eq(2)
+          expect(authorized_collection.find(name: 'bang').to_a.size).to eq(0)
+        end
+      end
+
+      context 'when the server selected does not support collations', unless: collation_enabled? do
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:method_options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
+      end
+    end
+
     context 'when a collation is not specified' do
 
       let(:selector) do
@@ -621,7 +817,7 @@ describe Mongo::Collection::View::Writable do
       end
 
       let(:result) do
-        view.delete_one(options)
+        view.delete_one
       end
 
       before do
@@ -663,6 +859,55 @@ describe Mongo::Collection::View::Writable do
       end
     end
 
+    context 'when a collation is provided as a method_option' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      let(:result) do
+        view.delete_one(method_options)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+      end
+
+      let(:method_options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+
+      context 'when the server selected supports collations', if: collation_enabled? do
+
+        it 'applies the collation' do
+          expect(result.written_count).to eq(1)
+          expect(authorized_collection.find(name: 'bang').to_a.size).to eq(0)
+        end
+      end
+
+      context 'when the server selected does not support collations', unless: collation_enabled? do
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:method_options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
+      end
+    end
+
     context 'when a collation is not specified' do
 
       let(:selector) do
@@ -800,7 +1045,7 @@ describe Mongo::Collection::View::Writable do
       end
 
       let(:result) do
-        view.replace_one({ name: 'doink' }, options)
+        view.replace_one({ name: 'doink' })
       end
 
       before do
@@ -842,6 +1087,55 @@ describe Mongo::Collection::View::Writable do
       end
     end
 
+    context 'when a collation is specified as method option' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      let(:result) do
+        view.replace_one({ name: 'doink' }, method_options)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+      end
+
+      let(:method_options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+
+      context 'when the server selected supports collations', if: collation_enabled? do
+
+        it 'applies the collation' do
+          expect(result.written_count).to eq(1)
+          expect(authorized_collection.find(name: 'doink').to_a.size).to eq(1)
+        end
+      end
+
+      context 'when the server selected does not support collations', unless: collation_enabled? do
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:method_options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
+      end
+    end
+
     context 'when a collation is not specified' do
 
       let(:selector) do
@@ -983,7 +1277,7 @@ describe Mongo::Collection::View::Writable do
       end
 
       let(:result) do
-        view.update_many({ '$set' => { other: 'doink' } }, options)
+        view.update_many({ '$set' => { other: 'doink' } })
       end
 
       before do
@@ -1026,6 +1320,56 @@ describe Mongo::Collection::View::Writable do
       end
     end
 
+    context 'when a collation is specified as a method option' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      let(:result) do
+        view.update_many({ '$set' => { other: 'doink' } }, method_options)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+        authorized_collection.insert_one(name: 'baNG')
+      end
+
+      let(:method_options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+
+      context 'when the server selected supports collations', if: collation_enabled? do
+
+        it 'applies the collation' do
+          expect(result.written_count).to eq(2)
+          expect(authorized_collection.find(other: 'doink').to_a.size).to eq(2)
+        end
+      end
+
+      context 'when the server selected does not support collations', unless: collation_enabled? do
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:method_options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
+      end
+    end
+
     context 'when collation is not specified' do
 
       let(:selector) do
@@ -1165,7 +1509,7 @@ describe Mongo::Collection::View::Writable do
       end
 
       let(:result) do
-        view.update_one({ '$set' => { other: 'doink' } }, options)
+        view.update_one({ '$set' => { other: 'doink' } })
       end
 
       before do
@@ -1207,6 +1551,55 @@ describe Mongo::Collection::View::Writable do
       end
     end
 
+    context 'when there is a collation specified as a method option' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      let(:result) do
+        view.update_one({ '$set' => { other: 'doink' } }, method_options)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+      end
+
+      let(:method_options) do
+        { collation: { locale: 'en_US', strength: 2 } }
+      end
+
+      context 'when the server selected supports collations', if: collation_enabled? do
+
+        it 'applies the collation' do
+          expect(result.written_count).to eq(1)
+          expect(authorized_collection.find(other: 'doink').to_a.size).to eq(1)
+        end
+      end
+
+      context 'when the server selected does not support collations', unless: collation_enabled? do
+
+        it 'raises an exception' do
+          expect {
+            result
+          }.to raise_exception(Mongo::Error::UnsupportedCollation)
+        end
+
+        context 'when a String key is used' do
+
+          let(:method_options) do
+            { 'collation' => { locale: 'en_US', strength: 2 } }
+          end
+
+          it 'raises an exception' do
+            expect {
+              result
+            }.to raise_exception(Mongo::Error::UnsupportedCollation)
+          end
+        end
+      end
+    end
+
     context 'when a collation is not specified' do
 
       let(:selector) do