state_machines-activerecord 0.10.0 → 0.40.0

data/test/machine_with_event_attributes_on_autosave_test.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithEventAttributesOnAutosaveTest < BaseTestCase
-  def setup
-    @vehicle_model = new_model(:vehicle) do
-      connection.add_column table_name, :owner_id, :integer
-    end
-    MachineWithEventAttributesOnAutosaveTest.const_set('Vehicle', @vehicle_model)
-
-    @owner_model = new_model(:owner)
-    MachineWithEventAttributesOnAutosaveTest.const_set('Owner', @owner_model)
-
-    machine = StateMachines::Machine.new(@vehicle_model)
-    machine.event :ignite do
-      transition :parked => :idling
-    end
-
-    @owner = @owner_model.create
-    @vehicle = @vehicle_model.create(:state => 'parked', :owner_id => @owner.id)
-  end
-
-  def test_should_persist_has_one_autosave
-    @owner_model.has_one :vehicle, :class_name => 'MachineWithEventAttributesOnAutosaveTest::Vehicle', :autosave => true
-    @owner.vehicle.state_event = 'ignite'
-    @owner.save
-
-    @vehicle.reload
-    assert_equal 'idling', @vehicle.state
-  end
-
-  def test_should_persist_has_many_autosave
-    @owner_model.has_many :vehicles, :class_name => 'MachineWithEventAttributesOnAutosaveTest::Vehicle', :autosave => true
-    @owner.vehicles[0].state_event = 'ignite'
-    @owner.save
-
-    @vehicle.reload
-    assert_equal 'idling', @vehicle.state
-  end
-
-  def teardown
-    MachineWithEventAttributesOnAutosaveTest.class_eval do
-      remove_const('Vehicle')
-      remove_const('Owner')
-    end
-    clear_active_support_dependencies
-    super
-  end
-end

data/test/machine_with_event_attributes_on_custom_action_test.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithEventAttributesOnCustomActionTest < BaseTestCase
-  def setup
-    @superclass = new_model do
-      def persist
-        create_or_update
-      end
-    end
-    @model = Class.new(@superclass)
-    @machine = StateMachines::Machine.new(@model, :action => :persist)
-    @machine.event :ignite do
-      transition :parked => :idling
-    end
-
-    @record = @model.new
-    @record.state = 'parked'
-    @record.state_event = 'ignite'
-  end
-
-  def test_should_not_transition_on_valid?
-    @record.valid?
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_not_transition_on_save
-    @record.save
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_not_transition_on_save!
-    @record.save!
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_transition_on_custom_action
-    @record.persist
-    assert_equal 'idling', @record.state
-  end
-end
-

data/test/machine_with_event_attributes_on_save_bang_test.rb

@@ -1,84 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithEventAttributesOnSaveBangTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.event :ignite do
-      transition :parked => :idling
-    end
-
-    @record = @model.new
-    @record.state = 'parked'
-    @record.state_event = 'ignite'
-  end
-
-  def test_should_fail_if_event_is_invalid
-    @record.state_event = 'invalid'
-    assert_raise(ActiveRecord::RecordInvalid) { @record.save! }
-  end
-
-  def test_should_fail_if_event_has_no_transition
-    @record.state = 'idling'
-    assert_raise(ActiveRecord::RecordInvalid) { @record.save! }
-  end
-
-  def test_should_be_successful_if_event_has_transition
-    assert_equal true, @record.save!
-  end
-
-  def test_should_run_before_callbacks
-    ran_callback = false
-    @machine.before_transition { ran_callback = true }
-
-    @record.save!
-    assert ran_callback
-  end
-
-  def test_should_run_before_callbacks_once
-    before_count = 0
-    @machine.before_transition { before_count += 1 }
-
-    @record.save!
-    assert_equal 1, before_count
-  end
-
-  def test_should_run_around_callbacks_before_yield
-    ran_callback = false
-    @machine.around_transition { |block| ran_callback = true; block.call }
-
-    @record.save!
-    assert ran_callback
-  end
-
-  def test_should_run_around_callbacks_before_yield_once
-    around_before_count = 0
-    @machine.around_transition { |block| around_before_count += 1; block.call }
-
-    @record.save!
-    assert_equal 1, around_before_count
-  end
-
-  def test_should_persist_new_state
-    @record.save!
-    assert_equal 'idling', @record.state
-  end
-
-  def test_should_run_after_callbacks
-    ran_callback = false
-    @machine.after_transition { ran_callback = true }
-
-    @record.save!
-    assert ran_callback
-  end
-
-  def test_should_run_around_callbacks_after_yield
-    ran_callback = false
-    @machine.around_transition { |block| block.call; ran_callback = true }
-
-    @record.save!
-    assert ran_callback
-  end
-end

data/test/machine_with_event_attributes_on_save_test.rb

@@ -1,246 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithEventAttributesOnSaveTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.event :ignite do
-      transition :parked => :idling
-    end
-
-    @record = @model.new
-    @record.state = 'parked'
-    @record.state_event = 'ignite'
-  end
-
-  def test_should_fail_if_event_is_invalid
-    @record.state_event = 'invalid'
-    assert_equal false, @record.save
-  end
-
-  def test_should_fail_if_event_has_no_transition
-    @record.state = 'idling'
-    assert_equal false, @record.save
-  end
-
-  def test_should_run_before_callbacks
-    ran_callback = false
-    @machine.before_transition { ran_callback = true }
-
-    @record.save
-    assert ran_callback
-  end
-
-  def test_should_run_before_callbacks_once
-    before_count = 0
-    @machine.before_transition { before_count += 1 }
-
-    @record.save
-    assert_equal 1, before_count
-  end
-
-  def test_should_run_around_callbacks_before_yield
-    ran_callback = false
-    @machine.around_transition { |block| ran_callback = true; block.call }
-
-    @record.save
-    assert ran_callback
-  end
-
-  def test_should_run_around_callbacks_before_yield_once
-    around_before_count = 0
-    @machine.around_transition { |block| around_before_count += 1; block.call }
-
-    @record.save
-    assert_equal 1, around_before_count
-  end
-
-  def test_should_persist_new_state
-    @record.save
-    assert_equal 'idling', @record.state
-  end
-
-  def test_should_run_after_callbacks
-    ran_callback = false
-    @machine.after_transition { ran_callback = true }
-
-    @record.save
-    assert ran_callback
-  end
-
-  def test_should_not_run_after_callbacks_with_failures_disabled_if_fails
-    @model.before_create { |record| abort_from_callback }
-
-    ran_callback = false
-    @machine.after_transition { ran_callback = true }
-
-    begin
-      ; @record.save;
-    rescue;
-    end
-    refute ran_callback
-  end
-
-  def test_should_run_failure_callbacks__if_fails
-    @model.before_create { |record| abort_from_callback }
-
-    ran_callback = false
-    @machine.after_failure { ran_callback = true }
-
-    begin
-      ; @record.save;
-    rescue;
-    end
-    assert ran_callback
-  end
-
-  def test_should_not_run_around_callbacks_if_fails
-    @model.before_create { |record| abort_from_callback }
-
-    ran_callback = false
-    @machine.around_transition { |block| block.call; ran_callback = true }
-
-    begin
-      ; @record.save;
-    rescue;
-    end
-    refute ran_callback
-  end
-
-  def test_should_run_around_callbacks_after_yield
-    ran_callback = false
-    @machine.around_transition { |block| block.call; ran_callback = true }
-
-    @record.save
-    assert ran_callback
-  end
-
-  def test_should_run_before_transitions_within_transaction
-    @machine.before_transition { @model.create; raise ActiveRecord::Rollback }
-
-    begin
-      @record.save
-    rescue Exception
-    end
-
-    assert_equal 0, @model.count
-  end
-
-  def test_should_run_after_transitions_within_transaction
-    @machine.after_transition { @model.create; raise ActiveRecord::Rollback }
-
-    begin
-      @record.save
-    rescue Exception
-    end
-
-    assert_equal 0, @model.count
-  end
-
-  def test_should_run_around_transition_within_transaction
-    @machine.around_transition { @model.create; raise ActiveRecord::Rollback }
-
-    begin
-      @record.save
-    rescue Exception
-    end
-
-    assert_equal 0, @model.count
-  end
-
-  def test_should_allow_additional_transitions_to_new_state_in_after_transitions
-    @machine.event :park do
-      transition :idling => :parked
-    end
-
-    @machine.after_transition(:on => :ignite) { @record.park }
-
-    @record.save
-    assert_equal 'parked', @record.state
-
-    @record.reload
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_allow_additional_transitions_to_previous_state_in_after_transitions
-    @machine.event :shift_up do
-      transition :idling => :first_gear
-    end
-
-    @machine.after_transition(:on => :ignite) { @record.shift_up }
-
-    @record.save
-    assert_equal 'first_gear', @record.state
-
-    @record.reload
-    assert_equal 'first_gear', @record.state
-  end
-
-  def test_should_yield_one_model!
-    assert_equal true, @record.save!
-    assert_equal 1, @model.count
-  end
-
-  # explicit tests of #save and #save! to ensure expected behavior
-  def test_should_yield_two_models_with_before
-    @machine.before_transition { @model.create! }
-    assert_equal true, @record.save
-    assert_equal 2, @model.count
-  end
-
-  def test_should_yield_two_models_with_before!
-    @machine.before_transition { @model.create! }
-    assert_equal true, @record.save!
-    assert_equal 2, @model.count
-  end
-
-  def test_should_raise_on_around_transition_rollback!
-    @machine.before_transition { @model.create! }
-    @machine.around_transition { @model.create!; raise ActiveRecord::Rollback }
-
-    raised = false
-    begin
-      @record.save!
-    rescue Exception
-      raised = true
-    end
-
-    assert_equal true, raised
-    assert_equal 0, @model.count
-  end
-
-  def test_should_return_nil_on_around_transition_rollback
-    @machine.before_transition { @model.create! }
-    @machine.around_transition { @model.create!; raise ActiveRecord::Rollback }
-    assert_nil @record.save
-    assert_equal 0, @model.count
-  end
-
-  def test_should_return_nil_on_before_transition_rollback
-    @machine.before_transition { raise ActiveRecord::Rollback }
-    assert_nil @record.save
-    assert_equal 0, @model.count
-  end
-
-  #
-  # @rosskevin - This fails and I'm not sure why, it was existing behavior.
-  #   see: https://github.com/state-machines/state_machines-activerecord/pull/26#issuecomment-112911886
-  #
-  # def test_should_yield_three_models_with_before_and_around_save
-  #   @machine.before_transition { @model.create!; puts "before ran, now #{@model.count}" }
-  #   @machine.around_transition { @model.create!; puts "around ran, now #{@model.count}" }
-  #
-  #   assert_equal true, @record.save
-  #   assert_equal 3, @model.count
-  # end
-  #
-  # def test_should_yield_three_models_with_before_and_around_save!
-  #   @machine.before_transition { @model.create!; puts "before ran, now #{@model.count}" }
-  #   @machine.around_transition { @model.create!; puts "around ran, now #{@model.count}" }
-  #
-  #   assert_equal true, @record.save!
-  #   assert_equal 3, @model.count
-  # end
-end

data/test/machine_with_event_attributes_on_validation_test.rb

@@ -1,145 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithEventAttributesOnValidationTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.event :ignite do
-      transition :parked => :idling
-    end
-
-    @record = @model.new
-    @record.state = 'parked'
-    @record.state_event = 'ignite'
-  end
-
-  def test_should_fail_if_event_is_invalid
-    @record.state_event = 'invalid'
-    refute @record.valid?
-    assert_equal ['State event is invalid'], @record.errors.full_messages
-  end
-
-  def test_should_fail_if_event_has_no_transition
-    @record.state = 'idling'
-    refute @record.valid?
-    assert_equal ['State event cannot transition when idling'], @record.errors.full_messages
-  end
-
-  def test_should_be_successful_if_event_has_transition
-    assert @record.valid?
-  end
-
-  def test_should_run_before_callbacks
-    ran_callback = false
-    @machine.before_transition { ran_callback = true }
-
-    @record.valid?
-    assert ran_callback
-  end
-
-  def test_should_run_around_callbacks_before_yield
-    ran_callback = false
-    @machine.around_transition { |block| ran_callback = true; block.call }
-
-    begin
-      @record.valid?
-    rescue ArgumentError
-      raise if StateMachines::Transition.pause_supported?
-    end
-    assert ran_callback
-  end
-
-  def test_should_persist_new_state
-    @record.valid?
-    assert_equal 'idling', @record.state
-  end
-
-  def test_should_not_run_after_callbacks
-    ran_callback = false
-    @machine.after_transition { ran_callback = true }
-
-    @record.valid?
-    refute ran_callback
-  end
-
-  def test_should_not_run_after_callbacks_with_failures_disabled_if_validation_fails
-    @model.class_eval do
-      attr_accessor :seatbelt
-      validates :seatbelt, presence: true
-    end
-
-    ran_callback = false
-    @machine.after_transition { ran_callback = true }
-
-    @record.valid?
-    refute ran_callback
-  end
-
-  def test_should_run_after_callbacks_if_validation_fails
-    @model.class_eval do
-      attr_accessor :seatbelt
-      validates :seatbelt, presence: true
-    end
-
-    ran_callback = false
-    @machine.after_failure { ran_callback = true }
-
-    @record.valid?
-    assert ran_callback
-  end
-
-  def test_should_not_run_around_callbacks_after_yield
-    ran_callback = false
-    @machine.around_transition { |block| block.call; ran_callback = true }
-
-    begin
-      @record.valid?
-    rescue ArgumentError
-      raise if StateMachines::Transition.pause_supported?
-    end
-    refute ran_callback
-  end
-
-  def test_should_not_run_around_callbacks_after_yield_with_failures_disabled_if_validation_fails
-    @model.class_eval do
-      attr_accessor :seatbelt
-      validates :seatbelt, presence: true
-    end
-
-    ran_callback = false
-    @machine.around_transition { |block| block.call; ran_callback = true }
-
-    @record.valid?
-    refute ran_callback
-  end
-
-  def test_should_rollback_before_transitions_with_raise
-    @machine.before_transition {
-      @model.create;
-      raise ActiveRecord::Rollback
-    }
-
-    begin
-      @record.valid?
-    rescue Exception
-    end
-
-    assert_equal 0, @model.count
-  end
-
-  def test_should_rollback_before_transitions_with_false
-    @machine.before_transition {
-      @model.create;
-      false
-    }
-
-    begin
-      @record.valid?
-    rescue Exception
-    end
-
-    assert_equal 0, @model.count
-  end
-end

data/test/machine_with_events_test.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithEventsTest < BaseTestCase
-  def setup
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.event :shift_up
-  end
-
-  def test_should_humanize_name
-    assert_equal 'shift up', @machine.event(:shift_up).human_name
-  end
-end

data/test/machine_with_failed_action_test.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithFailedActionTest < BaseTestCase
-  def setup
-    @model = new_model do
-      validates_inclusion_of :state, :in => %w(first_gear)
-    end
-
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-
-    @callbacks = []
-    @machine.before_transition { @callbacks << :before }
-    @machine.after_transition { @callbacks << :after }
-    @machine.after_failure { @callbacks << :after_failure }
-    @machine.around_transition { |block| @callbacks << :around_before; block.call; @callbacks << :around_after }
-
-    @record = @model.new(:state => 'parked')
-    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
-  end
-
-  def test_should_not_be_successful
-    refute @result
-  end
-
-  def test_should_not_change_current_state
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_not_save_record
-    assert @record.new_record?
-  end
-
-  def test_should_run_before_callbacks_and_after_callbacks_with_failures
-    assert_equal [:before, :around_before, :after_failure], @callbacks
-  end
-end
-

data/test/machine_with_failed_after_callbacks_test.rb

@@ -1,37 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithFailedAfterCallbacksTest < BaseTestCase
-  def setup
-    @callbacks = []
-
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-    @machine.after_transition { @callbacks << :after_1; false }
-    @machine.after_transition { @callbacks << :after_2 }
-    @machine.around_transition { |block| @callbacks << :around_before; block.call; @callbacks << :around_after }
-
-    @record = @model.new(:state => 'parked')
-    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
-  end
-
-  def test_should_be_successful
-    assert @result
-  end
-
-  def test_should_change_current_state
-    assert_equal 'idling', @record.state
-  end
-
-  def test_should_save_record
-    refute @record.new_record?
-  end
-
-  def test_should_not_run_further_after_callbacks
-    assert_equal [:around_before, :around_after, :after_1], @callbacks
-  end
-end

data/test/machine_with_failed_before_callbacks_test.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'test_helper'
-
-class MachineWithFailedBeforeCallbacksTest < BaseTestCase
-  def setup
-    @callbacks = []
-
-    @model = new_model
-    @machine = StateMachines::Machine.new(@model)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-    @machine.before_transition { @callbacks << :before_1; false }
-    @machine.before_transition { @callbacks << :before_2 }
-    @machine.after_transition { @callbacks << :after }
-    @machine.around_transition { |block| @callbacks << :around_before; block.call; @callbacks << :around_after }
-
-    @record = @model.new(:state => 'parked')
-    @transition = StateMachines::Transition.new(@record, @machine, :ignite, :parked, :idling)
-    @result = @transition.perform
-  end
-
-  def test_should_not_be_successful
-    refute @result
-  end
-
-  def test_should_not_change_current_state
-    assert_equal 'parked', @record.state
-  end
-
-  def test_should_not_run_action
-    assert @record.new_record?
-  end
-
-  def test_should_not_run_further_callbacks
-    assert_equal [:before_1], @callbacks
-  end
-end