ruby_event_store-rspec 2.1.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1362df53ba19bf0a2194492d627ab17cd22ee658c9fefa47b5c61c0b8eec562
-  data.tar.gz: c665c377cf751768cb1ec6abd8f486231ae382c6dafaef36e8cf0aaf01bc3800
+  metadata.gz: 8eb0afc118a3be2829fec2383858efaf7c8a1766a41db876e39969261b5dc017
+  data.tar.gz: a6c84fcff753ba1753eccda8029cff733885f4cd383bcd04a4976a591cf3c2d1
 SHA512:
-  metadata.gz: 94e802c2bbed41e35aa8f8a2507cc127afe2e853e2266d60a56ea240f98c09f357bf7c664e7489de95a3f69d0b4892cd7f50a1c261fe2e7c995b531b45518fe4
-  data.tar.gz: bf4cc3ec24389daf273187565731d7dc460e2d2ba9621605dafbbce46b19df9324f27cc98deb8c749955e15b10a3c6dd8167f36ae07fbea0592a2c2b8e884261
+  metadata.gz: 6f7db18e2cef98b5af008f636bc04fbdbb89763eb5eec488fa9fdc439d95793329c34e8ce17d2b1f0bd5423a767772e2c1dfae34867e3ff8b87c5c7d9de1a44f
+  data.tar.gz: 28be5f30b48d48b8d643f75afde951a706a96fbac8b3d3472f8e890e42c2e2ba2b02e78f6fd5836982021d4b601f02eb98da09a09d13497830f898a0d6d35e07

data/README.md

@@ -3,4 +3,3 @@
 RSpec matchers for RubyEventStore.
 
 Find out more at [https://railseventstore.org](https://railseventstore.org/)
-

data/lib/ruby_event_store/rspec/apply.rb

@@ -3,58 +3,51 @@
 module RubyEventStore
   module RSpec
     class Apply
+      def initialize(*expected, failure_message_formatter:)
+        @expected = ExpectedCollection.new(expected)
+        @failure_message_formatter = failure_message_formatter
+        @fetch_events = FetchUnpublishedEvents.new
+      end
+
       def in(aggregate)
-        @aggregate = aggregate
+        fetch_events.in(aggregate)
         self
       end
 
       def strict
-        @matcher = ::RSpec::Matchers::BuiltIn::Match.new(@expected)
+        expected.strict
         self
       end
 
-      def matches?(event_proc)
-        raise_aggregate_not_set unless @aggregate
-        before = @aggregate.unpublished_events.to_a
-        event_proc.call
-        @applied_events = @aggregate.unpublished_events.to_a - before
-        if match_events?
-          @matcher.matches?(@applied_events)
-        else
-          !@applied_events.empty?
-        end
+      def exactly(count)
+        expected.exactly(count)
+        self
       end
 
-      def failure_message
-        if match_events?
-          <<-EOS
-expected block to have applied:
+      def times
+        self
+      end
+      alias time times
 
-#{@expected}
+      def once
+        expected.once
+        self
+      end
 
-but applied:
+      def matches?(event_proc)
+        raise_aggregate_not_set unless fetch_events.aggregate?
+        before = fetch_events.aggregate.unpublished_events.to_a
+        event_proc.call
+        @applied_events = fetch_events.aggregate.unpublished_events.to_a - before
+        MatchEvents.new.call(expected, applied_events)
+      end
 
-#{@applied_events}
-EOS
-        else
-          "expected block to have applied any events"
-        end
+      def failure_message
+        failure_message_formatter.failure_message(expected, applied_events)
       end
 
       def failure_message_when_negated
-        if match_events?
-          <<-EOS
-expected block not to have applied:
-
-#{@expected}
-
-but applied:
-
-#{@applied_events}
-EOS
-        else
-          "expected block not to have applied any events"
-        end
+        failure_message_formatter.failure_message_when_negated(expected, applied_events)
       end
 
       def description
@@ -67,18 +60,11 @@ EOS
 
       private
 
-      def initialize(*expected)
-        @expected = expected
-        @matcher   = ::RSpec::Matchers::BuiltIn::Include.new(*expected)
-      end
-
-      def match_events?
-        !@expected.empty?
-      end
-
       def raise_aggregate_not_set
-        raise SyntaxError, "You have to set the aggregate instance with `in`, e.g. `expect { ... }.to apply(an_event(MyEvent)).in(aggregate)`"
+        raise "You have to set the aggregate instance with `in`, e.g. `expect { ... }.to apply(an_event(MyEvent)).in(aggregate)`"
       end
+
+      attr_reader :expected, :applied_events, :failure_message_formatter, :fetch_events
     end
   end
 end

data/lib/ruby_event_store/rspec/be_event.rb

@@ -29,9 +29,9 @@ module RubyEventStore
       class FailureMessage
         class ExpectedLine
           def initialize(expected_klass, expected_metadata, expected_data)
-            @expected_klass    = expected_klass
+            @expected_klass = expected_klass
             @expected_metadata = expected_metadata
-            @expected_data     = expected_data
+            @expected_data = expected_data
           end
 
           def to_s
@@ -55,11 +55,11 @@ module RubyEventStore
 
         class ActualLine
           def initialize(actual_klass, actual_metadata, actual_data, expected_metadata, expected_data)
-            @actual_klass      = actual_klass
-            @actual_metadata   = actual_metadata
-            @actual_data       = actual_data
+            @actual_klass = actual_klass
+            @actual_metadata = actual_metadata
+            @actual_data = actual_data
             @expected_metadata = expected_metadata
-            @expected_data     = expected_data
+            @expected_data = expected_data
           end
 
           def to_s
@@ -83,25 +83,33 @@ module RubyEventStore
 
         class Diff
           def initialize(actual, expected, label, differ:)
-            @actual   = actual
+            @actual = actual
             @expected = expected
-            @label    = label
-            @differ   = differ
+            @label = label
+            @differ = differ
           end
 
           def to_s
-            @expected && ["\n#{@label} diff:", @differ.diff_as_string(@actual.to_s, @expected.to_s)]
+            @expected && ["\n#{@label} diff:", @differ.diff(@actual.to_s + "\n", @expected.to_s)]
           end
         end
 
-        def initialize(expected_klass, actual_klass, expected_data, actual_data, expected_metadata, actual_metadata, differ:)
-          @expected_klass    = expected_klass
-          @actual_klass      = actual_klass
-          @expected_data     = expected_data
-          @actual_data       = actual_data
+        def initialize(
+          expected_klass,
+          actual_klass,
+          expected_data,
+          actual_data,
+          expected_metadata,
+          actual_metadata,
+          differ:
+        )
+          @expected_klass = expected_klass
+          @actual_klass = actual_klass
+          @expected_data = expected_data
+          @actual_data = actual_data
           @expected_metadata = expected_metadata
-          @actual_metadata   = actual_metadata
-          @differ            = differ
+          @actual_metadata = actual_metadata
+          @differ = differ
         end
 
         def to_s
@@ -117,14 +125,14 @@ module RubyEventStore
       include ::RSpec::Matchers::Composable
 
       def initialize(expected, differ:, formatter:)
-        @expected  = expected
-        @differ    = differ
+        @expected = expected
+        @differ = differ
         @formatter = formatter
       end
 
       def matches?(actual)
         @actual = actual
-        matches_kind && matches_data && matches_metadata
+        matches_kind?(actual) && matches_data?(actual) && matches_metadata?(actual)
       end
 
       def with_data(expected_data)
@@ -138,16 +146,24 @@ module RubyEventStore
       end
 
       def failure_message
-        actual_data     = actual.data     if actual.respond_to?(:data)
+        actual_data = actual.data if actual.respond_to?(:data)
         actual_metadata = actual.metadata if actual.respond_to?(:metadata)
-        FailureMessage.new(expected, actual.class, expected_data, actual_data, expected_metadata, actual_metadata, differ: differ).to_s
+        FailureMessage.new(
+          expected,
+          actual.class,
+          expected_data,
+          actual_data,
+          expected_metadata,
+          actual_metadata,
+          differ: differ
+        ).to_s
       end
 
       def failure_message_when_negated
-        %Q{
+        "
 expected: not a kind of #{expected}
      got: #{actual.class}
-}
+"
       end
 
       def strict
@@ -167,26 +183,27 @@ expected: not a kind of #{expected}
         " (#{expectation_list.join(" and ")})" if expectation_list.any?
       end
 
-      private
+      attr_reader :expected, :expected_data, :expected_metadata
 
-      def matches_kind
-        KindMatcher.new(expected).matches?(actual)
+      def strict?
+        @strict
       end
 
-      def matches_data
-        DataMatcher.new(expected_data, strict: strict?).matches?(actual.data)
+      def matches_kind?(actual_event)
+        KindMatcher.new(expected).matches?(actual_event)
       end
 
-      def matches_metadata
-        DataMatcher.new(expected_metadata, strict: strict?).matches?(actual.metadata.to_h)
-      end
+      private
 
-      attr_reader :expected_metadata, :expected_data, :actual, :expected, :differ, :formatter
+      def matches_data?(actual_event)
+        DataMatcher.new(expected_data, strict: strict?).matches?(actual_event.data)
+      end
 
-      def strict?
-        @strict
+      def matches_metadata?(actual_event)
+        DataMatcher.new(expected_metadata, strict: strict?).matches?(actual_event.metadata.to_h)
       end
+
+      attr_reader :actual, :differ, :formatter
     end
   end
 end
-

data/lib/ruby_event_store/rspec/crude_failure_message_formatter.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module RSpec
+    class CrudeFailureMessageFormatter
+      class HavePublished
+        def initialize(differ)
+          @differ = differ
+        end
+
+        def failure_message(expected, events, stream_name)
+          stream_expectation = " in stream #{stream_name}" unless stream_name.nil?
+          "expected #{expected.events} to be published#{stream_expectation}, diff:" +
+            differ.diff(expected.events.to_s + "\n", events)
+        end
+
+        def failure_message_when_negated(expected, events, stream_name)
+          stream_expectation = " in stream #{stream_name}" unless stream_name.nil?
+          "expected #{expected.events} not to be published#{stream_expectation}, diff:" +
+            differ.diff(expected.events.to_s + "\n", events)
+        end
+
+        private
+
+        attr_reader :differ
+      end
+
+      class Publish
+        def failure_message(expected, events, stream)
+          if !expected.empty?
+            <<~EOS
+            expected block to have published:
+
+            #{expected.events}
+
+            #{"in stream #{stream} " if stream}but published:
+
+            #{events}
+            EOS
+          else
+            "expected block to have published any events"
+          end
+        end
+
+        def failure_message_when_negated(expected, events, stream)
+          if !expected.empty?
+            <<~EOS
+            expected block not to have published:
+
+            #{expected.events}
+
+            #{"in stream #{stream} " if stream}but published:
+
+            #{events}
+            EOS
+          else
+            "expected block not to have published any events"
+          end
+        end
+      end
+
+      class HaveApplied
+        def initialize(differ)
+          @differ = differ
+        end
+
+        def failure_message(expected, events)
+          "expected #{expected.events} to be applied, diff:" + differ.diff(expected.events.to_s + "\n", events)
+        end
+
+        def failure_message_when_negated(expected, events)
+          "expected #{expected.events} not to be applied, diff:" + differ.diff(expected.events.inspect + "\n", events)
+        end
+
+        attr_reader :differ
+      end
+
+      class Apply
+        def failure_message(expected, applied_events)
+          if !expected.empty?
+            <<~EOS
+            expected block to have applied:
+
+            #{expected.events}
+
+            but applied:
+
+            #{applied_events}
+            EOS
+          else
+            "expected block to have applied any events"
+          end
+        end
+
+        def failure_message_when_negated(expected, applied_events)
+          if !expected.empty?
+            <<~EOS
+            expected block not to have applied:
+
+            #{expected.events}
+
+            but applied:
+
+            #{applied_events}
+            EOS
+          else
+            "expected block not to have applied any events"
+          end
+        end
+      end
+
+      def have_published(differ)
+        HavePublished.new(differ)
+      end
+
+      def publish(_differ)
+        Publish.new
+      end
+
+      def have_applied(differ)
+        HaveApplied.new(differ)
+      end
+
+      def apply(_differ)
+        Apply.new
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rspec/expected_collection.rb

@@ -0,0 +1,43 @@
+module RubyEventStore
+  module RSpec
+    class ExpectedCollection
+      def initialize(events)
+        @events = events
+        @strict = false
+      end
+
+      def exactly(count)
+        raise NotSupported if !events.size.equal?(1)
+        raise NotSupported if count < 1
+        @count = count
+      end
+
+      def empty?
+        events.empty?
+      end
+
+      def once
+        exactly(1)
+      end
+
+      def specified_count?
+        !count.nil?
+      end
+
+      def strict
+        @strict = true
+      end
+
+      def strict?
+        @strict
+      end
+
+      def event
+        raise NotSupported if !events.size.equal?(1)
+        events.first
+      end
+
+      attr_reader :events, :count
+    end
+  end
+end

data/lib/ruby_event_store/rspec/fetch_events.rb

@@ -0,0 +1,33 @@
+module RubyEventStore
+  module RSpec
+    class FetchEvents
+      MissingEventStore = Class.new(StandardError)
+
+      def from(event_id)
+        @start = event_id
+      end
+
+      def stream(stream_name)
+        @stream_name = stream_name
+      end
+
+      def in(event_store)
+        @event_store = event_store
+      end
+
+      def from_last
+        @start = call.last&.event_id
+      end
+
+      def call
+        raise MissingEventStore if event_store.nil?
+        events = event_store.read
+        events = events.stream(stream_name) if stream_name
+        events = events.from(start) if start
+        events
+      end
+
+      attr_reader :start, :stream_name, :event_store
+    end
+  end
+end

data/lib/ruby_event_store/rspec/fetch_unpublished_events.rb

@@ -0,0 +1,19 @@
+module RubyEventStore
+  module RSpec
+    class FetchUnpublishedEvents
+      def in(aggregate)
+        @aggregate = aggregate
+      end
+
+      def call
+        aggregate.unpublished_events.to_a
+      end
+
+      def aggregate?
+        !aggregate.nil?
+      end
+
+      attr_reader :aggregate
+    end
+  end
+end

data/lib/ruby_event_store/rspec/have_applied.rb

@@ -3,61 +3,54 @@
 module RubyEventStore
   module RSpec
     class HaveApplied
-      def initialize(mandatory_expected, *optional_expected, differ:, phraser:)
-        @expected  = [mandatory_expected, *optional_expected]
-        @matcher   = ::RSpec::Matchers::BuiltIn::Include.new(*expected)
-        @differ    = differ
-        @phraser   = phraser
+      def initialize(*expected, phraser:, failure_message_formatter:)
+        @expected = ExpectedCollection.new(expected)
+        @failure_message_formatter = failure_message_formatter
+        @phraser = phraser
+        @fetch_events = FetchUnpublishedEvents.new
       end
 
       def matches?(aggregate_root)
-        @events = aggregate_root.unpublished_events.to_a
-        matcher.matches?(events) && matches_count?
+        fetch_events.in(aggregate_root)
+        @events = fetch_events.call
+        MatchEvents.new.call(expected, events)
       end
 
       def exactly(count)
-        @count = count
+        expected.exactly(count)
         self
       end
 
       def times
         self
       end
-      alias :time :times
+      alias time times
 
       def once
-        exactly(1)
+        expected.once
+        self
       end
 
       def strict
-        @matcher = ::RSpec::Matchers::BuiltIn::Match.new(expected)
+        expected.strict
         self
       end
 
       def failure_message
-        "expected #{expected} to be applied, diff:" +
-          differ.diff_as_string(expected.to_s, events.to_s)
+        failure_message_formatter.failure_message(expected, events)
       end
 
       def failure_message_when_negated
-        "expected #{expected} not to be applied, diff:" +
-            differ.diff_as_string(expected.inspect, events.inspect)
+        failure_message_formatter.failure_message_when_negated(expected, events)
       end
 
       def description
-        "have applied events that have to (#{phraser.(expected)})"
+        "have applied events that have to (#{phraser.(expected.events)})"
       end
 
       private
 
-      def matches_count?
-        return true unless count
-        raise NotSupported if expected.size > 1
-        events.select { |e| expected.first === e }.size.equal?(count)
-      end
-
-      attr_reader :differ, :phraser, :expected, :events, :count, :matcher
+      attr_reader :phraser, :expected, :events, :failure_message_formatter, :fetch_events
     end
   end
 end
-

data/lib/ruby_event_store/rspec/have_published.rb

@@ -3,73 +3,77 @@
 module RubyEventStore
   module RSpec
     class HavePublished
-      def initialize(mandatory_expected, *optional_expected, differ:, phraser:)
-        @expected  = [mandatory_expected, *optional_expected]
-        @matcher   = ::RSpec::Matchers::BuiltIn::Include.new(*expected)
-        @differ    = differ
-        @phraser   = phraser
+      def initialize(*expected, phraser:, failure_message_formatter:)
+        @expected = ExpectedCollection.new(expected)
+        @phraser = phraser
+        @failure_message_formatter = failure_message_formatter
+        @fetch_events = FetchEvents.new
       end
 
       def matches?(event_store)
-        @events = event_store.read
-        @events = events.stream(stream_name) if stream_name
-        @events = events.from(start)         if start
-        @events = events.each
-        @matcher.matches?(events) && matches_count?
+        stream_names.all? do |stream_name|
+          fetch_events.stream(stream_name)
+          fetch_events.in(event_store)
+          @published_events = fetch_events.call.to_a
+          @failed_on_stream = stream_name
+          MatchEvents.new.call(expected, published_events)
+        end
       end
 
       def exactly(count)
-        @count = count
+        expected.exactly(count)
         self
       end
 
       def in_stream(stream_name)
-        @stream_name = stream_name
+        @stream_names = [stream_name]
+        self
+      end
+
+      def in_streams(stream_names)
+        @stream_names = Array(stream_names)
         self
       end
 
       def times
         self
       end
-      alias :time :times
+      alias time times
 
       def from(event_id)
-        @start = event_id
+        fetch_events.from(event_id)
         self
       end
 
       def once
-        exactly(1)
+        expected.once
+        self
       end
 
       def failure_message
-        "expected #{expected} to be published, diff:" +
-            differ.diff_as_string(expected.to_s, events.to_a.to_s)
+        failure_message_formatter.failure_message(expected, published_events, failed_on_stream)
       end
 
       def failure_message_when_negated
-        "expected #{expected} not to be published, diff:" +
-            differ.diff_as_string(expected.to_s, events.to_a.to_s)
+        failure_message_formatter.failure_message_when_negated(expected, published_events, failed_on_stream)
       end
 
       def description
-        "have published events that have to (#{phraser.(expected)})"
+        "have published events that have to (#{phraser.(expected.events)})"
       end
 
       def strict
-        @matcher = ::RSpec::Matchers::BuiltIn::Match.new(expected)
+        expected.strict
         self
       end
 
       private
 
-      def matches_count?
-        return true unless count
-        raise NotSupported if expected.size > 1
-        events.select { |e| expected.first === e }.size.equal?(count)
+      def stream_names
+        @stream_names || [nil]
       end
 
-      attr_reader :differ, :phraser, :stream_name, :expected, :count, :events, :start
+      attr_reader :phraser, :expected, :published_events, :failed_on_stream, :failure_message_formatter, :fetch_events
     end
   end
 end

data/lib/ruby_event_store/rspec/have_subscribed_to_events.rb

@@ -12,9 +12,7 @@ module RubyEventStore
 
       def matches?(handler)
         @handler = handler
-        @subscribed_to = expected.select do |event|
-          event_store.subscribers_for(event).include?(handler)
-        end
+        @subscribed_to = expected.select { |event| event_store.subscribers_for(event).include?(handler) }
 
         matcher.matches?(subscribed_to)
       end
@@ -25,13 +23,11 @@ module RubyEventStore
       end
 
       def failure_message
-        "expected #{handler} to be subscribed to events, diff:" +
-          differ.diff_as_string(expected.to_s, subscribed_to.to_s)
+        "expected #{handler} to be subscribed to events, diff:" + differ.diff(expected.to_s + "\n", subscribed_to)
       end
 
       def failure_message_when_negated
-        "expected #{handler} not to be subscribed to events, diff:" +
-          differ.diff_as_string(expected.to_s, subscribed_to.to_s)
+        "expected #{handler} not to be subscribed to events, diff:" + differ.diff(expected.to_s + "\n", subscribed_to)
       end
 
       def description
@@ -40,9 +36,7 @@ module RubyEventStore
 
       private
 
-      attr_reader :expected, :handler, :subscribed_to,
-                  :differ, :phraser, :matcher, :event_store
+      attr_reader :expected, :handler, :subscribed_to, :differ, :phraser, :matcher, :event_store
     end
   end
 end
-

data/lib/ruby_event_store/rspec/match_events.rb

@@ -0,0 +1,32 @@
+module RubyEventStore
+  module RSpec
+    class MatchEvents
+      def call(expected, events)
+        if match_events?(expected)
+          matcher(expected).matches?(events) && matches_count?(expected, events)
+        else
+          !events.empty?
+        end
+      end
+
+      private
+
+      def matches_count?(expected, events)
+        return true unless expected.specified_count?
+        events.select { |e| expected.event === e }.size.equal?(expected.count)
+      end
+
+      def matcher(expected)
+        if expected.strict?
+          ::RSpec::Matchers::BuiltIn::Match.new(expected.events)
+        else
+          ::RSpec::Matchers::BuiltIn::Include.new(*expected.events)
+        end
+      end
+
+      def match_events?(expected)
+        !expected.empty?
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rspec/matchers.rb

@@ -8,11 +8,7 @@ module RubyEventStore
           def call(object)
             items = Array(object).compact.map { |o| format(o) }
             return "" if items.empty?
-            if items.one?
-              items.join
-            else
-              "#{items[all_but_last].join(", ")} and #{items.fetch(-1)}"
-            end
+            items.one? ? items.join : "#{items[all_but_last].join(", ")} and #{items.fetch(-1)}"
           end
 
           private
@@ -22,11 +18,7 @@ module RubyEventStore
           end
 
           def format(object)
-            if object.respond_to?(:description)
-              ::RSpec::Support::ObjectFormatter.format(object)
-            else
-              "be a #{object}"
-            end
+            object.respond_to?(:description) ? ::RSpec::Support::ObjectFormatter.format(object) : "be a #{object}"
           end
         end
       end
@@ -34,16 +26,24 @@ module RubyEventStore
       def be_an_event(expected)
         BeEvent.new(expected, differ: differ, formatter: formatter)
       end
-      alias :be_event :be_an_event
-      alias :an_event :be_an_event
-      alias :event    :be_an_event
+      alias be_event be_an_event
+      alias an_event be_an_event
+      alias event be_an_event
 
       def have_published(*expected)
-        HavePublished.new(*expected, differ: differ, phraser: phraser)
+        HavePublished.new(
+          *expected,
+          phraser: phraser,
+          failure_message_formatter: RSpec.default_formatter.have_published(differ)
+        )
       end
 
       def have_applied(*expected)
-        HaveApplied.new(*expected, differ: differ, phraser: phraser)
+        HaveApplied.new(
+          *expected,
+          phraser: phraser,
+          failure_message_formatter: RSpec.default_formatter.have_applied(differ)
+        )
       end
 
       def have_subscribed_to_events(*expected)
@@ -51,11 +51,11 @@ module RubyEventStore
       end
 
       def publish(*expected)
-        Publish.new(*expected)
+        Publish.new(*expected, failure_message_formatter: RSpec.default_formatter.publish(differ))
       end
 
       def apply(*expected)
-        Apply.new(*expected)
+        Apply.new(*expected, failure_message_formatter: RSpec.default_formatter.apply(differ))
       end
 
       private
@@ -65,7 +65,7 @@ module RubyEventStore
       end
 
       def differ
-        ::RSpec::Support::Differ.new(color: ::RSpec::Matchers.configuration.color?)
+        ::RSpec::Expectations.differ
       end
 
       def phraser

data/lib/ruby_event_store/rspec/publish.rb

@@ -3,61 +3,66 @@
 module RubyEventStore
   module RSpec
     class Publish
+      def initialize(*expected, failure_message_formatter:)
+        @expected = ExpectedCollection.new(expected)
+        @failure_message_formatter = failure_message_formatter
+        @fetch_events = FetchEvents.new
+      end
+
       def in(event_store)
-        @event_store = event_store
+        fetch_events.in(event_store)
         self
       end
 
-      def in_stream(stream)
-        @stream = stream
+      def in_stream(stream_name)
+        @stream_names = [stream_name]
         self
       end
 
-      def matches?(event_proc)
-        raise_event_store_not_set unless @event_store
-        spec = @event_store.read
-        spec = spec.stream(@stream) if @stream
-        last_event_before_block = spec.last
-        event_proc.call
-        spec = spec.from(last_event_before_block.event_id) if last_event_before_block
-        @published_events = spec.to_a
-        if match_events?
-          ::RSpec::Matchers::BuiltIn::Include.new(*@expected).matches?(@published_events)
-        else
-          !@published_events.empty?
-        end
+      def in_streams(stream_names)
+        @stream_names = Array(stream_names)
+        self
       end
 
-      def failure_message
-        if match_events?
-          <<-EOS
-expected block to have published:
-
-#{@expected}
+      def exactly(count)
+        expected.exactly(count)
+        self
+      end
 
-#{"in stream #{@stream} " if @stream}but published:
+      def once
+        expected.once
+        self
+      end
 
-#{@published_events}
-EOS
-        else
-          "expected block to have published any events"
-        end
+      def times
+        self
       end
+      alias time times
 
-      def failure_message_when_negated
-        if match_events?
-          <<-EOS
-expected block not to have published:
+      def strict
+        expected.strict
+        self
+      end
 
-#{@expected}
+      def matches?(event_proc)
+        fetch_events.from_last
+        event_proc.call
+        stream_names.all? do |stream_name|
+          fetch_events.stream(stream_name)
+          @published_events = fetch_events.call.to_a
+          @failed_on_stream = stream_name
+          MatchEvents.new.call(expected, published_events)
+        end
+      rescue FetchEvents::MissingEventStore
+        raise "You have to set the event store instance with `in`, e.g. `expect { ... }.to publish(an_event(MyEvent)).in(event_store)`"
+      end
 
-#{"in stream #{@stream} " if @stream}but published:
+      def failure_message
+        failure_message_formatter.failure_message(expected, published_events, failed_on_stream)
+      end
 
-#{@published_events}
-EOS
-        else
-          "expected block not to have published any events"
-        end
+      def failure_message_when_negated
+        failure_message_formatter.failure_message_when_negated(expected, published_events, fetch_events.stream_name)
       end
 
       def description
@@ -70,17 +75,11 @@ EOS
 
       private
 
-      def initialize(*expected)
-        @expected = expected
+      def stream_names
+        @stream_names || [nil]
       end
 
-      def match_events?
-        !@expected.empty?
-      end
-
-      def raise_event_store_not_set
-        raise SyntaxError, "You have to set the event store instance with `in`, e.g. `expect { ... }.to publish(an_event(MyEvent)).in(event_store)`"
-      end
+      attr_reader :fetch_events, :expected, :failure_message_formatter, :published_events, :failed_on_stream
     end
   end
 end

data/lib/ruby_event_store/rspec/step_by_step_failure_message_formatter.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module RSpec
+    class StepByStepFailureMessageFormatter
+      class Lingo
+        def initialize(published)
+          @published = published
+        end
+        attr_reader :published
+      end
+
+      class HavePublished
+        def initialize(differ, lingo)
+          @differ = differ
+          @lingo = lingo
+        end
+
+        def failure_message(expected, events, stream_name = nil)
+          return failure_message_strict(expected, events) if expected.strict?
+          return failure_message_no_events if expected.empty?
+          expected.events.each do |expected_event|
+            correct_event_count = 0
+            events_with_correct_type = []
+            events.each do |actual_event|
+              if expected_event.matches?(actual_event)
+                correct_event_count += 1
+              elsif expected_event.matches_kind?(actual_event)
+                events_with_correct_type << actual_event
+              end
+            end
+
+            expectations = expected_message(expected, expected_event, stream_name)
+
+            if expected.specified_count?
+              if correct_event_count >= 1
+                reality = failure_message_incorrect_count(expected_event, events_with_correct_type, correct_event_count)
+              elsif !events_with_correct_type.empty?
+                reality = failure_message_correct_type_incorrect_payload(expected_event, events_with_correct_type)
+              else
+                reality = failure_message_incorrect_type
+              end
+            else
+              if correct_event_count >= 1
+                next
+              else
+                if !events_with_correct_type.empty?
+                  reality = failure_message_correct_type_incorrect_payload(expected_event, events_with_correct_type)
+                else
+                  reality = failure_message_incorrect_type
+                end
+              end
+            end
+
+            return expectations + reality
+          end
+        end
+
+        def failure_message_when_negated(expected, events, _stream_name = nil)
+          return failure_message_when_negated_no_events if expected.empty?
+          if expected.specified_count?
+            <<~EOS
+            expected
+              #{expected.events.first.description}
+            not to be #{lingo.published} exactly #{expected.count} times
+
+            #{actual_events_list(events)}
+            EOS
+          else
+            <<~EOS
+            expected #{expected_events_list(expected.events)} not to #{"exactly " if expected.strict?}be #{lingo.published}
+
+            #{actual_events_list(events)}
+            EOS
+          end
+        end
+
+        private
+
+        attr_reader :differ, :lingo
+
+        def failure_message_no_events
+          "expected anything to be #{lingo.published}\n"
+        end
+
+        def failure_message_when_negated_no_events
+          "expected something to be #{lingo.published}\n"
+        end
+
+        def failure_message_incorrect_count(expected_event, events_with_correct_type, correct_event_count)
+          [
+            <<~EOS,
+
+            but was #{lingo.published} #{correct_event_count} times
+            EOS
+            if !events_with_correct_type.empty?
+              [
+                <<~EOS.strip,
+              There are events of correct type but with incorrect payload:
+                EOS
+                events_with_correct_type.each_with_index.map do |event_with_correct_type, index|
+                  event_diff(expected_event, event_with_correct_type, index)
+                end,
+                nil
+              ]
+            end
+          ].compact.join("\n")
+        end
+
+        def failure_message_correct_type_incorrect_payload(expected_event, events_with_correct_type)
+          <<~EOS
+          , but it was not #{lingo.published}
+
+          There are events of correct type but with incorrect payload:
+          #{events_with_correct_type.each_with_index.map { |event_with_correct_type, index| event_diff(expected_event, event_with_correct_type, index) }.join("\n")}
+          EOS
+        end
+
+        def event_diff(expected_event, event_with_correct_type, index)
+          [
+            "#{index + 1}) #{event_with_correct_type.inspect}",
+            indent(data_diff(expected_event, event_with_correct_type), 4),
+            indent(metadata_diff(expected_event, event_with_correct_type), 4)
+          ].reject(&:empty?)
+        end
+
+        def indent(str, count)
+          str.to_s.split("\n").map { |l| l.sub(//, " " * count) }
+        end
+
+        def failure_message_incorrect_type
+          <<~EOS
+          , but there is no event with such type
+          EOS
+        end
+
+        def failure_message_strict(expected, events)
+          if expected.specified_count?
+            <<~EOS
+            expected only
+              #{expected.events.first.description}
+            to be #{lingo.published} #{expected.count} times
+
+            #{actual_events_list(events)}
+            EOS
+          else
+            <<~EOS
+            expected only #{expected_events_list(expected.events)} to be #{lingo.published}
+
+            #{actual_events_list(events)}
+            EOS
+          end
+        end
+
+        def data_diff(expected_event, event_with_correct_type)
+          if !expected_event.expected_data.nil?
+            "data diff:#{differ.diff(expected_event.expected_data, event_with_correct_type.data)}"
+          end
+        end
+
+        def metadata_diff(expected_event, event_with_correct_type)
+          if !expected_event.expected_metadata.nil?
+            "metadata diff:#{differ.diff(expected_event.expected_metadata, event_with_correct_type.metadata.to_h)}"
+          end
+        end
+
+        def expected_message(expected, expected_event, stream_name)
+          expected_stream = " in stream #{stream_name}" if stream_name
+          if expected.specified_count?
+            <<~EOS
+            expected event
+              #{expected_event.description}
+            to be #{lingo.published} #{expected.count} times#{expected_stream}
+            EOS
+          else
+            <<~EOS
+            expected #{expected_events_list(expected.events)} to be #{lingo.published}#{expected_stream}
+
+            i.e. expected event
+              #{expected_event.description}
+            to be #{lingo.published}
+            EOS
+          end.strip
+        end
+
+        def expected_events_list(expected)
+          <<~EOS.strip
+          [
+          #{expected.map(&:description).map { |d| indent(d, 2) }.join("\n")}
+          ]
+          EOS
+        end
+
+        def actual_events_list(actual)
+          <<~EOS.strip
+          but the following was #{lingo.published}: [
+          #{actual.map(&:inspect).map { |d| indent(d, 2) }.join("\n")}
+          ]
+          EOS
+        end
+      end
+
+      def have_published(differ)
+        HavePublished.new(differ, Lingo.new("published"))
+      end
+
+      def publish(differ)
+        HavePublished.new(differ, Lingo.new("published"))
+      end
+
+      def have_applied(differ)
+        HavePublished.new(differ, Lingo.new("applied"))
+      end
+
+      def apply(differ)
+        HavePublished.new(differ, Lingo.new("applied"))
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rspec/version.rb

@@ -2,6 +2,6 @@
 
 module RubyEventStore
   module RSpec
-    VERSION = "2.1.0"
+    VERSION = "2.4.0"
   end
 end

data/lib/ruby_event_store/rspec.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'rspec'
+require "rspec"
 
 module RubyEventStore
   module RSpec
@@ -8,15 +8,31 @@ module RubyEventStore
   end
 end
 
-require "ruby_event_store/rspec/version"
-require "ruby_event_store/rspec/be_event"
-require "ruby_event_store/rspec/have_published"
-require "ruby_event_store/rspec/have_applied"
-require "ruby_event_store/rspec/have_subscribed_to_events"
-require "ruby_event_store/rspec/publish"
-require "ruby_event_store/rspec/apply"
-require "ruby_event_store/rspec/matchers"
+require_relative "rspec/version"
+require_relative "rspec/be_event"
+require_relative "rspec/expected_collection"
+require_relative "rspec/fetch_events"
+require_relative "rspec/fetch_unpublished_events"
+require_relative "rspec/match_events"
+require_relative "rspec/have_published"
+require_relative "rspec/have_applied"
+require_relative "rspec/have_subscribed_to_events"
+require_relative "rspec/publish"
+require_relative "rspec/apply"
+require_relative "rspec/crude_failure_message_formatter"
+require_relative "rspec/step_by_step_failure_message_formatter"
+require_relative "rspec/matchers"
 
-::RSpec.configure do |config|
-  config.include ::RubyEventStore::RSpec::Matchers
+module RubyEventStore
+  module RSpec
+    def self.default_formatter=(new_formatter)
+      @@default_formatter = new_formatter
+    end
+
+    def self.default_formatter
+      @@default_formatter ||= CrudeFailureMessageFormatter.new
+    end
+  end
 end
+
+::RSpec.configure { |config| config.include ::RubyEventStore::RSpec::Matchers }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby_event_store-rspec
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.4.0
 platform: ruby
 authors:
 - Arkency
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2022-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -35,11 +35,17 @@ files:
 - lib/ruby_event_store/rspec.rb
 - lib/ruby_event_store/rspec/apply.rb
 - lib/ruby_event_store/rspec/be_event.rb
+- lib/ruby_event_store/rspec/crude_failure_message_formatter.rb
+- lib/ruby_event_store/rspec/expected_collection.rb
+- lib/ruby_event_store/rspec/fetch_events.rb
+- lib/ruby_event_store/rspec/fetch_unpublished_events.rb
 - lib/ruby_event_store/rspec/have_applied.rb
 - lib/ruby_event_store/rspec/have_published.rb
 - lib/ruby_event_store/rspec/have_subscribed_to_events.rb
+- lib/ruby_event_store/rspec/match_events.rb
 - lib/ruby_event_store/rspec/matchers.rb
 - lib/ruby_event_store/rspec/publish.rb
+- lib/ruby_event_store/rspec/step_by_step_failure_message_formatter.rb
 - lib/ruby_event_store/rspec/version.rb
 homepage: https://railseventstore.org
 licenses:
@@ -49,6 +55,7 @@ metadata:
   changelog_uri: https://github.com/RailsEventStore/rails_event_store/releases
   source_code_uri: https://github.com/RailsEventStore/rails_event_store
   bug_tracker_uri: https://github.com/RailsEventStore/rails_event_store/issues
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -57,14 +64,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.7'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.3.7
 signing_key:
 specification_version: 4
 summary: RSpec matchers for RubyEventStore