ruby_event_store-rspec 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e1362df53ba19bf0a2194492d627ab17cd22ee658c9fefa47b5c61c0b8eec562
-  data.tar.gz: c665c377cf751768cb1ec6abd8f486231ae382c6dafaef36e8cf0aaf01bc3800
+  metadata.gz: 2824fc38cdb13ea93b60cc332617ae107281ca075102897cf3b3627b5455bd07
+  data.tar.gz: 2ad9ac851fb63a5707d679679a86aa294bc80754c054d4b1210005212cb395d9
 SHA512:
-  metadata.gz: 94e802c2bbed41e35aa8f8a2507cc127afe2e853e2266d60a56ea240f98c09f357bf7c664e7489de95a3f69d0b4892cd7f50a1c261fe2e7c995b531b45518fe4
-  data.tar.gz: bf4cc3ec24389daf273187565731d7dc460e2d2ba9621605dafbbce46b19df9324f27cc98deb8c749955e15b10a3c6dd8167f36ae07fbea0592a2c2b8e884261
+  metadata.gz: 6756a69b71fb2c42cb484988a85f365134026f7fc8a4f9dde87cbac934d9190234a2788790fb89a6f9588e4b3ff9aa4b799ca893524c8614482aa76ec592dc5c
+  data.tar.gz: 5f9c80aff6dffe7c16ec7da698e7f1d84af2554121d51b0bcefae0ff113fc785cf97162d811441a7e29ba375ad4fee208c263c2ba9ac6b8c56d5711189f896cd

data/lib/ruby_event_store/rspec.rb

@@ -8,14 +8,32 @@ 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"
+
+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 do |config|
   config.include ::RubyEventStore::RSpec::Matchers

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

@@ -90,7 +90,7 @@ module RubyEventStore
           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
 
@@ -124,7 +124,7 @@ module RubyEventStore
 
       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)
@@ -167,25 +167,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,130 @@
+# 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,20 +3,21 @@
 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
+      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
 
@@ -26,38 +27,30 @@ module RubyEventStore
       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,28 +3,35 @@
 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
+      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
 
@@ -34,42 +41,39 @@ module RubyEventStore
       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

@@ -26,12 +26,12 @@ module RubyEventStore
 
       def failure_message
         "expected #{handler} to be subscribed to events, diff:" +
-          differ.diff_as_string(expected.to_s, subscribed_to.to_s)
+          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)
+          differ.diff(expected.to_s + "\n", subscribed_to)
       end
 
       def description

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

@@ -39,11 +39,11 @@ module RubyEventStore
       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,218 @@
+# 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 {|event_with_correct_type, index| event_diff(expected_event, event_with_correct_type, index) },
+                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.2.0"
   end
 end

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.2.0
 platform: ruby
 authors:
 - Arkency
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-01-07 00:00:00.000000000 Z
+date: 2021-04-09 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:
@@ -57,7 +63,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="