sequent 3.3.1 → 4.1.0

data/lib/sequent/support/database.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_support/hash_with_indifferent_access'
 
 module Sequent
@@ -16,20 +18,25 @@ module Sequent
       end
 
       def self.read_config(env)
-        fail ArgumentError.new("env is mandatory") unless env
+        fail ArgumentError, 'env is mandatory' unless env
 
         database_yml = File.join(Sequent.configuration.database_config_directory, 'database.yml')
-        YAML.load(ERB.new(File.read(database_yml)).result)[env]
+        config = YAML.safe_load(ERB.new(File.read(database_yml)).result, aliases: true)[env]
+        if Gem.loaded_specs['activerecord'].version >= Gem::Version.create('6.1.0')
+          ActiveRecord::Base.configurations.resolve(config).configuration_hash.with_indifferent_access
+        else
+          ActiveRecord::Base.resolve_config_for_connection(config)
+        end
       end
 
       def self.create!(db_config)
-        ActiveRecord::Base.establish_connection(db_config.merge('database' => 'postgres'))
-        ActiveRecord::Base.connection.create_database(db_config['database'])
+        ActiveRecord::Base.establish_connection(db_config.merge(database: 'postgres'))
+        ActiveRecord::Base.connection.create_database(db_config[:database])
       end
 
       def self.drop!(db_config)
-        ActiveRecord::Base.establish_connection(db_config.merge('database' => 'postgres'))
-        ActiveRecord::Base.connection.drop_database(db_config['database'])
+        ActiveRecord::Base.establish_connection(db_config.merge(database: 'postgres'))
+        ActiveRecord::Base.connection.drop_database(db_config[:database])
       end
 
       def self.establish_connection(db_config)
@@ -46,9 +53,8 @@ module Sequent
 
       def self.create_schema(schema)
         sql = "CREATE SCHEMA IF NOT EXISTS #{schema}"
-        if user = ActiveRecord::Base.connection_config[:username]
-          sql += " AUTHORIZATION #{user}"
-        end
+        user = configuration_hash[:username]
+        sql += %( AUTHORIZATION "#{user}") if user
         execute_sql(sql)
       end
 
@@ -57,27 +63,41 @@ module Sequent
       end
 
       def self.with_schema_search_path(search_path, db_config, env = ENV['RACK_ENV'])
-        fail ArgumentError.new("env is required") unless env
+        fail ArgumentError, 'env is required' unless env
 
         disconnect!
-        original_search_paths = db_config['schema_search_path'].dup
-        ActiveRecord::Base.configurations[env.to_s] = ActiveSupport::HashWithIndifferentAccess.new(db_config).stringify_keys
-        db_config['schema_search_path'] = search_path
+        original_search_paths = db_config[:schema_search_path].dup
+
+        if ActiveRecord::VERSION::MAJOR < 6
+          ActiveRecord::Base.configurations[env.to_s] =
+            ActiveSupport::HashWithIndifferentAccess.new(db_config).stringify_keys
+        end
+
+        db_config[:schema_search_path] = search_path
+
         ActiveRecord::Base.establish_connection db_config
 
         yield
       ensure
         disconnect!
-        db_config['schema_search_path'] = original_search_paths
+        db_config[:schema_search_path] = original_search_paths
         establish_connection(db_config)
       end
 
       def self.schema_exists?(schema)
         ActiveRecord::Base.connection.execute(
-          "SELECT schema_name FROM information_schema.schemata WHERE schema_name like '#{schema}'"
+          "SELECT schema_name FROM information_schema.schemata WHERE schema_name like '#{schema}'",
         ).count == 1
       end
 
+      def self.configuration_hash
+        if Gem.loaded_specs['activesupport'].version >= Gem::Version.create('6.1.0')
+          ActiveRecord::Base.connection_db_config.configuration_hash
+        else
+          ActiveRecord::Base.connection_config
+        end
+      end
+
       def schema_exists?(schema)
         self.class.schema_exists?(schema)
       end
@@ -94,9 +114,11 @@ module Sequent
         self.class.execute_sql(sql)
       end
 
-      def migrate(migrations_path, verbose: true)
+      def migrate(migrations_path, schema_migration: ActiveRecord::SchemaMigration, verbose: true)
         ActiveRecord::Migration.verbose = verbose
-        if ActiveRecord::VERSION::MAJOR >= 5 && ActiveRecord::VERSION::MINOR >= 2
+        if ActiveRecord::VERSION::MAJOR >= 6
+          ActiveRecord::MigrationContext.new([migrations_path], schema_migration).up
+        elsif ActiveRecord::VERSION::MAJOR >= 5 && ActiveRecord::VERSION::MINOR >= 2
           ActiveRecord::MigrationContext.new([migrations_path]).up
         else
           ActiveRecord::Migrator.migrate(migrations_path)

data/lib/sequent/support/view_projection.rb

@@ -1,9 +1,12 @@
+# frozen_string_literal: true
+
 require 'postgresql_cursor'
 
 module Sequent
   module Support
     class ViewProjection
       attr_reader :name, :version, :schema_definition
+
       def initialize(options)
         @name = options.fetch(:name)
         @version = options.fetch(:version)
@@ -20,7 +23,7 @@ module Sequent
           ordering = Events::ORDERED_BY_STREAM
           event_store.replay_events_from_cursor(
             block_size: 10_000,
-            get_events: ->() { ordering[event_store] }
+            get_events: -> { ordering[event_store] },
           )
         end
       end
@@ -42,13 +45,13 @@ module Sequent
     module Events
       extend ActiveRecord::ConnectionAdapters::Quoting
 
-      ORDERED_BY_STREAM = lambda do |event_store|
+      ORDERED_BY_STREAM = ->(_event_store) do
         event_records = quote_table_name(Sequent.configuration.event_record_class.table_name)
         stream_records = quote_table_name(Sequent.configuration.stream_record_class.table_name)
         snapshot_event_type = quote(Sequent.configuration.snapshot_event_class)
 
         Sequent.configuration.event_record_class
-          .select("event_type, event_json")
+          .select('event_type, event_json')
           .joins("INNER JOIN #{stream_records} ON #{event_records}.stream_record_id = #{stream_records}.id")
           .where("event_type <> #{snapshot_event_type}")
           .order!("#{stream_records}.id, #{event_records}.sequence_number")

data/lib/sequent/support/view_schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sequent
   module Support
     class ViewSchema < ActiveRecord::Schema

data/lib/sequent/support.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'support/database'
 require_relative 'support/view_projection'
 require_relative 'support/view_schema'

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,21 +90,31 @@ 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)
+          @event_streams[aggregate_id].present?
         end
 
         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
@@ -111,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
 
@@ -129,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

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require_relative '../test/command_handler_helpers'
+
+module Sequent
+  module Util
+    ##
+    # Dry run provides the ability to inspect what would
+    # happen if the given commands would be executed
+    # without actually committing the results.
+    # You can inspect which commands are executed
+    # and what the resulting events would be
+    # with theSequent::Projector's and Sequent::Workflow's
+    # that would be invoked (without actually invoking them).
+    #
+    # Since the Workflow's are not actually invoked new commands
+    # resulting from this Workflow will of course not be in the result.
+    #
+    # Caution: Since the Sequent Configuration is shared between threads this method
+    # is not Thread safe.
+    #
+    # Example usage:
+    #
+    #   result = Sequent.dry_run(create_foo_command, ping_foo_command)
+    #
+    #   result.print(STDOUT)
+    #
+    module DryRun
+      EventInvokedHandler = Struct.new(:event, :handler)
+
+      ##
+      # Proxies the given EventStore implements commit_events
+      # that instead of publish and store just publishes the events.
+      class EventStoreProxy
+        attr_reader :command_with_events, :event_store
+
+        delegate :load_events_for_aggregates,
+                 :load_events,
+                 :publish_events,
+                 :stream_exists?,
+                 to: :event_store
+
+        def initialize(result)
+          @event_store = Sequent::Test::CommandHandlerHelpers::FakeEventStore.new
+          @command_with_events = {}
+          @result = result
+        end
+
+        def commit_events(command, streams_with_events)
+          event_store.commit_events(command, streams_with_events)
+
+          new_events = streams_with_events.flat_map { |_, events| events }
+          @result.published_command_with_events(command, new_events)
+        end
+      end
+
+      ##
+      # Records which Projector's and Workflow's are executed
+      #
+      class RecordingEventPublisher < Sequent::Core::EventPublisher
+        attr_reader :projectors, :workflows
+
+        def initialize(result)
+          super()
+          @result = result
+        end
+
+        def process_event(event)
+          Sequent.configuration.event_handlers.each do |handler|
+            next unless handler.class.handles_message?(event)
+
+            if handler.is_a?(Sequent::Workflow)
+              @result.invoked_workflow(EventInvokedHandler.new(event, handler.class))
+            elsif handler.is_a?(Sequent::Projector)
+              @result.invoked_projector(EventInvokedHandler.new(event, handler.class))
+            else
+              fail "Unrecognized event_handler #{handler.class} called for event #{event.class}"
+            end
+          rescue StandardError
+            raise PublishEventError.new(handler.class, event)
+          end
+        end
+      end
+
+      ##
+      # Contains the result of a dry run.
+      #
+      # @see #tree
+      # @see #print
+      #
+      class Result
+        EventCalledHandlers = Struct.new(:event, :projectors, :workflows)
+
+        def initialize
+          @command_with_events = {}
+          @event_invoked_projectors = []
+          @event_invoked_workflows = []
+        end
+
+        def invoked_projector(event_invoked_handler)
+          event_invoked_projectors << event_invoked_handler
+        end
+
+        def invoked_workflow(event_invoked_handler)
+          event_invoked_workflows << event_invoked_handler
+        end
+
+        def published_command_with_events(command, events)
+          command_with_events[command] = events
+        end
+
+        ##
+        # Returns the command with events as a tree structure.
+        #
+        # {
+        #   command => [
+        #     EventCalledHandlers,
+        #     EventCalledHandlers,
+        #     EventCalledHandlers,
+        #   ]
+        # }
+        #
+        # The EventCalledHandlers contains an Event with the
+        # lists of `Sequent::Projector`s and `Sequent::Workflow`s
+        # that were called.
+        #
+        def tree
+          command_with_events.reduce({}) do |memo, (command, events)|
+            events_to_handlers = events.map do |event|
+              for_current_event = ->(pair) { pair.event == event }
+              EventCalledHandlers.new(
+                event,
+                event_invoked_projectors.select(&for_current_event).map(&:handler),
+                event_invoked_workflows.select(&for_current_event).map(&:handler),
+              )
+            end
+            memo[command] = events_to_handlers
+            memo
+          end
+        end
+
+        ##
+        # Prints the output from #tree to the given `io`
+        #
+        def print(io)
+          tree.each_with_index do |(command, event_called_handlerss), index|
+            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 "-- 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 '+++++++++++++++++++++++++++++++++++'
+          end
+        end
+
+        private
+
+        attr_reader :command_with_events, :event_invoked_projectors, :event_invoked_workflows
+      end
+
+      ##
+      # Main method of the DryRun.
+      #
+      # Caution: Since the Sequent Configuration is changed and is shared between threads this method
+      # is not Thread safe.
+      #
+      # After invocation the sequent configuration is reset to the state it was before
+      # invoking this method.
+      #
+      # @param commands - the commands to dry run
+      # @return Result - the Result of the dry run. See Result.
+      #
+      def self.these_commands(commands)
+        current_event_store = Sequent.configuration.event_store
+        current_event_publisher = Sequent.configuration.event_publisher
+        result = Result.new
+
+        Sequent.configuration.event_store = EventStoreProxy.new(result)
+        Sequent.configuration.event_publisher = RecordingEventPublisher.new(result)
+
+        Sequent.command_service.execute_commands(*commands)
+
+        result
+      ensure
+        Sequent.configuration.event_store = current_event_store
+        Sequent.configuration.event_publisher = current_event_publisher
+      end
+    end
+  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,15 +1,31 @@
+# frozen_string_literal: true
+
 module Sequent
   module Util
-    def self.skip_if_already_processing(already_processing_key, &block)
-      return if Thread.current[already_processing_key]
+    ##
+    # Returns if the current Thread is already processing work
+    # given the +processing_key+ otherwise
+    # it yields the given +&block+.
+    #
+    # Useful in a Queue and Processing strategy
+    def self.skip_if_already_processing(processing_key)
+      return if Thread.current[processing_key]
 
       begin
-        Thread.current[already_processing_key] = true
+        Thread.current[processing_key] = true
 
-        block.yield
+        yield
       ensure
-        Thread.current[already_processing_key] = nil
+        Thread.current[processing_key] = nil
       end
     end
+
+    ##
+    # Reset the given +processing_key+ for the current Thread.
+    #
+    # Usefull to make a block protected by +skip_if_already_processing+ reentrant.
+    def self.done_processing(processing_key)
+      Thread.current[processing_key] = nil
+    end
   end
 end

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,6 @@
+# frozen_string_literal: true
+
 require_relative 'skip_if_already_processing'
 require_relative 'timer'
 require_relative 'printer'
+require_relative 'dry_run'

data/lib/sequent.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 require_relative 'sequent/application_record'
 require_relative 'sequent/sequent'
 require_relative 'sequent/core/core'
 require_relative 'sequent/util/util'
 require_relative 'sequent/migrations/migrations'
+
+require_relative 'notices'