mongo 2.1.0.beta → 2.2.0

data/spec/mongo/retryable_spec.rb

@@ -0,0 +1,221 @@
+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 max_read_retries
+        cluster.max_read_retries
+      end
+
+      def read_retry_interval
+        cluster.read_retry_interval
+      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
+
+      context 'when the cluster is not a mongos' do
+
+        before do
+          expect(operation).to receive(:execute).and_raise(Mongo::Error::OperationFailure).ordered
+          expect(cluster).to receive(:sharded?).and_return(false)
+        end
+
+        it 'raises an exception' do
+          expect {
+            retryable.read
+          }.to raise_error(Mongo::Error::OperationFailure)
+        end
+      end
+
+      context 'when the cluster is a mongos' do
+
+        context 'when the operation failure is not retryable' do
+
+          let(:error) do
+            Mongo::Error::OperationFailure.new('not authorized')
+          end
+
+          before do
+            expect(operation).to receive(:execute).and_raise(error).ordered
+            expect(cluster).to receive(:sharded?).and_return(true)
+          end
+
+          it 'raises the exception' do
+            expect {
+              retryable.read
+            }.to raise_error(Mongo::Error::OperationFailure)
+          end
+        end
+
+        context 'when the operation failure is retryable' do
+
+          let(:error) do
+            Mongo::Error::OperationFailure.new('no master')
+          end
+
+          context 'when the retry succeeds' do
+
+            before do
+              expect(operation).to receive(:execute).and_raise(error).ordered
+              expect(cluster).to receive(:sharded?).and_return(true)
+              expect(cluster).to receive(:max_read_retries).and_return(1).ordered
+              expect(cluster).to receive(:read_retry_interval).and_return(0.1).ordered
+              expect(operation).to receive(:execute).and_return(true).ordered
+            end
+
+            it 'returns the result' do
+              expect(retryable.read).to be true
+            end
+          end
+
+          context 'when the retry fails once and then succeeds' do
+
+            before do
+              expect(operation).to receive(:execute).and_raise(error).ordered
+              expect(cluster).to receive(:sharded?).and_return(true)
+              expect(cluster).to receive(:max_read_retries).and_return(2).ordered
+              expect(cluster).to receive(:read_retry_interval).and_return(0.1).ordered
+              expect(operation).to receive(:execute).and_raise(error).ordered
+              expect(cluster).to receive(:sharded?).and_return(true)
+              expect(cluster).to receive(:max_read_retries).and_return(2).ordered
+              expect(cluster).to receive(:read_retry_interval).and_return(0.1).ordered
+              expect(operation).to receive(:execute).and_return(true).ordered
+            end
+
+            it 'returns the result' do
+              expect(retryable.read).to be true
+            end
+          end
+        end
+      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

data/spec/mongo/server/connection_pool_spec.rb

@@ -18,16 +18,25 @@ describe Mongo::Server::ConnectionPool do
     Mongo::Event::Listeners.new
   end
 
+  let(:cluster) do
+    double('cluster')
+  end
+
   describe '#checkin' do
 
     let(:server) do
-      Mongo::Server.new(address, double('cluster'), monitoring, listeners, options)
+      Mongo::Server.new(address, cluster, monitoring, listeners, options)
     end
 
     let!(:pool) do
       described_class.get(server)
     end
 
+    after do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      server.disconnect!
+    end
+
     context 'when a connection is checked out on the thread' do
 
       let!(:connection) do
@@ -51,7 +60,7 @@ describe Mongo::Server::ConnectionPool do
   describe '#checkout' do
 
     let(:server) do
-      Mongo::Server.new(address, double('cluster'), monitoring, listeners, options)
+      Mongo::Server.new(address, cluster, monitoring, listeners, options)
     end
 
     let!(:pool) do
@@ -96,31 +105,58 @@ describe Mongo::Server::ConnectionPool do
     end
   end
 
+  describe '#disconnect!' do
+
+    let(:server) do
+      Mongo::Server.new(address, cluster, monitoring, listeners, options)
+    end
+
+    let!(:pool) do
+      described_class.get(server)
+    end
+
+    it 'disconnects the queue' do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      expect(pool.send(:queue)).to receive(:disconnect!).once.and_call_original
+      server.disconnect!
+    end
+  end
+
   describe '.get' do
 
     let(:server) do
-      Mongo::Server.new(address, double('cluster'), monitoring, listeners, options)
+      Mongo::Server.new(address, cluster, monitoring, listeners, options)
     end
 
     let!(:pool) do
       described_class.get(server)
     end
 
+    after do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      server.disconnect!
+    end
+
     it 'returns the pool for the server' do
-      expect(pool).to eql(described_class.get(server))
+      expect(pool).to_not be_nil
     end
   end
 
   describe '#inspect' do
 
     let(:server) do
-      Mongo::Server.new(address, double('cluster'), monitoring, listeners, options)
+      Mongo::Server.new(address, cluster, monitoring, listeners, options)
     end
 
     let!(:pool) do
       described_class.get(server)
     end
 
+    after do
+      expect(cluster).to receive(:pool).with(server).and_return(pool)
+      server.disconnect!
+    end
+
     it 'includes the object id' do
       expect(pool.inspect).to include(pool.object_id.to_s)
     end
@@ -133,7 +169,7 @@ describe Mongo::Server::ConnectionPool do
   describe '#with_connection' do
 
     let(:server) do
-      Mongo::Server.new(address, double('cluster'), monitoring, listeners, options)
+      Mongo::Server.new(address, cluster, monitoring, listeners, options)
     end
 
     let!(:pool) do

data/spec/mongo/server/connection_spec.rb

@@ -14,8 +14,44 @@ describe Mongo::Server::Connection do
     Mongo::Event::Listeners.new
   end
 
+  let(:cluster) do
+    double('cluster')
+  end
+
   let(:server) do
-    Mongo::Server.new(address, double('cluster'), monitoring, listeners, TEST_OPTIONS)
+    Mongo::Server.new(address, cluster, monitoring, listeners, TEST_OPTIONS)
+  end
+
+  let(:pool) do
+    double('pool')
+  end
+
+  after do
+    expect(cluster).to receive(:pool).with(server).and_return(pool)
+    expect(pool).to receive(:disconnect!).and_return(true)
+    server.disconnect!
+  end
+
+  describe '#connectable?' do
+
+    context 'when the connection is not connectable' do
+
+      let(:bad_address) do
+        Mongo::Address.new('127.0.0.1:666')
+      end
+
+      let(:bad_server) do
+        Mongo::Server.new(bad_address, cluster, monitoring, listeners, TEST_OPTIONS)
+      end
+
+      let(:connection) do
+        described_class.new(bad_server)
+      end
+
+      it 'returns false' do
+        expect(connection).to_not be_connectable
+      end
+    end
   end
 
   describe '#connect!' do
@@ -203,6 +239,55 @@ describe Mongo::Server::Connection do
       end
     end
 
+    context 'when the message exceeds the max size' do
+
+      context 'when the message is an insert' do
+
+        before do
+          allow(connection).to receive(:max_message_size).and_return(200)
+        end
+
+        let(:documents) do
+          [{ 'name' => 'testing' } ] * 10
+        end
+
+        let(:reply) do
+          connection.dispatch([ insert ])
+        end
+
+        it 'checks the size against the max message size' do
+          expect {
+            reply
+          }.to raise_exception(Mongo::Error::MaxMessageSize)
+        end
+      end
+
+      context 'when the message is a command' do
+
+        before do
+          allow(connection).to receive(:max_bson_object_size).and_return(100)
+        end
+
+        let(:selector) do
+          { :getlasterror => '1' }
+        end
+
+        let(:command) do
+          Mongo::Protocol::Query.new(TEST_DB, '$cmd', selector, :limit => -1)
+        end
+
+        let(:reply) do
+          connection.dispatch([ command ])
+        end
+
+        it 'checks the size against the max bson size' do
+          expect {
+            reply
+          }.to raise_exception(Mongo::Error::MaxBSONSize)
+        end
+      end
+    end
+
     context 'when a network or socket error occurs' do
 
       let(:socket) do

data/spec/mongo/server/description/features_spec.rb

@@ -56,6 +56,31 @@ describe Mongo::Server::Description::Features do
     end
   end
 
+  describe '#find_command_enabled?' do
+
+    context 'when the wire range includes 4' do
+
+      let(:features) do
+        described_class.new(0..4)
+      end
+
+      it 'returns true' do
+        expect(features).to be_find_command_enabled
+      end
+    end
+
+    context 'when the wire range does not include 4' do
+
+      let(:features) do
+        described_class.new(0..2)
+      end
+
+      it 'returns false' do
+        expect(features).to_not be_find_command_enabled
+      end
+    end
+  end
+
   describe '#list_collections_enabled?' do
 
     context 'when the wire range includes 3' do

data/spec/mongo/server/description_spec.rb

@@ -617,6 +617,48 @@ describe Mongo::Server::Description do
     end
   end
 
+  describe '#me_mismatch?' do
+
+    let(:description) do
+      described_class.new(address, config)
+    end
+
+    context 'when the server address matches the me field' do
+
+      let(:config) do
+        replica.merge('me' => address.to_s)
+      end
+
+      it 'returns false' do
+        expect(description.me_mismatch?).to be(false)
+      end
+    end
+
+    context 'when the server address does not match the me field' do
+
+      let(:config) do
+        replica.merge('me' => 'localhost:27020')
+      end
+
+      it 'returns true' do
+        expect(description.me_mismatch?).to be(true)
+      end
+    end
+
+    context 'when there is no me field' do
+
+      let(:config) do
+        replica.tap do |r|
+          r.delete('me')
+        end
+      end
+
+      it 'returns false' do
+        expect(description.me_mismatch?).to be(false)
+      end
+    end
+  end
+
   describe '#lists_server?' do
 
     let(:description) do

data/spec/mongo/server/monitor_spec.rb

@@ -171,4 +171,48 @@ describe Mongo::Server::Monitor do
       end
     end
   end
+
+  describe '#stop' do
+
+    let(:monitor) do
+      described_class.new(address, listeners, TEST_OPTIONS)
+    end
+
+    let!(:thread) do
+      monitor.run!
+    end
+
+    before do
+      expect(monitor.connection).to receive(:disconnect!).and_call_original
+      monitor.stop!
+      sleep(1)
+    end
+
+    it 'kills the monitor thread' do
+      expect(thread.stop?).to be(true)
+    end
+  end
+
+  describe '#connection' do
+
+    context 'when there is a connect_timeout option set' do
+
+      let(:connect_timeout) do
+        1
+      end
+
+      let(:monitor) do
+        described_class.new(address, listeners, TEST_OPTIONS.merge(connect_timeout: connect_timeout))
+      end
+
+      it 'sets the value as the timeout on the connection' do
+        expect(monitor.connection.timeout).to eq(connect_timeout)
+      end
+
+      it 'set the value as the timeout on the socket' do
+        monitor.connection.connect!
+        expect(monitor.connection.send(:socket).timeout).to eq(connect_timeout)
+      end
+    end
+  end
 end

data/spec/mongo/server_discovery_and_monitoring_spec.rb

@@ -11,40 +11,26 @@ describe 'Server Discovery and Monitoring' do
 
       before(:all) do
 
-        # We monkey-patch the address, so that looking up the spec's hostname does
-        # not throw an error.
-        #
-        # @since 2.0.0
-        class Mongo::Address
-          private
-
-          def family(host)
-            fam = host == 'localhost' ? ::Socket::AF_INET : ::Socket::AF_UNSPEC
-            ::Socket.getaddrinfo(host, nil, fam, ::Socket::SOCK_STREAM).first[4]
-          rescue SocketError
-          end
-        end
+        module Mongo
+          # We monkey-patch the server here, so the monitors do not run and no
+          # real TCP connection is attempted. Thus we can control the server
+          # descriptions per-phase.
+          #
+          # @since 2.0.0
+          class Server
+
+            alias :original_initialize :initialize
+            def initialize(address, cluster, monitoring, event_listeners, options = {})
+              @address = address
+              @cluster = cluster
+              @monitoring = monitoring
+              @options = options.freeze
+              @monitor = Monitor.new(address, event_listeners, options)
+            end
 
-        # We monkey-patch the server here, so the monitors do not run and no
-        # real TCP connection is attempted. Thus we can control the server
-        # descriptions per-phase.
-        #
-        # @since 2.0.0
-        class Mongo::Server
-
-          # The constructor keeps the same API, but does not instantiate a
-          # monitor and run it.
-          def initialize(address, cluster, monitoring, event_listeners, options = {})
-            @address = address
-            @cluster = cluster
-            @monitoring = monitoring
-            @options = options.freeze
-            @monitor = Monitor.new(address, event_listeners, options)
+            alias :original_disconnect! :disconnect!
+            def disconnect!; true; end
           end
-
-          # Disconnect simply needs to return true since we have no monitor and
-          # no connection.
-          def disconnect!; true; end
         end
 
         # Client is set as an instance variable inside the scope of the spec to
@@ -54,37 +40,17 @@ describe 'Server Discovery and Monitoring' do
       end
 
       after(:all) do
+        @client.close
 
         # Return the server implementation to its original for the other
         # tests in the suite.
-        class Mongo::Server
-
-          # Returns the constructor to its original implementation.
-          def initialize(address, cluster, monitoring, event_listeners, options = {})
-            @address = address
-            @cluster = cluster
-            @monitoring = monitoring
-            @options = options.freeze
-            @monitor = Monitor.new(address, event_listeners, options)
-            @monitor.scan!
-            @monitor.run!
-          end
-
-          # Returns disconnect! to its original implementation.
-          def disconnect!
-            context.with_connection do |connection|
-              connection.disconnect!
-            end
-            @monitor.stop! and true
-          end
-        end
-
-        class Mongo::Address
-          private
+        module Mongo
+          class Server
+            alias :initialize :original_initialize
+            remove_method(:original_initialize)
 
-          def family(host)
-            fam = host == 'localhost' ? ::Socket::AF_INET : ::Socket::AF_UNSPEC
-            ::Socket.getaddrinfo(host, nil, fam, ::Socket::SOCK_STREAM).first[4]
+            alias :disconnect! :original_disconnect!
+            remove_method(:original_disconnect!)
           end
         end
       end