active_event_store 0.1.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 79a390bc7f50283a2ed74f34d62ae845dfa5208a19a2a174238a5ebf4a684203
-  data.tar.gz: cfd5584f0a8c56a645fdb58fb1dfe6b35252d1c23481898974a6c333233d59a1
+  metadata.gz: e19560b568e8765b86d3925070dd1414b0de0545107e1dc1c7df4e3402148690
+  data.tar.gz: 87816ce897dc26614f8834993373bb271345c25934142f055547ad0f5023fe22
 SHA512:
-  metadata.gz: 91d3ecb6b2635ff0e895176e687d3fa3820d519b3d50cbba6d3d4ec9a79c632c527fd17817317d9eddf15d3c6fdff6a581f729bdcc1df55231e9250bb7332c74
-  data.tar.gz: ce974d79cd1989cfdd86e1ecfdfbf408b1facae1b9ab0be50c72f644f9abb32a0ce0c8a024752b3f2450c921d1f3c0ec5b0a8bc31c311ff814aa0cbd8dba89df
+  metadata.gz: acf6017590c69d26066617c86ab63cd658c2307e8da89c53ec0afe18ebb4b384430bde9f632806f4e92a26293ed37cffa1c7abaa55ca2cd5f312d70d98ba873a
+  data.tar.gz: 181e900564fb3640a5484045ebbe6170b3871e05ea10a8e443bcadf7a530bf58bc227f4101d998a92ff96b82b569d1d24adcc1f97d3195c57fa2f0023c7db7db

data/CHANGELOG.md

@@ -2,8 +2,27 @@
 
 ## master
 
+## 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][])
+
+Now `ActiveSupport.on_load(:active_event_store) { ... }` works.
+
+## 0.2.0 (2020-05-11)
+
+- Update Event API to support both RES 1.0 and 0.42+. ([@palkan][])
+
 ## 0.1.0 (2020-04-22)
 
 - Open source Active Event Store. ([@palkan][])
 
 [@palkan]: https://github.com/palkan
+[@chriscz]: https://github.com/chriscz

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2020 Vladimir Dementyev
+Copyright (c) 2020-2021 Vladimir Dementyev
 
 MIT License
 

data/README.md

@@ -17,11 +17,11 @@ Secondly, we wanted to have a store implementation independent API that would al
 
 ## Installation
 
-Add gem to your project:
+Add the gem to your project:
 
 ```ruby
 # Gemfile
-gem "active_event_store"
+gem "active_event_store", "~> 1.0"
 ```
 
 Setup database according to the [Rails Event Store docs](https://railseventstore.org/docs/install/#setup-data-model):
@@ -33,8 +33,9 @@ rails db:migrate
 
 ### Requirements
 
-- Ruby (MRI) >= 2.5.0
-- Rails >= 5.0
+- Ruby (MRI) >= 2.6
+- Rails >= 6.0
+- RailsEventStore >= 2.1
 
 ## Usage
 
@@ -143,24 +144,40 @@ Subscribers could be any callable Ruby objects that accept a single argument (ev
 
 We suggest putting subscribers to the `app/subscribers` folder using the following convention: `app/subscribers/on_<event_type>/<subscriber.rb>`, e.g. `app/subscribers/on_profile_created/create_chat_user.rb`.
 
+**NOTE:** Active Job must be loaded to use async subscribers (i.e., `require "active_job/railtie"` or `require "rails/all"` in your `config/application.rb`).
+
 ### Testing
 
 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:
 
 ```ruby
@@ -178,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/config.rb

@@ -1,11 +1,17 @@
 # frozen_string_literal: true
 
+require "json"
+
 module ActiveEventStore
   class Config
-    attr_writer :repository, :job_queue_name, :store_options
+    attr_writer :repository, :serializer, :job_queue_name, :store_options
 
     def repository
-      @repository ||= RailsEventStoreActiveRecord::EventRepository.new
+      @repository ||= RailsEventStoreActiveRecord::EventRepository.new(serializer: serializer)
+    end
+
+    def serializer
+      @serializer ||= JSON
     end
 
     def job_queue_name

data/lib/active_event_store/engine.rb

@@ -18,7 +18,11 @@ module ActiveEventStore
       # See https://railseventstore.org/docs/subscribe/#scheduling-async-handlers-after-commit
       ActiveEventStore.event_store = RailsEventStore::Client.new(
         dispatcher: RubyEventStore::ComposedDispatcher.new(
-          RailsEventStore::AfterCommitAsyncDispatcher.new(scheduler: RailsEventStore::ActiveJobScheduler.new),
+          RailsEventStore::AfterCommitAsyncDispatcher.new(
+            scheduler: RailsEventStore::ActiveJobScheduler.new(
+              serializer: ActiveEventStore.config.serializer
+            )
+          ),
           RubyEventStore::Dispatcher.new
         ),
         repository: ActiveEventStore.config.repository,
@@ -26,7 +30,7 @@ module ActiveEventStore
         **ActiveEventStore.config.store_options
       )
 
-      ActiveSupport.run_load_hooks("active_event_store", ActiveEventStore)
+      ActiveSupport.run_load_hooks(:active_event_store, ActiveEventStore)
     end
   end
 end

data/lib/active_event_store/event.rb

@@ -72,8 +72,20 @@ module ActiveEventStore
       self.class.identifier
     end
 
+    alias_method :event_type, :type
+
     def inspect
-      "#{self.class.name}<#{type}##{message_id}>, data: #{data}, metadata: #{metadata}"
+      "#{self.class.name}<#{event_type}##{message_id}>, data: #{data}, metadata: #{metadata}"
+    end
+
+    # Has been removed from RES: https://github.com/RailsEventStore/rails_event_store/pull/726
+    def to_h
+      {
+        event_id: event_id,
+        metadata: metadata.to_h,
+        data: data,
+        type: event_type
+      }
     end
 
     protected

data/lib/active_event_store/mapper.rb

@@ -1,44 +1,44 @@
 # frozen_string_literal: true
 
-require "json"
-
 module ActiveEventStore
-  using(Module.new do
+  using(Module.new {
     refine Hash do
       def symbolize_keys
         RubyEventStore::TransformKeys.symbolize(self)
       end
     end
-  end)
+  })
 
   # Custom mapper for RES events.
   #
   # See https://github.com/RailsEventStore/rails_event_store/blob/v0.35.0/ruby_event_store/lib/ruby_event_store/mappers/default.rb
   class Mapper
-    def initialize(mapping:, serializer: JSON)
+    def initialize(mapping:, serializer: ActiveEventStore.config.serializer)
       @serializer = serializer
       @mapping = mapping
     end
 
-    def event_to_serialized_record(domain_event)
+    def event_to_record(domain_event)
       # lazily add type to mapping
       # NOTE: use class name instead of a class to handle code reload
       # in development (to avoid accessing orphaned classes)
-      mapping.register(domain_event.type, domain_event.class.name) unless mapping.exist?(domain_event.type)
+      mapping.register(domain_event.event_type, domain_event.class.name) unless mapping.exist?(domain_event.event_type)
 
-      RubyEventStore::SerializedRecord.new(
+      RubyEventStore::Record.new(
         event_id: domain_event.event_id,
         metadata: serializer.dump(domain_event.metadata.to_h),
         data: serializer.dump(domain_event.data),
-        event_type: domain_event.type
+        event_type: domain_event.event_type,
+        timestamp: domain_event.timestamp,
+        valid_at: domain_event.valid_at
       )
     end
 
-    def serialized_record_to_event(record)
-      event_class = mapping.fetch(record.event_type) do
+    def record_to_event(record)
+      event_class = mapping.fetch(record.event_type) {
         raise "Don't know how to deserialize event: \"#{record.event_type}\". " \
-              "Add explicit mapping: ActiveEventStore.mapper.register \"#{record.event_type}\", \"<Class Name>\""
-      end
+              "Add explicit mapping: ActiveEventStore.mapping.register \"#{record.event_type}\", \"<Class Name>\""
+      }
 
       Object.const_get(event_class).new(
         **serializer.load(record.data).symbolize_keys,

data/lib/active_event_store/rspec/have_enqueued_async_subscriber_for.rb

@@ -21,9 +21,12 @@ module ActiveEventStore
       end
 
       def matches?(actual_serialized)
-        actual = ActiveEventStore.event_store.deserialize(actual_serialized)
+        actual = ActiveEventStore.event_store.deserialize(
+          **actual_serialized,
+          serializer: ActiveEventStore.config.serializer
+        )
 
-        actual.type == event.type && data_matches?(actual.data)
+        actual.event_type == event.event_type && data_matches?(actual.data)
       end
 
       def description
@@ -62,9 +65,9 @@ module ActiveEventStore
 end
 
 RSpec.configure do |config|
-  config.include(Module.new do
+  config.include(Module.new {
     def have_enqueued_async_subscriber_for(*args)
       ActiveEventStore::HaveEnqueuedAsyncSubscriberFor.new(*args)
     end
-  end)
+  })
 end

data/lib/active_event_store/rspec/have_published_event.rb

@@ -66,7 +66,7 @@ module ActiveEventStore
 
       @matching_events, @unmatching_events =
         in_block_events.partition do |actual_event|
-          (event_class.identifier == actual_event.type) &&
+          (event_class.identifier == actual_event.event_type) &&
             (attributes.nil? || attributes_match?(actual_event))
         end
 

data/lib/active_event_store/subscriber_job.rb

@@ -38,7 +38,7 @@ module ActiveEventStore
     end
 
     def perform(payload)
-      event = event_store.deserialize(payload)
+      event = event_store.deserialize(**payload, serializer: ActiveEventStore.config.serializer)
 
       event_store.with_metadata(**event.metadata.to_h) do
         subscriber.call(event)

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 = "0.1.0"
+  VERSION = "1.0.1"
 end

data/lib/active_event_store.rb

@@ -24,8 +24,8 @@ module ActiveEventStore
       @config ||= Config.new
     end
 
-    def subscribe(subscriber = nil, to: nil, sync: false)
-      subscriber ||= Proc.new
+    def subscribe(subscriber = nil, to: nil, sync: false, &block)
+      subscriber ||= block
 
       to ||= infer_event_from_subscriber(subscriber) if subscriber.is_a?(Module)
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_event_store
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-04-22 00:00:00.000000000 Z
+date: 2021-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails_event_store
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.42.0
+        version: 2.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.42.0
+        version: 2.1.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -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:
@@ -111,7 +127,7 @@ metadata:
   documentation_uri: http://github.com/palkan/active_event_store
   homepage_uri: http://github.com/palkan/active_event_store
   source_code_uri: http://github.com/palkan/active_event_store
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -119,15 +135,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '2.5'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
-signing_key: 
+rubygems_version: 3.2.15
+signing_key:
 specification_version: 4
 summary: Rails Event Store in a more Rails way
 test_files: []