stepper_motor 0.1.7 → 0.1.8

data/test/stepper_motor/cyclic_scheduler_test.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class CyclicSchedulerTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+
+  setup do
+    @previous_scheduler = StepperMotor.scheduler
+    StepperMotor::Journey.delete_all
+  end
+
+  teardown do
+    StepperMotor.scheduler = @previous_scheduler
+  end
+
+  def far_future_journey_class
+    @klass ||= create_journey_subclass do
+      step :do_thing, wait: 40.minutes do
+        raise "We do not test this so it should never run"
+      end
+    end
+  end
+
+  test "does not schedule a journey which is too far in the future" do
+    scheduler = StepperMotor::CyclicScheduler.new(cycle_duration: 30.seconds)
+    StepperMotor.scheduler = scheduler
+
+    assert_no_enqueued_jobs do
+      far_future_journey_class.create!
+    end
+
+    assert_no_enqueued_jobs do
+      scheduler.run_scheduling_cycle
+    end
+  end
+
+  test "for a job inside the current scheduling cycle, enqueues the job immediately" do
+    scheduler = StepperMotor::CyclicScheduler.new(cycle_duration: 40.minutes)
+    StepperMotor.scheduler = scheduler
+
+    assert_enqueued_jobs 1, only: StepperMotor::PerformStepJobV2 do
+      far_future_journey_class.create!
+    end
+  end
+
+  test "also schedules journeys which had to run in the past" do
+    scheduler = StepperMotor::CyclicScheduler.new(cycle_duration: 10.seconds)
+    StepperMotor.scheduler = scheduler
+
+    journey = nil
+    assert_no_enqueued_jobs do
+      journey = far_future_journey_class.create!
+    end
+    journey.update!(next_step_to_be_performed_at: 10.minutes.ago)
+
+    assert_enqueued_jobs 1, only: StepperMotor::PerformStepJobV2 do
+      scheduler.run_scheduling_cycle
+    end
+  end
+
+  test "performs the scheduling job without raising exceptions even if the cycling scheduler is not the one active" do
+    StepperMotor.scheduler = StepperMotor::ForwardScheduler.new
+    assert_nothing_raised do
+      StepperMotor::CyclicScheduler::RunSchedulingCycleJob.new.perform
+    end
+  end
+
+  test "performs the scheduling job without raising exceptions if the cycling scheduler is the active" do
+    scheduler = StepperMotor::CyclicScheduler.new(cycle_duration: 10.seconds)
+    StepperMotor.scheduler = scheduler
+
+    assert_nothing_raised do
+      StepperMotor::CyclicScheduler::RunSchedulingCycleJob.new.perform
+    end
+  end
+end

data/{spec/stepper_motor/forward_scheduler_spec.rb → test/stepper_motor/forward_scheduler_test.rb}

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "../spec_helper"
+require "test_helper"
 
-RSpec.describe "StepperMotor::ForwardScheduler" do
+class ForwardSchedulerTest < ActiveSupport::TestCase
   include ActiveJob::TestHelper
 
-  before do
+  setup do
     @previous_scheduler = StepperMotor.scheduler
     StepperMotor::Journey.delete_all
   end
 
-  after do
+  teardown do
     StepperMotor.scheduler = @previous_scheduler
   end
 
@@ -22,20 +22,19 @@ RSpec.describe "StepperMotor::ForwardScheduler" do
     end
   end
 
-  it "schedules a journey 40 minutes ahead" do
+  test "schedules a journey 40 minutes ahead" do
     scheduler = StepperMotor::ForwardScheduler.new
     StepperMotor.scheduler = scheduler
 
-    expect(scheduler).to receive(:schedule).with(instance_of(far_future_journey_class)).once.and_call_original
     _journey = far_future_journey_class.create!
 
-    expect(enqueued_jobs.size).to eq(1)
+    assert_equal 1, enqueued_jobs.size
     job = enqueued_jobs.first
 
-    expect(job["job_class"]).to eq("StepperMotor::PerformStepJobV2")
-    expect(job["scheduled_at"]).not_to be_nil
+    assert_equal "StepperMotor::PerformStepJobV2", job["job_class"]
+    assert_not_nil job["scheduled_at"]
 
     scheduled_at = Time.parse(job["scheduled_at"])
-    expect(scheduled_at).to be_within(5.seconds).of(40.minutes.from_now)
+    assert_in_delta 40.minutes.from_now.to_f, scheduled_at.to_f, 5.seconds.to_f
   end
 end

data/test/stepper_motor/journey/exception_handling_test.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ExceptionHandlingTest < ActiveSupport::TestCase
+  # See below.
+  self.use_transactional_tests = false
+
+  class CustomEx < StandardError
+  end
+
+  test "with :reattempt!, reattempts the failing step and bumps the idempotency key" do
+    faulty_journey_class = create_journey_subclass do
+      step on_exception: :reattempt! do
+        raise CustomEx, "Something went wrong"
+      end
+    end
+
+    faulty_journey = faulty_journey_class.create!
+    assert faulty_journey.ready?
+    ik_before_step = faulty_journey.idempotency_key
+
+    assert_raises(CustomEx) { faulty_journey.perform_next_step! }
+
+    assert faulty_journey.persisted?
+    refute faulty_journey.changed?
+    assert faulty_journey.ready?
+    refute_equal faulty_journey.idempotency_key, ik_before_step
+  end
+
+  test "with :cancel!, cancels at the failig step" do
+    faulty_journey_class = create_journey_subclass do
+      step on_exception: :cancel! do
+        raise CustomEx, "Something went wrong"
+      end
+    end
+
+    faulty_journey = faulty_journey_class.create!
+    assert faulty_journey.ready?
+    faulty_journey.idempotency_key
+
+    assert_raises(CustomEx) { faulty_journey.perform_next_step! }
+
+    assert faulty_journey.persisted?
+    refute faulty_journey.changed?
+    assert faulty_journey.canceled?
+  end
+
+  test "pauses the journey by default at the failig step" do
+    faulty_journey_class = create_journey_subclass do
+      step do
+        raise CustomEx, "Something went wrong"
+      end
+    end
+
+    faulty_journey = faulty_journey_class.create!
+    assert faulty_journey.ready?
+    faulty_journey.idempotency_key
+
+    assert_raises(CustomEx) { faulty_journey.perform_next_step! }
+
+    assert faulty_journey.persisted?
+    refute faulty_journey.changed?
+    assert faulty_journey.paused?
+  end
+
+  test "is able to get the journey into reattempt even if the step has caused an invalid transaction" do
+    # We need to test a situation where a Journey causes a database transaction
+    # becoming invalid due to an invalid statement. Since we work with the same database
+    # as the code of the step, we won't be able to perform any SQL statments if the transaction
+    # gets left in the broken state and is not rolled back before we try to persist the failing
+    # Journey.
+
+    faulty_journey_class = create_journey_subclass do
+      step on_exception: :reattempt! do
+        StepperMotor::Journey.connection.execute("KERFUFFLE")
+      end
+    end
+
+    faulty_journey = faulty_journey_class.create!
+    assert faulty_journey.ready?
+    ik_before_step = faulty_journey.idempotency_key
+    assert_raises(ActiveRecord::StatementInvalid) { faulty_journey.perform_next_step! }
+
+    assert faulty_journey.persisted?
+    refute faulty_journey.changed?
+    refute_equal faulty_journey.idempotency_key, ik_before_step
+  end
+end

data/test/stepper_motor/journey/flow_control_test.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class FlowControlTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+  include SideEffects::TestHelper
+
+  test "can pause a Journey during a step" do
+    pausing_journey = create_journey_subclass do
+      step do
+        SideEffects.touch! "before pausing"
+        pause!
+        SideEffects.touch! "after pausing"
+      end
+    end
+
+    journey = pausing_journey.create!
+    assert journey.ready?
+
+    assert_produced_side_effects("before pausing") do
+      assert_did_not_produce_side_effects("after pausing") do
+        journey.perform_next_step!
+      end
+    end
+    assert journey.paused?
+  end
+
+  test "schedules a job on resume" do
+    pausing_journey = create_journey_subclass do
+      step do
+        SideEffects.touch! "after resume"
+      end
+    end
+
+    journey = pausing_journey.create!
+    journey.pause!
+    assert journey.paused?
+
+    clear_enqueued_jobs
+
+    assert_produced_side_effects("after resume") do
+      journey.resume!
+      perform_enqueued_jobs
+    end
+  end
+
+  test "changes the idempotency key at resume" do
+    pausing_journey = create_journey_subclass do
+      step do
+        SideEffects.touch! "after resume"
+      end
+    end
+
+    journey = pausing_journey.create!
+    journey.pause!
+    assert journey.paused?
+    ik_before = journey.idempotency_key
+
+    journey.resume!
+    assert journey.persisted?
+    refute_equal ik_before, journey.idempotency_key
+  end
+
+  test "does not perform the step on job that has been paused" do
+    pausing_journey = create_journey_subclass do
+      step do
+        SideEffects.touch! "should not run"
+      end
+    end
+
+    journey = pausing_journey.create!
+    journey.pause!
+    assert journey.paused?
+
+    assert_no_side_effects { journey.perform_next_step! }
+  end
+end

data/test/stepper_motor/journey/idempotency_test.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class JourneyIdempotencyTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+  include SideEffects::TestHelper
+
+  test "does not perform the step if the idempotency key passed does not match the one stored" do
+    journey_class = create_journey_subclass do
+      step do
+        raise "Should not happen"
+      end
+    end
+
+    journey = journey_class.create!
+
+    assert_predicate journey, :ready?
+    assert journey.idempotency_key
+    assert_nothing_raised do
+      journey.perform_next_step!(idempotency_key: journey.idempotency_key + "n")
+    end
+    assert_predicate journey, :ready?
+  end
+
+  test "does perform the step if the idempotency key is set but not passed to perform_next_step!" do
+    journey_class = create_journey_subclass do
+      step do
+        SideEffects.touch! :with_ik
+      end
+    end
+
+    journey = journey_class.create!
+
+    assert_predicate journey, :ready?
+    assert journey.idempotency_key
+    assert_produced_side_effects(:with_ik) do
+      journey.perform_next_step!
+    end
+    assert_predicate journey, :finished?
+  end
+
+  test "updates the idempotency key when a step gets reattempted" do
+    some_journey_class = create_journey_subclass do
+      step :one do
+        reattempt! wait: 2.minutes
+      end
+    end
+    freeze_time
+
+    journey = some_journey_class.create!
+
+    assert_equal "one", journey.next_step_name
+    assert journey.idempotency_key.present? # Since it was scheduled for the initial step
+    previous_idempotency_key = journey.idempotency_key
+
+    perform_enqueued_jobs # Should be reattempted
+
+    journey.reload
+
+    assert_equal "one", journey.next_step_name
+    assert journey.idempotency_key
+    refute_equal journey.idempotency_key, previous_idempotency_key
+  end
+end

data/test/stepper_motor/journey/step_definition_test.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "minitest/mock"
+
+class StepDefinitionTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+  include SideEffects::TestHelper
+
+  test "requires either a block or a name" do
+    assert_raises(StepperMotor::StepConfigurationError) do
+      create_journey_subclass do
+        step
+      end
+    end
+  end
+
+  test "passes any additional options to the step definition" do
+    step_def = StepperMotor::Step.new(name: "a_step", seq: 1, on_exception: :reattempt!)
+    assert_extra_arguments = ->(**options) {
+      assert options.key?(:extra)
+      # Return the original definition
+      step_def
+    }
+
+    StepperMotor::Step.stub :new, assert_extra_arguments do
+      create_journey_subclass do
+        step extra: true do
+          # noop
+        end
+      end
+    end
+  end
+
+  test "returns the created step definition" do
+    test_case = self # To pass it into the class_eval of create_journey_subclass
+    create_journey_subclass do
+      step_def1 = step do
+        # noop
+      end
+
+      step_def2 = step :another_step do
+        # noop
+      end
+
+      test_case.assert_kind_of StepperMotor::Step, step_def1
+      test_case.assert_kind_of StepperMotor::Step, step_def2
+      test_case.assert_equal "another_step", step_def2.name
+    end
+  end
+
+  test "allows steps to be defined as instance method names" do
+    journey_class = create_journey_subclass do
+      step :one
+      step :two
+
+      def one
+        SideEffects.touch!("from method one")
+      end
+
+      def two
+        SideEffects.touch!("from method two")
+      end
+    end
+
+    journey = journey_class.create!
+
+    assert_produced_side_effects("from method one", "from method two") do
+      2.times { journey.perform_next_step! }
+    end
+
+    assert journey.finished?
+  end
+
+  test "raises a custom NoMethodError when a blockless step was defined but no method to carry it" do
+    journey_class = create_journey_subclass do
+      step :one
+    end
+
+    journey = journey_class.create!
+
+    ex = assert_raises(NoMethodError) do
+      journey.perform_next_step!
+    end
+
+    assert_kind_of NoMethodError, ex
+    assert_match(/No block or method/, ex.message)
+  end
+
+  test "allows `step def'" do
+    journey_class = create_journey_subclass do
+      step def one
+        SideEffects.touch!(:woof)
+      end
+    end
+
+    journey = journey_class.create!
+    assert_produced_side_effects(:woof) do
+      journey.perform_next_step!
+    end
+  end
+
+  test "adds steps to step_definitions" do
+    journey_class = create_journey_subclass do
+      step :one do
+        # noop
+      end
+      step :two, wait: 20.minutes do
+        # noop
+      end
+    end
+
+    assert_kind_of Array, journey_class.step_definitions
+    assert_equal 2, journey_class.step_definitions.length
+
+    step_one, step_two = *journey_class.step_definitions
+
+    assert_equal "one", step_one.name
+    assert_equal 0, step_one.wait
+
+    assert_equal "two", step_two.name
+    assert_equal 20.minutes, step_two.wait
+  end
+
+  test "gives automatic names to anonymous steps" do
+    journey_class = create_journey_subclass do
+      step :one do
+        # noop
+      end
+      step wait: 20.minutes do
+        # noop
+      end
+    end
+
+    assert_kind_of Array, journey_class.step_definitions
+    assert_equal 2, journey_class.step_definitions.length
+
+    step_one, step_two = *journey_class.step_definitions
+
+    assert_equal "one", step_one.name
+    assert_equal "step_2", step_two.name
+  end
+
+  test "does not allow invalid values for after: and wait:" do
+    assert_raises(ArgumentError) do
+      create_journey_subclass do
+        step after: 10.hours do
+          # pass
+        end
+
+        step after: 5.hours do
+          # pass
+        end
+      end
+    end
+
+    assert_raises(ArgumentError) do
+      create_journey_subclass do
+        step wait: -5.hours do
+          # pass
+        end
+      end
+    end
+
+    assert_raises(ArgumentError) do
+      create_journey_subclass do
+        step after: 5.hours, wait: 2.seconds do
+          # pass
+        end
+      end
+    end
+  end
+
+  test "forbids multiple steps with the same name within a journey" do
+    assert_raises(ArgumentError) do
+      create_journey_subclass do
+        step :foo do
+          true
+        end
+
+        step "foo" do
+          true
+        end
+      end
+    end
+  end
+end

data/test/stepper_motor/journey/uniqueness_test.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class UniquenessTest < ActiveSupport::TestCase
+  test "forbids multiple similar journeys for the same hero at the same time unless allow_multiple is set" do
+    actor_class = create_journey_subclass
+    hero = actor_class.create!
+
+    exclusive_journey_class = create_journey_subclass do
+      step do
+        raise "The step should never be entered as we are not testing the step itself here"
+      end
+    end
+
+    assert_nothing_raised do
+      2.times { exclusive_journey_class.create! }
+    end
+
+    assert_raises(ActiveRecord::RecordNotUnique) do
+      2.times { exclusive_journey_class.create!(hero: hero) }
+    end
+
+    assert_nothing_raised do
+      2.times { exclusive_journey_class.create!(hero: hero, allow_multiple: true) }
+    end
+  end
+
+  test "forbids multiple similar journeys for the same hero even if one of them is paused" do
+    actor_class = create_journey_subclass
+    hero = actor_class.create!
+
+    exclusive_journey_class = create_journey_subclass do
+      step do
+        raise "The step should never be entered as we are not testing the step itself here"
+      end
+    end
+
+    ready_journey = exclusive_journey_class.create!(hero:)
+    assert ready_journey.ready?
+    ready_journey.pause!
+    assert ready_journey.paused?
+
+    assert_raises(ActiveRecord::RecordNotUnique) {
+      exclusive_journey_class.create!(hero:)
+    }
+  end
+end