ruby_event_store-rspec 2.0.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd0942f48e1aea9cc5a5a67ffb5bbe5816c774f9d41db4bc0fda35e5061dd9d6
-  data.tar.gz: 7376fe3939f833e8747fa3dd511de534a07616c45fd2f71704d05d325ae6d681
+  metadata.gz: 2aaf7916e409889b919cfb186ac2c7a0864658719a569138add1294941b66a6c
+  data.tar.gz: 1d03da7f66c3c055f07eaf066ebb1c780c39fc222e37fa92e31ff23918a13272
 SHA512:
-  metadata.gz: cd0d6771ff5f9716171c2eb33209d5844bed93b24acef8704259d8784d97bbd756cb41ef7d20b3d265a35f90b3d5b9a514987017091f8aec51550958b0e1f5bf
-  data.tar.gz: 2c1e227d7560312c0cc9f8934d1e501cbff3df854f109adf421c37909398931ccaefa1cc470e0aaae34578e141121160eb66853ac0dc902c11859704c8aeda5f
+  metadata.gz: 3b79ad1a3165e1355e3570a59242011570c39c47332a10947937d58b9f54881b65a9872b956736b5861840dbac5ff1ba21e3ea07e7c9238c62e2b1ac96504136
+  data.tar.gz: c4419133a70833970e69672a0b105c5076357753e073e88b6eadfe361a64516ddc8fda6a97d76bbc0020772a43e891391d0e873081a9d804273921ec052a6cfd

data/README.md

@@ -1,206 +1,6 @@
-# RailsEventStore::RSpec
+# RubyEventStore::RSpec
 
-## Installation
+RSpec matchers for RubyEventStore.
 
-Add this line to your application's Gemfile:
+Find out more at [https://railseventstore.org](https://railseventstore.org/)
 
-```ruby
-group :test do
-  gem 'ruby_event_store-rspec'
-end
-```
-
-## Usage
-
-### be_event
-
-The `be_event` matcher enables you to make expectations on a domain event. It exposes fluent interface.
-
-```ruby
-OrderPlaced  = Class.new(RubyEventStore::Event)
-domain_event = OrderPlaced.new(
-  data: {
-    order_id: 42,
-    net_value: BigDecimal.new("1999.0")
-  },
-  metadata: {
-    remote_ip: '1.2.3.4'
-  }
-)
-
-expect(domain_event)
-  .to(be_an_event(OrderPlaced)
-    .with_data(order_id: 42, net_value: BigDecimal.new("1999.0"))
-    .with_metadata(remote_ip: '1.2.3.4'))
-```
-
-By default the behaviour of `with_data` and `with_metadata` is not strict, that is the expectation is met when all specified values for keys match. Additional data or metadata that is not specified to be expected does not change the outcome.
-
-```ruby
-domain_event = OrderPlaced.new(
-  data: {
-    order_id: 42,
-    net_value: BigDecimal.new("1999.0")
-  }
-)
-
-# this would pass even though data contains also net_value
-expect(domain_event).to be_an_event(OrderPlaced).with_data(order_id: 42)
-```
-
-This matcher is both [composable](http://rspec.info/blog/2014/01/new-in-rspec-3-composable-matchers/) and accepting [built-in matchers](https://relishapp.com/rspec/rspec-expectations/v/3-6/docs/built-in-matchers) as a part of an expectation.
-
-```ruby
-expect(domain_event).to be_an_event(OrderPlaced).with_data(order_id: kind_of(Integer))
-expect([domain_event]).to include(an_event(OrderPlaced))
-```
-
-If you depend on matching the exact data or metadata, there's a `strict` modifier.
-
-```ruby
-domain_event = OrderPlaced.new(
-  data: {
-    order_id: 42,
-    net_value: BigDecimal.new("1999.0")
-  }
-)
-
-# this would fail as data contains unexpected net_value
-expect(domain_event).to be_an_event(OrderPlaced).with_data(order_id: 42).strict
-```
-
-Mind that `strict` makes both `with_data` and `with_metadata` behave in a stricter way. If you need to mix both, i.e. strict data but non-strict metadata then consider composing matchers.
-
-```ruby
-expect(domain_event)
-  .to(be_event(OrderPlaced).with_data(order_id: 42, net_value: BigDecimal.new("1999.0")).strict
-    .and(an_event(OrderPlaced).with_metadata(timestamp: kind_of(Time)))
-```
-
-You may have noticed the same matcher being referenced as `be_event`, `be_an_event` and `an_event`. There's also just `event`. Use whichever reads better grammatically.
-
-### have_published
-
-Use this matcher to target `event_store` and reading from streams specifically.
-In a simplest form it would read all streams backward up to a page limit (100 events) and check whether the expectation holds true. Its behaviour can be best compared to the `include` matcher — it is satisfied by at least one element present in the collection. You're encouraged to compose it with `be_event`.
-
-```ruby
-event_store = RailsEventStore::Client.new
-event_store.publish(OrderPlaced.new(data: { order_id: 42 }))
-
-expect(event_store).to have_published(an_event(OrderPlaced))
-```
-
-Expectation can be narrowed to the specific stream.
-
-```ruby
-event_store = RailsEventStore::Client.new
-event_store.publish(OrderPlaced.new(data: { order_id: 42 }), stream_name: "Order$42")
-
-expect(event_store).to have_published(an_event(OrderPlaced)).in_stream("Order$42")
-```
-
-It is sometimes important to ensure no additional events have been published. Luckliy there's a modifier to cover that usecase.
-
-```ruby
-expect(event_store).not_to have_published(an_event(OrderPlaced)).once
-expect(event_store).to have_published(an_event(OrderPlaced)).exactly(2).times
-```
-
-Finally you can make expectation on several events at once.
-
-```ruby
-expect(event_store).to have_published(
-  an_event(OrderPlaced),
-  an_event(OrderExpired).with_data(expired_at: be_between(Date.yesterday, Date.tomorrow))
-)
-```
-
-If there's a usecase not covered by examples above or you need a different set of events to make expectations on you can always resort to a more verbose approach and skip `have_published`.
-
-```ruby
-expect(event_store.read_events_forward("OrderAuditLog$42", count: 2)).to eq([
-  an_event(OrderPlaced),
-  an_event(OrderExpired)
-])
-```
-
-### have_applied
-
-This matcher is intended to be used on [aggregate root](https://github.com/RailsEventStore/rails_event_store/tree/master/aggregate_root#usage). Behaviour is almost identical to `have_published` counterpart, except the concept of stream. Expecations are made against internal unpublished events collection.
-
-```ruby
-class Order
-  include AggregateRoot
-  HasBeenAlreadySubmitted = Class.new(StandardError)
-  HasExpired              = Class.new(StandardError)
-
-  def initialize
-    self.state = :new
-    # any other code here
-  end
-
-  def submit
-    raise HasBeenAlreadySubmitted if state == :submitted
-    raise HasExpired if state == :expired
-    apply OrderSubmitted.new(data: {delivery_date: Time.now + 24.hours})
-  end
-
-  def expire
-    apply OrderExpired.new
-  end
-
-  private
-  attr_accessor :state
-
-  def apply_order_submitted(event)
-    self.state = :submitted
-  end
-
-  def apply_order_expired(event)
-    self.state = :expired
-  end
-end
-```
-
-```ruby
-aggregate_root = Order.new
-aggregate_root.submit
-
-expect(aggregate_root).to have_applied(event(OrderSubmitted)).once
-```
-
-### have_subscribed_to_events
-
-Use this matcher to make sure that a handler has subscribed to events in target `event_store` or not.
-
-```ruby
-event_store = RailsEventStore::Client.new
-
-# it will pass if Handler has subscribed to both events
-expect(Handler).to have_subscribed_to_events(FooEvent, BarEvent).in(event_store)
-
-# it will fail if Handler has subscribed to any event
-expect(Handler).not_to have_subscribed_to_events(FooEvent, BarEvent).in(event_store)
-```
-## Code status
-
-[![Build Status](https://travis-ci.org/RailsEventStore/rails_event_store-rspec.svg?branch=master)](https://travis-ci.org/RailsEventStore/rails_event_store-rspec)
-[![Gem Version](https://badge.fury.io/rb/rails_event_store-rspec.svg)](https://badge.fury.io/rb/rails_event_store-rspec)
-
-We're aiming for 100% mutation coverage in this project. This is why:
-
-* [Why I want to introduce mutation testing to the rails_event_store gem](https://blog.arkency.com/2015/04/why-i-want-to-introduce-mutation-testing-to-the-rails-event-store-gem/)
-* [Mutation testing and continuous integration](https://blog.arkency.com/2015/05/mutation-testing-and-continuous-integration/)
-
-Whenever you fix a bug or add a new feature, we require that the coverage doesn't go down.
-
-## Development
-
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
-
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
-
-## Contributing
-
-Bug reports and pull requests are welcome on GitHub at https://github.com/RailsEventStore/rails_event_store-rspec.

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