RUBY-2015 Convert sdam monitoring matchers to verifier (#1574)

Author: p-mongo

spec/runners/sdam/verifier.rb

@@ -0,0 +1,88 @@
+module Sdam
+  class Verifier
+    include RSpec::Matchers
+
+    def verify_sdam_event(expected_events, actual_events, i)
+      expect(expected_events.length).to be > i
+      expect(actual_events.length).to be > i
+
+      expected_event = expected_events[i]
+      actual_event = actual_events[i]
+
+      actual_event_name = Utils.underscore(actual_event.class.name.sub(/.*::/, ''))
+      actual_event_name = actual_event_name.to_s.sub('topology_changed', 'topology_description_changed') + '_event'
+      expect(actual_event_name).to eq(expected_event.name)
+
+      send("verify_#{expected_event.name}", expected_event, actual_event)
+    end
+
+    def verify_topology_opening_event(expected, actual)
+      expect(actual.topology).not_to be nil
+    end
+
+    def verify_topology_description_changed_event(expected, actual)
+      verify_topology_matches(expected.data['previousDescription'], actual.previous_topology)
+      verify_topology_matches(expected.data['newDescription'], actual.new_topology)
+    end
+
+    def verify_topology_matches(expected, actual)
+      expected_type = ::Mongo::Cluster::Topology.const_get(expected['topologyType'])
+      expect(actual).to be_a(expected_type)
+
+      expect(actual.replica_set_name).to eq(expected['setName'])
+
+      expected['servers'].each do |server|
+        desc = actual.server_descriptions[server['address'].to_s]
+        expect(desc).not_to be nil
+        verify_description_matches(server, desc)
+      end
+
+      actual.server_descriptions.keys.each do |address_str|
+        expect(
+          expected['servers'].any? { |server| server['address'] == address_str }
+        ).to be true
+      end
+    end
+
+    def verify_server_opening_event(expected, actual)
+      expect(actual.address.to_s).to eq(expected.data['address'])
+    end
+
+    def verify_server_description_changed_event(expected, actual)
+      verify_description_matches(expected.data['previousDescription'], actual.previous_description)
+      verify_description_matches(expected.data['newDescription'], actual.new_description)
+    end
+
+    def verify_description_matches(expected, actual)
+      case expected['type']
+      when 'Standalone'
+        expect(actual).to be_standalone
+      when 'RSPrimary'
+        expect(actual).to be_primary
+      when 'RSSecondary'
+        expect(actual).to be_secondary
+      when 'RSArbiter'
+        expect(actual).to be_arbiter
+      when 'Mongos'
+        expect(actual).to be_mongos
+      when 'Unknown', 'PossiblePrimary'
+        expect(actual).to be_unknown
+      when 'RSGhost'
+        expect(actual).to be_ghost
+      when 'RSOther'
+        expect(actual).to be_other
+      end
+
+      expect(actual.address.to_s).to eq(expected['address'])
+      expect(actual.arbiters).to eq(expected['arbiters'])
+      expect(actual.hosts).to eq(expected['hosts'])
+      expect(actual.passives).to eq(expected['passives'])
+      expect(actual.primary_host).to eq(expected['primary'])
+      expect(actual.replica_set_name).to eq(expected['setName'])
+    end
+
+    def verify_server_closed_event(expected, actual)
+      expect(actual.address.to_s).to eq(expected.data['address'])
+    end
+  end
+end

spec/spec_tests/sdam_monitoring_spec.rb

@@ -1,5 +1,7 @@
 require 'lite_spec_helper'
 
+require_relative '../runners/sdam/verifier'
+
 describe 'SDAM Monitoring' do
   include Mongo::SDAM
 
@@ -72,12 +74,15 @@
             expect(@subscriber.phase_events(phase_index).length).to eq(phase.outcome.events.length)
           end
 
+          let(:verifier) do
+            Sdam::Verifier.new
+          end
+
           phase.outcome.events.each_with_index do |expectation, index|
 
-            it "expects a #{expectation.name} to be published" do
-              published_event = @subscriber.phase_events(phase_index)[index]
-              expect(published_event).not_to be_nil
-              expect(published_event).to match_sdam_monitoring_event(expectation)
+            it "expects event #{index+1} to be #{expectation.name}" do
+              verifier.verify_sdam_event(
+                phase.outcome.events, @subscriber.phase_events(phase_index), index)
             end
           end
         end

spec/support/sdam_monitoring.rb

@@ -13,123 +13,8 @@
 # limitations under the License.
 #
 
-RSpec::Matchers.define :match_topology_opening_event do |expectation|
-
-  match do |event|
-    event.is_a?(Mongo::Monitoring::Event::TopologyOpening) &&
-      event.topology != nil
-  end
-end
-
-RSpec::Matchers.define :match_topology_description_changed_event do |expectation|
-  include Mongo::SDAMMonitoring::Matchable
-
-  match do |event|
-    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|
-    event.is_a?(Mongo::Monitoring::Event::ServerOpening) &&
-      event.address.to_s == expectation.data['address']
-  end
-end
-
-RSpec::Matchers.define :match_server_description_changed_event do |expectation|
-  include Mongo::SDAMMonitoring::Matchable
-
-  match do |event|
-    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.is_a?(Mongo::Monitoring::Event::ServerClosed) &&
-      event.address.to_s == expectation.data['address']
-  end
-end
-
-RSpec::Matchers.define :match_sdam_monitoring_event do |expectation|
-
-  match do |event|
-    expect(event).to send("match_#{expectation.name}", expectation)
-  end
-end
-
 module Mongo
   module SDAMMonitoring
-    module Matchable
-
-      def descriptions_match?(event, expectation)
-        description_matches?(event.previous_description, expectation.data['previousDescription']) &&
-          description_matches?(event.new_description, expectation.data['newDescription'])
-      end
-
-      def topologies_match?(event, expectation)
-        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)
-        type_ok = case expected['type']
-          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
-        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)
-        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
 
     # Test subscriber for SDAM monitoring.
     #