mongo 2.1.0.beta → 2.1.0.rc0

data/spec/mongo/client_spec.rb

@@ -20,6 +20,10 @@ describe Mongo::Client do
       )
     end
 
+    after do
+      client.close
+    end
+
     context 'when the other is a client' do
 
       context 'when the options and cluster are equal' do
@@ -222,6 +226,27 @@ describe Mongo::Client do
           expect(client[:users].name).to eq('users')
         end
       end
+
+      context 'when providing a custom logger' do
+
+        let(:logger) do
+          Logger.new($stdout).tap do |l|
+            l.level = Logger::FATAL
+          end
+        end
+
+        let(:client) do
+          authorized_client.with(logger: logger)
+        end
+
+        after do
+          client.close
+        end
+
+        it 'does not use the global logger' do
+          expect(client.cluster.logger).to_not eq(Mongo::Logger.logger)
+        end
+      end
     end
 
     context 'when providing a connection string' do

data/spec/mongo/cluster/topology/replica_set_spec.rb

@@ -239,6 +239,7 @@ describe Mongo::Cluster::Topology::ReplicaSet do
         double('description').tap do |d|
           allow(d).to receive(:config).and_return({ 'ismaster' => true })
           allow(d).to receive(:primary?).and_return(false)
+          allow(d).to receive(:me_mismatch?).and_return(false)
           allow(d).to receive(:hosts).and_return([])
         end
       end
@@ -257,6 +258,7 @@ describe Mongo::Cluster::Topology::ReplicaSet do
           allow(d).to receive(:hosts).and_return([ primary ])
           allow(d).to receive(:replica_set_name).and_return('test')
           allow(d).to receive(:replica_set_member?).and_return(true)
+          allow(d).to receive(:me_mismatch?).and_return(false)
         end
       end
 

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

@@ -300,4 +300,69 @@ describe Mongo::Collection::View::Aggregation do
       end
     end
   end
+
+  context 'when $out is in the pipeline', if: write_command_enabled? do
+
+    let(:pipeline) do
+      [{
+           "$group" => {
+               "_id" => "$city",
+               "totalpop" => { "$sum" => "$pop" }
+           }
+       },
+       {
+           '$out' => 'output_collection'
+       }
+      ]
+    end
+
+    after do
+      authorized_client['output_collection'].delete_many
+    end
+
+    context 'when $out is a string' do
+
+      it 'does not allow the operation on a secondary' do
+        expect(aggregation.send(:secondary_ok?)).to be(false)
+      end
+    end
+
+    context 'when $out is a symbol' do
+
+      let(:pipeline) do
+        [{
+             "$group" => {
+                 "_id" => "$city",
+                 "totalpop" => { "$sum" => "$pop" }
+             }
+         },
+         {
+             :$out => 'output_collection'
+         }
+        ]
+      end
+
+      it 'does not allow the operation on a secondary' do
+        expect(aggregation.send(:secondary_ok?)).to be(false)
+      end
+    end
+
+
+    context 'when the context is not a valid server for writing' do
+
+     it 'reroutes the operation to a primary' do
+       allow(aggregation).to receive(:valid_server?).and_return(false)
+       expect(Mongo::Logger.logger).to receive(:warn?).and_call_original
+       aggregation.to_a
+     end
+    end
+
+    context 'when the context is a valid server for writing' do
+
+     it 'does not reroute the operation to a primary' do
+       expect(Mongo::Logger.logger).not_to receive(:warn?)
+       aggregation.to_a
+     end
+    end
+  end
 end

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

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::Immutable do
+
+  let(:selector) do
+    {}
+  end
+
+  let(:options) do
+    {}
+  end
+
+  let(:view) do
+    Mongo::Collection::View.new(authorized_collection, selector, options)
+  end
+
+  after do
+    authorized_collection.delete_many
+  end
+
+  describe '#configure' do
+
+    context 'when the options has a modifiers document' do
+
+      let(:options) do
+        { modifiers: { :$maxTimeMS => 500 } }
+      end
+
+      let(:new_view) do
+        view.projection(_id: 1)
+      end
+
+      it 'returns a new view' do
+        expect(view).not_to be(new_view)
+      end
+
+      it 'creates a new options hash' do
+        expect(view.options).not_to be(new_view.options)
+      end
+
+      it 'keeps the modifier fields already in the options hash' do
+        expect(new_view.modifiers[:$maxTimeMS]).to eq(500)
+      end
+
+      it 'sets the option' do
+        expect(new_view.projection).to eq(_id: 1)
+      end
+
+      it 'creates a new modifiers document' do
+        expect(view.modifiers).not_to be(new_view.modifiers)
+      end
+    end
+  end
+
+  describe '#configure_modifier' do
+
+    let(:new_view) do
+      view.sort('x' => Mongo::Index::ASCENDING)
+    end
+
+    context 'when the options does not have a modifiers document' do
+
+      it 'returns a new view' do
+        expect(view).not_to be(new_view)
+      end
+
+      it 'returns a new view with the modifiers document containing the option' do
+        expect(new_view.modifiers[:$orderby]).to eq({ 'x' => Mongo::Index::ASCENDING })
+      end
+    end
+
+    context 'when the options has a modifiers document' do
+
+      let(:options) do
+        { modifiers: { :$maxTimeMS => 500 } }
+      end
+
+      it 'returns a new view' do
+        expect(view).not_to be(new_view)
+      end
+
+      it 'creates a new options hash' do
+        expect(view.options).not_to be(new_view.options)
+      end
+
+      it 'keeps the fields already in the options hash and merges in the new one' do
+        expect(new_view.modifiers[:$maxTimeMS]).to eq(500)
+      end
+
+      it 'sets the new value in the new view modifier document' do
+        expect(new_view.modifiers[:$orderby]).to eq('x' => Mongo::Index::ASCENDING)
+      end
+
+      it 'returns that value when the corresponding option method is called' do
+        expect(new_view.sort).to eq({ 'x' => Mongo::Index::ASCENDING })
+      end
+
+      it 'creates a new modifiers document' do
+        expect(view.modifiers).not_to be(new_view.modifiers)
+      end
+    end
+  end
+end

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

@@ -66,6 +66,39 @@ describe Mongo::Collection::View::MapReduce do
       end
     end
 
+    context 'when out is in the options' do
+
+      after do
+        authorized_client['output_collection'].delete_many
+      end
+
+      context 'when out is a string' do
+
+        let(:options) do
+          { :out => 'output_collection' }
+        end
+
+        it 'iterates over the documents in the result' do
+          map_reduce.each do |document|
+            expect(document[:value]).to_not be_nil
+          end
+        end
+      end
+
+      context 'when out is a document' do
+
+        let(:options) do
+          { :out => {  replace: 'output_collection' } }
+        end
+
+        it 'iterates over the documents in the result' do
+          map_reduce.each do |document|
+            expect(document[:value]).to_not be_nil
+          end
+        end
+      end
+    end
+
     context 'when out is inline' do
 
       let(:new_map_reduce) do
@@ -82,7 +115,7 @@ describe Mongo::Collection::View::MapReduce do
     context 'when out is a collection' do
 
       after do
-        authorized_client['output_collection'].find.delete_many
+        authorized_client['output_collection'].delete_many
       end
 
       context 'when the option is to replace' do
@@ -135,6 +168,17 @@ describe Mongo::Collection::View::MapReduce do
           expect(new_map_reduce.count).to eq(2)
         end
       end
+
+      context 'when the option is a collection name' do
+
+        let(:new_map_reduce) do
+          map_reduce.out('output_collection')
+        end
+
+        it 'fetches the results from the collection' do
+          expect(new_map_reduce.count).to eq(2)
+        end
+      end
     end
 
     context 'when the view has a selector' do
@@ -169,7 +213,7 @@ describe Mongo::Collection::View::MapReduce do
         end
 
         it 'includes the selector in the operation spec' do
-          expect(map_reduce.send(:map_reduce_spec)[:selector][:query]).to eq(selector[:$query])
+          expect(map_reduce.send(:map_reduce_spec)[:selector][:query]).to eq(BSON::Document.new(selector[:$query]))
         end
       end
     end
@@ -250,6 +294,57 @@ describe Mongo::Collection::View::MapReduce do
         expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to eq(inline: 1)
       end
     end
+
+    context 'when out is specified in the options' do
+
+      let(:location) do
+        { replace: 'testing' }
+      end
+
+      let(:options) do
+        { :out => location }
+      end
+
+      it 'sets the out value' do
+        expect(map_reduce.out).to eq(location)
+      end
+
+      it 'includes the out value in the operation spec' do
+        expect(map_reduce.send(:map_reduce_spec)[:selector][:out]).to be(location)
+      end
+    end
+
+    context 'when out is not inline' do
+
+      let(:location) do
+        { replace: 'testing' }
+      end
+
+      let(:options) do
+        { :out => location }
+      end
+
+      it 'does not allow the operation on a secondary' do
+        expect(map_reduce.send(:secondary_ok?)).to be(false)
+      end
+
+      context 'when the context is not a valid server for writing' do
+
+        it 'reroutes the operation to a primary' do
+          allow(map_reduce).to receive(:valid_server?).and_return(false)
+          expect(Mongo::Logger.logger).to receive(:warn?).and_call_original
+          map_reduce.to_a
+        end
+      end
+
+      context 'when the context is a valid server for writing' do
+
+        it 'does not reroute the operation to a primary' do
+          expect(Mongo::Logger.logger).not_to receive(:warn?)
+          map_reduce.to_a
+        end
+      end
+    end
   end
 
   describe '#scope' do
@@ -316,7 +411,7 @@ describe Mongo::Collection::View::MapReduce do
     end
 
     it 'includes the sort object in the operation spec' do
-      expect(map_reduce.send(:map_reduce_spec)[:selector][:sort]).to be(sort)
+      expect(map_reduce.send(:map_reduce_spec)[:selector][:sort][:name]).to eq(sort[:name])
     end
   end
 

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

@@ -465,53 +465,40 @@ describe Mongo::Collection::View::Readable do
     end
   end
 
-  describe '#no_cursor_timeout' do
+  describe '#max_value' do
 
     let(:new_view) do
-      view.no_cursor_timeout
+      view.max_value(_id: 1)
     end
 
-    it 'sets the flag' do
-      expect(new_view.send(:flags)).to include(:no_cursor_timeout)
-    end
-
-    it 'returns a new View' do
-      expect(new_view).not_to be(view)
+    it 'sets the value in the options' do
+      expect(new_view.max_value).to eq('_id' => 1)
     end
   end
 
-  describe '#parallel_scan', unless: sharded? do
+  describe '#min_value' do
 
-    let(:documents) do
-      (1..200).map do |i|
-        { name: "testing-scan-#{i}" }
-      end
+    let(:new_view) do
+      view.min_value(_id: 1)
     end
 
-    before do
-      authorized_collection.insert_many(documents)
+    it 'sets the value in the options' do
+      expect(new_view.min_value).to eq('_id' => 1)
     end
+  end
 
-    let(:cursors) do
-      view.parallel_scan(2)
-    end
+  describe '#no_cursor_timeout' do
 
-    it 'returns an array of cursors', if: write_command_enabled? do
-      cursors.each do |cursor|
-        expect(cursor.class).to be(Mongo::Cursor)
-      end
+    let(:new_view) do
+      view.no_cursor_timeout
     end
 
-    it 'returns the correct number of documents', if: write_command_enabled? do
-      expect(
-        cursors.reduce(0) { |total, cursor| total + cursor.to_a.size }
-      ).to eq(200)
+    it 'sets the flag' do
+      expect(new_view.send(:flags)).to include(:no_cursor_timeout)
     end
 
-    it 'raises an error', unless: write_command_enabled? do
-      expect {
-        cursors
-      }.to raise_error(Mongo::Error::OperationFailure)
+    it 'returns a new View' do
+      expect(new_view).not_to be(view)
     end
   end
 

data/spec/mongo/collection/view_spec.rb

@@ -18,6 +18,180 @@ describe Mongo::Collection::View do
     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
 
     context 'when the other object is not a collection view' do
@@ -165,7 +339,7 @@ describe Mongo::Collection::View do
         end
 
         it 'sets the batch size on the initial query' do
-          expect(query_spec[:options][:limit]).to eq(options[:batch_size])
+          expect(query_spec[:options][:batch_size]).to eq(options[:batch_size])
         end
 
         it 'returns all the documents' do
@@ -232,7 +406,11 @@ describe Mongo::Collection::View do
         end
 
         it 'sets the batch size on the initial query' do
-          expect(query_spec[:options][:limit]).to eq(options[:batch_size])
+          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
@@ -396,7 +574,6 @@ describe Mongo::Collection::View do
       context 'when the cluster is sharded', if: sharded? do
 
         before do
-          allow(authorized_collection.cluster).to receive(:sharded?).and_return(true)
           expect(view).to receive(:special_selector).and_call_original
         end
 
@@ -405,6 +582,40 @@ describe Mongo::Collection::View do
             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 a modifier document is provided' do
@@ -541,14 +752,11 @@ describe Mongo::Collection::View do
             end
 
             it 'overrides the modifier value with the option value' do
-              expect(query_spec[:selector][:$query]).to eq(selector)
+              expect(query_spec[:selector][:$query]).to eq(options[:modifiers][:$query])
             end
           end
-
-
         end
       end
-
     end
 
     context 'when there are no special fields' do
@@ -578,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