Reduce API surface.

Let's have one completely tested syntax before expanding options.

Author: mostlyobvious

rails_event_store-rspec/Makefile

@@ -6,7 +6,8 @@ IGNORE      = RailsEventStore::RSpec::Matchers\#differ \
               RailsEventStore::RSpec::Matchers\#have_published \
               RailsEventStore::RSpec::Matchers\#have_applied \
               RailsEventStore::RSpec::Matchers\#publish \
-              RailsEventStore::RSpec::Matchers\#be_an_event
+              RailsEventStore::RSpec::Matchers\#be_an_event \
+              RailsEventStore::RSpec::Publish\#last_event
 SUBJECT     ?= RailsEventStore::RSpec*
 
 install: ## Install gem dependencies

rails_event_store-rspec/lib/rails_event_store/rspec/matchers.rb

@@ -38,8 +38,8 @@ def have_applied(*expected)
         HaveApplied.new(*expected, differ: differ, phraser: phraser)
       end
 
-      def publish(event = nil, &block)
-        Publish.new(event, &block)
+      def publish(*expected)
+        Publish.new(*expected)
       end
 
       private

rails_event_store-rspec/lib/rails_event_store/rspec/publish.rb

@@ -2,69 +2,59 @@
 
 module RailsEventStore
   module RSpec
-    class Publish < ::RSpec::Matchers::BuiltIn::BaseMatcher
-      def in(event_store, &block)
+    class Publish
+      def in(event_store)
         @event_store = event_store
-        @block = block if block_given?
         self
       end
 
-      def in_stream(stream, &block)
+      def in_stream(stream)
         @stream = stream
-        @block = block if block_given?
         self
       end
 
       def matches?(event_proc)
         raise_event_store_not_set unless @event_store
-        @event_proc = event_proc
-        return false unless Proc === event_proc
         spec = @event_store.read
         spec = spec.stream(@stream) if @stream
-        last_event_before_block = spec.backward.limit(1).each.to_a.first
+        last_event_before_block = last_event(spec)
         event_proc.call
         spec = spec.from(last_event_before_block.event_id) if last_event_before_block
         @published_events = spec.each.to_a
-        if @block
-          @block.call(@published_events)
-        elsif @event
-          ::RSpec::Matchers::BuiltIn::Include.new(*@event).matches?(@published_events)
+        if match_events?
+          ::RSpec::Matchers::BuiltIn::Include.new(*@expected).matches?(@published_events)
         else
           !@published_events.empty?
         end
       end
 
-      def does_not_match?(event_proc)
-        !matches?(event_proc) && Proc === event_proc
-      end
-
       def failure_message
-        if @event
+        if match_events?
           <<-EOS
-  expected block to have published:
+expected block to have published:
 
-  #{@event.inspect}
+#{@expected}
 
-  #{"in stream #{@stream} " if @stream}but published:
+#{"in stream #{@stream} " if @stream}but published:
 
-  #{@published_events.inspect}
-          EOS
+#{@published_events}
+EOS
         else
           "expected block to have published any events"
         end
       end
 
       def failure_message_when_negated
-        if @event
+        if match_events?
           <<-EOS
-  expected block not to have published:
+expected block not to have published:
 
-  #{@event.inspect}
+#{@expected}
 
-  #{"in stream #{@stream} " if @stream}but published:
+#{"in stream #{@stream} " if @stream}but published:
 
-  #{@published_events.inspect}
-          EOS
+#{@published_events}
+EOS
         else
           "expected block not to have published any events"
         end
@@ -80,11 +70,16 @@ def supports_block_expectations?
 
       private
 
-      def initialize(event = nil, &block)
-        @event = event
-        @stream = nil
-        @event_store = nil
-        @block = block
+      def initialize(*expected)
+        @expected = expected
+      end
+
+      def match_events?
+        !@expected.empty?
+      end
+
+      def last_event(spec)
+        spec.backward.limit(1).each.first
       end
 
       def raise_event_store_not_set

rails_event_store-rspec/spec/rails_event_store/rspec/matchers_spec.rb

@@ -68,6 +68,10 @@ module RSpec
         aggregate_root.bar
         expect(aggregate_root).to matchers.have_applied(matchers.an_event(FooEvent), matchers.an_event(BarEvent))
       end
+
+      specify do
+        expect(matchers.publish).to be_a(Publish)
+      end
     end
 
     module Matchers

rails_event_store-rspec/spec/rails_event_store/rspec/publish_spec.rb

@@ -11,58 +11,64 @@ module RSpec
         )
       end
 
-      def matcher(*events, &block)
-        Publish.new(events, &block)
+      def matcher(*expected)
+        Publish.new(*expected)
       end
 
       specify do
         expect {
           expect {
             true
-          }.to Publish.new()
+          }.to matcher
         }.to raise_error(SyntaxError, "You have to set the event store instance with `in`, e.g. `expect { ... }.to publish(an_event(MyEvent)).in(event_store)`")
       end
 
       specify do
         expect {
           true
-        }.not_to Publish.new.in(event_store)
+        }.not_to matcher.in(event_store)
       end
 
       specify do
         expect {
           event_store.publish_event(FooEvent.new)
-        }.to Publish.new.in(event_store)
+        }.to matcher.in(event_store)
       end
 
       specify do
         expect {
-          true
-        }.to Publish.new{ |events|
-          expect(events).to eq []
-        }.in(event_store)
+          event_store.publish_event(FooEvent.new, stream_name: 'Foo$1')
+        }.to matcher.in(event_store).in_stream('Foo$1')
       end
 
       specify do
-        foo_event = FooEvent.new
-        bar_event = BarEvent.new
         expect {
-          event_store.publish_event(foo_event)
-          event_store.publish_event(bar_event)
-        }.to Publish.new.in(event_store){ |events|
-          expect(events).to eq [foo_event, bar_event]
-        }
+          event_store.publish_event(FooEvent.new, stream_name: 'Foo$1')
+        }.not_to matcher.in(event_store).in_stream('Bar$1')
       end
 
       specify do
-        foo_event = FooEvent.new
-        bar_event = BarEvent.new
-        event_store.publish_event(foo_event)
         expect {
-          event_store.publish_event(bar_event)
-        }.to Publish.new.in(event_store){ |events|
-          expect(events).to eq [bar_event]
-        }
+          event_store.publish_event(FooEvent.new)
+        }.not_to matcher(matchers.an_event(BarEvent)).in(event_store)
+      end
+
+      specify do
+        expect {
+          event_store.publish_event(FooEvent.new)
+        }.to matcher(matchers.an_event(FooEvent)).in(event_store)
+      end
+
+      specify do
+        expect {
+          event_store.publish_event(FooEvent.new, stream_name: "Foo$1")
+        }.to matcher(matchers.an_event(FooEvent)).in(event_store).in_stream("Foo$1")
+      end
+
+      specify do
+        expect {
+          event_store.publish_event(FooEvent.new)
+        }.not_to matcher(matchers.an_event(FooEvent)).in(event_store).in_stream("Foo$1")
       end
 
       specify do
@@ -71,39 +77,108 @@ def matcher(*events, &block)
         expect {
           event_store.publish_event(foo_event, stream_name: "Foo$1")
           event_store.publish_event(bar_event, stream_name: "Bar$1")
-        }.to Publish.new.in(event_store).in_stream("Foo$1"){ |events|
-          expect(events).to eq [foo_event]
-        }
+        }.to matcher(matchers.an_event(FooEvent), matchers.an_event(BarEvent)).in(event_store)
       end
 
       specify do
+        foo_event = FooEvent.new
+        bar_event = BarEvent.new
+
+        event_store.publish_event(foo_event)
         expect {
-          event_store.publish_event(FooEvent.new, stream_name: 'Foo$1')
-        }.to Publish.new.in(event_store).in_stream('Foo$1')
+          event_store.publish_event(bar_event)
+        }.not_to matcher(matchers.an_event(FooEvent)).in(event_store)
       end
 
       specify do
         expect {
-          event_store.publish_event(FooEvent.new, stream_name: 'Foo$1')
-        }.not_to Publish.new.in(event_store).in_stream('Bar$1')
+          true
+        }.not_to matcher.in(event_store)
       end
 
       specify do
-        expect {
-          event_store.publish_event(FooEvent.new)
-        }.to Publish.new(matchers.an_event(FooEvent)).in(event_store)
+        _matcher = matcher.in(event_store)
+        _matcher.matches?(Proc.new { })
+
+        expect(_matcher.failure_message_when_negated.to_s).to eq(<<~EOS.strip)
+          expected block not to have published any events
+        EOS
       end
 
       specify do
-        expect {
-          event_store.publish_event(FooEvent.new, stream_name: "Foo$1")
-        }.to Publish.new(matchers.an_event(FooEvent)).in(event_store).in_stream("Foo$1")
+        _matcher = matcher.in(event_store)
+        _matcher.matches?(Proc.new { })
+
+        expect(_matcher.failure_message.to_s).to eq(<<~EOS.strip)
+          expected block to have published any events
+        EOS
       end
 
       specify do
-        expect {
-          event_store.publish_event(FooEvent.new)
-        }.not_to Publish.new(matchers.an_event(FooEvent)).in(event_store).in_stream("Foo$1")
+        _matcher = matcher(actual = matchers.an_event(FooEvent)).in(event_store)
+        _matcher.matches?(Proc.new { })
+
+        expect(_matcher.failure_message.to_s).to eq(<<~EOS)
+          expected block to have published:
+
+          #{[actual].inspect}
+
+          but published:
+
+          []
+        EOS
+      end
+
+      specify do
+        _matcher = matcher(actual = matchers.an_event(FooEvent)).in_stream('foo').in(event_store)
+        _matcher.matches?(Proc.new { })
+
+        expect(_matcher.failure_message.to_s).to eq(<<~EOS)
+          expected block to have published:
+
+          #{[actual].inspect}
+
+          in stream foo but published:
+
+          []
+        EOS
+      end
+
+      specify do
+        foo_event = FooEvent.new
+        _matcher = matcher(actual = matchers.an_event(FooEvent)).in(event_store)
+        _matcher.matches?(Proc.new { event_store.publish_event(foo_event) })
+
+        expect(_matcher.failure_message_when_negated.to_s).to eq(<<~EOS)
+          expected block not to have published:
+
+          #{[actual].inspect}
+
+          but published:
+
+          #{[foo_event].inspect}
+        EOS
+      end
+
+      specify do
+        foo_event = FooEvent.new
+        _matcher = matcher(actual = matchers.an_event(FooEvent)).in_stream('foo').in(event_store)
+        _matcher.matches?(Proc.new { event_store.publish_event(foo_event, stream_name: 'foo') })
+
+        expect(_matcher.failure_message_when_negated.to_s).to eq(<<~EOS)
+          expected block not to have published:
+
+          #{[actual].inspect}
+
+          in stream foo but published:
+
+          #{[foo_event].inspect}
+        EOS
+      end
+
+      specify do
+        _matcher = matcher
+        expect(_matcher.description).to eq("publish events")
       end
     end
   end