mongo 2.1.0.rc0 → 2.1.0

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

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

data/spec/mongo/server/connection_pool_spec.rb

@@ -28,6 +28,10 @@ describe Mongo::Server::ConnectionPool do
       described_class.get(server)
     end
 
+    after do
+      server.disconnect!
+    end
+
     context 'when a connection is checked out on the thread' do
 
       let!(:connection) do
@@ -96,6 +100,26 @@ describe Mongo::Server::ConnectionPool do
     end
   end
 
+  describe '#disconnect!' do
+
+    let(:server) do
+      Mongo::Server.new(address, double('cluster'), monitoring, listeners, options)
+    end
+
+    let!(:pool) do
+      described_class.get(server)
+    end
+
+    after do
+      server.disconnect!
+    end
+
+    it 'disconnects the queue' do
+      expect(pool.send(:queue)).to receive(:disconnect!).twice.and_call_original
+      pool.disconnect!
+    end
+  end
+
   describe '.get' do
 
     let(:server) do
@@ -106,6 +130,10 @@ describe Mongo::Server::ConnectionPool do
       described_class.get(server)
     end
 
+    after do
+      server.disconnect!
+    end
+
     it 'returns the pool for the server' do
       expect(pool).to eql(described_class.get(server))
     end
@@ -121,6 +149,10 @@ describe Mongo::Server::ConnectionPool do
       described_class.get(server)
     end
 
+    after do
+      server.disconnect!
+    end
+
     it 'includes the object id' do
       expect(pool.inspect).to include(pool.object_id.to_s)
     end

data/spec/mongo/server/connection_spec.rb

@@ -18,6 +18,43 @@ describe Mongo::Server::Connection do
     Mongo::Server.new(address, double('cluster'), monitoring, listeners, TEST_OPTIONS)
   end
 
+  after do
+    server.disconnect!
+  end
+
+  describe '#connectable?' do
+
+    # context 'when the connection is connectable' do
+
+    #   let(:connection) do
+    #     described_class.new(server)
+    #   end
+
+    #   it 'returns true' do
+    #     expect(connection).to be_connectable
+    #   end
+    # end
+
+    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, double('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
 
     context 'when no socket exists' do

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
@@ -58,34 +44,13 @@ describe 'Server Discovery and Monitoring' do
 
         # 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

data/spec/mongo/server_selection_rtt_spec.rb

@@ -8,80 +8,60 @@ describe 'Server Selection moving average round trip time calculation' do
 
     spec = Mongo::ServerSelection::RTT::Spec.new(file)
 
-    before(:all) do
-
-      module Mongo
-        class Server
-
-          # We monkey-patch the monitor here, so the last average rtt can be controlled.
-          # We keep the API of Monitor#initialize but add in an extra option and set the last rtt.
-          #
-          # @since 2.0.0
-          class Monitor
-
-            def initialize(address, listeners, options = {})
-              @description = Mongo::Server::Description.new(address, {})
-              @inspector = Mongo::Server::Description::Inspector.new(listeners)
-              @options = options.freeze
-              @connection = Connection.new(address, options)
-              @last_round_trip_time = options[:avg_rtt_ms]
-              @mutex = Mutex.new
-            end
+    context(spec.description) do
 
-            private
+      before(:all) do
 
-            # We monkey patch this method to use an instance variable instead of calculating time elapsed.
+        module Mongo
+          class Server
+
+            # We monkey-patch the monitor here, so the last average rtt can be controlled.
+            # We keep the API of Monitor#initialize but add in an extra option and set the last rtt.
             #
             # @since 2.0.0
-            def average_round_trip_time(start)
-              new_rtt = @new_rtt_ms
-              RTT_WEIGHT_FACTOR * new_rtt + (1 - RTT_WEIGHT_FACTOR) * (@last_round_trip_time || new_rtt)
+            class Monitor
+
+              alias :original_initialize :initialize
+              def initialize(address, listeners, options = {})
+                @description = Mongo::Server::Description.new(address, {})
+                @inspector = Mongo::Server::Description::Inspector.new(listeners)
+                @options = options.freeze
+                @connection = Connection.new(address, options)
+                @last_round_trip_time = options[:avg_rtt_ms]
+                @mutex = Mutex.new
+              end
+
+              # We monkey patch this method to use an instance variable instead of calculating time elapsed.
+              #
+              # @since 2.0.0
+              alias :original_average_round_trip_time :average_round_trip_time
+              def average_round_trip_time(start)
+                new_rtt = @new_rtt_ms
+                RTT_WEIGHT_FACTOR * new_rtt + (1 - RTT_WEIGHT_FACTOR) * (@last_round_trip_time || new_rtt)
+              end
             end
           end
         end
       end
-    end
 
-    after(:all) do
+      after(:all) do
 
-      module Mongo
-        class Server
+        module Mongo
+          class Server
 
-          # Return the monitor implementation to its original for the other
-          # tests in the suite.
-          class Monitor
+            # Return the monitor implementation to its original for the other
+            # tests in the suite.
+            class Monitor
 
-            # Create the new server monitor.
-            #
-            # @example Create the server monitor.
-            #   Mongo::Server::Monitor.new(address, listeners)
-            #
-            # @param [ Address ] address The address to monitor.
-            # @param [ Event::Listeners ] listeners The event listeners.
-            # @param [ Hash ] options The options.
-            #
-            # @since 2.0.0
-            def initialize(address, listeners, options = {})
-              @description = Description.new(address, {})
-              @inspector = Description::Inspector.new(listeners)
-              @options = options.freeze
-              @connection = Connection.new(address, options)
-              @last_round_trip_time = nil
-              @mutex = Mutex.new
-            end
-
-            private
+              alias :initialize :original_initialize
+              remove_method(:original_initialize)
 
-            def average_round_trip_time(start)
-              new_rtt = Time.now - start
-              RTT_WEIGHT_FACTOR * new_rtt + (1 - RTT_WEIGHT_FACTOR) * (@last_round_trip_time || new_rtt)
+              alias :average_round_trip_time :original_average_round_trip_time
+              remove_method(:original_average_round_trip_time)
             end
           end
         end
       end
-    end
-
-    context(spec.description) do
 
       let(:address) do
         Mongo::Address.new('127.0.0.1:27017')