mongo 2.0.6 → 2.1.0

data/spec/mongo/bulk_write_spec.rb

@@ -0,0 +1,428 @@
+require 'spec_helper'
+
+describe Mongo::BulkWrite do
+
+  before do
+    authorized_collection.delete_many
+  end
+
+  after do
+    authorized_collection.delete_many
+  end
+
+  describe '#execute' do
+
+    shared_examples_for 'an executable bulk write' do
+
+      context 'when providing a bad operation' do
+
+        let(:requests) do
+          [{ not_an_operation: { _id: 0 }}]
+        end
+
+        it 'raises an exception' do
+          expect {
+            bulk_write.execute
+          }.to raise_error(Mongo::Error::InvalidBulkOperationType)
+        end
+      end
+
+      context 'when the operations do not need to be split' do
+
+        context 'when a write error occurs' do
+
+          let(:requests) do
+            [
+              { insert_one: { _id: 0 }},
+              { insert_one: { _id: 1 }},
+              { insert_one: { _id: 0 }},
+              { insert_one: { _id: 1 }}
+            ]
+          end
+
+          let(:error) do
+            begin
+              bulk_write.execute
+            rescue => e
+              e
+            end
+          end
+
+          it 'raises an exception' do
+            expect {
+              bulk_write.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
+
+          it 'sets the document index on the error' do
+            expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(2)
+          end
+        end
+
+        context 'when provided a single insert one' do
+
+          let(:requests) do
+            [{ insert_one: { _id: 0 }}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          it 'inserts the document' do
+            expect(result.inserted_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).count).to eq(1)
+          end
+        end
+
+        context 'when provided multiple insert ones' do
+
+          let(:requests) do
+            [
+              { insert_one: { _id: 0 }},
+              { insert_one: { _id: 1 }},
+              { insert_one: { _id: 2 }}
+            ]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          it 'inserts the documents' do
+            expect(result.inserted_count).to eq(3)
+            expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(3)
+          end
+        end
+
+        context 'when provided a single delete one' do
+
+          let(:requests) do
+            [{ delete_one: { filter: { _id: 0 }}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'deletes the document' do
+            expect(result.deleted_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).count).to eq(0)
+          end
+        end
+
+        context 'when provided multiple delete ones' do
+
+          let(:requests) do
+            [
+              { delete_one: { filter: { _id: 0 }}},
+              { delete_one: { filter: { _id: 1 }}},
+              { delete_one: { filter: { _id: 2 }}}
+            ]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_many([
+              { _id: 0 }, { _id: 1 }, { _id: 2 }
+            ])
+          end
+
+          it 'deletes the documents' do
+            expect(result.deleted_count).to eq(3)
+            expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(0)
+          end
+        end
+
+        context 'when provided a single delete many' do
+
+          let(:requests) do
+            [{ delete_many: { filter: { _id: 0 }}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'deletes the documents' do
+            expect(result.deleted_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).count).to eq(0)
+          end
+        end
+
+        context 'when provided multiple delete many ops' do
+
+          let(:requests) do
+            [
+              { delete_many: { filter: { _id: 0 }}},
+              { delete_many: { filter: { _id: 1 }}},
+              { delete_many: { filter: { _id: 2 }}}
+            ]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_many([
+              { _id: 0 }, { _id: 1 }, { _id: 2 }
+            ])
+          end
+
+          it 'deletes the documents' do
+            expect(result.deleted_count).to eq(3)
+            expect(authorized_collection.find(_id: { '$in'=> [ 0, 1, 2 ]}).count).to eq(0)
+          end
+        end
+
+        context 'when providing a single replace one' do
+
+          let(:requests) do
+            [{ replace_one: { filter: { _id: 0 }, replacement: { name: 'test' }}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'replaces the document' do
+            expect(result.modified_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+          end
+        end
+
+        context 'when providing a single update one' do
+
+          let(:requests) do
+            [{ update_one: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'updates the document' do
+            expect(result.modified_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+          end
+        end
+
+        context 'when providing a single update many' do
+
+          let(:requests) do
+            [{ update_many: { filter: { _id: 0 }, update: { "$set" => { name: 'test' }}}}]
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          before do
+            authorized_collection.insert_one({ _id: 0 })
+          end
+
+          it 'updates the documents' do
+            expect(result.modified_count).to eq(1)
+            expect(authorized_collection.find(_id: 0).first[:name]).to eq('test')
+          end
+        end
+      end
+
+      context 'when the operations need to be split' do
+
+        context 'when a write error occurs' do
+
+          let(:requests) do
+            1001.times.map do |i|
+              { insert_one: { _id: i }}
+            end
+          end
+
+          let(:error) do
+            begin
+              bulk_write.execute
+            rescue => e
+              e
+            end
+          end
+
+          it 'raises an exception' do
+            expect {
+              requests.push({ insert_one: { _id: 5 }})
+              bulk_write.execute
+            }.to raise_error(Mongo::Error::BulkWriteError)
+          end
+
+          it 'sets the document index on the error' do
+            requests.push({ insert_one: { _id: 5 }})
+            expect(error.result[Mongo::Error::WRITE_ERRORS].first['index']).to eq(1001)
+          end
+        end
+
+        context 'when no write errors occur' do
+
+          let(:requests) do
+            1001.times.map do |i|
+              { insert_one: { _id: i }}
+            end
+          end
+
+          let(:result) do
+            bulk_write.execute
+          end
+
+          it 'inserts the documents' do
+            expect(result.inserted_count).to eq(1001)
+          end
+        end
+      end
+
+      context 'when an operation exceeds the max bson size' do
+
+        let(:requests) do
+          5.times.map do |i|
+            { insert_one: { _id: i, x: 'y' * 4000000 }}
+          end
+        end
+
+        let(:result) do
+          bulk_write.execute
+        end
+
+        it 'inserts the documents' do
+          expect(result.inserted_count).to eq(5)
+        end
+      end
+    end
+
+    context 'when the bulk write is unordered' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests, ordered: false)
+      end
+
+      it_behaves_like 'an executable bulk write'
+    end
+
+    context 'when the bulk write is ordered' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests, ordered: true)
+      end
+
+      it_behaves_like 'an executable bulk write'
+    end
+  end
+
+  describe '#initialize' do
+
+    let(:requests) do
+      [{ insert_one: { _id: 0 }}]
+    end
+
+    shared_examples_for 'a bulk write initializer' do
+
+      it 'sets the collection' do
+        expect(bulk_write.collection).to eq(authorized_collection)
+      end
+
+      it 'sets the requests' do
+        expect(bulk_write.requests).to eq(requests)
+      end
+    end
+
+    context 'when no options are provided' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests)
+      end
+
+      it 'sets empty options' do
+        expect(bulk_write.options).to be_empty
+      end
+
+      it_behaves_like 'a bulk write initializer'
+    end
+
+    context 'when options are provided' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests, ordered: true)
+      end
+
+      it 'sets the options' do
+        expect(bulk_write.options).to eq(ordered: true)
+      end
+    end
+
+    context 'when nil options are provided' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, requests, nil)
+      end
+
+      it 'sets empty options' do
+        expect(bulk_write.options).to be_empty
+      end
+    end
+  end
+
+  describe '#ordered?' do
+
+    context 'when no option provided' do
+
+      let(:bulk_write) do
+        described_class.new(authorized_collection, [])
+      end
+
+      it 'returns true' do
+        expect(bulk_write).to be_ordered
+      end
+    end
+
+    context 'when the option is provided' do
+
+      context 'when the option is true' do
+
+        let(:bulk_write) do
+          described_class.new(authorized_collection, [], ordered: true)
+        end
+
+        it 'returns true' do
+          expect(bulk_write).to be_ordered
+        end
+      end
+
+      context 'when the option is false' do
+
+        let(:bulk_write) do
+          described_class.new(authorized_collection, [], ordered: false)
+        end
+
+        it 'returns false' do
+          expect(bulk_write).to_not be_ordered
+        end
+      end
+    end
+  end
+end

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
@@ -163,16 +167,20 @@ describe Mongo::Client do
         ['127.0.0.1:27017'],
         :read => { :mode => :primary },
         :local_threshold_ms => 10,
-        :server_selection_timeout_ms => 10000,
+        :server_selection_timeout => 10000,
         :database => TEST_DB
       )
     end
 
+    let(:options) do
+      Mongo::Options::Redacted.new(:read => { :mode => :primary },
+                                    :local_threshold_ms => 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
 
@@ -323,7 +381,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 +400,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 +458,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
@@ -448,6 +534,17 @@ describe Mongo::Client do
 
   describe '#with' do
 
+    let(:client) do
+      described_class.new(['127.0.0.1:27017'], :database => TEST_DB)
+    end
+
+    context 'when providing nil' do
+
+      it 'returns the cloned client' do
+        expect(client.with(nil)).to eq(client)
+      end
+    end
+
     context 'when the write concern is not changed' do
 
       let(:client) do
@@ -461,20 +558,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
@@ -543,7 +648,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
 
@@ -592,4 +697,49 @@ describe Mongo::Client do
         end).to include('admin')
     end
   end
+
+    describe '#close' do
+
+    let(:client) do
+      described_class.new(['127.0.0.1:27017'])
+    end
+
+    before do
+      expect(client.cluster).to receive(:disconnect!).and_call_original
+    end
+
+    it 'disconnects the cluster and returns true' do
+      expect(client.close).to be(true)
+    end
+  end
+
+  describe '#reconnect' do
+
+    let(:client) do
+      described_class.new(['127.0.0.1:27017'])
+    end
+
+    before do
+      expect(client.cluster).to receive(:reconnect!).and_call_original
+    end
+
+    it 'reconnects the cluster and returns true' do
+      expect(client.reconnect).to be(true)
+    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
 end