rails_event_store-rspec 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '0384d5116d56586a7f7da3b03855609bb2ea9a05'
+  data.tar.gz: 6caf1a937e31986e93658bbc93faa187f93bc625
+SHA512:
+  metadata.gz: 97dac1b86a4963e8548755d2fe8255ead37bec13696aa5f214474538b121750d950dd6280423b5130fed4c5d1c58d3e78921ce305c2726cffdea180abd7b721e
+  data.tar.gz: 0432ec0d4534a94de83ed3b500bcea0ad9ac367fba24d565a01e2274394f385348c63ab69c8aace7c8a4ecc8443c6da170a0eae8de76faf0b95a3111af530e61

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+# rspec failure tracking
+.rspec_status

data/.rspec

@@ -0,0 +1 @@
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.4.1
+before_install: gem install bundler -v 1.15.4

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in rails_event_store-rspec.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Arkency
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/Makefile

@@ -0,0 +1,20 @@
+install-bundler: ## Install gem dependencies
+	@echo "Installing gem dependencies"
+	@bundle install
+
+install: install-bundler ## Prepare current development environment
+
+test: ## Run tests
+	@echo "Running basic tests - beware: this won't guarantee build pass"
+	@bundle exec rspec
+
+mutate: test  ## Run mutation tests
+	@echo "Running mutation tests - only 100% free mutation will be accepted"
+	@bundle exec mutant --include lib --require rails_event_store/rspec --use rspec --ignore-subject "RailsEventStore::RSpec::Matchers#differ" "RailsEventStore::RSpec*"
+
+.PHONY: help
+
+help:
+	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
+
+.DEFAULT_GOAL := help

data/README.md

@@ -0,0 +1,217 @@
+# RailsEventStore::RSpec
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rails_event_store-rspec'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rails_event_store-rspec
+
+## Usage
+
+Configure your rspec to include matchers in all examples first:
+
+```ruby
+RSpec.configure do |config|
+  config.include ::RailsEventStore::RSpec::Matchers
+end
+```
+
+You can as well choose to have RES matches in particular test file only:
+
+```ruby
+RSpec.describe MySubject do
+  include ::RailsEventStore::RSpec::Matchers
+
+  specify do
+    # matchers available here
+  end
+end
+```
+
+### be_event
+
+The `be_event` matcher enables you to make expectations on a domain event. It exposes fluent interface.
+
+```ruby
+OrderPlaced  = Class.new(RailsEventStore::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_event(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_event(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
+```
+## 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)](http://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](http://blog.arkency.com/2015/04/why-i-want-to-introduce-mutation-testing-to-the-rails-event-store-gem/)
+* [Mutation testing and continuous integration](http://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/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rails_event_store/rspec"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/rails_event_store/rspec.rb

@@ -0,0 +1,12 @@
+module RailsEventStore
+  module RSpec
+    NotSupported = Class.new(StandardError)
+  end
+end
+
+require "rails_event_store/rspec/version"
+require "rails_event_store/rspec/be_event"
+require "rails_event_store/rspec/have_published"
+require "rails_event_store/rspec/have_applied"
+require "rails_event_store/rspec/matchers"
+

data/lib/rails_event_store/rspec/be_event.rb

@@ -0,0 +1,171 @@
+module RailsEventStore
+  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, @actual_data, @expected_metadata, @expected_data),
+            Diff.new(@actual_metadata, @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:)
+        @differ   = differ
+        @expected = expected
+      end
+
+      def matches?(actual)
+        @actual = actual
+        [matches_kind, matches_data, matches_metadata].all?
+      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
+        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
+
+      private
+
+      attr_reader :differ
+
+      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)
+      end
+    end
+  end
+end
+

data/lib/rails_event_store/rspec/have_applied.rb

@@ -0,0 +1,42 @@
+module RailsEventStore
+  module RSpec
+    class HaveApplied
+      def initialize(*expected)
+        raise ArgumentError if expected.empty?
+        @expected = expected
+        @matcher  = ::RSpec::Matchers::BuiltIn::Include.new(*@expected)
+      end
+
+      def matches?(aggregate_root)
+        events = aggregate_root.__send__(:unpublished_events)
+        @matcher.matches?(events) && matches_count(events, @expected, @count)
+      end
+
+      def exactly(count)
+        @count = count
+        self
+      end
+
+      def times
+        self
+      end
+      alias :time :times
+
+      def once
+        exactly(1)
+      end
+
+      private
+
+      def matches_count(events, expected, count)
+        return true unless count
+        raise NotSupported if expected.size > 1
+
+        expected.all? do |event_or_matcher|
+          events.select { |e| event_or_matcher === e }.size.equal?(count)
+        end
+      end
+    end
+  end
+end
+

data/lib/rails_event_store/rspec/have_published.rb

@@ -0,0 +1,47 @@
+module RailsEventStore
+  module RSpec
+    class HavePublished
+      def initialize(*expected)
+        raise ArgumentError if expected.empty?
+        @expected = expected
+        @matcher  = ::RSpec::Matchers::BuiltIn::Include.new(*@expected)
+      end
+
+      def matches?(event_store)
+        events = @stream_name ? event_store.read_events_backward(@stream_name)
+                              : event_store.read_all_streams_backward
+        @matcher.matches?(events) && matches_count(events, @expected, @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 once
+        exactly(1)
+      end
+
+      private
+
+      def matches_count(events, expected, count)
+        return true unless count
+        raise NotSupported if expected.size > 1
+
+        expected.all? do |event_or_matcher|
+          events.select { |e| event_or_matcher === e }.size.equal?(count)
+        end
+      end
+    end
+  end
+end

data/lib/rails_event_store/rspec/matchers.rb

@@ -0,0 +1,26 @@
+module RailsEventStore
+  module RSpec
+    module Matchers
+      def be_an_event(expected)
+        BeEvent.new(expected, differ: differ)
+      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)
+      end
+
+      def have_applied(*expected)
+        HaveApplied.new(*expected)
+      end
+
+      private
+
+      def differ
+        ::RSpec::Support::Differ.new(color: ::RSpec::Matchers.configuration.color?)
+      end
+    end
+  end
+end

data/lib/rails_event_store/rspec/version.rb

@@ -0,0 +1,5 @@
+module RailsEventStore
+  module RSpec
+    VERSION = "0.1.1"
+  end
+end

data/rails_event_store-rspec.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "rails_event_store/rspec/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "rails_event_store-rspec"
+  spec.version       = RailsEventStore::RSpec::VERSION
+  spec.authors       = ["Arkency"]
+  spec.email         = ["dev@arkency.com"]
+
+  spec.summary       = %q{RSpec matchers for RailsEventStore}
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.15"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "mutant-rspec", "~> 0.8.11"
+  spec.add_development_dependency "rails", "~> 4.2"
+  spec.add_development_dependency "rails_event_store", "~> 0.15.0"
+
+  spec.add_dependency "rspec", "~> 3.0"
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: rails_event_store-rspec
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Arkency
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: mutant-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.11
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: rails_event_store
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.15.0
+- !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:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- Makefile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/rails_event_store/rspec.rb
+- lib/rails_event_store/rspec/be_event.rb
+- lib/rails_event_store/rspec/have_applied.rb
+- lib/rails_event_store/rspec/have_published.rb
+- lib/rails_event_store/rspec/matchers.rb
+- lib/rails_event_store/rspec/version.rb
+- rails_event_store-rspec.gemspec
+homepage: 
+licenses: []
+metadata: {}
+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: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: RSpec matchers for RailsEventStore
+test_files: []