mongo 2.0.6 → 2.1.0

data/spec/mongo/options/redacted_spec.rb

@@ -0,0 +1,350 @@
+require 'spec_helper'
+
+describe Mongo::Options::Redacted do
+
+  let(:options) do
+    described_class.new(original_opts)
+  end
+
+  describe '#to_s' do
+
+    context 'when the hash contains a sensitive key' do
+
+      let(:original_opts) do
+        { password: 'sensitive_data' }
+      end
+
+      it 'replaces the value with the redacted string' do
+        expect(options.to_s).not_to match(original_opts[:password])
+      end
+
+      it 'replaces the value with the redacted string' do
+        expect(options.to_s).to match(Mongo::Options::Redacted::STRING_REPLACEMENT)
+      end
+    end
+
+    context 'when the hash does not contain a sensitive key' do
+
+      let(:original_opts) do
+        { user: 'emily' }
+      end
+
+      it 'prints all the values' do
+        expect(options.to_s).to match(original_opts[:user])
+      end
+    end
+  end
+
+  describe '#inspect' do
+
+    context 'when the hash contains a sensitive key' do
+
+      let(:original_opts) do
+        { password: 'sensitive_data' }
+      end
+
+      it 'replaces the value with the redacted string' do
+        expect(options.inspect).not_to match(original_opts[:password])
+      end
+
+      it 'replaces the value with the redacted string' do
+        expect(options.inspect).to match(Mongo::Options::Redacted::STRING_REPLACEMENT)
+      end
+    end
+
+    context 'when the hash does not contain a sensitive key' do
+
+      let(:original_opts) do
+        { name: 'some_name' }
+      end
+
+      it 'does not replace the value with the redacted string' do
+        expect(options.inspect).to match(original_opts[:name])
+      end
+
+      it 'does not replace the value with the redacted string' do
+        expect(options.inspect).not_to match(Mongo::Options::Redacted::STRING_REPLACEMENT)
+      end
+    end
+  end
+
+  describe '#has_key?' do
+
+    context 'when the original key is a String' do
+
+      let(:original_opts) do
+        { 'name' => 'Emily' }
+      end
+
+      context 'when the method argument is a String' do
+
+        it 'returns true' do
+          expect(options.has_key?('name')).to be(true)
+        end
+      end
+
+      context 'when method argument is a Symbol' do
+
+        it 'returns true' do
+          expect(options.has_key?(:name)).to be(true)
+        end
+      end
+    end
+
+    context 'when the original key is a Symbol' do
+
+      let(:original_opts) do
+        { name: 'Emily' }
+      end
+
+      context 'when the method argument is a String' do
+
+        it 'returns true' do
+          expect(options.has_key?('name')).to be(true)
+        end
+      end
+
+      context 'when method argument is a Symbol' do
+
+        it 'returns true' do
+          expect(options.has_key?(:name)).to be(true)
+        end
+      end
+    end
+
+    context 'when the hash does not contain the key' do
+
+      let(:original_opts) do
+        { other: 'Emily' }
+      end
+
+      context 'when the method argument is a String' do
+
+        it 'returns false' do
+          expect(options.has_key?('name')).to be(false)
+        end
+      end
+
+      context 'when method argument is a Symbol' do
+
+        it 'returns false' do
+          expect(options.has_key?(:name)).to be(false)
+        end
+      end
+    end
+  end
+
+  describe '#reject' do
+
+    let(:options) do
+      described_class.new(a: 1, b: 2, c: 3)
+    end
+
+    context 'when no block is provided' do
+
+      it 'returns an enumerable' do
+        expect(options.reject).to be_a(Enumerator)
+      end
+    end
+
+    context 'when a block is provided' do
+
+      context 'when the block evaluates to true for some pairs' do
+
+        let(:result) do
+          options.reject { |k,v| k == 'a' }
+        end
+
+        it 'returns an object consisting of only the remaining pairs' do
+          expect(result).to eq(described_class.new(b: 2, c: 3))
+        end
+
+        it 'returns a new object' do
+          expect(result).not_to be(options)
+        end
+      end
+
+      context 'when the block does not evaluate to true for any pairs' do
+
+        let(:result) do
+          options.reject { |k,v| k == 'd' }
+        end
+
+        it 'returns an object with all pairs intact' do
+          expect(result).to eq(described_class.new(a: 1, b: 2, c: 3))
+        end
+
+        it 'returns a new object' do
+          expect(result).not_to be(options)
+        end
+      end
+    end
+  end
+
+  describe '#reject!' do
+
+    let(:options) do
+      described_class.new(a: 1, b: 2, c: 3)
+    end
+
+    context 'when no block is provided' do
+
+      it 'returns an enumerable' do
+        expect(options.reject).to be_a(Enumerator)
+      end
+    end
+
+    context 'when a block is provided' do
+
+      context 'when the block evaluates to true for some pairs' do
+
+        let(:result) do
+          options.reject! { |k,v| k == 'a' }
+        end
+
+        it 'returns an object consisting of only the remaining pairs' do
+          expect(result).to eq(described_class.new(b: 2, c: 3))
+        end
+
+        it 'returns the same object' do
+          expect(result).to be(options)
+        end
+      end
+
+      context 'when the block does not evaluate to true for any pairs' do
+
+        let(:result) do
+          options.reject! { |k,v| k == 'd' }
+        end
+
+        it 'returns nil' do
+          expect(result).to be(nil)
+        end
+      end
+    end
+  end
+
+  describe '#select' do
+
+    let(:options) do
+      described_class.new(a: 1, b: 2, c: 3)
+    end
+
+    context 'when no block is provided' do
+
+      it 'returns an enumerable' do
+        expect(options.reject).to be_a(Enumerator)
+      end
+    end
+
+    context 'when a block is provided' do
+
+      context 'when the block evaluates to true for some pairs' do
+
+        let(:result) do
+          options.select { |k,v| k == 'a' }
+        end
+
+        it 'returns an object consisting of those pairs' do
+          expect(result).to eq(described_class.new(a: 1))
+        end
+
+        it 'returns a new object' do
+          expect(result).not_to be(options)
+        end
+      end
+
+      context 'when the block does not evaluate to true for any pairs' do
+
+        let(:result) do
+          options.select { |k,v| k == 'd' }
+        end
+
+        it 'returns an object with no pairs' do
+          expect(result).to eq(described_class.new)
+        end
+
+        it 'returns a new object' do
+          expect(result).not_to be(options)
+        end
+      end
+
+      context 'when the object is unchanged' do
+
+        let(:options) do
+          described_class.new(a: 1, b: 2, c: 3)
+        end
+
+        let(:result) do
+          options.select { |k,v| ['a', 'b', 'c'].include?(k) }
+        end
+
+        it 'returns a new object' do
+          expect(result).to eq(described_class.new(a: 1, b: 2, c: 3))
+        end
+      end
+    end
+  end
+
+  describe '#select!' do
+
+    let(:options) do
+      described_class.new(a: 1, b: 2, c: 3)
+    end
+
+    context 'when no block is provided' do
+
+      it 'returns an enumerable' do
+        expect(options.reject).to be_a(Enumerator)
+      end
+    end
+
+    context 'when a block is provided' do
+
+      context 'when the block evaluates to true for some pairs' do
+
+        let(:result) do
+          options.select! { |k,v| k == 'a' }
+        end
+
+        it 'returns an object consisting of those pairs' do
+          expect(result).to eq(described_class.new(a: 1))
+        end
+
+        it 'returns the same object' do
+          expect(result).to be(options)
+        end
+      end
+
+      context 'when the block does not evaluate to true for any pairs' do
+
+        let(:result) do
+          options.select! { |k,v| k == 'd' }
+        end
+
+        it 'returns an object with no pairs' do
+          expect(result).to eq(described_class.new)
+        end
+
+        it 'returns the same object' do
+          expect(result).to be(options)
+        end
+      end
+
+      context 'when the object is unchanged' do
+
+        let(:options) do
+          described_class.new(a: 1, b: 2, c: 3)
+        end
+
+        let(:result) do
+          options.select! { |k,v| ['a', 'b', 'c'].include?(k) }
+        end
+
+        it 'returns nil' do
+          expect(result).to be(nil)
+        end
+      end
+    end
+  end
+end

data/spec/mongo/protocol/kill_cursors_spec.rb

@@ -5,8 +5,10 @@ describe Mongo::Protocol::KillCursors do
   let(:opcode)     { 2007 }
   let(:cursor_ids) { [123, 456, 789] }
   let(:id_count)   { cursor_ids.size }
+  let(:collection) { TEST_COLL }
+  let(:database)   { TEST_DB }
   let(:message) do
-    described_class.new(cursor_ids)
+    described_class.new(collection, database, cursor_ids)
   end
 
   describe '#initialize' do
@@ -26,7 +28,7 @@ describe Mongo::Protocol::KillCursors do
 
       context 'when the cursor ids are equal' do
         let(:other) do
-          described_class.new(cursor_ids)
+          described_class.new(collection, database, cursor_ids)
         end
 
         it 'returns true' do
@@ -36,7 +38,7 @@ describe Mongo::Protocol::KillCursors do
 
       context 'when the cursor ids are not equal' do
         let(:other) do
-          described_class.new([123, 456])
+          described_class.new(collection, database, [123, 456])
         end
 
         it 'returns false' do

data/spec/mongo/protocol/query_spec.rb

@@ -1,3 +1,4 @@
+# encoding: UTF-8
 require 'spec_helper'
 
 describe Mongo::Protocol::Query do
@@ -15,7 +16,7 @@ describe Mongo::Protocol::Query do
 
   describe '#initialize' do
 
-    it 'sets the namepsace' do
+    it 'sets the namespace' do
       expect(message.namespace).to eq(ns)
     end
 
@@ -220,6 +221,19 @@ describe Mongo::Protocol::Query do
       it 'serializes the namespace' do
         expect(field).to be_cstring(ns)
       end
+
+      context 'when the namespace contains unicode characters' do
+        let(:field) { bytes[20..40] }
+
+        let(:coll) do
+          'områder'
+        end
+
+        it 'serializes the namespace' do
+          expect(field).to be_cstring(ns)
+        end
+
+      end
     end
 
     describe 'skip' do
@@ -282,33 +296,4 @@ describe Mongo::Protocol::Query do
       end
     end
   end
-
-  describe '#log_message' do
-
-    context 'when the selector is greater than LOG_STRING_LIMIT characters' do
-
-      let(:selector) do
-        'z'*260
-      end
-
-      it 'Only prints LOG_STRING_LIMIT number of characters' do
-        expect(message.log_message.scan(/z/).length).to eq(Mongo::Protocol::Query::LOG_STRING_LIMIT)
-      end
-    end
-
-    context 'when the selector cannot be inspected' do
-
-      let(:selector) do
-        'invalid string'
-      end
-
-      before do
-        allow(selector).to receive(:inspect).and_raise(ArgumentError)
-      end
-
-      it 'Does not include the selector in the log message' do
-        expect(message.log_message.scan(/invalid string/).length).to eq(0)
-      end
-    end
-  end
 end

data/spec/mongo/retryable_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe Mongo::Retryable do
+
+  let(:klass) do
+    Class.new do
+      include Mongo::Retryable
+
+      attr_reader :cluster
+      attr_reader :operation
+
+      def initialize(operation, cluster)
+        @operation = operation
+        @cluster = cluster
+      end
+
+      def read
+        read_with_retry do
+          operation.execute
+        end
+      end
+
+      def write
+        write_with_retry do
+          operation.execute
+        end
+      end
+    end
+  end
+
+  describe '#read_with_retry' do
+
+    let(:operation) do
+      double('operation')
+    end
+
+    let(:cluster) do
+      double('cluster')
+    end
+
+    let(:retryable) do
+      klass.new(operation, cluster)
+    end
+
+    context 'when no exception occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_return(true)
+      end
+
+      it 'executes the operation once' do
+        expect(retryable.read).to be true
+      end
+    end
+
+    context 'when a socket error occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(Mongo::Error::SocketError).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
+      end
+
+      it 'executes the operation twice' do
+        expect(retryable.read).to be true
+      end
+    end
+
+    context 'when a socket timeout error occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(Mongo::Error::SocketTimeoutError).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
+      end
+
+      it 'executes the operation twice' do
+        expect(retryable.read).to be true
+      end
+    end
+
+    context 'when an operation failure occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure).ordered
+      end
+
+      it 'raises an exception' do
+        expect {
+          retryable.read
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+
+  describe '#write_with_retry' do
+
+    let(:operation) do
+      double('operation')
+    end
+
+    let(:cluster) do
+      double('cluster')
+    end
+
+    let(:retryable) do
+      klass.new(operation, cluster)
+    end
+
+    context 'when no exception occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_return(true)
+      end
+
+      it 'executes the operation once' do
+        expect(retryable.write).to be true
+      end
+    end
+
+    context 'when a not master error occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure.new('not master')).ordered
+        expect(cluster).to receive(:scan!).and_return(true).ordered
+        expect(operation).to receive(:execute).and_return(true).ordered
+      end
+
+      it 'executes the operation twice' do
+        expect(retryable.write).to be true
+      end
+    end
+
+    context 'when a normal operation failure occurs' do
+
+      before do
+        expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure).ordered
+      end
+
+      it 'raises an exception' do
+        expect {
+          retryable.write
+        }.to raise_error(Mongo::Error::OperationFailure)
+      end
+    end
+  end
+end

data/spec/mongo/server/connection_pool/queue_spec.rb

@@ -47,6 +47,22 @@ describe Mongo::Server::ConnectionPool::Queue do
     end
   end
 
+  describe '#disconnect!' do
+
+    let(:connection) do
+      double('connection')
+    end
+
+    let(:queue) do
+      described_class.new(:max_pool_size => 1) { connection }
+    end
+
+    it 'disconnects all connections in the queue' do
+      expect(connection).to receive(:disconnect!)
+      queue.disconnect!
+    end
+  end
+
   describe '#enqueue' do
 
     let(:connection) do