stepper_motor 0.1.6 → 0.1.8

data/test/stepper_motor/journey_test.rb

@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class JourneyTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper
+  include SideEffects::TestHelper
+
+  test "allows an empty journey to be defined and performed to completion" do
+    pointless_class = create_journey_subclass
+    journey = pointless_class.create!
+    journey.perform_next_step!
+    assert journey.finished?
+  end
+
+  test "allows a journey consisting of one step to be defined and performed to completion" do
+    single_step_class = create_journey_subclass do
+      step :do_thing do
+        SideEffects.touch!("do_thing")
+      end
+    end
+
+    journey = single_step_class.create!
+    assert_not_nil journey.next_step_to_be_performed_at
+    journey.perform_next_step!
+    assert journey.finished?
+    assert SideEffects.produced?("do_thing")
+  end
+
+  test "allows a journey consisting of multiple named steps to be defined and performed to completion" do
+    multi_step_journey_class = create_journey_subclass do
+      [:step1, :step2, :step3].each do |step_name|
+        step step_name do
+          SideEffects.touch!("from_#{step_name}")
+        end
+      end
+    end
+
+    journey = multi_step_journey_class.create!
+    assert_equal "step1", journey.next_step_name
+
+    journey.perform_next_step!
+    assert_equal "step2", journey.next_step_name
+    assert_equal "step1", journey.previous_step_name
+
+    journey.perform_next_step!
+    assert_equal "step3", journey.next_step_name
+    assert_equal "step2", journey.previous_step_name
+
+    journey.perform_next_step!
+    assert journey.finished?
+    assert_nil journey.next_step_name
+    assert_equal "step3", journey.previous_step_name
+
+    assert SideEffects.produced?("from_step1")
+    assert SideEffects.produced?("from_step2")
+    assert SideEffects.produced?("from_step3")
+  end
+
+  test "allows a journey consisting of multiple anonymous steps to be defined and performed to completion" do
+    anonymous_steps_class = create_journey_subclass do
+      3.times do |n|
+        step do
+          SideEffects.touch!("sidefx_#{n}")
+        end
+      end
+    end
+
+    journey = anonymous_steps_class.create!
+    assert_equal "step_1", journey.next_step_name
+
+    journey.perform_next_step!
+    assert_equal "step_2", journey.next_step_name
+    assert_equal "step_1", journey.previous_step_name
+
+    journey.perform_next_step!
+    assert_equal "step_3", journey.next_step_name
+    assert_equal "step_2", journey.previous_step_name
+
+    journey.perform_next_step!
+    assert journey.finished?
+    assert_nil journey.next_step_name
+    assert_equal "step_3", journey.previous_step_name
+
+    assert SideEffects.produced?("sidefx_0")
+    assert SideEffects.produced?("sidefx_1")
+    assert SideEffects.produced?("sidefx_2")
+  end
+
+  test "allows an arbitrary ActiveRecord to be attached as the hero" do
+    carried_journey_class = create_journey_subclass
+    carrier_journey_class = create_journey_subclass do
+      step :only do
+        raise "Incorrect" unless hero.instance_of?(carried_journey_class)
+      end
+    end
+
+    hero = carried_journey_class.create!
+    journey = carrier_journey_class.create!(hero: hero)
+    assert_nothing_raised do
+      journey.perform_next_step!
+    end
+  end
+
+  test "allows a journey where steps are delayed in time using wait:" do
+    timely_journey_class = create_journey_subclass do
+      step wait: 10.hours do
+        SideEffects.touch! "after_10_hours.txt"
+      end
+
+      step wait: 5.minutes do
+        SideEffects.touch! "after_5_minutes.txt"
+      end
+
+      step do
+        SideEffects.touch! "final_nowait.txt"
+      end
+    end
+
+    freeze_time
+    timely_journey_class.create!
+
+    assert_no_side_effects do
+      perform_enqueued_jobs
+    end
+
+    travel 10.hours
+    assert_produced_side_effects "after_10_hours.txt" do
+      perform_enqueued_jobs
+    end
+
+    travel 4.minutes
+    assert_no_side_effects do
+      perform_enqueued_jobs
+    end
+
+    travel 1.minutes
+    assert_produced_side_effects "after_5_minutes.txt" do
+      perform_enqueued_jobs
+    end
+
+    assert_produced_side_effects "final_nowait.txt" do
+      perform_enqueued_jobs
+    end
+  end
+
+  test "allows a journey where steps are delayed in time using after:" do
+    journey_class = create_journey_subclass do
+      step after: 10.hours do
+        SideEffects.touch! "step1"
+      end
+
+      step after: 605.minutes do
+        SideEffects.touch! "step2"
+      end
+
+      step do
+        SideEffects.touch! "step3"
+      end
+    end
+
+    timely_journey = journey_class.create!
+    freeze_time
+
+    assert_no_side_effects do
+      perform_enqueued_jobs
+    end
+
+    travel_to(timely_journey.next_step_to_be_performed_at + 1.second)
+    assert_produced_side_effects "step1" do
+      perform_enqueued_jobs
+    end
+
+    travel(4.minutes)
+    assert_no_side_effects do
+      perform_enqueued_jobs
+    end
+
+    travel(1.minutes + 1.second)
+    assert_produced_side_effects "step2" do
+      perform_enqueued_jobs
+    end
+    assert_produced_side_effects "step3" do
+      perform_enqueued_jobs
+    end
+    assert_empty enqueued_jobs # Journey ended
+  end
+
+  test "tracks steps entered and completed using counters" do
+    failing = create_journey_subclass do
+      step do
+        raise "oops"
+      end
+    end
+
+    not_failing = create_journey_subclass do
+      step do
+        true # no-op
+      end
+    end
+
+    failing_journey = failing.create!
+    assert_raises(RuntimeError) { failing_journey.perform_next_step! }
+    assert_equal 1, failing_journey.steps_entered
+    assert_equal 0, failing_journey.steps_completed
+
+    failing_journey.ready!
+    assert_raises(RuntimeError) { failing_journey.perform_next_step! }
+    assert_equal 2, failing_journey.steps_entered
+    assert_equal 0, failing_journey.steps_completed
+
+    non_failing_journey = not_failing.create!
+    non_failing_journey.perform_next_step!
+    assert_equal 1, non_failing_journey.steps_entered
+    assert_equal 1, non_failing_journey.steps_completed
+  end
+
+  test "allows a step to reattempt itself" do
+    deferring = create_journey_subclass do
+      step do
+        reattempt! wait: 5.minutes
+        raise "Should never be reached"
+      end
+    end
+
+    journey = deferring.create!
+    perform_enqueued_jobs
+
+    journey.reload
+    assert_equal "step_1", journey.previous_step_name
+    assert_equal "step_1", journey.next_step_name
+    assert_in_delta Time.current + 5.minutes, journey.next_step_to_be_performed_at, 1.second
+
+    travel 5.minutes + 1.second
+    perform_enqueued_jobs
+
+    journey.reload
+    assert_equal "step_1", journey.previous_step_name
+    assert_equal "step_1", journey.next_step_name
+    assert_in_delta Time.current + 5.minutes, journey.next_step_to_be_performed_at, 1.second
+  end
+
+  test "allows a journey consisting of multiple steps where the first step bails out to be defined and performed to the point of cancellation" do
+    interrupting = create_journey_subclass do
+      step :step1 do
+        SideEffects.touch!("step1_before_cancel")
+        cancel!
+        SideEffects.touch!("step1_after_cancel")
+      end
+
+      step :step2 do
+        raise "Should never be reached"
+      end
+    end
+
+    journey = interrupting.create!
+    assert_equal "step1", journey.next_step_name
+
+    perform_enqueued_jobs
+    assert SideEffects.produced?("step1_before_cancel")
+    assert_not SideEffects.produced?("step1_after_cancel")
+    assert_canceled_or_finished(journey)
+  end
+
+  test "finishes the journey after perform_next_step" do
+    rapid = create_journey_subclass do
+      step :one do
+        true # no-op
+      end
+      step :two do
+        true # no-op
+      end
+    end
+
+    journey = rapid.create!
+    assert journey.ready?
+    journey.perform_next_step!
+    assert journey.ready?
+    journey.perform_next_step!
+    assert journey.finished?
+  end
+
+  test "does not enter next step on a finished journey" do
+    near_instant = create_journey_subclass do
+      step :one do
+        finished!
+      end
+
+      step :two do
+        raise "Should never be reached"
+      end
+    end
+
+    journey = near_instant.create!
+    assert journey.ready?
+    journey.perform_next_step!
+    assert journey.finished?
+
+    assert_nothing_raised do
+      journey.perform_next_step!
+    end
+  end
+
+  test "raises an exception if a step changes the journey but does not save it" do
+    mutating = create_journey_subclass do
+      step :one do
+        self.state = "canceled"
+      end
+    end
+
+    journey = mutating.create!
+    assert_raises(StepperMotor::JourneyNotPersisted) do
+      journey.perform_next_step!
+    end
+  end
+
+  test "resets the instance variables after performing a step" do
+    self_resetting = create_journey_subclass do
+      step :one do
+        raise unless @current_step_definition
+      end
+
+      step :two do
+        @reattempt_after = 2.minutes
+      end
+    end
+
+    journey = self_resetting.create!
+    assert_nothing_raised do
+      journey.perform_next_step!
+    end
+    assert_nil journey.instance_variable_get(:@current_step_definition)
+
+    assert_nothing_raised do
+      journey.perform_next_step!
+    end
+    assert_nil journey.instance_variable_get(:@current_step_definition)
+    assert_nil journey.instance_variable_get(:@reattempt_after)
+  end
+
+  private
+
+  def assert_canceled_or_finished(model)
+    model.reload
+    assert_includes ["canceled", "finished"], model.state
+  end
+
+  def assert_produced_side_effects(name)
+    yield
+    assert SideEffects.produced?(name)
+  end
+end

data/{spec/stepper_motor/recover_stuck_journeys_job_spec.rb → test/stepper_motor/recover_stuck_journeys_job_test.rb}

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "../spec_helper"
+require "test_helper"
 
-RSpec.describe "RecoveryStuckJourneysJobV1" do
-  before do
+class RecoverStuckJourneysJobTest < ActiveSupport::TestCase
+  setup do
     StepperMotor::Journey.delete_all
   end
 
-  it "handles recovery from a background job" do
+  test "handles recovery from a background job" do
     stuck_journey_class1 = create_journey_subclass do
       self.when_stuck = :cancel
 
@@ -49,21 +49,21 @@ RSpec.describe "RecoveryStuckJourneysJobV1" do
       journey_to_reattempt.perform_next_step!
     end.resume
 
-    expect(journey_to_cancel.reload).to be_performing
-    expect(journey_to_reattempt.reload).to be_performing
+    assert journey_to_cancel.reload.performing?
+    assert journey_to_reattempt.reload.performing?
 
     StepperMotor::RecoverStuckJourneysJobV1.perform_now(stuck_for: 2.days)
-    expect(journey_to_cancel.reload).to be_performing
-    expect(journey_to_reattempt.reload).to be_performing
+    assert journey_to_cancel.reload.performing?
+    assert journey_to_reattempt.reload.performing?
 
     travel_to Time.now + 2.days + 1.second
     StepperMotor::RecoverStuckJourneysJobV1.perform_now(stuck_for: 2.days)
 
-    expect(journey_to_cancel.reload).to be_canceled
-    expect(journey_to_reattempt.reload).to be_ready
+    assert journey_to_cancel.reload.canceled?
+    assert journey_to_reattempt.reload.ready?
   end
 
-  it "does not raise when the class of the journey is no longer present" do
+  test "does not raise when the class of the journey is no longer present" do
     stuck_journey_class1 = create_journey_subclass do
       self.when_stuck = :cancel
 
@@ -78,12 +78,12 @@ RSpec.describe "RecoveryStuckJourneysJobV1" do
     Fiber.new do
       journey_to_cancel.perform_next_step!
     end.resume
-    expect(journey_to_cancel.reload).to be_performing
+    assert journey_to_cancel.reload.performing?
 
     journey_to_cancel.class.update_all(type: "UnknownJourneySubclass")
 
-    expect {
+    assert_nothing_raised do
       StepperMotor::RecoverStuckJourneysJobV1.perform_now(stuck_for: 2.days)
-    }.not_to raise_error
+    end
   end
 end

data/{spec/stepper_motor/recovery_spec.rb → test/stepper_motor/recovery_test.rb}

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
-require_relative "../spec_helper"
+require "test_helper"
 
-RSpec.describe "Recovery of stuck journeys" do
-  before do
+class RecoveryTest < ActiveSupport::TestCase
+  setup do
     StepperMotor::Journey.delete_all
   end
 
-  it "recovers a journey by reattempting it" do
+  test "recovers a journey by reattempting it" do
     stuck_journey_class = create_journey_subclass do
       step :first do
       end
@@ -24,12 +24,12 @@ RSpec.describe "Recovery of stuck journeys" do
     journey = stuck_journey_class.create!
 
     journey.perform_next_step!
-    expect(journey.next_step_name).to eq("second")
+    assert_equal "second", journey.next_step_name
 
     travel_to Time.now + 5.days
 
-    expect(stuck_journey_class.when_stuck).to eq(:reattempt)
-    expect(journey.when_stuck).to eq(:reattempt)
+    assert_equal :reattempt, stuck_journey_class.when_stuck
+    assert_equal :reattempt, journey.when_stuck
 
     # Hang the journey in "performing"
     stuck_fiber = Fiber.new do
@@ -37,26 +37,26 @@ RSpec.describe "Recovery of stuck journeys" do
     end
     stuck_fiber.resume
 
-    expect(journey).to be_persisted
-    expect(journey).to be_performing
-    expect(journey.updated_at).to eq(Time.now)
+    assert journey.persisted?
+    assert journey.performing?
+    assert_equal Time.now, journey.updated_at
 
-    expect(StepperMotor::Journey.stuck(1.days.ago)).not_to include(journey)
+    assert_not_includes StepperMotor::Journey.stuck(1.days.ago), journey
 
     travel_to Time.now + 2.days
-    expect(StepperMotor::Journey.stuck(2.days.ago)).to include(journey)
+    assert_includes StepperMotor::Journey.stuck(2.days.ago), journey
 
     perform_at_before_recovery = journey.next_step_to_be_performed_at
-    expect {
+    assert_nothing_raised do
       journey.reload.recover!
-    }.not_to raise_error
+    end
 
     journey.reload
-    expect(journey.next_step_to_be_performed_at).to eq(perform_at_before_recovery)
-    expect(journey.next_step_name).to eq("second")
+    assert_equal perform_at_before_recovery, journey.next_step_to_be_performed_at
+    assert_equal "second", journey.next_step_name
   end
 
-  it "recovers a journey by canceling it" do
+  test "recovers a journey by canceling it" do
     stuck_journey_class = create_journey_subclass do
       self.when_stuck = :cancel
 
@@ -75,12 +75,12 @@ RSpec.describe "Recovery of stuck journeys" do
     journey = stuck_journey_class.create!
 
     journey.perform_next_step!
-    expect(journey.next_step_name).to eq("second")
+    assert_equal "second", journey.next_step_name
 
     travel_to Time.now + 5.days
 
-    expect(stuck_journey_class.when_stuck).to eq(:cancel)
-    expect(journey.when_stuck).to eq(:cancel)
+    assert_equal :cancel, stuck_journey_class.when_stuck
+    assert_equal :cancel, journey.when_stuck
 
     # Hang the journey in "performing"
     stuck_fiber = Fiber.new do
@@ -88,18 +88,18 @@ RSpec.describe "Recovery of stuck journeys" do
     end
     stuck_fiber.resume
 
-    expect(journey).to be_persisted
-    expect(journey).to be_performing
-    expect(journey.updated_at).to eq(Time.now)
+    assert journey.persisted?
+    assert journey.performing?
+    assert_equal Time.now, journey.updated_at
 
     travel_to Time.now + 2.days
-    expect(StepperMotor::Journey.stuck(2.days.ago)).to include(journey)
+    assert_includes StepperMotor::Journey.stuck(2.days.ago), journey
 
-    expect {
+    assert_nothing_raised do
       journey.reload.recover!
-    }.not_to raise_error
+    end
 
     journey.reload
-    expect(journey).to be_canceled
+    assert journey.canceled?
   end
 end

data/test/stepper_motor/test_helper_test.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class TestHelperTest < ActiveSupport::TestCase
+  include SideEffects::TestHelper
+  include StepperMotor::TestHelper
+
+  def speedy_journey_class
+    create_journey_subclass do
+      step :step_1, wait: 40.minutes do
+        SideEffects.touch!("step_1")
+      end
+
+      step :step_2, wait: 2.days do
+        SideEffects.touch!("step_2")
+      end
+
+      step do
+        SideEffects.touch!("step_3")
+      end
+    end
+  end
+
+  test "speedruns the journey despite waits being configured" do
+    journey = speedy_journey_class.create!
+    assert journey.ready?
+
+    SideEffects.clear!
+    speedrun_journey(journey)
+    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?
+
+    SideEffects.clear!
+    immediately_perform_single_step(journey, :step_2)
+    assert SideEffects.produced?("step_2")
+  end
+end

data/test/stepper_motor_test.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class StepperMotorTest < ActiveSupport::TestCase
+  test "it has a version number" do
+    assert StepperMotor::VERSION
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require_relative "../test/dummy/config/environment"
+require_relative "side_effects_helper"
+
+ActiveRecord::Migrator.migrations_paths = [File.expand_path("../test/dummy/db/migrate", __dir__)]
+require "rails/test_help"
+
+# Load fixtures from the engine
+if ActiveSupport::TestCase.respond_to?(:fixture_paths=)
+  ActiveSupport::TestCase.fixture_paths = [File.expand_path("fixtures", __dir__)]
+  ActionDispatch::IntegrationTest.fixture_paths = ActiveSupport::TestCase.fixture_paths
+  ActiveSupport::TestCase.file_fixture_path = File.expand_path("fixtures", __dir__) + "/files"
+  ActiveSupport::TestCase.fixtures :all
+end
+
+module JourneyDefinitionHelper
+  def setup
+    @class_names_rng = Random.new(Minitest.seed)
+    @dynamic_class_names = Set.new
+    super
+  end
+
+  def teardown
+    @dynamic_class_names.each do |name|
+      Object.send(:remove_const, name)
+    end
+    @dynamic_class_names.clear
+    super
+  end
+
+  def create_journey_subclass(&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)
+    Object.const_set(random_name, klass)
+    @dynamic_class_names << random_name
+    klass
+  end
+end
+
+ActiveSupport::TestCase.include(JourneyDefinitionHelper)