mongo 2.1.0.beta → 2.2.0

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
@@ -162,17 +166,21 @@ describe Mongo::Client do
       described_class.new(
         ['127.0.0.1:27017'],
         :read => { :mode => :primary },
-        :local_threshold_ms => 10,
-        :server_selection_timeout_ms => 10000,
+        :local_threshold => 10,
+        :server_selection_timeout => 10000,
         :database => TEST_DB
       )
     end
 
+    let(:options) do
+      Mongo::Options::Redacted.new(:read => { :mode => :primary },
+                                    :local_threshold => 10,
+                                    :server_selection_timeout => 10000,
+                                    :database => TEST_DB)
+    end
+
     let(:expected) do
-      [client.cluster, { :read => { :mode => :primary },
-                         :local_threshold_ms => 10,
-                         :server_selection_timeout_ms => 10000,
-                         :database => TEST_DB }].hash
+      [client.cluster, options].hash
     end
 
     it 'returns a hash of the cluster and options' do
@@ -195,6 +203,23 @@ describe Mongo::Client do
         "<Mongo::Client:0x#{client.object_id} cluster=127.0.0.1:27017"
       )
     end
+
+    context 'when there is sensitive data in the options' do
+
+      let(:client) do
+        described_class.new(
+            ['127.0.0.1:27017'],
+            :read => { :mode => :primary },
+            :database => TEST_DB,
+            :password => 'some_password',
+            :user => 'emily'
+        )
+      end
+
+      it 'does not print out sensitive data' do
+        expect(client.inspect).not_to match('some_password')
+      end
+    end
   end
 
   describe '#initialize' do
@@ -222,6 +247,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
@@ -266,8 +312,12 @@ describe Mongo::Client do
           described_class.new(uri)
         end
 
+        let(:expected_options) do
+          Mongo::Options::Redacted.new(:write => { :w => 3 }, :database => 'testdb')
+        end
+
         it 'sets the options' do
-          expect(client.options).to eq(:write => { :w => 3 }, :database => 'testdb')
+          expect(client.options).to eq(expected_options)
         end
       end
 
@@ -281,8 +331,12 @@ describe Mongo::Client do
           described_class.new(uri, :write => { :w => 3 })
         end
 
+        let(:expected_options) do
+          Mongo::Options::Redacted.new(:write => { :w => 3 }, :database => 'testdb')
+        end
+
         it 'sets the options' do
-          expect(client.options).to eq(:write => { :w => 3 }, :database => 'testdb')
+          expect(client.options).to eq(expected_options)
         end
       end
 
@@ -296,8 +350,12 @@ describe Mongo::Client do
           described_class.new(uri, :write => { :w => 4 })
         end
 
+        let(:expected_options) do
+          Mongo::Options::Redacted.new(:write => { :w => 4 }, :database => 'testdb')
+        end
+
         it 'allows explicit options to take preference' do
-          expect(client.options).to eq(:write => { :w => 4 }, :database => 'testdb')
+          expect(client.options).to eq(expected_options)
         end
       end
 
@@ -315,6 +373,26 @@ describe Mongo::Client do
           expect(client.cluster.topology).to be_a(Mongo::Cluster::Topology::ReplicaSet)
         end
       end
+
+      context 'when an invalid option is provided' do
+
+        let(:client) do
+          described_class.new(['127.0.0.1:27017'], :ssl => false, :invalid => :test)
+        end
+
+        it 'does not set the option' do
+          expect(client.options.keys).not_to include('invalid')
+        end
+
+        it 'sets the valid options' do
+          expect(client.options.keys).to include('ssl')
+        end
+
+        it 'warns that an invalid option has been specified' do
+          expect(Mongo::Logger.logger).to receive(:warn)
+          expect(client.options.keys).not_to include('invalid')
+        end
+      end
     end
   end
 
@@ -323,7 +401,8 @@ describe Mongo::Client do
     let(:client) do
       described_class.new(['127.0.0.1:27017'],
                           :database => TEST_DB,
-                          :read => mode)
+                          :read => mode,
+                          :server_selection_timeout => 2)
     end
 
     let(:preference) do
@@ -341,7 +420,7 @@ describe Mongo::Client do
       end
 
       it 'passes the options to the read preference' do
-        expect(preference.options[:database]).to eq(TEST_DB)
+        expect(preference.options[:server_selection_timeout]).to eq(2)
       end
     end
 
@@ -399,6 +478,33 @@ describe Mongo::Client do
         expect(preference).to be_a(Mongo::ServerSelector::Primary)
       end
     end
+
+    context 'when the read preference is printed' do
+
+      let(:client) do
+        described_class.new([ DEFAULT_ADDRESS ], options)
+      end
+
+      let(:options) do
+        { user: 'Emily', password: 'sensitive_data', server_selection_timeout: 0.1 }
+      end
+
+      before do
+        allow(client.database.cluster).to receive(:single?).and_return(false)
+      end
+
+      let(:error) do
+        begin
+          client.database.command(ping: 1)
+        rescue => e
+          e
+        end
+      end
+
+      it 'redacts sensitive client options' do
+        expect(error.message).not_to match(options[:password])
+      end
+    end
   end
 
   describe '#use' do
@@ -472,20 +578,28 @@ describe Mongo::Client do
         client.with(:read => { :mode => :primary })
       end
 
+      let(:new_options) do
+        Mongo::Options::Redacted.new(:read => { :mode => :primary },
+                                             :write => { :w => 1 },
+                                             :database => TEST_DB)
+      end
+
+      let(:original_options) do
+        Mongo::Options::Redacted.new(:read => { :mode => :secondary },
+                                             :write => { :w => 1 },
+                                             :database => TEST_DB)
+      end
+
       it 'returns a new client' do
         expect(new_client).not_to equal(client)
       end
 
       it 'replaces the existing options' do
-        expect(new_client.options).to eq({
-          :read => { :mode => :primary }, :write => { :w => 1 }, :database => TEST_DB
-        })
+        expect(new_client.options).to eq(new_options)
       end
 
       it 'does not modify the original client' do
-        expect(client.options).to eq({
-          :read => { :mode => :secondary }, :write => { :w => 1 }, :database => TEST_DB
-        })
+        expect(client.options).to eq(original_options)
       end
 
       it 'keeps the same cluster' do
@@ -530,6 +644,26 @@ describe Mongo::Client do
         end
       end
     end
+
+    context 'when an invalid option is provided' do
+
+      let(:new_client) do
+        client.with(invalid: :option, ssl: false)
+      end
+
+      it 'does not set the invalid option' do
+        expect(new_client.options.keys).not_to include('invalid')
+      end
+
+      it 'sets the valid options' do
+        expect(new_client.options.keys).to include('ssl')
+      end
+
+      it 'warns that an invalid option has been specified' do
+        expect(Mongo::Logger.logger).to receive(:warn)
+        expect(new_client.options.keys).not_to include('invalid')
+      end
+    end
   end
 
   describe '#write_concern' do
@@ -540,8 +674,8 @@ describe Mongo::Client do
 
       let(:client) { described_class.new(['127.0.0.1:27017'], :database => TEST_DB) }
 
-      it 'returns a acknowledged write concern' do
-        expect(concern.get_last_error).to eq(:getlasterror => 1, :w => 1)
+      it 'does not set the write concern' do
+        expect(concern).to be_nil
       end
     end
 
@@ -554,7 +688,7 @@ describe Mongo::Client do
         end
 
         it 'returns a acknowledged write concern' do
-          expect(concern.get_last_error).to eq(:getlasterror => 1, :j => true)
+          expect(concern.get_last_error).to eq(:getlasterror => 1, 'j' => true)
         end
       end
 
@@ -577,8 +711,10 @@ describe Mongo::Client do
             described_class.new(['127.0.0.1:27017'], :write => { :w => -1 }, :database => TEST_DB)
           end
 
-          it 'returns an unacknowledged write concern' do
-            expect(concern.get_last_error).to be_nil
+          it 'raises an error' do
+            expect {
+              concern
+            }.to raise_error(Mongo::Error::InvalidWriteConcern)
           end
         end
       end
@@ -631,7 +767,41 @@ describe Mongo::Client do
 
     it 'reconnects the cluster and returns true' do
       expect(client.reconnect).to be(true)
-      sleep(2)
+    end
+  end
+
+  describe '#dup' do
+
+    let(:client) do
+      described_class.new(
+          ['127.0.0.1:27017'],
+          :read => { :mode => :primary },
+          :database => TEST_DB
+      )
+    end
+
+    it 'creates a client with Redacted options' do
+      expect(client.dup.options).to be_a(Mongo::Options::Redacted)
+    end
+  end
+
+  describe '#collections' do
+
+    before do
+      authorized_client.database[:users].create
+    end
+
+    after do
+      authorized_client.database[:users].drop
+    end
+
+    let(:collection) do
+      Mongo::Collection.new(authorized_client.database, 'users')
+    end
+
+    it 'refers the current database collections' do
+      expect(authorized_client.collections).to include(collection)
+      expect(authorized_client.collections).to all(be_a(Mongo::Collection))
     end
   end
 end

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/builder/find_command_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::Builder::FindCommand do
+
+  describe '#specification' do
+
+    let(:view) do
+      Mongo::Collection::View.new(authorized_collection, filter, options)
+    end
+
+    let(:builder) do
+      described_class.new(view)
+    end
+
+    let(:specification) do
+      builder.specification
+    end
+
+    let(:selector) do
+      specification[:selector]
+    end
+
+    context 'when the options are standard' do
+
+      let(:filter) do
+        { 'name' => 'test' }
+      end
+
+      let(:options) do
+        {
+          sort: { _id: 1 },
+          projection: { name: 1 },
+          hint: { name: 1 },
+          skip: 10,
+          limit: 20,
+          batch_size: 5,
+          single_batch: false,
+          comment: "testing",
+          max_scan: 200,
+          max_time_ms: 40,
+          max_value: { name: 'joe' },
+          min_value: { name: 'albert' },
+          return_key: true,
+          show_disk_loc: true,
+          snapshot: true,
+          tailable: true,
+          oplog_replay: true,
+          no_cursor_timeout: true,
+          await_data: true,
+          allow_partial_results: true,
+          read_concern: { level: 'local' }
+        }
+      end
+
+      it 'maps the collection name' do
+        expect(selector['find']).to eq(authorized_collection.name)
+      end
+
+      it 'maps the filter' do
+        expect(selector['filter']).to eq(filter)
+      end
+
+      it 'maps sort' do
+        expect(selector['sort']).to eq('_id' => 1)
+      end
+
+      it 'maps projection' do
+        expect(selector['projection']).to eq('name' => 1)
+      end
+
+      it 'maps hint' do
+        expect(selector['hint']).to eq('name' => 1)
+      end
+
+      it 'maps skip' do
+        expect(selector['skip']).to eq(10)
+      end
+
+      it 'maps limit' do
+        expect(selector['limit']).to eq(20)
+      end
+
+      it 'maps batch size' do
+        expect(selector['batchSize']).to eq(5)
+      end
+
+      it 'maps single batch' do
+        expect(selector['singleBatch']).to be false
+      end
+
+      it 'maps comment' do
+        expect(selector['comment']).to eq('testing')
+      end
+
+      it 'maps max scan' do
+        expect(selector['maxScan']).to eq(200)
+      end
+
+      it 'maps max time ms' do
+        expect(selector['maxTimeMS']).to eq(40)
+      end
+
+      it 'maps max' do
+        expect(selector['max']).to eq('name' => 'joe')
+      end
+
+      it 'maps min' do
+        expect(selector['min']).to eq('name' => 'albert')
+      end
+
+      it 'maps read concern' do
+        expect(selector['readConcern']).to eq('level' => 'local')
+      end
+
+      it 'maps return key' do
+        expect(selector['returnKey']).to be true
+      end
+
+      it 'maps show record id' do
+        expect(selector['showRecordId']).to be true
+      end
+
+      it 'maps snapshot' do
+        expect(selector['snapshot']).to be true
+      end
+
+      it 'maps tailable' do
+        expect(selector['tailable']).to be true
+      end
+
+      it 'maps oplog replay' do
+        expect(selector['oplogReplay']).to be true
+      end
+
+      it 'maps no cursor timeout' do
+        expect(selector['noCursorTimeout']).to be true
+      end
+
+      it 'maps await data' do
+        expect(selector['awaitData']).to be true
+      end
+
+      it 'maps allow partial results' do
+        expect(selector['allowPartialResults']).to be true
+      end
+    end
+
+    context 'when limit is negative' do
+
+      let(:filter) do
+        { 'name' => 'test' }
+      end
+
+      let(:options) do
+        { limit: -1 }
+      end
+
+      it 'sets single batch to true' do
+        expect(selector['singleBatch']).to be true
+      end
+
+      it 'removes the limit from the command' do
+        expect(selector['limit']).to be_nil
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Mongo::Collection::View::Builder::Flags do
+
+  describe '.map_flags' do
+
+    shared_examples_for 'a flag mapper' do
+
+      let(:flags) do
+        described_class.map_flags(options)
+      end
+
+      it 'maps allow partial results' do
+        expect(flags).to include(:partial)
+      end
+
+      it 'maps oplog replay' do
+        expect(flags).to include(:oplog_replay)
+      end
+
+      it 'maps no cursor timeout' do
+        expect(flags).to include(:no_cursor_timeout)
+      end
+
+      it 'maps tailable' do
+        expect(flags).to include(:tailable_cursor)
+      end
+
+      it 'maps await data' do
+        expect(flags).to include(:await_data)
+      end
+
+      it 'maps exhaust' do
+        expect(flags).to include(:exhaust)
+      end
+    end
+
+    context 'when the options are standard' do
+
+      let(:options) do
+        {
+          :allow_partial_results => true,
+          :oplog_replay => true,
+          :no_cursor_timeout => true,
+          :tailable => true,
+          :await_data => true,
+          :exhaust => true
+        }
+      end
+
+      it_behaves_like 'a flag mapper'
+    end
+
+    context 'when the options already have flags' do
+
+      let(:options) do
+        {
+          :flags => [
+            :partial,
+            :oplog_replay,
+            :no_cursor_timeout,
+            :tailable_cursor,
+            :await_data,
+            :exhaust
+          ]
+        }
+      end
+
+      it_behaves_like 'a flag mapper'
+    end
+
+    context 'when the options include tailable_await' do
+
+      let(:options) do
+        { :tailable_await => true }
+      end
+
+      let(:flags) do
+        described_class.map_flags(options)
+      end
+
+      it 'maps the await data option' do
+        expect(flags).to include(:await_data)
+      end
+
+      it 'maps the tailable option' do
+        expect(flags).to include(:tailable_cursor)
+      end
+    end
+
+    context 'when the options provide a cursor type' do
+
+      let(:options) do
+        { :cursor_type => :await_data }
+      end
+
+      let(:flags) do
+        described_class.map_flags(options)
+      end
+
+      it 'maps the cursor type to a flag' do
+        expect(flags).to include(:await_data)
+      end
+    end
+  end
+end