mongo 2.3.1 → 2.4.0.rc0

data/spec/mongo/collection/view/builder/find_command_spec.rb

@@ -48,7 +48,8 @@ describe Mongo::Collection::View::Builder::FindCommand do
           no_cursor_timeout: true,
           await_data: true,
           allow_partial_results: true,
-          read_concern: { level: 'local' }
+          read_concern: { level: 'local' },
+          collation: { locale: 'en_US' }
         }
       end
 
@@ -143,258 +144,20 @@ describe Mongo::Collection::View::Builder::FindCommand do
       it 'maps allow partial results' do
         expect(selector['allowPartialResults']).to be true
       end
-    end
-
-
-    context 'when there is a limit' do
-
-      let(:filter) do
-        { 'name' => 'test' }
-      end
-
-      context 'when limit is 0' do
-
-        context 'when batch_size is also 0' do
-
-          let(:options) do
-            { limit: 0, batch_size: 0 }
-          end
-
-          it 'does not set the singleBatch' do
-            expect(selector['singleBatch']).to be nil
-          end
-
-          it 'does not set the limit' do
-            expect(selector['limit']).to be nil
-          end
-
-          it 'does not set the batch size' do
-            expect(selector['batchSize']).to be nil
-          end
-        end
-
-        context 'when batch_size is not set' do
-
-          let(:options) do
-            { limit: 0 }
-          end
-
-          it 'does not set the singleBatch' do
-            expect(selector['singleBatch']).to be nil
-          end
-
-          it 'does not set the limit' do
-            expect(selector['limit']).to be nil
-          end
-
-          it 'does not set the batch size' do
-            expect(selector['batchSize']).to be nil
-          end
-        end
-      end
-
-      context 'when the limit is negative' do
-
-        context 'when there is a batch_size' do
-
-          context 'when the batch_size is positive' do
-
-            let(:options) do
-              { limit: -1, batch_size: 3 }
-            end
-
-            it 'sets single batch to true' do
-              expect(selector['singleBatch']).to be true
-            end
-
-            it 'converts the limit to a positive value' do
-              expect(selector['limit']).to be(options[:limit].abs)
-            end
-
-            it 'sets the batch size' do
-              expect(selector['batchSize']).to be(options[:batch_size])
-            end
-          end
-
-          context 'when the batch_size is negative' do
-
-            let(:options) do
-              { limit: -1, batch_size: -3 }
-            end
-
-            it 'sets single batch to true' do
-              expect(selector['singleBatch']).to be true
-            end
-
-            it 'converts the limit to a positive value' do
-              expect(selector['limit']).to be(options[:limit].abs)
-            end
-
-            it 'sets the batch size to the limit' do
-              expect(selector['batchSize']).to be(options[:limit].abs)
-            end
-          end
-        end
-
-        context 'when there is not a batch_size' do
-
-          let(:options) do
-            { limit: -5 }
-          end
-
-          it 'sets single batch to true' do
-            expect(selector['singleBatch']).to be true
-          end
-
-          it 'converts the limit to a positive value' do
-            expect(selector['limit']).to be(options[:limit].abs)
-          end
-
-          it 'does not set the batch size' do
-            expect(selector['batchSize']).to be_nil
-          end
-        end
-      end
-
-      context 'when the limit is positive' do
-
-        context 'when there is a batch_size' do
 
-          context 'when the batch_size is positive' do
-
-            let(:options) do
-              { limit: 5, batch_size: 3 }
-            end
-
-            it 'does not set singleBatch' do
-              expect(selector['singleBatch']).to be nil
-            end
-
-            it 'sets the limit' do
-              expect(selector['limit']).to be(options[:limit])
-            end
-
-            it 'sets the batch size' do
-              expect(selector['batchSize']).to be(options[:batch_size])
-            end
-          end
-
-          context 'when the batch_size is negative' do
-
-            let(:options) do
-              { limit: 5, batch_size: -3 }
-            end
-
-            it 'sets the singleBatch' do
-              expect(selector['singleBatch']).to be true
-            end
-
-            it 'sets the limit' do
-              expect(selector['limit']).to be(options[:limit])
-            end
-
-            it 'sets the batch size to a positive value' do
-              expect(selector['batchSize']).to be(options[:batch_size].abs)
-            end
-          end
-        end
-
-        context 'when there is not a batch_size' do
-
-          let(:options) do
-            { limit: 5 }
-          end
-
-          it 'does not set the singleBatch' do
-            expect(selector['singleBatch']).to be nil
-          end
-
-          it 'sets the limit' do
-            expect(selector['limit']).to be(options[:limit])
-          end
-
-          it 'does not set the batch size' do
-            expect(selector['batchSize']).to be nil
-          end
-        end
-      end
-    end
-
-    context 'when there is a batch_size' do
-
-      let(:filter) do
-        { 'name' => 'test' }
-      end
-
-      context 'when there is no limit' do
-
-        context 'when the batch_size is positive' do
-
-          let(:options) do
-            { batch_size: 3 }
-          end
-
-          it 'does not set the singleBatch' do
-            expect(selector['singleBatch']).to be nil
-          end
-
-          it 'does not set the limit' do
-            expect(selector['limit']).to be nil
-          end
-
-          it 'sets the batch size' do
-            expect(selector['batchSize']).to be(options[:batch_size])
-          end
-        end
-
-        context 'when the batch_size is negative' do
-
-          let(:options) do
-            { batch_size: -3 }
-          end
-
-          it 'sets the singleBatch' do
-            expect(selector['singleBatch']).to be true
-          end
-
-          it 'does not set the limit' do
-            expect(selector['limit']).to be nil
-          end
-
-          it 'sets the batch size to a positive value' do
-            expect(selector['batchSize']).to be(options[:batch_size].abs)
-          end
-        end
-
-        context 'when batch_size is 0' do
-
-          let(:options) do
-            { batch_size: 0 }
-          end
-
-          it 'does not set the singleBatch' do
-            expect(selector['singleBatch']).to be nil
-          end
-
-          it 'does not set the limit' do
-            expect(selector['limit']).to be nil
-          end
-
-          it 'does not set the batch size' do
-            expect(selector['batchSize']).to be nil
-          end
-        end
+      it 'maps collation' do
+        expect(selector['collation']).to eq('locale' => 'en_US')
       end
     end
 
-    context 'when limit and batch_size are negative' do
+    context 'when limit is negative' do
 
       let(:filter) do
         { 'name' => 'test' }
       end
 
       let(:options) do
-        { limit: -1, batch_size: -3 }
+        { limit: -1 }
       end
 
       it 'sets single batch to true' do

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

@@ -335,6 +335,65 @@ describe Mongo::Collection::View::MapReduce do
           expect(Mongo::Logger.logger).to receive(:warn?).and_call_original
           map_reduce.to_a
         end
+
+        context 'when the view has a write concern' do
+
+          let(:collection) do
+            authorized_collection.with(write: { w: WRITE_CONCERN[:w]+1 })
+          end
+
+          let(:view) do
+            Mongo::Collection::View.new(collection, selector, view_options)
+          end
+
+          shared_examples_for 'map reduce that writes accepting write concern' do
+
+            context 'when the server supports write concern on the mapReduce command', if: (collation_enabled? && standalone?) do
+
+              it 'uses the write concern' do
+                expect {
+                  map_reduce.to_a
+                }.to raise_exception(Mongo::Error::OperationFailure)
+              end
+            end
+
+            context 'when the server does not support write concern on the mapReduce command', unless: collation_enabled? do
+
+              it 'does not apply the write concern' do
+                expect(map_reduce.to_a.size).to eq(2)
+              end
+            end
+          end
+
+          context 'when out is a String' do
+
+            let(:options) do
+              { :out => 'new-collection' }
+            end
+
+            it_behaves_like 'map reduce that writes accepting write concern'
+          end
+
+          context 'when out is a document and not inline' do
+
+            let(:options) do
+              { :out => { merge: 'exisiting-collection' } }
+            end
+
+            it_behaves_like 'map reduce that writes accepting write concern'
+          end
+
+          context 'when out is a document but inline is specified' do
+
+            let(:options) do
+              { :out => { inline: 1 } }
+            end
+
+            it 'does not use the write concern' do
+              expect(map_reduce.to_a.size).to eq(2)
+            end
+          end
+        end
       end
 
       context 'when the server is a valid for writing' do
@@ -426,4 +485,49 @@ describe Mongo::Collection::View::MapReduce do
       expect(map_reduce.send(:map_reduce_spec)[:read]).to eq(read_preference)
     end
   end
+
+  context 'when collation is specified' do
+
+    let(:map) do
+      %Q{
+         function() {
+           emit(this.name, 1);
+        }}
+    end
+
+    let(:reduce) do
+      %Q{
+         function(key, values) {
+           return Array.sum(values);
+        }}
+    end
+
+    before 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)
+      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)
+      end
+    end
+  end
 end

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

@@ -405,6 +405,41 @@ describe Mongo::Collection::View::Readable do
     it 'sets the max_time_ms option on the command', if: write_command_enabled? do
       expect(view.count(max_time_ms: 100)).to eq(10)
     end
+
+    context 'when a collation is specified' do
+
+      let(:selector) do
+        { name: 'BANG' }
+      end
+
+      let(:result) do
+        view.count(count_options)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+      end
+
+      let(:count_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
+      end
+    end
   end
 
   describe '#distinct' do
@@ -648,6 +683,54 @@ describe Mongo::Collection::View::Readable do
         expect(view.distinct(:nofieldexists)).to be_empty
       end
     end
+
+    context 'when a collation is specified' do
+
+      let(:result) do
+        view.distinct(:name, distinct_options)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+        authorized_collection.insert_one(name: 'BANG')
+      end
+
+      let(:distinct_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
+      end
+    end
+
+    context 'when a collation is not specified' do
+
+      let(:result) do
+        view.distinct(:name)
+      end
+
+      before do
+        authorized_collection.insert_one(name: 'bang')
+        authorized_collection.insert_one(name: 'BANG')
+      end
+
+      it 'does not apply the collation to the distinct' do
+        expect(result).to eq(['bang', 'BANG'])
+      end
+    end
   end
 
   describe '#hint' do