stepper_motor 0.1.17 → 0.1.19

data/test/stepper_motor/journey/step_ordering_test.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class StepOrderingTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+  include SideEffects::TestHelper
+  include StepperMotor::TestHelper
+
+  test "allows inserting step before another step using string" do
+    journey_class = create_journey_subclass do
+      step :first do
+        # noop
+      end
+      step :third do
+        # noop
+      end
+      step :second, before_step: "first" do
+        # noop
+      end
+    end
+
+    assert_equal ["second", "first", "third"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "allows inserting step before another step using symbol" do
+    journey_class = create_journey_subclass do
+      step :first do
+        # noop
+      end
+      step :third do
+        # noop
+      end
+      step :second, before_step: :first do
+        # noop
+      end
+    end
+
+    assert_equal ["second", "first", "third"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "allows inserting step after another step using string" do
+    journey_class = create_journey_subclass do
+      step :first do
+        # noop
+      end
+      step :third do
+        # noop
+      end
+      step :second, after_step: "first" do
+        # noop
+      end
+    end
+
+    assert_equal ["first", "second", "third"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "allows inserting step after another step using symbol" do
+    journey_class = create_journey_subclass do
+      step :first do
+        # noop
+      end
+      step :third do
+        # noop
+      end
+      step :second, after_step: :first do
+        # noop
+      end
+    end
+
+    assert_equal ["first", "second", "third"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "allows inserting step at the beginning using before_step" do
+    journey_class = create_journey_subclass do
+      step :second do
+        # noop
+      end
+      step :third do
+        # noop
+      end
+      step :first, before_step: "second" do
+        # noop
+      end
+    end
+
+    assert_equal ["first", "second", "third"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "allows inserting step at the end using after_step" do
+    journey_class = create_journey_subclass do
+      step :first do
+        # noop
+      end
+      step :second do
+        # noop
+      end
+      step :third, after_step: "second" do
+        # noop
+      end
+    end
+
+    assert_equal ["first", "second", "third"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "allows complex step ordering with multiple insertions" do
+    journey_class = create_journey_subclass do
+      step :step_1 do
+        # noop
+      end
+      step :step_4 do
+        # noop
+      end
+      step :step_2, after_step: "step_1" do
+        # noop
+      end
+      step :step_3, before_step: "step_4" do
+        # noop
+      end
+    end
+
+    assert_equal ["step_1", "step_2", "step_3", "step_4"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "raises error when both before_step and after_step are specified" do
+    assert_raises(StepperMotor::StepConfigurationError, "Either before_step: or after_step: can be specified, but not both") do
+      create_journey_subclass do
+        step :first do
+          # noop
+        end
+        step :second, before_step: "first", after_step: "first" do
+          # noop
+        end
+      end
+    end
+  end
+
+  test "raises error when before_step references non-existent step" do
+    assert_raises(StepperMotor::StepConfigurationError, "Step named \"nonexistent\" not found for before_step: parameter") do
+      create_journey_subclass do
+        step :first, before_step: "nonexistent" do
+          # noop
+        end
+      end
+    end
+  end
+
+  test "raises error when after_step references non-existent step" do
+    assert_raises(StepperMotor::StepConfigurationError, "Step named \"nonexistent\" not found for after_step: parameter") do
+      create_journey_subclass do
+        step :first, after_step: "nonexistent" do
+          # noop
+        end
+      end
+    end
+  end
+
+  test "maintains existing after: timing functionality" do
+    journey_class = create_journey_subclass do
+      step :first, after: 5.minutes do
+        # noop
+      end
+      step :second, after: 10.minutes do
+        # noop
+      end
+    end
+
+    assert_equal ["first", "second"], journey_class.step_definitions.map(&:name)
+    assert_equal 5.minutes, journey_class.step_definitions[0].wait
+    assert_equal 5.minutes, journey_class.step_definitions[1].wait
+  end
+
+  test "allows mixing step ordering with timing" do
+    journey_class = create_journey_subclass do
+      step :first, wait: 1.minute do
+        # noop
+      end
+      step :third, after_step: "first" do
+        # noop
+      end
+      step :second, before_step: "third", wait: 2.minutes do
+        # noop
+      end
+    end
+
+    assert_equal ["first", "second", "third"], journey_class.step_definitions.map(&:name)
+    assert_equal 1.minute, journey_class.step_definitions[0].wait
+    assert_equal 2.minutes, journey_class.step_definitions[1].wait
+    assert_equal 0, journey_class.step_definitions[2].wait
+  end
+
+  test "allows inserting step with method name" do
+    journey_class = create_journey_subclass do
+      step :first do
+        # noop
+      end
+      step :third do
+        # noop
+      end
+      step :second, after_step: "first"
+
+      def second
+        # noop
+      end
+    end
+
+    assert_equal ["first", "second", "third"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "allows inserting step with automatic name generation" do
+    journey_class = create_journey_subclass do
+      step :first do
+        # noop
+      end
+      step :third do
+        # noop
+      end
+      step before_step: "third" do
+        # noop
+      end
+    end
+
+    assert_equal ["first", "step_3", "third"], journey_class.step_definitions.map(&:name)
+  end
+
+  test "allows inserting step with additional options" do
+    journey_class = create_journey_subclass do
+      step :first do
+        # noop
+      end
+      step :third do
+        # noop
+      end
+      step :second, after_step: "first", on_exception: :skip! do
+        # noop
+      end
+    end
+
+    assert_equal ["first", "second", "third"], journey_class.step_definitions.map(&:name)
+    assert_equal :skip!, journey_class.step_definitions[1].instance_variable_get(:@on_exception)
+  end
+
+  test "allows inserting steps before or after steps defined in superclass" do
+    parent_class = create_journey_subclass do
+      step :parent_first do
+        # noop
+      end
+      step :parent_last do
+        # noop
+      end
+    end
+
+    child_class = create_journey_subclass(parent_class) do
+      step :child_before, before_step: "parent_first" do
+        # noop
+      end
+      step :child_after, after_step: "parent_last" do
+        # noop
+      end
+      step :child_middle, after_step: "parent_first" do
+        # noop
+      end
+    end
+
+    assert_equal ["child_before", "parent_first", "child_middle", "parent_last", "child_after"], child_class.step_definitions.map(&:name)
+  end
+end

data/test/stepper_motor/test_helper_test.rb

@@ -22,6 +22,16 @@ class TestHelperTest < ActiveSupport::TestCase
     end
   end
 
+  def infinite_journey_class
+    create_journey_subclass do
+      step :step_1 do
+        SideEffects.touch!("step_1")
+        # This step never finishes, causing infinite loop
+        reattempt!
+      end
+    end
+  end
+
   test "speedruns the journey despite waits being configured" do
     journey = speedy_journey_class.create!
     assert journey.ready?
@@ -33,6 +43,36 @@ class TestHelperTest < ActiveSupport::TestCase
     assert SideEffects.produced?("step_3")
   end
 
+  test "speedruns the journey with time travel by default" do
+    journey = speedy_journey_class.create!
+    assert journey.ready?
+
+    original_time = Time.current
+    SideEffects.clear!
+    speedrun_journey(journey)
+    assert SideEffects.produced?("step_1")
+    assert SideEffects.produced?("step_2")
+    assert SideEffects.produced?("step_3")
+
+    # Calculate expected time difference: 40 minutes + 2 days + 1 second buffer per step
+    expected_time_difference = 40.minutes + 2.days + 3.seconds
+
+    # Verify that time has traveled forward by approximately the expected amount
+    # (allowing for small execution time differences)
+    assert_in_delta expected_time_difference, Time.current - original_time, 1.second
+  end
+
+  test "speedruns the journey without time travel when specified" do
+    journey = speedy_journey_class.create!
+    assert journey.ready?
+
+    SideEffects.clear!
+    speedrun_journey(journey, time_travel: false)
+    assert SideEffects.produced?("step_1")
+    assert SideEffects.produced?("step_2")
+    assert SideEffects.produced?("step_3")
+  end
+
   test "is able to perform a single step forcibly" do
     journey = speedy_journey_class.create!
     assert journey.ready?
@@ -41,4 +81,23 @@ class TestHelperTest < ActiveSupport::TestCase
     immediately_perform_single_step(journey, :step_2)
     assert SideEffects.produced?("step_2")
   end
+
+  test "fails when maximum_steps limit is exceeded" do
+    journey = infinite_journey_class.create!
+    assert journey.ready?
+
+    SideEffects.clear!
+
+    # This should raise an exception because the journey will try to perform more than 2 steps
+    # but the infinite loop in step_1 will never finish
+    error = assert_raises(RuntimeError) do
+      speedrun_journey(journey, maximum_steps: 2)
+    end
+
+    # Verify the error message indicates the journey didn't finish after the maximum steps
+    assert_match(/did not finish or cancel after performing 2 steps/, error.message)
+
+    # Verify that the step was executed (at least once)
+    assert SideEffects.produced?("step_1")
+  end
 end

data/test/stepper_motor/wrap_conditional_test.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class WrapConditionalTest < ActiveSupport::TestCase
+  # Validate the skip_if condition
+  # if ![true, false, nil].include?(@skip_if_condition) && !@skip_if_condition.is_a?(Symbol) && !@skip_if_condition.respond_to?(:call)
+  #   raise ArgumentError, "skip_if: condition must be a boolean, nil, Symbol or a callable object, but was a #{@skip_if_condition.inspect}"
+  # end
+
+  test "wraps true without negate" do
+    conditional = StepperMotor::Conditional.new(true)
+    assert_equal true, conditional.satisfied_by?(nil)
+    assert_equal true, conditional.satisfied_by?("something")
+  end
+
+  test "wraps true with negate" do
+    conditional = StepperMotor::Conditional.new(true, negate: true)
+    assert_equal false, conditional.satisfied_by?(nil)
+    assert_equal false, conditional.satisfied_by?("something")
+  end
+
+  test "wraps false without negate" do
+    conditional = StepperMotor::Conditional.new(false)
+    assert_equal false, conditional.satisfied_by?(nil)
+    assert_equal false, conditional.satisfied_by?("something")
+  end
+
+  test "wraps false with negate" do
+    conditional = StepperMotor::Conditional.new(false, negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+    assert_equal true, conditional.satisfied_by?("something")
+  end
+
+  test "wraps nil without negate" do
+    conditional = StepperMotor::Conditional.new(nil)
+    assert_equal false, conditional.satisfied_by?(nil)
+    assert_equal false, conditional.satisfied_by?("something")
+  end
+
+  test "wraps nil with negate" do
+    conditional = StepperMotor::Conditional.new(nil, negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+    assert_equal true, conditional.satisfied_by?("something")
+  end
+
+  test "wraps multiple without negate" do
+    conditional = StepperMotor::Conditional.new([true, true])
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([true, false])
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([false, false])
+    assert_equal false, conditional.satisfied_by?(nil)
+  end
+
+  test "wraps multiple with proc" do
+    conditional = StepperMotor::Conditional.new([true, -> { true }])
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([true, -> { false }])
+    assert_equal false, conditional.satisfied_by?(nil)
+  end
+
+  test "wraps multiple with negate" do
+    conditional = StepperMotor::Conditional.new([true, true], negate: true)
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([true, false], negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new([false, false], negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+  end
+
+  test "wraps callable without negate" do
+    conditional = StepperMotor::Conditional.new(-> { :foo })
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> {})
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> { false })
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> { true })
+    assert_equal true, conditional.satisfied_by?(nil)
+  end
+
+  test "wraps callable with negate" do
+    conditional = StepperMotor::Conditional.new(-> { :foo }, negate: true)
+    assert_equal false, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> {}, negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> { false }, negate: true)
+    assert_equal true, conditional.satisfied_by?(nil)
+
+    conditional = StepperMotor::Conditional.new(-> { true }, negate: true)
+    assert_equal false, conditional.satisfied_by?(nil)
+  end
+
+  class Doer
+    def should_do?
+      true
+    end
+  end
+
+  class NotDoer
+    def should_do?
+      false
+    end
+  end
+
+  test "wraps method without negate" do
+    doer = Doer.new
+
+    conditional = StepperMotor::Conditional.new(:should_do?)
+    assert_equal true, conditional.satisfied_by?(doer)
+
+    not_doer = NotDoer.new
+    assert_equal false, conditional.satisfied_by?(not_doer)
+  end
+
+  test "wraps method with negate" do
+    doer = Doer.new
+
+    conditional = StepperMotor::Conditional.new(:should_do?, negate: true)
+    assert_equal false, conditional.satisfied_by?(doer)
+
+    not_doer = NotDoer.new
+    assert_equal true, conditional.satisfied_by?(not_doer)
+  end
+
+  test "wraps conditional without negate" do
+    inner_conditional = StepperMotor::Conditional.new(true)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional)
+
+    assert_equal true, outer_conditional.satisfied_by?(nil)
+    assert_equal true, outer_conditional.satisfied_by?("something")
+  end
+
+  test "wraps conditional with negate" do
+    inner_conditional = StepperMotor::Conditional.new(true)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional, negate: true)
+
+    assert_equal false, outer_conditional.satisfied_by?(nil)
+    assert_equal false, outer_conditional.satisfied_by?("something")
+  end
+
+  test "wraps negated conditional without negate" do
+    inner_conditional = StepperMotor::Conditional.new(true, negate: true)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional)
+
+    assert_equal false, outer_conditional.satisfied_by?(nil)
+    assert_equal false, outer_conditional.satisfied_by?("something")
+  end
+
+  test "wraps negated conditional with negate" do
+    inner_conditional = StepperMotor::Conditional.new(true, negate: true)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional, negate: true)
+
+    assert_equal true, outer_conditional.satisfied_by?(nil)
+    assert_equal true, outer_conditional.satisfied_by?("something")
+  end
+
+  test "wraps conditional with method" do
+    doer = Doer.new
+    inner_conditional = StepperMotor::Conditional.new(:should_do?)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional)
+
+    assert_equal true, outer_conditional.satisfied_by?(doer)
+
+    not_doer = NotDoer.new
+    assert_equal false, outer_conditional.satisfied_by?(not_doer)
+  end
+
+  test "wraps conditional with method and negate" do
+    doer = Doer.new
+    inner_conditional = StepperMotor::Conditional.new(:should_do?)
+    outer_conditional = StepperMotor::Conditional.new(inner_conditional, negate: true)
+
+    assert_equal false, outer_conditional.satisfied_by?(doer)
+
+    not_doer = NotDoer.new
+    assert_equal true, outer_conditional.satisfied_by?(not_doer)
+  end
+end

data/test/test_helper.rb

@@ -32,11 +32,12 @@ module JourneyDefinitionHelper
     super
   end
 
-  def create_journey_subclass(&blk)
+  def create_journey_subclass(parent_class = nil, &blk)
     # https://stackoverflow.com/questions/4113479/dynamic-class-definition-with-a-class-name
     random_component = @class_names_rng.hex(8)
     random_name = "JourneySubclass_#{random_component}"
-    klass = Class.new(StepperMotor::Journey, &blk)
+    parent_class ||= StepperMotor::Journey
+    klass = Class.new(parent_class, &blk)
     Object.const_set(random_name, klass)
     @dynamic_class_names << random_name
     klass

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stepper_motor
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.19
 platform: ruby
 authors:
 - Julik Tarkhanov
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-06-20 00:00:00.000000000 Z
+date: 2025-06-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -236,6 +237,7 @@ files:
 - lib/generators/stepper_motor_migration_005.rb.erb
 - lib/stepper_motor.rb
 - lib/stepper_motor/base_job.rb
+- lib/stepper_motor/conditional.rb
 - lib/stepper_motor/cyclic_scheduler.rb
 - lib/stepper_motor/delete_completed_journeys_job.rb
 - lib/stepper_motor/forward_scheduler.rb
@@ -309,17 +311,20 @@ files:
 - test/stepper_motor/cyclic_scheduler_test.rb
 - test/stepper_motor/forward_scheduler_test.rb
 - test/stepper_motor/housekeeping_job_test.rb
+- test/stepper_motor/journey/cancel_if_test.rb
 - test/stepper_motor/journey/exception_handling_test.rb
 - test/stepper_motor/journey/flow_control_test.rb
 - test/stepper_motor/journey/idempotency_test.rb
 - test/stepper_motor/journey/if_condition_test.rb
 - test/stepper_motor/journey/step_definition_test.rb
+- test/stepper_motor/journey/step_ordering_test.rb
 - test/stepper_motor/journey/uniqueness_test.rb
 - test/stepper_motor/journey_test.rb
 - test/stepper_motor/perform_step_job_test.rb
 - test/stepper_motor/recover_stuck_journeys_job_test.rb
 - test/stepper_motor/recovery_test.rb
 - test/stepper_motor/test_helper_test.rb
+- test/stepper_motor/wrap_conditional_test.rb
 - test/stepper_motor_test.rb
 - test/test_helper.rb
 homepage: https://steppermotor.dev
@@ -330,6 +335,7 @@ metadata:
   homepage_uri: https://steppermotor.dev
   source_code_uri: https://github.com/stepper-motor/stepper_motor
   changelog_uri: https://github.com/stepper-motor/stepper_motor/blob/main/CHANGELOG.md
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -344,7 +350,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.6
+rubygems_version: 3.4.10
+signing_key:
 specification_version: 4
 summary: Effortless step workflows that embed nicely inside Rails
 test_files: []