state_machines-activerecord 0.0.1

data/test/machine_with_failed_action_test.rb

@@ -0,0 +1,40 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,36 @@
+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

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)
+    @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,180 @@
+require_relative 'test_helper'
+
+class MachineWithInternationalizationTest < BaseTestCase
+  def setup
+    I18n.backend = I18n::Backend::Simple.new
+
+    # Initialize the backend
+    StateMachines::Machine.new(new_model)
+
+    @model = new_model
+  end
+
+  def test_should_use_defaults
+    I18n.backend.store_translations(:en, {
+                                           :activerecord => {:errors => {:messages => {:invalid_transition => "cannot #{interpolation_key('event')}"}}}
+                                       })
+
+    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 transition via "ignite"'], record.errors.full_messages
+  end
+
+  def test_should_allow_customized_error_key
+    I18n.backend.store_translations(:en, {
+                                           :activerecord => {:errors => {:messages => {:bad_transition => "cannot #{interpolation_key('event')}"}}}
+                                       })
+
+    machine = StateMachines::Machine.new(@model, :messages => {:invalid_transition => :bad_transition})
+    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_error_string
+    machine = StateMachines::Machine.new(@model, :messages => {:invalid_transition => "cannot #{interpolation_key('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, {
+                                           :activerecord => {: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, {
+                                           :activerecord => {: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, {
+                                           :activerecord => {: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, {
+                                           :activerecord => {: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, {
+                                           :activerecord => {: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, {
+                                           :activerecord => {: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, {
+                                           :activerecord => {: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, {
+                                           :activerecord => {: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, {
+                                           :activerecord => {: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_record/locale\.rb$} }.length
+
+    # Create another ActiveRecord model that will trigger the i18n feature
+    new_model
+
+    assert_equal 1, I18n.load_path.select { |path| path =~ %r{active_record/locale\.rb$} }.length
+  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 transition'], record.errors.full_messages
+  ensure
+    I18n.load_path = @original_load_path
+  end
+
+  private
+  def interpolation_key(key)
+    "%{#{key}}"
+  end
+end

data/test/machine_with_loopback_test.rb

@@ -0,0 +1,22 @@
+require_relative 'test_helper'
+
+class MachineWithLoopbackTest < BaseTestCase
+  def setup
+    @model = new_model do
+      connection.add_column table_name, :updated_at, :datetime
+    end
+
+    @machine = StateMachines::Machine.new(@model, :initial => :parked)
+    @machine.event :park
+
+    @record = @model.create(:updated_at => Time.now - 1)
+    @transition = StateMachines::Transition.new(@record, @machine, :park, :parked, :parked)
+
+    @timestamp = @record.updated_at
+    @transition.perform
+  end
+
+  def test_should_not_update_record
+    assert_equal @timestamp, @record.updated_at
+  end
+end

data/test/machine_with_non_column_state_attribute_defined_test.rb

@@ -0,0 +1,35 @@
+require_relative 'test_helper'
+
+class MachineWithNonColumnStateAttributeDefinedTest < BaseTestCase
+  def setup
+    @model = new_model do
+      def status=(value)
+        self['status'] = value
+      end
+
+      def status
+        self['status']
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@model, :status, :initial => :parked)
+    @machine.other_states(:idling)
+    @record = @model.new
+  end
+
+  def test_should_return_false_for_predicate_if_does_not_match_current_value
+    refute @record.status?(:idling)
+  end
+
+  def test_should_return_true_for_predicate_if_matches_current_value
+    assert @record.status?(:parked)
+  end
+
+  def test_should_raise_exception_for_predicate_if_invalid_state_specified
+    assert_raise(IndexError) { @record.status?(:invalid) }
+  end
+
+  def test_should_set_initial_state_on_created_object
+    assert_equal 'parked', @record.status
+  end
+end

data/test/machine_with_non_column_state_attribute_undefined_test.rb

@@ -0,0 +1,33 @@
+require_relative 'test_helper'
+
+class MachineWithNonColumnStateAttributeUndefinedTest < BaseTestCase
+  def setup
+    @model = new_model do
+      def initialize
+        # Skip attribute initialization
+        @initialized_state_machines = true
+        super
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@model, :status, :initial => :parked)
+    @machine.other_states(:idling)
+    @record = @model.new
+  end
+
+  def test_should_not_define_a_column_for_the_attribute
+    assert_nil @model.columns_hash['status']
+  end
+
+  def test_should_define_a_reader_attribute_for_the_attribute
+    assert @record.respond_to?(:status)
+  end
+
+  def test_should_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_same_column_default_test.rb

@@ -0,0 +1,26 @@
+require_relative 'test_helper'
+
+class MachineWithSameColumnDefaultTest < BaseTestCase
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @model = new_model do
+      connection.add_column table_name, :status, :string, :default => 'parked'
+    end
+    @machine = StateMachines::Machine.new(@model, :status, :initial => :parked)
+    @record = @model.new
+  end
+
+  def test_should_use_machine_default
+    assert_equal 'parked', @record.status
+  end
+
+  def test_should_not_generate_a_warning
+    assert_no_match(/have defined a different default/, $stderr.string)
+  end
+
+  def teardown
+    $stderr = @original_stderr
+    super
+  end
+end