mongo 2.6.4 → 2.7.0.rc0

data/spec/support/monitoring_ext.rb

@@ -0,0 +1,16 @@
+module Mongo
+  class Monitoring
+    # #subscribers writes to the subscribers even when reading them,
+    # confusing the tests.
+    # This method returns only events with populated subscribers.
+    def present_subscribers
+      subs = {}
+      subscribers.each do |k, v|
+        unless v.empty?
+          subs[k] = v
+        end
+      end
+      subs
+    end
+  end
+end

data/spec/support/sdam_formatter_integration.rb

@@ -0,0 +1,110 @@
+module SdamFormatterIntegration
+  def log_entries
+    @log_entries ||= []
+  end
+  module_function :log_entries
+
+  def clear_log_entries
+    @log_entries = []
+  end
+  module_function :clear_log_entries
+
+  def assign_log_entries(example_id)
+    @log_entries_by_example_id ||= {}
+    @log_entries_by_example_id[example_id] ||= []
+    @log_entries_by_example_id[example_id] += log_entries
+    clear_log_entries
+  end
+  module_function :assign_log_entries
+
+  def example_log_entries(example_id)
+    @log_entries_by_example_id ||= {}
+    @log_entries_by_example_id[example_id]
+  end
+  module_function :example_log_entries
+
+  def subscribe
+    topology_opening_subscriber = TopologyOpeningLogSubscriber.new
+    server_opening_subscriber = ServerOpeningLogSubscriber.new
+    server_description_changed_subscriber = ServerDescriptionChangedLogSubscriber.new
+    topology_changed_subscriber = TopologyChangedLogSubscriber.new
+    server_closed_subscriber = ServerClosedLogSubscriber.new
+    topology_closed_subscriber = TopologyClosedLogSubscriber.new
+
+    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_OPENING,
+      topology_opening_subscriber)
+    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_OPENING,
+      server_opening_subscriber)
+    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_DESCRIPTION_CHANGED,
+      server_description_changed_subscriber)
+    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_CHANGED,
+      topology_changed_subscriber)
+    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::SERVER_CLOSED,
+      server_closed_subscriber)
+    Mongo::Monitoring::Global.subscribe(Mongo::Monitoring::TOPOLOGY_CLOSED,
+      topology_closed_subscriber)
+  end
+  module_function :subscribe
+
+  class SDAMLogSubscriber
+    def succeeded(event)
+      SdamFormatterIntegration.log_entries <<
+        Time.now.strftime('%Y-%m-%d %H:%M:%S.%L %z') + ' | ' + format_event(event)
+    end
+  end
+
+  class TopologyOpeningLogSubscriber < SDAMLogSubscriber
+    private
+
+    def format_event(event)
+      "Topology type '#{event.topology.display_name}' initializing."
+    end
+  end
+
+  class ServerOpeningLogSubscriber < SDAMLogSubscriber
+    private
+
+    def format_event(event)
+      "Server #{event.address} initializing."
+    end
+  end
+
+  class ServerDescriptionChangedLogSubscriber < SDAMLogSubscriber
+    private
+
+    def format_event(event)
+      "Server description for #{event.address} changed from " +
+      "'#{event.previous_description.server_type}' to '#{event.new_description.server_type}'."
+    end
+  end
+
+  class TopologyChangedLogSubscriber < SDAMLogSubscriber
+    private
+
+    def format_event(event)
+      if event.previous_topology != event.new_topology
+        "Topology type '#{event.previous_topology.display_name}' changed to " +
+        "type '#{event.new_topology.display_name}'."
+      else
+        "There was a change in the members of the '#{event.new_topology.display_name}' " +
+        "topology."
+      end
+    end
+  end
+
+  class ServerClosedLogSubscriber < SDAMLogSubscriber
+    private
+
+    def format_event(event)
+      "Server #{event.address} connection closed."
+    end
+  end
+
+  class TopologyClosedLogSubscriber < SDAMLogSubscriber
+    private
+
+    def format_event(event)
+      "Topology type '#{event.topology.display_name}' closed."
+    end
+  end
+end

data/spec/support/sdam_monitoring.rb

@@ -16,7 +16,8 @@
 RSpec::Matchers.define :match_topology_opening_event do |expectation|
 
   match do |event|
-    event.topology != nil
+    event.is_a?(Mongo::Monitoring::Event::TopologyOpening) &&
+      event.topology != nil
   end
 end
 
@@ -24,14 +25,16 @@ RSpec::Matchers.define :match_topology_description_changed_event do |expectation
   include Mongo::SDAMMonitoring::Matchable
 
   match do |event|
-    topologies_match?(event, expectation)
+    event.is_a?(Mongo::Monitoring::Event::TopologyChanged) &&
+      topologies_match?(event, expectation)
   end
 end
 
 RSpec::Matchers.define :match_server_opening_event do |expectation|
 
   match do |event|
-    true
+    event.is_a?(Mongo::Monitoring::Event::ServerOpening) &&
+      event.address.to_s == expectation.data['address']
   end
 end
 
@@ -39,14 +42,16 @@ RSpec::Matchers.define :match_server_description_changed_event do |expectation|
   include Mongo::SDAMMonitoring::Matchable
 
   match do |event|
-    descriptions_match?(event, expectation)
+    event.is_a?(Mongo::Monitoring::Event::ServerDescriptionChanged) &&
+      descriptions_match?(event, expectation)
   end
 end
 
 RSpec::Matchers.define :match_server_closed_event do |expectation|
 
   match do |event|
-    event.address.to_s == expectation.data['address']
+    event.is_a?(Mongo::Monitoring::Event::ServerClosed) &&
+      event.address.to_s == expectation.data['address']
   end
 end
 
@@ -67,12 +72,23 @@ module Mongo
       end
 
       def topologies_match?(event, expectation)
-        topology_matches?(event.previous_topology, expectation.data['previousDescription']) &&
-          topology_matches?(event.new_topology, expectation.data['newDescription'])
+        unless topology_matches?(event.previous_topology, expectation.data['previousDescription'])
+          if ENV['VERBOSE_MATCHERS']
+            $stderr.puts "Previous topology mismatch"
+          end
+          return false
+        end
+        unless topology_matches?(event.new_topology, expectation.data['newDescription'])
+          if ENV['VERBOSE_MATCHERS']
+            $stderr.puts "New topology mismatch:\nHave: #{event.new_topology}\nWant: #{expectation.data['newDescription']}"
+          end
+          return false
+        end
+        true
       end
 
       def description_matches?(actual, expected)
-        case expected['type']
+        type_ok = case expected['type']
           when 'Standalone' then actual.standalone?
           when 'RSPrimary' then actual.primary?
           when 'RSSecondary' then actual.secondary?
@@ -83,16 +99,35 @@ module Mongo
           when 'RSGhost' then actual.ghost?
           when 'RSOther' then actual.other?
         end
+        return false unless type_ok
+
+        return false if actual.address.to_s != expected['address']
+        return false if actual.arbiters != expected['arbiters']
+        return false if actual.hosts != expected['hosts']
+        return false if actual.passives != expected['passives']
+        return false if actual.primary_host != expected['primary']
+        return false if actual.replica_set_name != expected['setName']
+        true
       end
 
       def topology_matches?(actual, expected)
-        case expected['topologyType']
-          when 'ReplicaSetWithPrimary' then actual.replica_set?
-          when 'ReplicaSetNoPrimary' then (actual.replica_set? || actual.unknown?)
-          when 'Sharded' then actual.sharded?
-          when 'Single' then actual.single?
-          when 'Unknown' then actual.unknown?
+        expected_type = ::Mongo::Cluster::Topology.const_get(expected['topologyType'])
+        return false unless actual.is_a?(expected_type)
+
+        return false unless actual.replica_set_name == expected['setName']
+
+        expected['servers'].each do |server|
+          desc = actual.server_descriptions[server['address'].to_s]
+          return false unless description_matches?(desc, server)
         end
+
+        actual.server_descriptions.keys.each do |address_str|
+          unless expected['servers'].any? { |server| server['address'] == address_str }
+            return false
+          end
+        end
+
+        true
       end
     end
 
@@ -107,6 +142,7 @@ module Mongo
       MAPPINGS = {
         'topology_opening_event' => Mongo::Monitoring::Event::TopologyOpening,
         'topology_description_changed_event' => Mongo::Monitoring::Event::TopologyChanged,
+        'topology_closed_event' => Mongo::Monitoring::Event::TopologyClosed,
         'server_opening_event' => Mongo::Monitoring::Event::ServerOpening,
         'server_description_changed_event' => Mongo::Monitoring::Event::ServerDescriptionChanged,
         'server_closed_event' => Mongo::Monitoring::Event::ServerClosed
@@ -127,18 +163,42 @@ module Mongo
       #
       # @return [ Event ] The matching event.
       def first_event(name)
+        cls = MAPPINGS[name]
+        if cls.nil?
+          raise ArgumentError, "Bogus event name #{name}"
+        end
         matching = events.find do |event|
-          event.class == MAPPINGS[name]
+          cls === event
         end
         events.delete(matching)
         matching
       end
 
-      private
-
       def events
         @events ||= []
       end
     end
+
+    class PhasedTestSubscriber < TestSubscriber
+      def initialize
+        super
+        @phase_events = {}
+      end
+
+      def phase_finished(phase_index)
+        @phase_events[phase_index] = events
+        @events = []
+      end
+
+      def phase_events(phase_index)
+        @phase_events[phase_index]
+      end
+
+      def event_count
+        @phase_events.inject(0) do |sum, event|
+          sum + event.length
+        end
+      end
+    end
   end
 end

data/spec/support/server_discovery_and_monitoring.rb

@@ -5,17 +5,7 @@
 RSpec::Matchers.define :be_server_type do |expected|
 
   match do |actual|
-    case expected
-      when 'Standalone' then actual.standalone?
-      when 'RSPrimary' then actual.primary?
-      when 'RSSecondary' then actual.secondary?
-      when 'RSArbiter' then actual.arbiter?
-      when 'Mongos' then actual.mongos?
-      when 'Unknown' then actual.unknown?
-      when 'PossiblePrimary' then actual.unknown?
-      when 'RSGhost' then actual.ghost?
-      when 'RSOther' then actual.other?
-    end
+    Mongo::SDAM.server_of_type?(actual, expected)
   end
 end
 
@@ -25,24 +15,37 @@ end
 RSpec::Matchers.define :be_topology do |expected|
 
   match do |actual|
-    case expected
-      when 'ReplicaSetWithPrimary' then actual.replica_set?
-      when 'ReplicaSetNoPrimary' then actual.replica_set?
-      when 'Sharded' then actual.sharded?
-      when 'Single' then actual.single?
-      when 'Unknown' then actual.unknown?
-    end
+    actual.topology.class.name.sub(/.*::/, '') == expected
   end
 end
 
 module Mongo
   module SDAM
 
+    module UniversalMethods
+      def server_of_type?(server, type)
+        case type
+          when 'Standalone' then server.standalone?
+          when 'RSPrimary' then server.primary?
+          when 'RSSecondary' then server.secondary?
+          when 'RSArbiter' then server.arbiter?
+          when 'Mongos' then server.mongos?
+          when 'Unknown' then server.unknown?
+          when 'PossiblePrimary' then server.unknown?
+          when 'RSGhost' then server.ghost?
+          when 'RSOther' then server.other?
+        end
+      end
+    end
+
+    include UniversalMethods
+    extend UniversalMethods
+
     # Convenience helper to find a server by it's URI.
     #
     # @since 2.0.0
-    def find_server(client, uri)
-      client.cluster.instance_variable_get(:@servers).detect{ |s| s.address.to_s == uri }
+    def find_server(client, address_str)
+      client.cluster.servers_list.detect{ |s| s.address.to_s == address_str }
     end
 
     # Helper to convert an extended JSON ObjectId electionId to BSON::ObjectId.
@@ -166,6 +169,10 @@ module Mongo
       # @return [ Integer, nil ] logical_session_timeout The expected logical session timeout.
       attr_reader :logical_session_timeout
 
+      attr_reader :max_election_id
+
+      attr_reader :max_set_version
+
       # Create the new outcome.
       #
       # @example Create the new outcome.
@@ -181,6 +188,10 @@ module Mongo
         @logical_session_timeout = outcome['logicalSessionTimeoutMinutes']
         @events = process_events(outcome['events']) if outcome['events']
         @compatible = outcome['compatible']
+        if outcome['maxElectionId']
+          @max_election_id = BSON::ObjectId.from_string(outcome['maxElectionId']['$oid'])
+        end
+        @max_set_version = outcome['maxSetVersion']
       end
 
       # Whether the server responses indicate that their versions are supported by the driver.
@@ -195,6 +206,10 @@ module Mongo
         @compatible.nil? || !!@compatible
       end
 
+      def compatible_specified?
+        !@compatible.nil?
+      end
+
       private
 
       def process_events(events)
@@ -234,3 +249,11 @@ module Mongo
     end
   end
 end
+
+class SdamSpecEventPublisher
+  include Mongo::Event::Publisher
+
+  def initialize(event_listeners)
+    @event_listeners = event_listeners
+  end
+end

data/spec/support/server_selection.rb

@@ -7,17 +7,6 @@ module Mongo
       # @since 2.0.0
       class Spec
 
-        # Mapping of topology description strings to topology type classes.
-        #
-        # @since 2.0.0
-        TOPOLOGY_TYPES = {
-          'ReplicaSetNoPrimary' => Mongo::Cluster::Topology::ReplicaSet,
-          'ReplicaSetWithPrimary' => Mongo::Cluster::Topology::ReplicaSet,
-          'Sharded' => Mongo::Cluster::Topology::Sharded,
-          'Single' => Mongo::Cluster::Topology::Single,
-          'Unknown' => Mongo::Cluster::Topology::Unknown
-        }
-
         # Mapping of read preference modes.
         #
         # @since 2.0.0
@@ -86,7 +75,7 @@ module Mongo
           @candidate_servers = @test['topology_description']['servers']
           @suitable_servers = @test['suitable_servers'] || []
           @in_latency_window = @test['in_latency_window'] || []
-          @type = TOPOLOGY_TYPES[@test['topology_description']['type']]
+          @type = Mongo::Cluster::Topology.const_get(@test['topology_description']['type'])
         end
 
         # Whether this spec describes a replica set.
@@ -98,7 +87,8 @@ module Mongo
         #
         # @since 2.0.0
         def replica_set?
-          type == Mongo::Cluster::Topology::ReplicaSet
+          type == Mongo::Cluster::Topology::ReplicaSetNoPrimary ||
+          type == Mongo::Cluster::Topology::ReplicaSetWithPrimary
         end
 
         # Does this spec expect a server to be found.

data/spec/support/server_selection_rtt.rb

@@ -10,14 +10,14 @@ module Mongo
         # @return [ String ] description The spec description.
         attr_reader :description
 
-        # @return [ Float ] avg_rtt_ms The starting average round trip time.
-        attr_reader :avg_rtt_ms
+        # @return [ Float ] average_rtt The starting average round trip time, in seconds.
+        attr_reader :average_rtt
 
-        # @return [ Float ] new_rtt_ms The new round trip time for ismaster.
-        attr_reader :new_rtt_ms
+        # @return [ Float ] new_rtt The new round trip time for ismaster, in seconds.
+        attr_reader :new_rtt
 
-        # @return [ Float ] new_avg_rtt The newly calculated moving average round trip time.
-        attr_reader :new_avg_rtt
+        # @return [ Float ] new_average_rtt The newly calculated moving average round trip time, in seconds.
+        attr_reader :new_average_rtt
 
         # Instantiate the new spec.
         #
@@ -29,11 +29,11 @@ module Mongo
         # @since 2.0.0
         def initialize(file)
           @test = YAML.load(ERB.new(File.new(file).read).result)
-          @description = "avg_rtt_ms: #{@test['avg_rtt_ms']}, new_rtt_ms: #{@test['new_rtt_ms']}," +
+          @description = "#{File.basename(file)}: avg_rtt_ms: #{@test['avg_rtt_ms']}, new_rtt_ms: #{@test['new_rtt_ms']}," +
                            " new_avg_rtt: #{@test['new_avg_rtt']}"
-          @avg_rtt_ms = @test['avg_rtt_ms'] == 'NULL' ? nil : @test['avg_rtt_ms'].to_f
-          @new_rtt_ms = @test['new_rtt_ms'].to_f
-          @new_avg_rtt = @test['new_avg_rtt'].to_f
+          @average_rtt = @test['avg_rtt_ms'] == 'NULL' ? nil : @test['avg_rtt_ms'].to_f / 1000
+          @new_rtt = @test['new_rtt_ms'].to_f / 1000
+          @new_average_rtt = @test['new_avg_rtt'].to_f / 1000
         end
       end
     end