ruby_event_store-rspec 2.0.0 → 2.3.0

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