Merge branch 'kassio/improve-rspec-matches-for-gitlab-event-store' into 'master'

Fix composability of `:published_event` with `:not_publish_event`

See merge request https://gitlab.com/gitlab-org/gitlab/-/merge_requests/144777



Merged-by: Dzmitry Meshcharakou <12459192-dmeshcharakou@users.noreply.gitlab.com>
Approved-by: Nicolas Dular <ndular@gitlab.com>
Approved-by: Dzmitry Meshcharakou <12459192-dmeshcharakou@users.noreply.gitlab.com>
Reviewed-by: Kassio Borges <kborges@gitlab.com>
Reviewed-by: Nicolas Dular <ndular@gitlab.com>
Reviewed-by: Dzmitry Meshcharakou <12459192-dmeshcharakou@users.noreply.gitlab.com>
Co-authored-by: Kassio Borges <kassioborgesm@gmail.com>

spec/support/matchers/event_store.rb

 # frozen_string_literal: true
 
-RSpec::Matchers.define :publish_event do |expected_event_class|
-  include RSpec::Matchers::Composable
+module RSpec
+  module PublishedGitlabEventStoreEvents
+    class FakeGitlabEventStore
+      include ::RSpec::Mocks::ExampleMethods
+
+      attr_reader :events
+
+      def initialize
+        @events = []
+        allow(Gitlab::EventStore).to receive(:publish) do |published_event|
+          @events << published_event
+        end
+      end
+    end
 
-  supports_block_expectations
+    # Ensure to use the same stubbed Gitlab::EventStore within the test example, this
+    # way the list of published events is shared within the example enabling us to
+    # use .(not_)to publish_event multiple times and also mix it with .[to/and] not_publish_event
+    def self.setup(test)
+      @tests ||= Hash.new { |h, k| h[k] = [] }.tap(&:compare_by_identity)
+      @tests[test] = FakeGitlabEventStore.new
+    end
 
-  match do |proc|
-    raise ArgumentError, 'publish_event matcher only supports block expectation' unless proc.respond_to?(:call)
+    def self.on(test)
+      @tests[test]&.events
+    end
+  end
 
-    @events ||= []
+  Matchers.define :publish_event do |expected_event_class|
+    include RSpec::Matchers::Composable
 
-    allow(Gitlab::EventStore).to receive(:publish) do |published_event|
-      @events << published_event
-    end
+    supports_block_expectations
 
-    proc.call
+    match do |proc|
+      raise ArgumentError, 'publish_event matcher only supports block expectation' unless proc.respond_to?(:call)
 
-    @events.any? do |event|
-      event.instance_of?(expected_event_class) && match_data?(event.data, @expected_data)
-    end
-  end
+      RSpec::PublishedGitlabEventStoreEvents.setup(@matcher_execution_context)
 
-  def match_data?(actual, expected)
-    return if actual.blank? || expected.blank?
+      proc.call
 
-    values_match?(actual.keys, expected.keys) &&
-      actual.keys.all? do |key|
-        values_match?(expected[key], actual[key])
+      RSpec::PublishedGitlabEventStoreEvents.on(@matcher_execution_context).any? do |event|
+        event.instance_of?(expected_event_class) && match_data?(event.data, @expected_data)
       end
-  end
+    end
 
-  chain :with do |expected_data|
-    @expected_data = expected_data.with_indifferent_access
-  end
+    chain :with do |expected_data|
+      @expected_data = expected_data.with_indifferent_access
+    end
 
-  failure_message do
-    message = "expected #{expected_event_class} with #{@expected_data || 'no data'} to be published"
+    failure_message do
+      message = "expected #{expected_event_class} with #{@expected_data || 'no data'} to be published"
 
-    if @events.present?
-      <<~MESSAGE
-      #{message}, but only the following events were published:
-      #{events_list}
-      MESSAGE
-    else
-      "#{message}, but no events were published."
+      if RSpec::PublishedGitlabEventStoreEvents.on(@matcher_execution_context).present?
+        <<~MESSAGE
+        #{message}, but only the following events were published:
+        #{published_events_description}
+        MESSAGE
+      else
+        "#{message}, but no events were published."
+      end
     end
-  end
 
-  match_when_negated do |proc|
-    raise ArgumentError, 'publish_event matcher only supports block expectation' unless proc.respond_to?(:call)
+    failure_message_when_negated do
+      "expected #{expected_event_class} not to be published"
+    end
 
-    allow(Gitlab::EventStore).to receive(:publish)
+    private
 
-    proc.call
+    def match_data?(actual, expected)
+      return if actual.blank? || expected.blank?
 
-    expect(Gitlab::EventStore).not_to have_received(:publish).with(instance_of(expected_event_class))
-  end
+      values_match?(actual.keys, expected.keys) &&
+        actual.keys.all? { |key| values_match?(expected[key], actual[key]) }
+    end
 
-  def events_list
-    @events.map do |event|
-      " - #{event.class.name} with #{event.data}"
-    end.join("\n")
+    def published_events_description
+      RSpec::PublishedGitlabEventStoreEvents.on(@matcher_execution_context).map do |event|
+        " - #{event.class.name} with #{event.data}"
+      end.join("\n")
+    end
   end
-end
-
-# not_publish_event enables multiple assertions on a single block, for example:
-#     expect { Model.create(invalid: :attribute) }
-#       .to not_change(Model, :count)
-#       .and not_publish_event(ModelCreated)
-RSpec::Matchers.define :not_publish_event do |expected_event_class|
-  include RSpec::Matchers::Composable
 
-  supports_block_expectations
+  # not_publish_event enables multiple assertions on a single block, for example:
+  #     expect { Model.create(invalid: :attribute) }
+  #       .to not_change(Model, :count)
+  #       .and not_publish_event(ModelCreated)
+  Matchers.define :not_publish_event do |expected_event_class|
+    include RSpec::Matchers::Composable
 
-  match do |proc|
-    raise ArgumentError, 'not_publish_event matcher only supports block expectation' unless proc.respond_to?(:call)
+    supports_block_expectations
 
-    @events ||= []
+    match do |proc|
+      raise ArgumentError, 'not_publish_event matcher only supports block expectation' unless proc.respond_to?(:call)
 
-    allow(Gitlab::EventStore).to receive(:publish) do |published_event|
-      @events << published_event
-    end
+      RSpec::PublishedGitlabEventStoreEvents.setup(@matcher_execution_context)
 
-    proc.call
+      proc.call
 
-    @events.none? do |event|
-      event.instance_of?(expected_event_class)
+      RSpec::PublishedGitlabEventStoreEvents.on(@matcher_execution_context).none? do |event|
+        event.instance_of?(expected_event_class)
+      end
     end
-  end
 
-  failure_message do
-    "expected #{expected_event_class} not to be published"
-  end
+    failure_message do
+      "expected #{expected_event_class} not to be published"
+    end
 
-  chain :with do |_| # rubocop: disable Lint/UnreachableLoop
-    raise ArgumentError, 'not_publish_event does not permit .with to avoid ambiguity'
-  end
+    chain :with do |_| # rubocop: disable Lint/UnreachableLoop -- false positive
+      raise ArgumentError, 'not_publish_event does not permit .with to avoid ambiguity'
+    end
 
-  match_when_negated do |proc|
-    raise ArgumentError, 'not_publish_event matcher does not support negation. Use `expect {}.to publish_event` instead'
+    match_when_negated do |_proc|
+      raise ArgumentError,
+        'not_publish_event matcher does not support negation. Use `expect {}.to publish_event` instead'
+    end
   end
 end

spec/support_specs/matchers/event_store_spec.rb

@@ -2,6 +2,7 @@
 
 require 'fast_spec_helper'
 require 'json_schemer'
+require 'oj'
 
 load File.expand_path('../../../spec/support/matchers/event_store.rb', __dir__)
 
@@ -123,4 +124,24 @@ def publishing_event(event_type, data = {})
         .to raise_error('expected FakeEventType1 not to be published')
     end
   end
+
+  it 'validates with published_event and not_publish_event' do
+    matcher = -> do
+      expect { publishing_event(FakeEventType1, { 'id' => 1 }) }
+        .to publish_event(FakeEventType1).with('id' => 1)
+        .and not_publish_event(FakeEventType2)
+    end
+
+    expect(&matcher).not_to raise_error
+  end
+
+  it 'validates with not_publish_event and published_event' do
+    matcher = -> do
+      expect { publishing_event(FakeEventType2, { 'id' => 1 }) }
+        .to not_publish_event(FakeEventType1)
+        .and publish_event(FakeEventType2).with('id' => 1)
+    end
+
+    expect(&matcher).not_to raise_error
+  end
 end