mongo 2.0.6 → 2.1.0

data/spec/mongo/collection/view_spec.rb

@@ -15,7 +15,181 @@ describe Mongo::Collection::View do
   end
 
   after do
-    authorized_collection.find.delete_many
+    authorized_collection.delete_many
+  end
+
+  context 'when query modifiers are provided' do
+
+    context 'when a selector has a query modifier' do
+
+      let(:options) do
+        {}
+      end
+
+      let(:expected_modifiers) do
+        BSON::Document.new(selector)
+      end
+
+      let(:parsed_selector) do
+        {}
+      end
+
+      let(:query_selector) do
+        BSON::Document.new(selector)
+      end
+
+      context 'when the $query key is a string' do
+
+        let(:selector) do
+          { "$query" => { a: 1 }, :$someMod => 100 }
+        end
+
+        let(:expected_modifiers) do
+          BSON::Document.new(selector)
+        end
+
+        it 'sets the modifiers' do
+          expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
+        end
+
+        it 'removes the modifiers from the selector' do
+          expect(view.selector).to eq(parsed_selector)
+        end
+
+        it 'creates the correct query selector' do
+          expect(view.send(:query_spec)[:selector]).to eq(query_selector)
+        end
+
+      end
+
+      context 'when the $query key is a symbol' do
+
+        let(:selector) do
+          { :$query => { a: 1 }, :$someMod => 100 }
+        end
+
+        let(:expected_modifiers) do
+          BSON::Document.new(selector)
+        end
+
+        it 'sets the modifiers' do
+          expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
+        end
+
+        it 'removes the modifiers from the selector' do
+          expect(view.selector).to eq(parsed_selector)
+        end
+
+        it 'creates the correct query selector' do
+          expect(view.send(:query_spec)[:selector]).to eq(query_selector)
+        end
+      end
+    end
+
+    context 'when a modifiers document is provided in the options' do
+
+      let(:selector) do
+        { a: 1 }
+      end
+
+      let(:options) do
+        { :modifiers => { :$someMod => 100 } }
+      end
+
+      let(:expected_modifiers) do
+        options[:modifiers]
+      end
+
+      let(:parsed_selector) do
+        { a: 1 }
+      end
+
+      let(:query_selector) do
+        BSON::Document.new(:$query => { a: 1 }, :$someMod => 100)
+      end
+
+      it 'sets the modifiers' do
+        expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
+      end
+
+      it 'removes the modifiers from the selector' do
+        expect(view.selector).to eq(parsed_selector)
+      end
+
+      it 'creates the correct query selector' do
+        expect(view.send(:query_spec)[:selector]).to eq(query_selector)
+      end
+
+      context 'when modifiers and options are both provided' do
+
+        let(:selector) do
+          { a: 1 }
+        end
+
+        let(:options) do
+          { :sort =>  { a: Mongo::Index::ASCENDING }, :modifiers => { :$orderby => { a: Mongo::Index::DESCENDING } } }
+        end
+
+        let(:expected_modifiers) do
+          { :$orderby => options[:sort] }
+        end
+
+        let(:parsed_selector) do
+          { a: 1 }
+        end
+
+        let(:query_selector) do
+          BSON::Document.new(:$query => selector, :$orderby => { a: Mongo::Index::ASCENDING })
+        end
+
+        it 'sets the modifiers' do
+          expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
+        end
+
+        it 'removes the modifiers from the selector' do
+          expect(view.selector).to eq(parsed_selector)
+        end
+
+        it 'creates the correct query selector' do
+          expect(view.send(:query_spec)[:selector]).to eq(query_selector)
+        end
+      end
+
+      context 'when modifiers, options and a query modifier are provided' do
+
+        let(:selector) do
+          { b: 2, :$query => { a: 1 }, :$someMod => 100 }
+        end
+
+        let(:options) do
+          { :sort =>  { a: Mongo::Index::ASCENDING }, :modifiers => { :$someMod => true, :$orderby => { a: Mongo::Index::DESCENDING } } }
+        end
+
+        let(:expected_modifiers) do
+          { :$query => { a: 1 }, :$orderby => { a: Mongo::Index::ASCENDING }, :$someMod => 100 }
+        end
+
+        let(:parsed_selector) do
+          { b: 2 }
+        end
+
+        let(:query_selector) do
+          BSON::Document.new(:$query => { a: 1 }, :$someMod => 100, :$orderby => { a: Mongo::Index::ASCENDING })
+        end
+
+        it 'sets the modifiers' do
+          expect(view.instance_variable_get(:@modifiers)).to eq(expected_modifiers)
+        end
+
+        it 'removes the modifiers from the selector' do
+          expect(view.selector).to eq(parsed_selector)
+        end
+
+        it 'creates the correct query selector' do
+          expect(view.send(:query_spec)[:selector]).to eq(query_selector)
+        end
+      end
+    end
   end
 
   describe '#==' do
@@ -116,32 +290,38 @@ describe Mongo::Collection::View do
     end
 
     after do
-      authorized_collection.find.delete_many
+      authorized_collection.delete_many
     end
 
     context 'when sending the initial query' do
 
+      let(:returned) do
+        view.to_a
+      end
+
+      let(:query_spec) do
+        view.send(:query_spec)
+      end
+
       context 'when limit is specified' do
 
         let(:options) do
           { :limit => 5 }
         end
 
-        before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:options][:limit]).to eq(options[:limit])
-          end.and_call_original
-        end
-
         let(:returned) do
           view.to_a
         end
 
+        it 'sets the limit on the initial query' do
+          expect(query_spec[:options][:limit]).to eq(options[:limit])
+        end
+
         it 'returns limited documents' do
           expect(returned.count).to eq(5)
         end
 
-        it 'allows iteration of the documents' do
+        it 'iterates over all of the documents' do
           returned.each do |doc|
             expect(doc).to have_key('field')
           end
@@ -154,21 +334,19 @@ describe Mongo::Collection::View do
           { :batch_size => 5 }
         end
 
-        before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:options][:limit]).to eq(options[:batch_size])
-          end.and_call_original
-        end
-
         let(:returned) do
           view.to_a
         end
 
+        it 'sets the batch size on the initial query' do
+          expect(query_spec[:options][:batch_size]).to eq(options[:batch_size])
+        end
+
         it 'returns all the documents' do
           expect(returned.count).to eq(10)
         end
 
-        it 'allows iteration of all documents' do
+        it 'iterates over all of the documents' do
           returned.each do |doc|
             expect(doc).to have_key('field')
           end
@@ -177,21 +355,15 @@ describe Mongo::Collection::View do
 
       context 'when no limit is specified' do
 
-        before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:options][:limit]).to eq(nil)
-          end.and_call_original
-        end
-
-        let(:returned) do
-          view.to_a
+        it 'does not set a limit on the initial query' do
+          expect(query_spec[:options][:limit]).to be_nil
         end
 
         it 'returns all the documents' do
           expect(returned.count).to eq(10)
         end
 
-        it 'allows iteration of all documents' do
+        it 'iterates over all of the documents' do
           returned.each do |doc|
             expect(doc).to have_key('field')
           end
@@ -204,21 +376,19 @@ describe Mongo::Collection::View do
           { :batch_size => 5, :limit => 3 }
         end
 
-        before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:options][:limit]).to eq(options[:limit])
-          end.and_call_original
-        end
-
         let(:returned) do
           view.to_a
         end
 
+        it 'sets the limit on the initial query' do
+          expect(query_spec[:options][:limit]).to eq(options[:limit])
+        end
+
         it 'returns the limit of documents' do
           expect(returned.count).to eq(3)
         end
 
-        it 'allows iteration of the documents' do
+        it 'iterates over all of the documents' do
           returned.each do |doc|
             expect(doc).to have_key('field')
           end
@@ -231,21 +401,23 @@ describe Mongo::Collection::View do
           { :limit => 5, :batch_size => 3 }
         end
 
-        before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:options][:limit]).to eq(options[:batch_size])
-          end.and_call_original
-        end
-
         let(:returned) do
           view.to_a
         end
 
+        it 'sets the batch size on the initial query' do
+          expect(query_spec[:options][:batch_size]).to eq(options[:batch_size])
+        end
+
+        it 'sets the limit on the initial query' do
+          expect(query_spec[:options][:limit]).to eq(options[:limit])
+        end
+
         it 'returns the limit of documents' do
           expect(returned.count).to eq(5)
         end
 
-        it 'allows iteration of the documents' do
+        it 'iterates over all of the documents' do
           returned.each do |doc|
             expect(doc).to have_key('field')
           end
@@ -254,20 +426,22 @@ describe Mongo::Collection::View do
 
       context 'when the selector has special fields' do
 
-        context 'when a snapshot option is provided' do
+        context 'when a snapshot option is specified' do
 
           let(:options) do
             { :snapshot => true }
           end
 
           before do
-            expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-              expect(spec[:selector][:$query]).to eq(selector)
-            end.and_call_original
+            expect(view).to receive(:special_selector).and_call_original
           end
 
           it 'creates a special query selector' do
-            view.each do |doc|
+            expect(query_spec[:selector][:$snapshot]).to eq(options[:snapshot])
+          end
+
+          it 'iterates over all of the documents' do
+            returned.each do |doc|
               expect(doc).to have_key('field')
             end
           end
@@ -280,13 +454,36 @@ describe Mongo::Collection::View do
           end
 
           before do
-            expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-              expect(spec[:selector][:$query]).to eq(selector)
-            end.and_call_original
+            expect(view).to receive(:special_selector).and_call_original
           end
 
           it 'creates a special query selector' do
-            view.each do |doc|
+            expect(query_spec[:selector][:$maxScan]).to eq(options[:max_scan])
+          end
+
+          it 'iterates over all of the documents' do
+            returned.each do |doc|
+              expect(doc).to have_key('field')
+            end
+          end
+        end
+
+        context 'when a max_time_ms option is provided' do
+
+          let(:options) do
+            { :max_time_ms => 100 }
+          end
+
+          before do
+            expect(view).to receive(:special_selector).and_call_original
+          end
+
+          it 'creates a special query selector' do
+            expect(query_spec[:selector][:$maxTimeMS]).to eq(options[:max_time_ms])
+          end
+
+          it 'iterates over all of the documents' do
+            returned.each do |doc|
               expect(doc).to have_key('field')
             end
           end
@@ -299,15 +496,16 @@ describe Mongo::Collection::View do
           end
 
           before do
-            expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-              expect(spec[:selector][:$query]).to eq(selector)
-            end.and_call_original
+            expect(view).to receive(:special_selector).and_call_original
           end
 
           it 'creates a special query selector' do
-            view.each do |doc|
+            expect(query_spec[:selector][:$showDiskLoc]).to eq(options[:show_disk_loc])
+          end
+
+          it 'iterates over all of the documents' do
+            returned.each do |doc|
               expect(doc).to have_key('field')
-              break
             end
           end
         end
@@ -320,13 +518,15 @@ describe Mongo::Collection::View do
         end
 
         before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:selector][:$query]).to eq(selector)
-          end.and_call_original
+          expect(view).to receive(:special_selector).and_call_original
         end
 
         it 'creates a special query selector' do
-          view.each do |doc|
+          expect(query_spec[:selector][:$orderby]).to eq(options[:sort])
+        end
+
+        it 'iterates over all of the documents' do
+          returned.each do |doc|
             expect(doc).to have_key('field')
           end
         end
@@ -341,15 +541,11 @@ describe Mongo::Collection::View do
           end
 
           before do
-            expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-              expect(spec[:selector][:$query]).to eq(selector)
-            end.and_call_original
+            expect(view).to receive(:special_selector).and_call_original
           end
 
-          it'creates a special query selector' do
-            expect {
-              view.to_a
-            }.to raise_error(Mongo::Error::OperationFailure)
+          it 'creates a special query selector' do
+            expect(query_spec[:selector][:$hint]).to eq(options[:hint])
           end
         end
       end
@@ -361,31 +557,205 @@ describe Mongo::Collection::View do
         end
 
         before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:selector][:$query]).to eq(selector)
-          end.and_call_original
+          expect(view).to receive(:special_selector).and_call_original
         end
 
         it 'creates a special query selector' do
+          expect(query_spec[:selector][:$comment]).to eq(options[:comment])
+        end
+
+        it 'iterates over all of the documents' do
+          returned.each do |doc|
+            expect(doc).to have_key('field')
+          end
+        end
+      end
+
+      context 'when the cluster is sharded', if: sharded? do
+
+        before do
+          expect(view).to receive(:special_selector).and_call_original
+        end
+
+        it 'iterates over all of the documents' do
           view.each do |doc|
             expect(doc).to have_key('field')
           end
         end
+
+        context 'when there is a read preference' do
+
+          let(:collection) do
+            authorized_collection.with(read: { mode: :secondary})
+          end
+
+          let(:view) do
+            described_class.new(collection, selector, options)
+          end
+
+          let(:formatted_read_pref) do
+            BSON::Document.new(Mongo::ServerSelector.get(mode: :secondary).to_mongos)
+          end
+
+          it 'adds the formatted read preference to the selector' do
+            expect(view.send(:query_spec)[:selector][:$readPreference]).to eq(formatted_read_pref)
+          end
+        end
+
+        context 'when the read preference is primary' do
+
+          let(:collection) do
+            authorized_collection.with(read: { mode: :primary})
+          end
+
+          let(:view) do
+            described_class.new(collection, selector, options)
+          end
+
+          it 'does not add the formatted read preference to the selector' do
+            expect(view.send(:query_spec)[:selector][:$readPreference]).to be(nil)
+          end
+        end
       end
 
-      context 'when the cluster is sharded' do
+      context 'when a modifier document is provided' do
+
+        let(:options) do
+          { :modifiers => {
+                            :$orderby => {'x' => Mongo::Index::ASCENDING }
+                          }
+          }
+        end
 
         before do
-          expect(Mongo::Operation::Read::Query).to receive(:new) do |spec|
-            expect(spec[:selector][:$query]).to eq(selector)
-          end.and_call_original
+          expect(view).to receive(:special_selector).and_call_original
         end
 
         it 'creates a special query selector' do
+          expect(query_spec[:selector][:$orderby]).to eq(options[:modifiers][:$orderby])
+        end
+
+        it 'iterates over all of the documents' do
           view.each do |doc|
             expect(doc).to have_key('field')
           end
         end
+
+        context 'when $explain is specified' do
+          let(:options) do
+            { :modifiers => {
+                             :$explain => 1
+                            }
+            }
+          end
+
+          let(:explain) do
+            view.to_a.first
+          end
+
+          it 'executes an explain' do
+            expect(explain['cursor'] == 'BasicCursor' ||
+                       explain['queryPlanner']).to be_truthy
+          end
+
+        end
+
+        context 'when an option is also provided' do
+
+          context 'when $orderby and sort are specified' do
+
+            let(:options) do
+              { :modifiers => {
+                               :$orderby => { 'x' => Mongo::Index::ASCENDING }
+                              },
+                :sort => { 'x' => Mongo::Index::DESCENDING }
+              }
+            end
+
+            it 'overrides the modifier value with the option value' do
+              expect(query_spec[:selector][:$orderby]).to eq(options[:sort])
+            end
+          end
+
+          context 'when $comment and comment are specified' do
+
+            let(:options) do
+              { :modifiers => {
+                               :$comment => 'query1'
+                              },
+                :comment => 'query2'
+              }
+            end
+
+            it 'overrides the modifier value with the option value' do
+              expect(query_spec[:selector][:$comment]).to eq(options[:comment])
+            end
+          end
+
+          context 'when $hint and hint are specified' do
+
+            let(:options) do
+              { :modifiers => {
+                               :$hint => 'x'
+                              },
+                :hint => 'y'
+              }
+            end
+
+            it 'overrides the modifier value with the option value' do
+              expect(query_spec[:selector][:$hint]).to eq(options[:hint])
+            end
+
+          end
+
+          context 'when $maxScan and max_scan are specified' do
+
+            let(:options) do
+              { :modifiers => {
+                               :$maxScan => 4
+                              },
+                :max_scan => 5
+              }
+            end
+
+            it 'overrides the modifier value with the option value' do
+              expect(query_spec[:selector][:$maxScan]).to eq(options[:max_scan])
+            end
+          end
+
+          context 'when $maxTimeMS and max_time_ms are specified' do
+
+            let(:options) do
+              { :modifiers => {
+                               :$maxTimeMS => 100
+                              },
+                :max_time_ms => 200
+              }
+            end
+
+            it 'overrides the modifier value with the option value' do
+              expect(query_spec[:selector][:$maxTimeMS]).to eq(options[:max_time_ms])
+            end
+          end
+
+          context 'when $query and a selector are specified' do
+
+            let(:selector) do
+              { 'y' => 1 }
+            end
+
+            let(:options) do
+              { :modifiers => {
+                                :$query => { 'field' => 1 }
+                              }
+              }
+            end
+
+            it 'overrides the modifier value with the option value' do
+              expect(query_spec[:selector][:$query]).to eq(options[:modifiers][:$query])
+            end
+          end
+        end
       end
     end
 
@@ -416,6 +786,24 @@ describe Mongo::Collection::View do
         end
       end
     end
+
+    describe '#close_query' do
+
+      let(:options) do
+        { :batch_size => 1 }
+      end
+
+      before do
+        e = view.to_enum
+        e.next
+        cursor = view.instance_variable_get(:@cursor)
+        expect(cursor).to receive(:kill_cursors).and_call_original
+      end
+
+      it 'sends a kill cursors command for the cursor' do
+        view.close_query
+      end
+    end
   end
 
   describe '#hash' do