ruby_reactor 0.2.0 → 0.3.1

data/lib/ruby_reactor/reactor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 module RubyReactor
+  # rubocop:disable Metrics/ClassLength
   class Reactor
     include RubyReactor::Dsl::Reactor
 
@@ -64,34 +65,71 @@ module RubyReactor
     def initialize(context = {})
       @context = context
       @result = :unexecuted
-      @undo_trace = []
-      @execution_trace = []
+
+      if @context.is_a?(Context)
+        @execution_trace = @context.execution_trace || []
+        @undo_trace = @execution_trace.select { |e| e[:type] == :undo }
+        @result = reconstruct_result
+      else
+        @undo_trace = []
+        @execution_trace = []
+      end
     end
 
+    # rubocop:disable Metrics/MethodLength
     def run(inputs = {})
-      if self.class.async?
-        # For async reactors, enqueue the job and return immediately
-        context = Context.new(inputs, self.class)
-        serialized_context = ContextSerializer.serialize(context)
-        configuration.async_router.perform_async(serialized_context)
+      # For all reactors, initialize context first to capture execution ID
+      @context = @context.is_a?(Context) ? @context : Context.new(inputs, self.class)
+
+      # Validate inputs
+      validation_result = self.class.validate_inputs(inputs)
+      if validation_result.failure?
+        @result = validation_result
+        @context.status = "failed"
+        @context.failure_reason = {
+          message: validation_result.error.message,
+          validation_errors: validation_result.error.field_errors
+        }
+        save_context
+        return validation_result
+      end
+
+      if self.class.async? && !@context.inline_async_execution
+        # For async reactors, queue a job for the whole reactor
+        @context.status = :running
+        save_context
+
+        serialized_context = ContextSerializer.serialize(@context)
+        @result = configuration.async_router.perform_async(serialized_context, self.class.name,
+                                                           intermediate_results: @context.intermediate_results)
+
+        # Even if it's an AsyncResult, it might have finished inline (e.g. Sidekiq::Testing.inline!)
+        # Check storage to see if it's already finished or paused (interrupted).
+        begin
+          reloaded = self.class.find(@context.context_id)
+          if reloaded.finished? || reloaded.context.status.to_s == "paused"
+            @context = reloaded.context
+            @result = reloaded.result
+            @execution_trace = reloaded.execution_trace
+            @undo_trace = reloaded.undo_trace
+            return @result
+          end
+        rescue StandardError
+          # Ignore if not found or other errors during reload check
+        end
+
       else
         # For sync reactors (potentially with async steps), execute normally
         context = @context.is_a?(Context) ? @context : nil
         executor = Executor.new(self.class, inputs, context)
         @result = executor.execute
-
         @context = executor.context
-
-        # Merge traces
-        @undo_trace = executor.undo_trace
         @execution_trace = executor.execution_trace
-
-        # If execution returned an AsyncResult (from step-level async), return it
-        return @result if @result.is_a?(RubyReactor::AsyncResult)
-
-        @result
+        @undo_trace = executor.undo_trace
       end
+      @result
     end
+    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
 
     def continue(payload:, step_name:, idempotency_key: nil)
       _ = idempotency_key
@@ -178,6 +216,125 @@ module RubyReactor
       raise Error::DependencyError, "Dependency graph contains cycles"
     end
 
+    def reconstruct_result
+      case @context.status.to_s
+      when "completed" then reconstruct_success_result
+      when "failed" then reconstruct_failure_result
+      when "paused" then reconstruct_paused_result
+      else :unexecuted
+      end
+    end
+
+    def reconstruct_success_result
+      rs = self.class.respond_to?(:returns) ? self.class.returns : nil
+      val = if rs
+              @context.intermediate_results[rs.to_sym] || @context.intermediate_results[rs.to_s]
+            else
+              find_last_step_result
+            end
+      Success.new(val)
+    end
+
+    def find_last_step_result
+      last_run = @execution_trace.reverse.find { |e| e[:type] == :run || e["type"] == "run" }
+      return unless last_run
+
+      step_name = last_run[:step] || last_run["step"]
+      @context.intermediate_results[step_name.to_sym] || @context.intermediate_results[step_name.to_s]
+    end
+
+    def reconstruct_failure_result
+      reason = @context.failure_reason || {}
+      return reason if reason.is_a?(RubyReactor::Failure)
+
+      # Use string keys preferred, fallback to symbol
+      r = ->(k) { reason[k.to_s] || reason[k.to_sym] }
+
+      Failure.new(
+        r[:message],
+        step_name: r[:step_name],
+        inputs: r[:inputs] || {},
+        backtrace: r[:backtrace],
+        reactor_name: r[:reactor_name],
+        step_arguments: r[:step_arguments] || {},
+        exception_class: r[:exception_class],
+        file_path: r[:file_path],
+        line_number: r[:line_number],
+        code_snippet: r[:code_snippet],
+        validation_errors: r[:validation_errors],
+        retryable: r[:retryable],
+        invalid_payload: r[:invalid_payload]
+      )
+    end
+
+    def reconstruct_paused_result
+      InterruptResult.new(
+        execution_id: @context.context_id,
+        intermediate_results: @context.intermediate_results
+      )
+    end
+
+    def initialize_and_validate_run?(inputs)
+      # For all reactors, initialize context first to capture execution ID
+      @context = @context.is_a?(Context) ? @context : Context.new(inputs, self.class)
+
+      validation_result = self.class.validate_inputs(inputs)
+      if validation_result.failure?
+        handle_validation_failure(validation_result)
+        return false
+      end
+      true
+    end
+
+    def handle_validation_failure(result)
+      @result = result
+      @context.status = "failed"
+      @context.failure_reason = {
+        message: result.error.message,
+        validation_errors: result.error.field_errors
+      }
+      save_context
+    end
+
+    def perform_async_run
+      @context.status = :running
+      save_context
+
+      serialized_context = ContextSerializer.serialize(@context)
+      @result = configuration.async_router.perform_async(serialized_context, self.class.name,
+                                                         intermediate_results: @context.intermediate_results)
+
+      check_for_inline_completion
+    end
+
+    def check_for_inline_completion
+      # Even if it's an AsyncResult, it might have finished inline (e.g. Sidekiq::Testing.inline!)
+      # Check storage to see if it's already finished or paused (interrupted).
+      reloaded = self.class.find(@context.context_id)
+      if reloaded.finished? || reloaded.context.status.to_s == "paused"
+        update_state_from_reloaded(reloaded)
+        @result
+      end
+    rescue StandardError
+      # Ignore if not found or other errors during reload check
+    end
+
+    def update_state_from_reloaded(reloaded)
+      @context = reloaded.context
+      @result = reloaded.result
+      @execution_trace = reloaded.execution_trace
+      @undo_trace = reloaded.undo_trace
+    end
+
+    def perform_sync_run(inputs)
+      context = @context.is_a?(Context) ? @context : nil
+      executor = Executor.new(self.class, inputs, context)
+      @result = executor.execute
+      @context = executor.context
+      @execution_trace = executor.execution_trace
+      @undo_trace = executor.undo_trace
+    end
+
     def validate_continue_step!(step_name)
       return if step_name.to_s == @context.current_step.to_s
 
@@ -258,4 +415,5 @@ module RubyReactor
       storage.store_context(@context.context_id, serialized_context, reactor_class_name)
     end
   end
+  # rubocop:enable Metrics/ClassLength
 end

data/lib/ruby_reactor/rspec/helpers.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module RSpec
+    module Helpers
+      def test_reactor(reactor_class, inputs, context: {}, async: nil, process_jobs: true)
+        TestSubject.new(
+          reactor_class: reactor_class,
+          inputs: inputs,
+          context: context,
+          async: async,
+          process_jobs: process_jobs
+        )
+      end
+    end
+  end
+end

data/lib/ruby_reactor/rspec/matchers.rb

@@ -0,0 +1,256 @@
+# frozen_string_literal: true
+
+module RubyReactor
+  module RSpec
+    module Matchers
+      # rubocop:disable Metrics/BlockLength
+      ::RSpec::Matchers.define :be_success do
+        match do |subject|
+          subject.ensure_executed!
+          subject.success?
+        end
+
+        failure_message do |subject|
+          result = subject.result
+          if result&.failure?
+            format_failure_message(result)
+          else
+            "expected reactor to be success, but failed (Status: #{subject.reactor_instance.context.status})"
+          end
+        end
+
+        def format_failure_message(error)
+          # Safely extract values
+          err_msg = error.respond_to?(:error) ? error.error.to_s : error.to_s
+          ex_class = error.respond_to?(:exception_class) ? error.exception_class : nil
+          step = error.respond_to?(:step_name) ? error.step_name : nil
+          file = error.respond_to?(:file_path) ? error.file_path : nil
+          line = error.respond_to?(:line_number) ? error.line_number : nil
+          snippet = error.respond_to?(:code_snippet) ? error.code_snippet : nil
+          backtrace = error.respond_to?(:backtrace) ? error.backtrace : nil
+
+          lines = []
+          lines << "Error: #{ex_class || "UnknownError"}"
+          lines << err_msg.to_s
+          lines << "Step: :#{step}" if step
+          lines << "File: #{file}:#{line}" if file
+
+          append_snippet(lines, snippet)
+          append_backtrace(lines, backtrace)
+
+          lines.join("\n")
+        end
+
+        def append_snippet(lines, snippet)
+          return unless snippet.is_a?(Array) && !snippet.empty?
+
+          lines << ""
+          snippet.each do |s|
+            prefix = s[:target] ? "--> " : "    "
+            lines << "#{prefix}#{s[:content]}"
+          end
+        end
+
+        def append_backtrace(lines, backtrace)
+          return unless backtrace && !backtrace.empty?
+
+          lines << ""
+          lines << "Backtrace:"
+          lines << backtrace.take(10).map { |l| "- #{l}" }
+        end
+      end
+
+      ::RSpec::Matchers.define :be_failure do
+        match do |subject|
+          subject.ensure_executed!
+          subject.failure?
+        end
+
+        failure_message do |_subject|
+          "expected reactor to be failure, but succeeded"
+        end
+      end
+
+      ::RSpec::Matchers.define :have_run_step do |step_name|
+        match do |subject|
+          subject.ensure_executed!
+          @trace = subject.reactor_instance.context.execution_trace
+          @entry = @trace.find { |t| t[:step].to_s == step_name.to_s }
+
+          return false unless @entry
+
+          matches_result?(subject, step_name) && matches_order?
+        end
+
+        def matches_result?(subject, step_name)
+          return true unless @check_result
+
+          actual_result = subject.step_result(step_name)
+          if @expected_result.is_a?(Regexp)
+            actual_result.to_s.match?(@expected_result)
+          else
+            values_match?(@expected_result, actual_result)
+          end
+        end
+
+        def matches_order?
+          return true unless @after_step
+
+          after_index = @trace.index(@entry)
+          before_entry = @trace.find { |t| t[:step].to_s == @after_step.to_s }
+
+          return false unless before_entry
+
+          after_index > @trace.index(before_entry)
+        end
+
+        chain :returning do |value|
+          @check_result = true
+          @expected_result = value
+        end
+
+        chain :after do |step|
+          @after_step = step
+        end
+
+        failure_message do |subject|
+          msg = "expected reactor to have run step :#{step_name}"
+          if @check_result
+            actual_result = subject.step_result(step_name)
+            msg += " returning #{@expected_result.inspect}, but returned #{actual_result.inspect}"
+          end
+          msg += " after :#{@after_step}" if @after_step
+          msg
+        end
+      end
+
+      ::RSpec::Matchers.define :have_retried_step do |step_name|
+        match do |subject|
+          subject.ensure_executed!
+          attempts = subject.reactor_instance.context.retry_context.attempts_for_step(step_name)
+          retries = attempts - 1
+
+          if @expected_retries
+            retries == @expected_retries
+          else
+            retries.positive?
+          end
+        end
+
+        chain :times do |count|
+          @expected_retries = count
+        end
+
+        failure_message do |_subject|
+          msg = "expected reactor to have retried step :#{step_name}"
+          msg += " #{@expected_retries} times" if @expected_retries
+          msg
+        end
+      end
+
+      ::RSpec::Matchers.define :have_validation_error do |field|
+        match do |subject|
+          subject.ensure_executed!
+          return false unless subject.failure?
+
+          # Try to get validation errors from failure reason
+          reason = subject.reactor_instance.context.failure_reason || {}
+
+          # If failure is InputValidationError, it might be serialized differently
+          # Or stored in validation_errors key
+          errors = reason["validation_errors"] || reason[:validation_errors]
+
+          if errors
+            errors.key?(field.to_s) || errors.key?(field.to_sym)
+          else
+            false
+          end
+        end
+
+        failure_message do |_subject|
+          "expected reactor to have validation error on :#{field}"
+        end
+      end
+
+      # Matcher to check if reactor is paused at an interrupt
+      ::RSpec::Matchers.define :be_paused do
+        match do |subject|
+          subject.ensure_executed!
+          subject.paused?
+        end
+
+        failure_message do |subject|
+          "expected reactor to be paused, but status was #{subject.reactor_instance.context.status}"
+        end
+
+        failure_message_when_negated do |_subject|
+          "expected reactor not to be paused, but it is"
+        end
+      end
+
+      # Matcher to check if reactor is paused at a specific interrupt step
+      # Works with both single and multiple concurrent interrupts
+      ::RSpec::Matchers.define :be_paused_at do |*step_names|
+        match do |subject|
+          subject.ensure_executed!
+          return false unless subject.paused?
+
+          ready_steps = subject.ready_interrupt_steps
+          step_names.all? { |name| ready_steps.include?(name.to_sym) }
+        end
+
+        failure_message do |subject|
+          if subject.paused?
+            ready_steps = subject.ready_interrupt_steps
+            if step_names.size == 1
+              "expected reactor to be paused at :#{step_names.first}, " \
+                "but ready interrupt steps are: #{ready_steps.inspect}"
+            else
+              "expected reactor to be paused at #{step_names.map { |s| ":#{s}" }.join(", ")}, " \
+                "but ready interrupt steps are: #{ready_steps.inspect}"
+            end
+          else
+            "expected reactor to be paused at #{step_names.map { |s| ":#{s}" }.join(", ")}, " \
+              "but status was #{subject.reactor_instance.context.status}"
+          end
+        end
+
+        failure_message_when_negated do |_subject|
+          "expected reactor not to be paused at #{step_names.map { |s| ":#{s}" }.join(", ")}, but it is"
+        end
+      end
+
+      # Matcher to check the exact set of ready interrupt steps
+      ::RSpec::Matchers.define :have_ready_interrupts do |*expected_steps|
+        match do |subject|
+          subject.ensure_executed!
+          return false unless subject.paused?
+
+          actual_steps = subject.ready_interrupt_steps.sort
+          expected = expected_steps.map(&:to_sym).sort
+          actual_steps == expected
+        end
+
+        failure_message do |subject|
+          if subject.paused?
+            actual_steps = subject.ready_interrupt_steps
+            "expected ready interrupt steps to be #{expected_steps.map { |s| ":#{s}" }}, " \
+              "but got #{actual_steps.inspect}"
+          else
+            "expected reactor to be paused with ready interrupt steps, " \
+              "but status was #{subject.reactor_instance.context.status}"
+          end
+        end
+
+        failure_message_when_negated do |subject|
+          actual_steps = subject.ready_interrupt_steps
+          "expected ready interrupt steps not to be #{expected_steps.map { |s| ":#{s}" }}, " \
+            "but it was #{actual_steps.inspect}"
+        end
+      end
+
+      # Add more matchers as per plan
+      # rubocop:enable Metrics/BlockLength
+    end
+  end
+end

data/lib/ruby_reactor/rspec/step_executor_patch.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "ruby_reactor"
+
+module RubyReactor
+  module RSpec
+    # Patch StepExecutor to handle inline async execution during tests.
+    # This ensures that when a worker runs inline (e.g. Sidekiq::Testing.inline!),
+    # the calling executor can pick up the state change immediately and continue,
+    # preventing stalled execution in nested async scenarios.
+    module StepExecutorPatch
+      def execute_step(step_config)
+        # 1. Call original implementation
+        result = super
+
+        # 2. Add test-specific logic for inline async execution
+        # Only interfere if we got an AsyncResult and we are in a testing environment that supports inline execution
+        if should_check_inline_completion?(result)
+          # Check if it finished or paused inline (e.g. Sidekiq::Testing.inline!)
+          refresh_context_from_storage
+
+          # If the step itself now has a result, it means it ran inline
+          if @context.has_result?(step_config.name)
+            # If the step failed, we should return failure
+            return reconstruct_failure(@context.failure_reason) if @context.failed?
+
+            return nil # Continue to next step
+          end
+
+          # If the overall reactor finished or paused for other reasons (e.g. error in worker)
+          if @context.finished? || @context.status.to_s == "paused"
+            return reconstruct_failure(@context.failure_reason) if @context.failed?
+
+            if @context.status.to_s == "paused"
+              return RubyReactor::InterruptResult.new(
+                execution_id: @context.context_id,
+                intermediate_results: @context.intermediate_results
+              )
+            end
+            return nil # Finished successfully
+          end
+        end
+
+        # Return original result if no intervention needed
+        result
+      end
+
+      private
+
+      def refresh_context_from_storage
+        storage = RubyReactor::Configuration.instance.storage_adapter
+        reactor_class_name = @reactor_class.name
+        serialized = storage.retrieve_context(@context.context_id, reactor_class_name)
+        return unless serialized
+
+        reloaded_context = Context.deserialize_from_retry(serialized)
+
+        # Update local context state
+        @context.status = reloaded_context.status
+        @context.failure_reason = reloaded_context.failure_reason
+        @context.cancelled = reloaded_context.cancelled
+        @context.cancellation_reason = reloaded_context.cancellation_reason
+        @context.intermediate_results.merge!(reloaded_context.intermediate_results)
+        @context.execution_trace = reloaded_context.execution_trace
+        @context.private_data.merge!(reloaded_context.private_data)
+        @context.retry_context = reloaded_context.retry_context
+        @context.composed_contexts.merge!(reloaded_context.composed_contexts)
+        @context.map_operations.merge!(reloaded_context.map_operations)
+        @context.map_metadata = reloaded_context.map_metadata
+
+        # Also need to mark step as completed in dependency graph
+        reloaded_context.intermediate_results.each_key do |step_name|
+          @dependency_graph.complete_step(step_name.to_sym)
+        end
+      end
+
+      def should_check_inline_completion?(result)
+        return false unless result.is_a?(RubyReactor::AsyncResult) || result.is_a?(RubyReactor::RetryQueuedResult)
+        return true if defined?(Sidekiq::Testing) && Sidekiq::Testing.inline?
+
+        false
+      end
+    end
+  end
+end