active_event_store 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8791927b35712c61094dcb6cc915e2b27912129e675c84230cd6f5271585902e
-  data.tar.gz: fe58f1151444dc521caa4666adf06dd97d00bc37882843b1252d776683a98dcf
+  metadata.gz: e19560b568e8765b86d3925070dd1414b0de0545107e1dc1c7df4e3402148690
+  data.tar.gz: 87816ce897dc26614f8834993373bb271345c25934142f055547ad0f5023fe22
 SHA512:
-  metadata.gz: 95f22443b58343d34b93b0400b53c63bf5190ff5f0c8e56c3c96c2e9ebf3d8137bee3136035f7f12d17f8c4488f8bdebef3a4e971eb67dfd17dbafdb48b857ba
-  data.tar.gz: c947302a3db94490b5a781f3fb74bacc0b45d437240599766dd33138147b8807119604105b55034482861254463f4a49919dba2689d52eb16599459c2fe15b7a
+  metadata.gz: acf6017590c69d26066617c86ab63cd658c2307e8da89c53ec0afe18ebb4b384430bde9f632806f4e92a26293ed37cffa1c7abaa55ca2cd5f312d70d98ba873a
+  data.tar.gz: 181e900564fb3640a5484045ebbe6170b3871e05ea10a8e443bcadf7a530bf58bc227f4101d998a92ff96b82b569d1d24adcc1f97d3195c57fa2f0023c7db7db

data/CHANGELOG.md

@@ -2,9 +2,14 @@
 
 ## master
 
-## 1.0.0 (2021-01-14)
+## 1.0.1 (2021-09-16)
+
+- Add minitest assertions: `assert_event_published`, `refute_event_published`, `assert_async_event_subscriber_enqueued`  ([@chriscz][])
+
+## 1.0.0 (2021-09-14)
 
 - Ruby 2.6+, Rails 6+ and RailsEventStore 2.1+ is required.
+
 ## 0.2.1 (2020-09-30)
 
 - Fix Active Support load hook name. ([@palkan][])
@@ -20,3 +25,4 @@ Now `ActiveSupport.on_load(:active_event_store) { ... }` works.
 - Open source Active Event Store. ([@palkan][])
 
 [@palkan]: https://github.com/palkan
+[@chriscz]: https://github.com/chriscz

data/README.md

@@ -150,20 +150,32 @@ We suggest putting subscribers to the `app/subscribers` folder using the followi
 
 You can test subscribers as normal Ruby objects.
 
-**NOTE:** Currently, we provide additional matchers only for RSpec. PRs with Minitest support are welcomed!
+**NOTE** To test using minitest include the `ActiveEventStore::TestHelpers` module in your tests.
 
 To test that a given subscriber exists, you can use the `have_enqueued_async_subscriber_for` matcher:
 
 ```ruby
-# for asynchronous subscriptions
+# for asynchronous subscriptions (rspec)
 it "is subscribed to some event" do
   event = MyEvent.new(some: "data")
   expect { ActiveEventStore.publish event }
     .to have_enqueued_async_subscriber_for(MySubscriberService)
     .with(event)
 end
+
+# for asynchronous subscriptions (minitest)
+def test_is_subscribed_to_some_event
+  event = MyEvent.new(some: "data")
+
+  assert_async_event_subscriber_enqueued(MySubscriberService, event: event) do
+    ActiveEventStore.publish event
+  end
+end
 ```
 
+**NOTE** Async event subscribers are queued only after the current transaction has committed so when using `assert_enqued_async_subcriber` in rails
+make sure to have `self.use_transactional_fixtures = false` at the top of your test class.
+
 **NOTE:** You must have `rspec-rails` gem in your bundle to use `have_enqueued_async_subscriber_for` matcher.
 
 For synchronous subscribers using `have_received` is enough:
@@ -183,10 +195,14 @@ end
 To test event publishing, use `have_published_event` matcher:
 
 ```ruby
+# rspec
 expect { subject }.to have_published_event(ProfileCreated).with(user_id: user.id)
+
+# minitest
+assert_event_published(ProfileCreated, with: {user_id: user.id}) { subject }
 ```
 
-**NOTE:** `have_published_event` only supports block expectations.
+**NOTE:** `have_published_event` and `assert_event_published` only supports block expectations.
 
 **NOTE 2** `with` modifier works like `have_attributes` matcher (not `contain_exactly`); you can only specify serializable attributes in `with` (i.e. sync attributes are not supported, 'cause they are not persistent).
 

data/lib/active_event_store/test_helper/event_published_matcher.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module ActiveEventStore
+  module TestHelper
+    class EventPublishedMatcher
+      attr_reader :attributes,
+        :matching_events
+
+      def initialize(expected_event_class, store: nil, with: nil, exactly: nil, at_least: nil, at_most: nil, refute: false)
+        @event_class = expected_event_class
+        @store = store || ActiveEventStore.event_store
+        @attributes = with
+        @refute = refute
+
+        count_expectations = {
+          exactly: exactly,
+          at_most: at_most,
+          at_least: at_least
+        }.reject { |_, v| v.nil? }
+
+        if count_expectations.length > 1
+          raise ArgumentError("Only one of :exactly, :at_least or :at_most can be specified")
+        elsif count_expectations.length == 0
+          @count_expectation_kind = :at_least
+          @expected_count = 1
+        else
+          @count_expectation_kind = count_expectations.keys.first
+          @expected_count = count_expectations.values.first
+        end
+      end
+
+      def with_published_events(&block)
+        original_count = @store.read.count
+        block.call
+        in_block_events(original_count, @store.read.count)
+      end
+
+      def matches?(block)
+        raise ArgumentError, "#{assertion_name} only support block assertions" if block.nil?
+
+        events = with_published_events do
+          block.call
+        end
+
+        @matching_events, @unmatching_events = partition_events(events)
+
+        mismatch_message = count_mismatch_message(@matching_events.size)
+
+        if mismatch_message
+          expectations = [
+            "Expected #{mismatch_message} #{@event_class.identifier}"
+          ]
+
+          expectations << if refute?
+            report_events = @matching_events
+            "not to have been published"
+          else
+            report_events = @unmatching_events
+            "to have been published"
+          end
+
+          expectations << "with attributes #{attributes.inspect}" unless attributes.nil?
+
+          expectations << expectations.pop + ", but"
+
+          expectations << if report_events.any?
+            report_events.inject("published the following events instead:") do |msg, event|
+              msg + "\n  #{event.inspect}"
+            end
+          else
+            "hasn't published anything"
+          end
+
+          return expectations.join(" ")
+        end
+
+        nil
+      end
+
+      private
+
+      def refute?
+        @refute
+      end
+
+      def assertion_name
+        if refute?
+          "refute_event_published"
+        else
+          "assert_event_published"
+        end
+      end
+
+      def negate_on_refute(cond)
+        if refute?
+          !cond
+        else
+          cond
+        end
+      end
+
+      def in_block_events(before_block_count, after_block_count)
+        count_difference = after_block_count - before_block_count
+        if count_difference.positive?
+          @store.read.backward.limit(count_difference).to_a
+        else
+          []
+        end
+      end
+
+      # Partitions events into matching and unmatching
+      def partition_events(events)
+        events.partition { |e| self.class.event_matches?(@event_class, @attributes, e) }
+      end
+
+      def count_mismatch_message(actual_count)
+        case @count_expectation_kind
+        when :exactly
+          if negate_on_refute(actual_count != @expected_count)
+            "exactly #{@expected_count}"
+          end
+        when :at_most
+          if negate_on_refute(actual_count > @expected_count)
+            "at most #{@expected_count}"
+          end
+        when :at_least
+          if negate_on_refute(actual_count < @expected_count)
+            "at least #{@expected_count}"
+          end
+        else
+          raise ArgumentError, "Unrecognized expectation kind: #{@count_expectation_kind}"
+        end
+      end
+
+      class << self
+        def event_matches?(event_class, attributes, event)
+          event_type_matches?(event_class, event) && event_data_matches?(attributes, event)
+        end
+
+        def event_type_matches?(event_class, event)
+          event_class.identifier == event.event_type
+        end
+
+        def event_data_matches?(attributes, event)
+          (attributes.nil? || attributes.all? { |k, v| v == event.public_send(k) })
+        end
+      end
+    end
+  end
+end

data/lib/active_event_store/test_helper.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "active_event_store/test_helper/event_published_matcher"
+
+module ActiveEventStore
+  module TestHelper
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveJob::TestHelper
+    end
+
+    # Asserts that the given event was published `exactly`, `at_least` or `at_most` number of times
+    # to a specific `store` `with` a particular hash of attributes.
+    def assert_event_published(expected_event, store: nil, with: nil, exactly: nil, at_least: nil, at_most: nil, &block)
+      matcher = EventPublishedMatcher.new(
+        expected_event,
+        store: store,
+        with: with,
+        exactly: exactly,
+        at_least: at_least,
+        at_most: at_most
+      )
+
+      if (msg = matcher.matches?(block))
+        fail(msg)
+      end
+
+      matcher.matching_events
+    end
+
+    # Asserts that the given event was *not* published `exactly`, `at_least` or `at_most` number of times
+    # to a specific `store` `with` a particular hash of attributes.
+    def refute_event_published(expected_event, store: nil, with: nil, exactly: nil, at_least: nil, at_most: nil, &block)
+      matcher = EventPublishedMatcher.new(
+        expected_event,
+        store: store,
+        with: with,
+        exactly: exactly,
+        at_least: at_least,
+        at_most: at_most,
+        refute: true
+      )
+
+      if (msg = matcher.matches?(block))
+        fail(msg)
+      end
+    end
+
+    def assert_async_event_subscriber_enqueued(subscriber_class, event: nil, queue: "events_subscribers", &block)
+      subscriber_job = ActiveEventStore::SubscriberJob.for(subscriber_class)
+      if subscriber_job.nil?
+        fail("No such async subscriber: #{subscriber_class.name}")
+      end
+
+      expected_event = event
+      event_matcher = ->(actual_event) { EventPublishedMatcher.event_matches?(expected_event, expected_event.data, actual_event) }
+
+      expected_args = if expected_event
+        event_matcher
+      end
+
+      assert_enqueued_with(job: subscriber_job, queue: queue, args: expected_args) do
+        ActiveRecord::Base.transaction do
+          block.call
+        end
+      end
+    end
+  end
+end

data/lib/active_event_store/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveEventStore # :nodoc:
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_event_store
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Vladimir Dementyev
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-09-14 00:00:00.000000000 Z
+date: 2021-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails_event_store
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
 description: Wrapper over Rails Event Store with conventions and transparent Rails
   integration
 email:
@@ -101,6 +115,8 @@ files:
 - lib/active_event_store/rspec/have_enqueued_async_subscriber_for.rb
 - lib/active_event_store/rspec/have_published_event.rb
 - lib/active_event_store/subscriber_job.rb
+- lib/active_event_store/test_helper.rb
+- lib/active_event_store/test_helper/event_published_matcher.rb
 - lib/active_event_store/version.rb
 homepage: http://github.com/palkan/active_event_store
 licenses: