mongo 1.12.5 → 2.0.0

data/spec/mongo/server/monitor_spec.rb

@@ -0,0 +1,144 @@
+require 'spec_helper'
+
+describe Mongo::Server::Monitor do
+
+  let(:address) do
+    Mongo::Address.new(DEFAULT_ADDRESS)
+  end
+
+  let(:listeners) do
+    Mongo::Event::Listeners.new
+  end
+
+  describe '#scan!' do
+
+    context 'when calling multiple times in succession' do
+
+      let(:monitor) do
+        described_class.new(address, listeners)
+      end
+
+      it 'throttles the scans to minimum 500ms' do
+        start = Time.now
+        monitor.scan!
+        monitor.scan!
+        expect(Time.now - start).to be > 0.5
+      end
+    end
+
+    context 'when the ismaster command succeeds' do
+
+      let(:monitor) do
+        described_class.new(address, listeners)
+      end
+
+      before do
+        monitor.scan!
+      end
+
+      it 'updates the server description', if: standalone? do
+        expect(monitor.description).to be_standalone
+      end
+
+      it 'updates the server description', if: replica_set? do
+        expect(monitor.description).to be_primary
+      end
+
+      it 'updates the server description', if: sharded? do
+        expect(monitor.description).to be_mongos
+      end
+    end
+
+    context 'when the ismaster command fails' do
+
+      context 'when no server is running on the address' do
+
+        let(:bad_address) do
+          Mongo::Address.new('127.0.0.1:27050')
+        end
+
+        let(:monitor) do
+          described_class.new(bad_address, listeners)
+        end
+
+        before do
+          monitor.scan!
+        end
+
+        it 'keeps the server unknown' do
+          expect(monitor.description).to be_unknown
+        end
+      end
+
+      context 'when the socket gets an exception' do
+
+        let(:bad_address) do
+          Mongo::Address.new(DEFAULT_ADDRESS)
+        end
+
+        let(:monitor) do
+          described_class.new(bad_address, listeners)
+        end
+
+        let(:socket) do
+          monitor.connection.connect!
+          monitor.connection.__send__(:socket)
+        end
+
+        before do
+          expect(socket).to receive(:write).and_raise(Mongo::Error::SocketError)
+          monitor.scan!
+        end
+
+        it 'keeps the server unknown' do
+          expect(monitor.description).to be_unknown
+        end
+
+        it 'disconnects the connection' do
+          expect(monitor.connection).to_not be_connected
+        end
+      end
+    end
+  end
+
+  describe '#heartbeat_frequency' do
+
+    context 'when an option is provided' do
+
+      let(:monitor) do
+        described_class.new(address, listeners, :heartbeat_frequency => 5)
+      end
+
+      it 'returns the option' do
+        expect(monitor.heartbeat_frequency).to eq(5)
+      end
+    end
+
+    context 'when no option is provided' do
+
+      let(:monitor) do
+        described_class.new(address, listeners)
+      end
+
+      it 'defaults to 5' do
+        expect(monitor.heartbeat_frequency).to eq(10)
+      end
+    end
+  end
+
+  describe '#run!' do
+
+    let(:monitor) do
+      described_class.new(address, listeners, :heartbeat_frequency => 1)
+    end
+
+    before do
+      monitor.run!
+      sleep(1)
+    end
+
+    it 'refreshes the server on the provided interval' do
+      expect(monitor.description).to_not be_nil
+    end
+  end
+end

data/spec/mongo/server_discovery_and_monitoring_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe 'Server Discovery and Monitoring' do
+  include Mongo::SDAM
+
+  SERVER_DISCOVERY_TESTS.each do |file|
+
+    spec = Mongo::SDAM::Spec.new(file)
+
+    context(spec.description) do
+
+      before(:all) do
+
+        # 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 contructor keeps the same API, but does not instantiate a
+          # monitor and run it.
+          def initialize(address, event_listeners, options = {})
+            @address = address
+            @options = options.freeze
+            @monitor = Monitor.new(address, event_listeners, options)
+          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
+        # retain its modifications across contexts/phases. Let is no good
+        # here as we have a clean slate for each context/phase.
+        @client = Mongo::Client.new(spec.uri_string)
+      end
+
+      after(:all) 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, event_listeners, options = {})
+            @address = address
+            @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
+      end
+
+      spec.phases.each_with_index do |phase, index|
+
+        context("Phase: #{index + 1}") do
+
+          phase.responses.each do |response|
+
+            before do
+              # For each response in the phase, we need to change that server's
+              # description.
+              server = find_server(@client, response.address)
+              monitor = server.instance_variable_get(:@monitor)
+              description = monitor.inspector.run(server.description, response.ismaster, 0.5)
+              monitor.instance_variable_set(:@description, description)
+            end
+          end
+
+          it "sets the cluster topology to #{phase.outcome.topology_type}" do
+            expect(@client.cluster).to be_topology(phase.outcome.topology_type)
+          end
+
+          it "sets the cluster replica set name to #{phase.outcome.set_name.inspect}" do
+            expect(@client.cluster.replica_set_name).to eq(phase.outcome.set_name)
+          end
+
+          phase.outcome.servers.each do |uri, server|
+
+            it "sets #{uri} to #{server['type']}" do
+              expect(find_server(@client, uri)).to be_server_type(server['type'])
+            end
+
+            it "sets #{uri} replica set name to #{server['setName'].inspect}" do
+              expect(find_server(@client, uri).replica_set_name).to eq(server['setName'])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/mongo/server_selection_rtt_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe 'Server Selection moving average round trip time calculation' do
+
+  include Mongo::ServerSelection::RTT
+
+  SERVER_SELECTION_RTT_TESTS.each do |file|
+
+    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
+
+            private
+
+            # We monkey patch this method to use an instance variable instead of calculating time elapsed.
+            #
+            # @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)
+            end
+          end
+        end
+      end
+    end
+
+    after(:all) do
+
+      module Mongo
+        class Server
+
+          # 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
+
+            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)
+            end
+          end
+        end
+      end
+    end
+
+    context(spec.description) do
+
+      let(:address) do
+        Mongo::Address.new('127.0.0.1:27017')
+      end
+
+      let(:monitor) do
+        Mongo::Server::Monitor.new(address, Mongo::Event::Listeners.new, avg_rtt_ms: spec.avg_rtt_ms)
+      end
+
+      before do
+        monitor.instance_variable_set(:@new_rtt_ms, spec.new_rtt_ms)
+        monitor.scan!
+      end
+
+      it 'correctly calculates the moving average round trip time' do
+        expect(monitor.description.average_round_trip_time).to eq(spec.new_avg_rtt)
+      end
+    end
+  end
+end

data/spec/mongo/server_selection_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe 'Server Selection' do
+
+  include Mongo::ServerSelection::Read
+
+  SERVER_SELECTION_TESTS.each do |file|
+
+    spec = Mongo::ServerSelection::Read::Spec.new(file)
+
+    context(spec.description) do
+
+      let(:topology) do
+        spec.type.new({})
+      end
+
+      let(:cluster) do
+        double('cluster').tap do |c|
+          allow(c).to receive(:topology).and_return(topology)
+          allow(c).to receive(:standalone?).and_return(topology.standalone?)
+          allow(c).to receive(:sharded?).and_return(topology.sharded?)
+          allow(c).to receive(:replica_set?).and_return(topology.replica_set?)
+        end
+      end
+
+      let(:candidate_servers) do
+        spec.candidate_servers.collect do |server|
+          address = Mongo::Address.new(server['address'])
+          Mongo::Server.new(address, Mongo::Event::Listeners.new).tap do |s|
+            allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'])
+            allow(s).to receive(:tags).and_return(server['tags'])
+            allow(s).to receive(:secondary?).and_return(server['type'] == 'RSSecondary')
+            allow(s).to receive(:primary?).and_return(server['type'] == 'RSPrimary')
+          end
+        end
+      end
+
+      let(:in_latency_window) do
+        spec.in_latency_window.collect do |server|
+          address = Mongo::Address.new(server['address'])
+          Mongo::Server.new(address, Mongo::Event::Listeners.new).tap do |s|
+            allow(s).to receive(:average_round_trip_time).and_return(server['avg_rtt_ms'])
+            allow(s).to receive(:tags).and_return(server['tags'])
+          end
+        end
+      end
+
+      let(:server_selector) do
+        Mongo::ServerSelector.get({ :mode => spec.read_preference['mode'],
+                                    :tag_sets => spec.read_preference['tag_sets'] },
+                                    :server_selection_timeout => 1)
+      end
+
+      before do
+        allow(cluster).to receive(:servers).and_return(candidate_servers)
+        allow(cluster).to receive(:scan!).and_return(true)
+      end
+
+      context 'Valid read preference and matching server available', unless: spec.raises_exception? do
+      
+        it 'Finds all suitable servers in the latency window', if: spec.replica_set? do
+          expect(server_selector.send(:select, cluster.servers)).to eq(in_latency_window)   
+        end
+      
+        it 'Finds the most suitable server in the latency window' do
+          expect(in_latency_window).to include(server_selector.select_server(cluster))
+        end
+      end
+
+      context 'Invalid read preference', if: spec.invalid_server_preference? do
+      
+        it 'Raises exception' do
+          expect do
+            server_selector.select_server(cluster)
+          end.to raise_exception(Mongo::ServerSelector::InvalidServerPreference) 
+        end
+      end
+
+      context 'No matching server available', unless: spec.server_available? do
+      
+        it 'Raises exception' do
+          expect do
+            server_selector.select_server(cluster)
+          end.to raise_exception(Mongo::ServerSelector::NoServerAvailable) 
+        end
+      end
+    end
+  end
+end

data/spec/mongo/server_selector/nearest_spec.rb

@@ -0,0 +1,250 @@
+require 'spec_helper'
+
+describe Mongo::ServerSelector::Nearest do
+
+  include_context 'server selector'
+
+  it_behaves_like 'a read preference mode' do
+    let(:name) { :nearest }
+    let(:slave_ok) { true }
+  end
+
+  it_behaves_like 'a read preference mode accepting tag sets'
+
+  describe '#to_mongos' do
+
+    context 'tag set not provided' do
+      it 'returns a read preference formatted for mongos' do
+        expect(read_pref.to_mongos).to eq({ :mode => 'nearest' })
+      end
+    end
+
+    context 'tag set provided' do
+      let(:tag_sets) do
+        [tag_set]
+      end
+
+      it 'returns a read preference formatted for mongos' do
+        expect(read_pref.to_mongos).to eq(
+          { :mode => 'nearest', :tags => tag_sets }
+        )
+      end
+    end
+  end
+
+  describe '#select' do
+
+    context 'no candidates' do
+      let(:candidates) { [] }
+
+      it 'returns an empty array' do
+        expect(read_pref.send(:select, candidates)).to be_empty
+      end
+    end
+
+    context 'single primary candidates' do
+      let(:candidates) { [primary] }
+
+      it 'returns an array with the primary' do
+        expect(read_pref.send(:select, candidates)).to eq([primary])
+      end
+    end
+
+    context 'single secondary candidate' do
+      let(:candidates) { [secondary] }
+
+      it 'returns an array with the secondary' do
+        expect(read_pref.send(:select, candidates)).to eq([secondary])
+      end
+    end
+
+    context 'primary and secondary candidates' do
+      let(:candidates) { [primary, secondary] }
+
+      it 'returns an array with the primary and secondary' do
+        expect(read_pref.send(:select, candidates)).to match_array([primary, secondary])
+      end
+    end
+
+    context 'multiple secondary candidates' do
+      let(:candidates) { [secondary, secondary] }
+
+      it 'returns an array with the secondaries' do
+        expect(read_pref.send(:select, candidates)).to match_array([secondary, secondary])
+      end
+    end
+
+    context 'tag sets provided' do
+      let(:tag_sets) { [tag_set] }
+      let(:matching_primary) do
+        server(:primary, :tags => server_tags)
+      end
+      let(:matching_secondary) do
+        server(:secondary, :tags => server_tags)
+      end
+
+      context 'single candidate' do
+
+        context 'primary' do
+          let(:candidates) { [primary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'matching primary' do
+          let(:candidates) { [matching_primary] }
+
+          it 'returns an array with the primary' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_primary])
+          end
+        end
+
+        context 'secondary' do
+          let(:candidates) { [secondary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'matching secondary' do
+          let(:candidates) { [matching_secondary] }
+
+          it 'returns an array with the matching secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_secondary])
+          end
+        end
+      end
+
+      context 'mtuliple candidates' do
+
+        context 'no matching servers' do
+          let(:candidates) { [primary, secondary, secondary] }
+
+          it 'returns an empty array' do
+            expect(read_pref.send(:select, candidates)).to be_empty
+          end
+        end
+
+        context 'one matching primary' do
+          let(:candidates) { [matching_primary, secondary, secondary] }
+
+          it 'returns an array with the matching primary' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_primary])
+          end
+        end
+
+        context 'one matching secondary' do
+          let(:candidates) { [primary, matching_secondary, secondary] }
+
+          it 'returns an array with the matching secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([matching_secondary])
+          end
+        end
+
+        context 'two matching secondaries' do
+          let(:candidates) { [primary, matching_secondary, matching_secondary] }
+          let(:expected) { [matching_secondary, matching_secondary] }
+
+          it 'returns an array with the matching secondaries' do
+            expect(read_pref.send(:select, candidates)).to eq(expected)
+          end
+        end
+
+        context 'one matching primary and one matching secondary' do
+          let(:candidates) { [matching_primary, matching_secondary, secondary] }
+          let(:expected) { [matching_primary, matching_secondary] }
+
+          it 'returns an array with the matching primary and secondary' do
+            expect(read_pref.send(:select, candidates)).to match_array(expected)
+          end
+        end
+      end
+    end
+
+    context 'high latency servers' do
+      let(:far_primary) { server(:primary, :average_round_trip_time => 113) }
+      let(:far_secondary) { server(:secondary, :average_round_trip_time => 114) }
+
+      context 'single candidate' do
+
+        context 'far primary' do
+          let(:candidates) { [far_primary] }
+
+          it 'returns array with far primary' do
+            expect(read_pref.send(:select, candidates)).to eq([far_primary])
+          end
+        end
+
+        context 'far secondary' do
+          let(:candidates) { [far_secondary] }
+
+          it 'returns array with far primary' do
+            expect(read_pref.send(:select, candidates)).to eq([far_secondary])
+          end
+        end
+      end
+
+      context 'multiple candidates' do
+
+        context 'local primary, local secondary' do
+          let(:candidates) { [primary, secondary] }
+
+          it 'returns array with primary and secondary' do
+            expect(read_pref.send(:select, candidates)).to match_array(
+              [primary, secondary]
+            )
+          end
+        end
+
+        context 'local primary, far secondary' do
+          let(:candidates) { [primary, far_secondary] }
+
+          it 'returns array with local primary' do
+            expect(read_pref.send(:select, candidates)).to eq([primary])
+          end
+        end
+
+        context 'far primary, local secondary' do
+          let(:candidates) { [far_primary, secondary] }
+
+          it 'returns array with local secondary' do
+            expect(read_pref.send(:select, candidates)).to eq([secondary])
+          end
+        end
+
+        context 'far primary, far secondary' do
+          let(:candidates) { [far_primary, far_secondary] }
+          let(:expected) { [far_primary, far_secondary] }
+
+          it 'returns array with both servers' do
+            expect(read_pref.send(:select, candidates)).to match_array(expected)
+          end
+        end
+
+        context 'two local servers, one far server' do
+
+          context 'local primary, local secondary' do
+            let(:candidates) { [primary, secondary, far_secondary] }
+            let(:expected) { [primary, secondary] }
+
+            it 'returns array with local primary and local secondary' do
+              expect(read_pref.send(:select, candidates)).to match_array(expected)
+            end
+          end
+
+          context 'two near secondaries' do
+            let(:candidates) { [far_primary, secondary, secondary] }
+            let(:expected) { [secondary, secondary] }
+
+            it 'returns array with the two local secondaries' do
+              expect(read_pref.send(:select, candidates)).to match_array(expected)
+            end
+          end
+        end
+      end
+    end
+  end
+end