sequent 4.0.0 → 4.1.0

data/lib/sequent/test/command_handler_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'thread_safe'
 require 'sequent/core/event_store'
 
@@ -36,7 +38,6 @@ module Sequent
     #
     # end
     module CommandHandlerHelpers
-
       class FakeEventStore
         extend Forwardable
 
@@ -89,7 +90,7 @@ module Sequent
         end
 
         def stream_exists?(aggregate_id)
-          @event_streams.has_key?(aggregate_id)
+          @event_streams.key?(aggregate_id)
         end
 
         def events_exists?(aggregate_id)
@@ -99,15 +100,21 @@ module Sequent
         private
 
         def to_event_streams(events)
-          # Specs use a simple list of given events. We need a mapping from StreamRecord to the associated events for the event store.
+          # Specs use a simple list of given events.
+          # We need a mapping from StreamRecord to the associated events for the event store.
           streams_by_aggregate_id = {}
           events.map do |event|
             event_stream = streams_by_aggregate_id.fetch(event.aggregate_id) do |aggregate_id|
               streams_by_aggregate_id[aggregate_id] =
                 find_event_stream(aggregate_id) ||
                 begin
-                  aggregate_type = FakeEventStore.aggregate_type_for_event(event)
-                  raise "cannot find aggregate type associated with creation event #{event}, did you include an event handler in your aggregate for this event?" unless aggregate_type
+                  aggregate_type = aggregate_type_for_event(event)
+                  unless aggregate_type
+                    fail <<~EOS
+                      Cannot find aggregate type associated with creation event #{event}, did you include an event handler in your aggregate for this event?
+                    EOS
+                  end
+
                   Sequent::Core::EventStream.new(aggregate_type: aggregate_type.name, aggregate_id: aggregate_id)
                 end
             end
@@ -115,10 +122,10 @@ module Sequent
           end
         end
 
-        def self.aggregate_type_for_event(event)
+        def aggregate_type_for_event(event)
           @event_to_aggregate_type ||= ThreadSafe::Cache.new
           @event_to_aggregate_type.fetch_or_store(event.class) do |klass|
-            Sequent::Core::AggregateRoot.descendants.find { |x| x.message_mapping.has_key?(klass) }
+            Sequent::Core::AggregateRoots.all.find { |x| x.message_mapping.key?(klass) }
           end
         end
 
@@ -133,30 +140,41 @@ module Sequent
         end
       end
 
-      def given_events *events
+      def given_events(*events)
         Sequent.configuration.event_store.given_events(events.flatten(1))
       end
 
-      def when_command command
+      def when_command(command)
         Sequent.configuration.command_service.execute_commands command
       end
 
       def then_events(*expected_events)
-        expected_classes = expected_events.flatten(1).map { |event| event.class == Class ? event : event.class }
+        expected_classes = expected_events.flatten(1).map { |event| event.instance_of?(Class) ? event : event.class }
         expect(Sequent.configuration.event_store.stored_events.map(&:class)).to eq(expected_classes)
 
-        Sequent.configuration.event_store.stored_events.zip(expected_events.flatten(1)).each_with_index do |(actual, expected), index|
-          next if expected.class == Class
-          _actual = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))
-          _expected = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))
-          expect(_actual).to eq(_expected), "#{index+1}th Event of type #{actual.class} not equal\nexpected: #{_expected.inspect}\n     got: #{_actual.inspect}" if expected
-        end
+        Sequent
+          .configuration
+          .event_store
+          .stored_events
+          .zip(expected_events.flatten(1))
+          .each_with_index do |(actual, expected), index|
+            next if expected.instance_of?(Class)
+
+            actual_hash = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))
+            expected_hash = Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))
+            next unless expected
+
+            # rubocop:disable Layout/LineLength
+            expect(actual_hash)
+              .to eq(expected_hash),
+                  "#{index + 1}th Event of type #{actual.class} not equal\nexpected: #{expected_hash.inspect}\n     got: #{actual_hash.inspect}"
+            # rubocop:enable Layout/LineLength
+          end
       end
 
       def then_no_events
         then_events
       end
-
     end
   end
 end

data/lib/sequent/test/event_handler_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Test
     ##
@@ -26,7 +28,6 @@ module Sequent
     #   end
     # end
     module WorkflowHelpers
-
       class FakeTransactionProvider
         def initialize
           @after_commit_blocks = []
@@ -55,12 +56,17 @@ module Sequent
       end
 
       def then_events(*expected_events)
-        expected_classes = expected_events.flatten(1).map { |event| event.class == Class ? event : event.class }
+        expected_classes = expected_events.flatten(1).map { |event| event.instance_of?(Class) ? event : event.class }
         expect(Sequent.configuration.event_store.stored_events.map(&:class)).to eq(expected_classes)
 
         Sequent.configuration.event_store.stored_events.zip(expected_events.flatten(1)).each do |actual, expected|
-          next if expected.class == Class
-          expect(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload))).to eq(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload))) if expected
+          next if expected.instance_of?(Class)
+
+          next unless expected
+
+          expect(
+            Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(actual.payload)),
+          ).to eq(Sequent::Core::Oj.strict_load(Sequent::Core::Oj.dump(expected.payload)))
         end
       end
 

data/lib/sequent/test/event_stream_helpers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Test
     ##
@@ -41,12 +43,14 @@ module Sequent
           @events = []
         end
 
+        # rubocop:disable Style/MissingRespondToMissing
         def method_missing(name, *args, &block)
           args = prepare_arguments(args)
           @events << FactoryBot.build(name, *args, &block)
         end
+        # rubocop:enable Style/MissingRespondToMissing
 
-      private
+        private
 
         def prepare_arguments(args)
           options = args.last.is_a?(Hash) ? args.pop : {}
@@ -68,10 +72,10 @@ module Sequent
         given_events(*event_stream(aggregate_id: aggregate_id, &block))
       end
 
-      def self.included(spec)
+      def self.included(_spec)
         require 'factory_bot'
       rescue LoadError
-        raise ArgumentError, "Factory bot is required to use the event stream helpers"
+        raise ArgumentError, 'Factory bot is required to use the event stream helpers'
       end
     end
   end

data/lib/sequent/test/time_comparison.rb

@@ -1,20 +1,25 @@
+# frozen_string_literal: true
+
 module Sequent
   module Test
     module DateTimePatches
       module Normalize
         def normalize
-          in_time_zone("UTC")
+          in_time_zone('UTC')
         end
       end
 
       module Compare
-        alias_method :'___<=>', :<=>
+        # rubocop:disable Style/Alias
+        alias :'___<=>' :'<=>'
+        # rubocop:enable Style/Alias
 
         # omit nsec in datetime comparisons
         def <=>(other)
-          if other && other.is_a?(DateTimePatches::Normalize)
+          if other&.is_a?(DateTimePatches::Normalize)
             result = normalize.iso8601 <=> other.normalize.iso8601
             return result unless result == 0
+
             # use usec here, which *truncates* the nsec (ie. like Postgres)
             return normalize.usec <=> other.normalize.usec
           end
@@ -35,6 +40,8 @@ class DateTime
   prepend Sequent::Test::DateTimePatches::Compare
 end
 
-class ActiveSupport::TimeWithZone
-  prepend Sequent::Test::DateTimePatches::Normalize
+module ActiveSupport
+  class TimeWithZone
+    prepend Sequent::Test::DateTimePatches::Normalize
+  end
 end

data/lib/sequent/test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'sequent'
 require_relative 'test/command_handler_helpers'
 require_relative 'test/event_stream_helpers'

data/lib/sequent/util/dry_run.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative '../test/command_handler_helpers'
 
 module Sequent
@@ -33,10 +35,10 @@ module Sequent
         attr_reader :command_with_events, :event_store
 
         delegate :load_events_for_aggregates,
-          :load_events,
-          :publish_events,
-          :stream_exists?,
-          to: :event_store
+                 :load_events,
+                 :publish_events,
+                 :stream_exists?,
+                 to: :event_store
 
         def initialize(result)
           @event_store = Sequent::Test::CommandHandlerHelpers::FakeEventStore.new
@@ -59,6 +61,7 @@ module Sequent
         attr_reader :projectors, :workflows
 
         def initialize(result)
+          super()
           @result = result
         end
 
@@ -73,7 +76,7 @@ module Sequent
             else
               fail "Unrecognized event_handler #{handler.class} called for event #{event.class}"
             end
-          rescue
+          rescue StandardError
             raise PublishEventError.new(handler.class, event)
           end
         end
@@ -141,16 +144,16 @@ module Sequent
         #
         def print(io)
           tree.each_with_index do |(command, event_called_handlerss), index|
-            io.puts "+++++++++++++++++++++++++++++++++++" if index == 0
+            io.puts '+++++++++++++++++++++++++++++++++++' if index == 0
             io.puts "Command: #{command.class} resulted in #{event_called_handlerss.length} events"
             event_called_handlerss.each_with_index do |event_called_handlers, i|
-              io.puts "" if i > 0
+              io.puts '' if i > 0
               io.puts "-- Event #{event_called_handlers.event.class} was handled by:"
               io.puts "-- Projectors: [#{event_called_handlers.projectors.join(', ')}]"
               io.puts "-- Workflows: [#{event_called_handlers.workflows.join(', ')}]"
             end
 
-            io.puts "+++++++++++++++++++++++++++++++++++"
+            io.puts '+++++++++++++++++++++++++++++++++++'
           end
         end
 

data/lib/sequent/util/printer.rb

@@ -1,16 +1,17 @@
+# frozen_string_literal: true
+
 module Sequent
   module Util
     module Printer
       def recursively_print(e)
-        logger.error "#{e.to_s}\n\n#{e.backtrace.join("\n")}"
+        logger.error "#{e}\n\n#{e.backtrace.join("\n")}"
 
-        while e.cause do
-          logger.error "+++++++++++++++ CAUSE +++++++++++++++"
-          logger.error "#{e.cause.to_s}\n\n#{e.cause.backtrace.join("\n")}"
+        while e.cause
+          logger.error '+++++++++++++++ CAUSE +++++++++++++++'
+          logger.error "#{e.cause}\n\n#{e.cause.backtrace.join("\n")}"
           e = e.cause
         end
       end
     end
   end
 end
-

data/lib/sequent/util/skip_if_already_processing.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Util
     ##
@@ -6,7 +8,7 @@ module Sequent
     # it yields the given +&block+.
     #
     # Useful in a Queue and Processing strategy
-    def self.skip_if_already_processing(processing_key, &block)
+    def self.skip_if_already_processing(processing_key)
       return if Thread.current[processing_key]
 
       begin

data/lib/sequent/util/timer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Util
     module Timer

data/lib/sequent/util/util.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'skip_if_already_processing'
 require_relative 'timer'
 require_relative 'printer'

data/lib/sequent.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'sequent/application_record'
 require_relative 'sequent/sequent'
 require_relative 'sequent/core/core'

data/lib/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
-  VERSION = '4.0.0'
+  VERSION = '4.1.0'
 end