state_machines-activemodel 0.0.2 → 0.0.3

data/test/machine_with_dynamic_initial_state_test.rb

@@ -0,0 +1,14 @@
+require_relative 'test_helper'
+
+class MachineWithDynamicInitialStateTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, initial: lambda { |_object| :parked }, integration: :active_model)
+    @machine.state :parked
+  end
+
+  def test_should_set_initial_state_on_created_object
+    record = @model.new
+    assert_equal 'parked', record.state
+  end
+end

data/test/machine_with_events_test.rb

@@ -0,0 +1,13 @@
+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_after_callbacks_test.rb

@@ -0,0 +1,31 @@
+require_relative 'test_helper'
+
+class MachineWithFailedAfterCallbacksTest < BaseTestCase
+  def setup
+    @callbacks = []
+
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, integration: :active_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_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

@@ -0,0 +1,32 @@
+require_relative 'test_helper'
+
+class MachineWithFailedBeforeCallbacksTest < BaseTestCase
+  def setup
+    @callbacks = []
+
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, integration: :active_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
+    assert !@result
+  end
+
+  def test_should_not_change_current_state
+    assert_equal 'parked', @record.state
+  end
+
+  def test_should_not_run_further_callbacks
+    assert_equal [:before_1], @callbacks
+  end
+end

data/test/machine_with_initialized_state_test.rb

@@ -0,0 +1,35 @@
+require_relative 'test_helper'
+
+class MachineWithInitializedStateTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, initial: :parked, integration: :active_model)
+    @machine.state :idling
+  end
+
+  def test_should_allow_nil_initial_state_when_static
+    @machine.state nil
+
+    record = @model.new(state: nil)
+    assert_nil record.state
+  end
+
+  def test_should_allow_nil_initial_state_when_dynamic
+    @machine.state nil
+
+    @machine.initial_state = lambda { :parked }
+    record = @model.new(state: nil)
+    assert_nil record.state
+  end
+
+  def test_should_allow_different_initial_state_when_static
+    record = @model.new(state: 'idling')
+    assert_equal 'idling', record.state
+  end
+
+  def test_should_allow_different_initial_state_when_dynamic
+    @machine.initial_state = lambda { :parked }
+    record = @model.new(state: 'idling')
+    assert_equal 'idling', record.state
+  end
+end

data/test/machine_with_internationalization_test.rb

@@ -0,0 +1,190 @@
+require_relative 'test_helper'
+require 'i18n'
+
+class MachineWithInternationalizationTest < BaseTestCase
+  def setup
+    I18n.backend = I18n::Backend::Simple.new
+    # Initialize the backend
+    I18n.backend.translate(:en, 'activemodel.errors.messages.invalid_transition', event: 'ignite', value: 'idling')
+
+    @model = new_model { include ActiveModel::Validations }
+  end
+
+  def test_should_use_defaults
+    I18n.backend.store_translations(:en,
+                                    activemodel: { errors: { messages: { invalid_transition: 'cannot %{event}' } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model, action: :save)
+    machine.state :parked, :idling
+    machine.event :ignite
+
+    record = @model.new(state: 'idling')
+
+    machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+    assert_equal ['State cannot ignite'], record.errors.full_messages
+  end
+
+  def test_should_allow_customized_error_key
+    I18n.backend.store_translations(:en,
+                                    activemodel: { errors: { messages: { bad_transition: 'cannot %{event}' } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model, action: :save, messages: { invalid_transition: :bad_transition })
+    machine.state :parked, :idling
+
+    record = @model.new
+    record.state = 'idling'
+
+    machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+    assert_equal ['State cannot ignite'], record.errors.full_messages
+  end
+
+  def test_should_allow_customized_error_string
+    machine = StateMachines::Machine.new(@model, action: :save, messages: { invalid_transition: 'cannot %{event}' })
+    machine.state :parked, :idling
+
+    record = @model.new(state: 'idling')
+
+    machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+    assert_equal ['State cannot ignite'], record.errors.full_messages
+  end
+
+  def test_should_allow_customized_state_key_scoped_to_class_and_machine
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { :'foo' => { state: { states: { parked: 'shutdown' } } } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+    machine.state :parked
+    assert_equal 'shutdown', machine.state(:parked).human_name
+  end
+
+  def test_should_allow_customized_state_key_scoped_to_class
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { :'foo' => { states: { parked: 'shutdown' } } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+    machine.state :parked
+
+    assert_equal 'shutdown', machine.state(:parked).human_name
+  end
+
+  def test_should_allow_customized_state_key_scoped_to_machine
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { state: { states: { parked: 'shutdown' } } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+    machine.state :parked
+
+    assert_equal 'shutdown', machine.state(:parked).human_name
+  end
+
+  def test_should_allow_customized_state_key_unscoped
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { states: { parked: 'shutdown' } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+    machine.state :parked
+
+    assert_equal 'shutdown', machine.state(:parked).human_name
+  end
+
+  def test_should_support_nil_state_key
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { states: { nil: 'empty' } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+
+    assert_equal 'empty', machine.state(nil).human_name
+  end
+
+  def test_should_allow_customized_event_key_scoped_to_class_and_machine
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { :'foo' => { state: { events: { park: 'stop' } } } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+    machine.event :park
+
+    assert_equal 'stop', machine.event(:park).human_name
+  end
+
+  def test_should_allow_customized_event_key_scoped_to_class
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { :'foo' => { events: { park: 'stop' } } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+    machine.event :park
+
+    assert_equal 'stop', machine.event(:park).human_name
+  end
+
+  def test_should_allow_customized_event_key_scoped_to_machine
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { state: { events: { park: 'stop' } } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+    machine.event :park
+
+    assert_equal 'stop', machine.event(:park).human_name
+  end
+
+  def test_should_allow_customized_event_key_unscoped
+    I18n.backend.store_translations(:en,
+                                    activemodel: { state_machines: { events: { park: 'stop' } } }
+                                    )
+
+    machine = StateMachines::Machine.new(@model)
+    machine.event :park
+
+    assert_equal 'stop', machine.event(:park).human_name
+  end
+
+  def test_should_only_add_locale_once_in_load_path
+    assert_equal 1, I18n.load_path.select { |path| path =~ %r{active_model/locale\.rb$} }.length
+
+    # Create another ActiveModel model that will triger the i18n feature
+    new_model
+
+    assert_equal 1, I18n.load_path.select { |path| path =~ %r{active_model/locale\.rb$} }.length
+  end
+
+  def test_should_add_locale_to_beginning_of_load_path
+    @original_load_path = I18n.load_path
+    I18n.backend = I18n::Backend::Simple.new
+
+    app_locale = File.dirname(__FILE__) + '/files/en.yml'
+    default_locale = File.dirname(__FILE__) + '/../lib/state_machines/integrations/active_model/locale.rb'
+    I18n.load_path = [app_locale]
+
+    StateMachines::Machine.new(@model)
+
+    assert_equal [default_locale, app_locale].map { |path| File.expand_path(path) }, I18n.load_path.map { |path| File.expand_path(path) }
+  ensure
+    I18n.load_path = @original_load_path
+  end
+
+  def test_should_prefer_other_locales_first
+    @original_load_path = I18n.load_path
+    I18n.backend = I18n::Backend::Simple.new
+    I18n.load_path = [File.dirname(__FILE__) + '/files/en.yml']
+
+    machine = StateMachines::Machine.new(@model)
+    machine.state :parked, :idling
+    machine.event :ignite
+
+    record = @model.new(state: 'idling')
+
+    machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+    assert_equal ['State cannot ignite'], record.errors.full_messages
+  ensure
+    I18n.load_path = @original_load_path
+  end
+end

data/test/machine_with_model_state_attribute_test.rb

@@ -0,0 +1,31 @@
+require_relative 'test_helper'
+
+class MachineWithModelStateAttributeTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, initial: :parked, integration: :active_model)
+    @machine.other_states(:idling)
+
+    @record = @model.new
+  end
+
+  def test_should_have_an_attribute_predicate
+    assert @record.respond_to?(:state?)
+  end
+
+  def test_should_raise_exception_for_predicate_without_parameters
+    assert_raises(ArgumentError) { @record.state? }
+  end
+
+  def test_should_return_false_for_predicate_if_does_not_match_current_value
+    assert !@record.state?(:idling)
+  end
+
+  def test_should_return_true_for_predicate_if_matches_current_value
+    assert @record.state?(:parked)
+  end
+
+  def test_should_raise_exception_for_predicate_if_invalid_state_specified
+    assert_raises(IndexError) { @record.state?(:invalid) }
+  end
+end

data/test/machine_with_non_model_state_attribute_undefined_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+
+class MachineWithNonModelStateAttributeUndefinedTest < BaseTestCase
+  def setup
+    @model = new_model do
+      def initialize
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@model, :status, initial: :parked, integration: :active_model)
+    @machine.other_states(:idling)
+    @record = @model.new
+  end
+
+  def test_should_not_define_a_reader_attribute_for_the_attribute
+    assert !@record.respond_to?(:status)
+  end
+
+  def test_should_not_define_a_writer_attribute_for_the_attribute
+    assert !@record.respond_to?(:status=)
+  end
+
+  def test_should_define_an_attribute_predicate
+    assert @record.respond_to?(:status?)
+  end
+end

data/test/machine_with_state_driven_validations_test.rb

@@ -0,0 +1,31 @@
+require_relative 'test_helper'
+
+class MachineWithStateDrivenValidationsTest < BaseTestCase
+  def setup
+    @model = new_model do
+      include ActiveModel::Validations
+      attr_accessor :seatbelt
+    end
+
+    @machine = StateMachines::Machine.new(@model)
+    @machine.state :first_gear, :second_gear do
+      validates_presence_of :seatbelt
+    end
+    @machine.other_states :parked
+  end
+
+  def test_should_be_valid_if_validation_fails_outside_state_scope
+    record = @model.new(state: 'parked', seatbelt: nil)
+    assert record.valid?
+  end
+
+  def test_should_be_invalid_if_validation_fails_within_state_scope
+    record = @model.new(state: 'first_gear', seatbelt: nil)
+    assert !record.valid?
+  end
+
+  def test_should_be_valid_if_validation_succeeds_within_state_scope
+    record = @model.new(state: 'second_gear', seatbelt: true)
+    assert record.valid?
+  end
+end

data/test/machine_with_states_test.rb

@@ -0,0 +1,13 @@
+require_relative 'test_helper'
+
+class MachineWithStatesTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model)
+    @machine.state :first_gear
+  end
+
+  def test_should_humanize_name
+    assert_equal 'first gear', @machine.state(:first_gear).human_name
+  end
+end

data/test/machine_with_static_initial_state_test.rb

@@ -0,0 +1,13 @@
+require_relative 'test_helper'
+
+class MachineWithStaticInitialStateTest < BaseTestCase
+  def setup
+    @model = new_model
+    @machine = StateMachines::Machine.new(@model, initial: :parked, integration: :active_model)
+  end
+
+  def test_should_set_initial_state_on_created_object
+    record = @model.new
+    assert_equal 'parked', record.state
+  end
+end

data/test/machine_with_validations_and_custom_attribute_test.rb

@@ -0,0 +1,22 @@
+require_relative 'test_helper'
+
+class MachineWithValidationsAndCustomAttributeTest < BaseTestCase
+  def setup
+    @model = new_model { include ActiveModel::Validations }
+
+    @machine = StateMachines::Machine.new(@model, :status, attribute: :state)
+    @machine.state :parked
+
+    @record = @model.new
+  end
+
+  def test_should_add_validation_errors_to_custom_attribute
+    @record.state = 'invalid'
+
+    assert !@record.valid?
+    assert_equal ['State is invalid'], @record.errors.full_messages
+
+    @record.state = 'parked'
+    assert @record.valid?
+  end
+end