active_event_store 0.2.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e89b6923e7b41bac70b72e2f535d964be074e8a22ada023af08899895a286793
-  data.tar.gz: 29c61f9350f3fc6575e0f95ed799ef164bd275b5c6f7a070f26637793957c6d0
+  metadata.gz: f4ccb82314fce7aa4504e6834af793ad82e4613ef970a0277664de839e72a543
+  data.tar.gz: 38ea7210977f150226cf63f3cdec4793210e054e207cf71bcfcf5643cab21b28
 SHA512:
-  metadata.gz: ae0e00e377d9bebafe57fa92cdfd4c2c6d6fd7005eca1ca7e612400476a2392211d568f5497dfad7299a4445ecb0bbeebdc4e906220521d089da07344fcfa355
-  data.tar.gz: 305cf18193777091f474193a9d5b4591e3ad505a485caafa2bb127bcc1f0ec5794d159857db0503e3a89639bb6a2c2bcd71fc748038dc5d01a0ef046ebf1d4c0
+  metadata.gz: 26ff53ad69fe94b9643031511072ef1d3b89e17eebae6b492570ad56829afc03ccb39c1ae16b26e3da038a549e4ae63c95eab117e1f4f0781e1202b32d6662b1
+  data.tar.gz: bb66fa72aed216e1328dc7b52737a273de13da41dcdc723c6250e015c7aee5574523c9ed6de876ae0525599076326f6bb847c5115eb146801f8e177dc04b13b4

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## master
 
+## 1.0.2 (2021-03-15)
+
+- Support using classes with `#call` as async subscribers. ([@caws][])
+
+## 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][])
@@ -17,3 +29,5 @@ Now `ActiveSupport.on_load(:active_event_store) { ... }` works.
 - Open source Active Event Store. ([@palkan][])
 
 [@palkan]: https://github.com/palkan
+[@chriscz]: https://github.com/chriscz
+[@caws]: https://github.com/caws

data/LICENSE.txt

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

data/README.md

@@ -21,7 +21,7 @@ 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
 
@@ -139,30 +140,44 @@ ActiveSupport.on_load :active_event_store do |store|
 end
 ```
 
-Subscribers could be any callable Ruby objects that accept a single argument (event) as its input.
+Subscribers could be any callable Ruby objects that accept a single argument (event) as its input or classes that inherit from `Class` and have `#call` as an instance method.
 
 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`).
 
+**NOTE:** Subscribers that inherit from `Class` and implement `call` as a class method will not be instantiated.
+
 ### 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:
@@ -182,10 +197,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,

data/lib/active_event_store/event.rb

@@ -68,20 +68,12 @@ module ActiveEventStore
       super(**{event_id: event_id, metadata: metadata, data: params}.compact)
     end
 
-    # RES 0.44+
-    # https://github.com/RailsEventStore/rails_event_store/pull/724
-    if method_defined?(:event_type)
-      def event_type
-        self.class.identifier
-      end
-    else
-      def type
-        self.class.identifier
-      end
-
-      alias event_type type
+    def type
+      self.class.identifier
     end
 
+    alias_method :event_type, :type
+
     def inspect
       "#{self.class.name}<#{event_type}##{message_id}>, data: #{data}, metadata: #{metadata}"
     end

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.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.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,7 +21,10 @@ 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.event_type == event.event_type && data_matches?(actual.data)
       end
@@ -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/subscriber_job.rb

@@ -14,11 +14,11 @@ module ActiveEventStore
 
         raise ArgumentError, "Async subscriber must be a module/class, not instance" unless callable.is_a?(Module)
 
-        if callable.const_defined?("SubscriberJob", false)
-          callable.const_get("SubscriberJob", false)
+        if callable.const_defined?(:SubscriberJob, false)
+          callable.const_get(:SubscriberJob, false)
         else
           callable.const_set(
-            "SubscriberJob",
+            :SubscriberJob,
             Class.new(self).tap do |job|
               queue_as ActiveEventStore.config.job_queue_name
 
@@ -31,14 +31,14 @@ module ActiveEventStore
       def for(callable)
         raise ArgumentError, "Async subscriber must be a module/class" unless callable.is_a?(Module)
 
-        callable.const_defined?("SubscriberJob", false) ?
-          callable.const_get("SubscriberJob", false) :
+        callable.const_defined?(:SubscriberJob, false) ?
+          callable.const_get(:SubscriberJob, false) :
           nil
       end
     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)
@@ -48,6 +48,10 @@ module ActiveEventStore
     private
 
     def subscriber
+      if self.class.subscriber.is_a?(Class) && !self.class.subscriber.respond_to?(:call)
+        return self.class.subscriber.new
+      end
+
       self.class.subscriber
     end
 

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.2.1"
+  VERSION = "1.0.2"
 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.2.1
+  version: 1.0.2
 platform: ruby
 authors:
 - Vladimir Dementyev
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-09-30 00:00:00.000000000 Z
+date: 2022-03-15 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.22
+signing_key:
 specification_version: 4
 summary: Rails Event Store in a more Rails way
 test_files: []