ruby_event_store-rspec 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fd0942f48e1aea9cc5a5a67ffb5bbe5816c774f9d41db4bc0fda35e5061dd9d6
+  data.tar.gz: 7376fe3939f833e8747fa3dd511de534a07616c45fd2f71704d05d325ae6d681
+SHA512:
+  metadata.gz: cd0d6771ff5f9716171c2eb33209d5844bed93b24acef8704259d8784d97bbd756cb41ef7d20b3d265a35f90b3d5b9a514987017091f8aec51550958b0e1f5bf
+  data.tar.gz: 2c1e227d7560312c0cc9f8934d1e501cbff3df854f109adf421c37909398931ccaefa1cc470e0aaae34578e141121160eb66853ac0dc902c11859704c8aeda5f

data/.mutant.yml

@@ -0,0 +1 @@
+../.mutant.yml

data/Gemfile

@@ -0,0 +1,10 @@
+source 'https://rubygems.org'
+git_source(:github) { |repo| "https://github.com/#{repo}.git" }
+gemspec name: 'ruby_event_store-rspec'
+
+eval_gemfile '../support/bundler/Gemfile.shared'
+
+gem 'ruby_event_store', path: '../ruby_event_store'
+gem 'aggregate_root', path: '../aggregate_root'
+
+gem 'diff-lcs', '= 1.3.0'

data/Gemfile.lock

@@ -0,0 +1,113 @@
+PATH
+  remote: ../aggregate_root
+  specs:
+    aggregate_root (2.0.0)
+      ruby_event_store (= 2.0.0)
+
+PATH
+  remote: ../ruby_event_store
+  specs:
+    ruby_event_store (2.0.0)
+      concurrent-ruby (~> 1.0, >= 1.1.6)
+
+PATH
+  remote: .
+  specs:
+    ruby_event_store-rspec (2.0.0)
+      rspec (~> 3.0)
+
+GEM
+  remote: https://rubygems.org/
+  remote: https://oss:7AXfeZdAfCqL1PvHm2nvDJO6Zd9UW8IK@gem.mutant.dev/
+  specs:
+    abstract_type (0.0.7)
+    adamantium (0.2.0)
+      ice_nine (~> 0.11.0)
+      memoizable (~> 0.4.0)
+    anima (0.3.2)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2)
+      equalizer (~> 0.0.11)
+    ast (2.4.1)
+    concord (0.1.6)
+      adamantium (~> 0.2.0)
+      equalizer (~> 0.0.9)
+    concurrent-ruby (1.1.7)
+    diff-lcs (1.3)
+    equalizer (0.0.11)
+    ice_nine (0.11.2)
+    memoizable (0.4.2)
+      thread_safe (~> 0.3, >= 0.3.1)
+    mprelude (0.1.0)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      concord (~> 0.1.5)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.1)
+      procto (~> 0.0.2)
+    mutant (0.10.22)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.3.1)
+      ast (~> 2.2)
+      concord (~> 0.1.5)
+      diff-lcs (~> 1.3)
+      equalizer (~> 0.0.9)
+      ice_nine (~> 0.11.1)
+      memoizable (~> 0.4.2)
+      mprelude (~> 0.1.0)
+      parser (~> 3.0.0)
+      procto (~> 0.0.2)
+      unparser (~> 0.5.6)
+      variable (~> 0.0.1)
+    mutant-license (0.1.1.2.1627430819213747598431630701693729869473.0)
+    mutant-rspec (0.10.22)
+      mutant (= 0.10.22)
+      rspec-core (>= 3.8.0, < 4.0.0)
+    parser (3.0.0.0)
+      ast (~> 2.4.1)
+    procto (0.0.3)
+    rake (13.0.3)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.1)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.1)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.1)
+    thread_safe (0.3.6)
+    unparser (0.5.6)
+      abstract_type (~> 0.0.7)
+      adamantium (~> 0.2.0)
+      anima (~> 0.3.1)
+      concord (~> 0.1.5)
+      diff-lcs (~> 1.3)
+      equalizer (~> 0.0.9)
+      mprelude (~> 0.1.0)
+      parser (>= 3.0.0)
+      procto (~> 0.0.2)
+    variable (0.0.1)
+      equalizer (~> 0.0.11)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  aggregate_root!
+  diff-lcs (= 1.3.0)
+  mutant (~> 0.10.21)
+  mutant-license!
+  mutant-rspec (~> 0.10.21)
+  rake (>= 10.0)
+  rspec (~> 3.6)
+  ruby_event_store!
+  ruby_event_store-rspec!
+
+BUNDLED WITH
+   2.1.4

data/Makefile

@@ -0,0 +1,21 @@
+GEM_VERSION = $(shell cat ../RES_VERSION)
+GEM_NAME    = ruby_event_store-rspec
+REQUIRE     = ruby_event_store/rspec
+IGNORE      = RubyEventStore::RSpec::Matchers\#differ \
+              RubyEventStore::RSpec::Matchers\#formatter \
+              RubyEventStore::RSpec::Matchers\#have_published \
+              RubyEventStore::RSpec::Matchers\#have_applied \
+              RubyEventStore::RSpec::Matchers\#have_subscribed_to_events \
+              RubyEventStore::RSpec::Matchers\#publish \
+              RubyEventStore::RSpec::Matchers\#be_an_event \
+              RubyEventStore::RSpec::Publish\#last_event \
+              RubyEventStore::RSpec::Matchers::ListPhraser.all_but_last
+
+SUBJECT      ?= RubyEventStore::RSpec*
+DATABASE_URL ?= sqlite3::memory:
+
+include ../support/make/install.mk
+include ../support/make/test.mk
+include ../support/make/mutant.mk
+include ../support/make/gem.mk
+include ../support/make/help.mk

data/README.md

@@ -0,0 +1,206 @@
+# RailsEventStore::RSpec
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```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/rails_event_store/rspec.rb

@@ -0,0 +1,13 @@
+require 'ruby_event_store/rspec'
+
+warn <<~EOW
+  The 'rails_event_store-rspec' gem has been renamed.
+
+  Please change your Gemfile or gemspec
+  to reflect its new name:
+
+    'ruby_event_store-rspec'
+
+EOW
+
+RailsEventStore::RSpec = RubyEventStore::RSpec

data/lib/ruby_event_store/rspec.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'rspec'
+
+module RubyEventStore
+  module RSpec
+    NotSupported = Class.new(StandardError)
+  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"
+
+::RSpec.configure do |config|
+  config.include ::RubyEventStore::RSpec::Matchers
+end

data/lib/ruby_event_store/rspec/apply.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module RSpec
+    class Apply
+      def in(aggregate)
+        @aggregate = aggregate
+        self
+      end
+
+      def strict
+        @matcher = ::RSpec::Matchers::BuiltIn::Match.new(@expected)
+        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
+      end
+
+      def failure_message
+        if match_events?
+          <<-EOS
+expected block to have applied:
+
+#{@expected}
+
+but applied:
+
+#{@applied_events}
+EOS
+        else
+          "expected block to have applied any events"
+        end
+      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
+      end
+
+      def description
+        "apply events"
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      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)`"
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rspec/be_event.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module RSpec
+    class BeEvent
+      class KindMatcher
+        def initialize(expected)
+          @expected = expected
+        end
+
+        def matches?(actual)
+          @expected === actual
+        end
+      end
+
+      class DataMatcher
+        def initialize(expected, strict:)
+          @strict = strict
+          @expected = expected
+        end
+
+        def matches?(actual)
+          return true unless @expected
+          matcher = @strict ? ::RSpec::Matchers::BuiltIn::Match : ::RSpec::Matchers::BuiltIn::Include
+          matcher.new(@expected).matches?(actual)
+        end
+      end
+
+      class FailureMessage
+        class ExpectedLine
+          def initialize(expected_klass, expected_metadata, expected_data)
+            @expected_klass    = expected_klass
+            @expected_metadata = expected_metadata
+            @expected_data     = expected_data
+          end
+
+          def to_s
+            ["\nexpected: ", @expected_klass, with, metadata, data]
+          end
+
+          private
+
+          def with
+            " with" if [@expected_data, @expected_metadata].any?
+          end
+
+          def data
+            [" data: ", @expected_data] if @expected_data
+          end
+
+          def metadata
+            [" metadata: ", @expected_metadata] if @expected_metadata
+          end
+        end
+
+        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
+            @expected_metadata = expected_metadata
+            @expected_data     = expected_data
+          end
+
+          def to_s
+            ["\n     got: ", @actual_klass, with, metadata, data, "\n"]
+          end
+
+          private
+
+          def with
+            " with" if [@expected_data, @expected_metadata].any?
+          end
+
+          def data
+            [" data: ", @actual_data] if @expected_data
+          end
+
+          def metadata
+            [" metadata: ", @actual_metadata] if @expected_metadata
+          end
+        end
+
+        class Diff
+          def initialize(actual, expected, label, differ:)
+            @actual   = actual
+            @expected = expected
+            @label    = label
+            @differ   = differ
+          end
+
+          def to_s
+            @expected && ["\n#{@label} diff:", @differ.diff_as_string(@actual.to_s, @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
+          @expected_metadata = expected_metadata
+          @actual_metadata   = actual_metadata
+          @differ            = differ
+        end
+
+        def to_s
+          [
+            ExpectedLine.new(@expected_klass, @expected_metadata, @expected_data),
+            ActualLine.new(@actual_klass, @actual_metadata.to_h, @actual_data, @expected_metadata, @expected_data),
+            Diff.new(@actual_metadata.to_h, @expected_metadata, "Metadata", differ: @differ),
+            Diff.new(@actual_data, @expected_data, "Data", differ: @differ)
+          ].map(&:to_s).join
+        end
+      end
+
+      include ::RSpec::Matchers::Composable
+
+      def initialize(expected, differ:, formatter:)
+        @expected  = expected
+        @differ    = differ
+        @formatter = formatter
+      end
+
+      def matches?(actual)
+        @actual = actual
+        matches_kind && matches_data && matches_metadata
+      end
+
+      def with_data(expected_data)
+        @expected_data = expected_data
+        self
+      end
+
+      def with_metadata(expected_metadata)
+        @expected_metadata = expected_metadata
+        self
+      end
+
+      def failure_message
+        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
+      end
+
+      def failure_message_when_negated
+        %Q{
+expected: not a kind of #{expected}
+     got: #{actual.class}
+}
+      end
+
+      def strict
+        @strict = true
+        self
+      end
+
+      def description
+        "be an event #{formatter.(expected)}#{data_and_metadata_expectations_description}"
+      end
+
+      def data_and_metadata_expectations_description
+        predicate = strict? ? "matching" : "including"
+        expectation_list = []
+        expectation_list << "with data #{predicate} #{formatter.(expected_data)}" if expected_data
+        expectation_list << "with metadata #{predicate} #{formatter.(expected_metadata)}" if expected_metadata
+        " (#{expectation_list.join(" and ")})" if expectation_list.any?
+      end
+
+      private
+
+      def matches_kind
+        KindMatcher.new(expected).matches?(actual)
+      end
+
+      def matches_data
+        DataMatcher.new(expected_data, strict: strict?).matches?(actual.data)
+      end
+
+      def matches_metadata
+        DataMatcher.new(expected_metadata, strict: strict?).matches?(actual.metadata.to_h)
+      end
+
+      attr_reader :expected_metadata, :expected_data, :actual, :expected, :differ, :formatter
+
+      def strict?
+        @strict
+      end
+    end
+  end
+end
+

data/lib/ruby_event_store/rspec/have_applied.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+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
+      end
+
+      def matches?(aggregate_root)
+        @events = aggregate_root.unpublished_events.to_a
+        matcher.matches?(events) && matches_count?
+      end
+
+      def exactly(count)
+        @count = count
+        self
+      end
+
+      def times
+        self
+      end
+      alias :time :times
+
+      def once
+        exactly(1)
+      end
+
+      def strict
+        @matcher = ::RSpec::Matchers::BuiltIn::Match.new(expected)
+        self
+      end
+
+      def failure_message
+        "expected #{expected} to be applied, diff:" +
+          differ.diff_as_string(expected.to_s, events.to_s)
+      end
+
+      def failure_message_when_negated
+        "expected #{expected} not to be applied, diff:" +
+            differ.diff_as_string(expected.inspect, events.inspect)
+      end
+
+      def description
+        "have applied events that have to (#{phraser.(expected)})"
+      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
+    end
+  end
+end
+

data/lib/ruby_event_store/rspec/have_published.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+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
+      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?
+      end
+
+      def exactly(count)
+        @count = count
+        self
+      end
+
+      def in_stream(stream_name)
+        @stream_name = stream_name
+        self
+      end
+
+      def times
+        self
+      end
+      alias :time :times
+
+      def from(event_id)
+        @start = event_id
+        self
+      end
+
+      def once
+        exactly(1)
+      end
+
+      def failure_message
+        "expected #{expected} to be published, diff:" +
+            differ.diff_as_string(expected.to_s, events.to_a.to_s)
+      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)
+      end
+
+      def description
+        "have published events that have to (#{phraser.(expected)})"
+      end
+
+      def strict
+        @matcher = ::RSpec::Matchers::BuiltIn::Match.new(expected)
+        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)
+      end
+
+      attr_reader :differ, :phraser, :stream_name, :expected, :count, :events, :start
+    end
+  end
+end

data/lib/ruby_event_store/rspec/have_subscribed_to_events.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module RSpec
+    class HaveSubscribedToEvents
+      def initialize(mandatory_expected, *optional_expected, differ:, phraser:)
+        @expected = [mandatory_expected, *optional_expected]
+        @matcher = ::RSpec::Matchers::BuiltIn::ContainExactly.new(expected)
+        @differ = differ
+        @phraser = phraser
+      end
+
+      def matches?(handler)
+        @handler = handler
+        @subscribed_to = expected.select do |event|
+          event_store.subscribers_for(event).include?(handler)
+        end
+
+        matcher.matches?(subscribed_to)
+      end
+
+      def in(event_store)
+        @event_store = event_store
+        self
+      end
+
+      def failure_message
+        "expected #{handler} to be subscribed to events, diff:" +
+          differ.diff_as_string(expected.to_s, subscribed_to.to_s)
+      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)
+      end
+
+      def description
+        "have subscribed to events that have to (#{phraser.(expected)})"
+      end
+
+      private
+
+      attr_reader :expected, :handler, :subscribed_to,
+                  :differ, :phraser, :matcher, :event_store
+    end
+  end
+end
+

data/lib/ruby_event_store/rspec/matchers.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module RSpec
+    module Matchers
+      class ListPhraser
+        class << self
+          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
+          end
+
+          private
+
+          def all_but_last
+            (0...-1)
+          end
+
+          def format(object)
+            if object.respond_to?(:description)
+              ::RSpec::Support::ObjectFormatter.format(object)
+            else
+              "be a #{object}"
+            end
+          end
+        end
+      end
+
+      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
+
+      def have_published(*expected)
+        HavePublished.new(*expected, differ: differ, phraser: phraser)
+      end
+
+      def have_applied(*expected)
+        HaveApplied.new(*expected, differ: differ, phraser: phraser)
+      end
+
+      def have_subscribed_to_events(*expected)
+        HaveSubscribedToEvents.new(*expected, differ: differ, phraser: phraser)
+      end
+
+      def publish(*expected)
+        Publish.new(*expected)
+      end
+
+      def apply(*expected)
+        Apply.new(*expected)
+      end
+
+      private
+
+      def formatter
+        ::RSpec::Support::ObjectFormatter.public_method(:format)
+      end
+
+      def differ
+        ::RSpec::Support::Differ.new(color: ::RSpec::Matchers.configuration.color?)
+      end
+
+      def phraser
+        ListPhraser
+      end
+    end
+  end
+end

data/lib/ruby_event_store/rspec/publish.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module RSpec
+    class Publish
+      def in(event_store)
+        @event_store = event_store
+        self
+      end
+
+      def in_stream(stream)
+        @stream = stream
+        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
+      end
+
+      def failure_message
+        if match_events?
+          <<-EOS
+expected block to have published:
+
+#{@expected}
+
+#{"in stream #{@stream} " if @stream}but published:
+
+#{@published_events}
+EOS
+        else
+          "expected block to have published any events"
+        end
+      end
+
+      def failure_message_when_negated
+        if match_events?
+          <<-EOS
+expected block not to have published:
+
+#{@expected}
+
+#{"in stream #{@stream} " if @stream}but published:
+
+#{@published_events}
+EOS
+        else
+          "expected block not to have published any events"
+        end
+      end
+
+      def description
+        "publish events"
+      end
+
+      def supports_block_expectations?
+        true
+      end
+
+      private
+
+      def initialize(*expected)
+        @expected = expected
+      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
+    end
+  end
+end

data/lib/ruby_event_store/rspec/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyEventStore
+  module RSpec
+    VERSION = "2.0.0"
+  end
+end

data/rails_event_store-rspec.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rails_event_store-rspec'
+  spec.version       = '2.0.0'
+  spec.licenses      = ['MIT']
+  spec.authors       = ['Arkency']
+  spec.email         = ['dev@arkency.com']
+
+  spec.summary       = %q{RSpec matchers for RailsEventStore}
+  spec.homepage      = 'https://railseventstore.org'
+  spec.metadata    = {
+    "homepage_uri" => "https://railseventstore.org/",
+    "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",
+  }
+
+  spec.files         = ['lib/rails_event_store/rspec.rb']
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'rspec', '~> 3.0'
+  spec.add_runtime_dependency 'ruby_event_store-rspec', '= 2.0.0'
+
+  spec.post_install_message = <<~EOW
+    The 'rails_event_store-rspec' gem has been renamed.
+
+    Please change your Gemfile or gemspec
+    to reflect its new name:
+
+      'ruby_event_store-rspec'
+
+  EOW
+end

data/ruby_event_store-rspec.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_event_store/rspec/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ruby_event_store-rspec'
+  spec.version       = RubyEventStore::RSpec::VERSION
+  spec.licenses      = ['MIT']
+  spec.authors       = ['Arkency']
+  spec.email         = ['dev@arkency.com']
+
+  spec.summary       = %q{RSpec matchers for RailsEventStore}
+  spec.homepage      = 'https://railseventstore.org'
+  spec.metadata    = {
+    "homepage_uri" => "https://railseventstore.org/",
+    "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",
+  }
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,78 @@
+--- !ruby/object:Gem::Specification
+name: ruby_event_store-rspec
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Arkency
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-12-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description:
+email:
+- dev@arkency.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".mutant.yml"
+- Gemfile
+- Gemfile.lock
+- Makefile
+- README.md
+- lib/rails_event_store/rspec.rb
+- 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/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/matchers.rb
+- lib/ruby_event_store/rspec/publish.rb
+- lib/ruby_event_store/rspec/version.rb
+- rails_event_store-rspec.gemspec
+- ruby_event_store-rspec.gemspec
+homepage: https://railseventstore.org
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://railseventstore.org/
+  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
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key:
+specification_version: 4
+summary: RSpec matchers for RailsEventStore
+test_files: []