state_machine 0.9.4 → 0.10.0

data/test/unit/integrations/sequel_test.rb

@@ -26,7 +26,9 @@ module SequelTest
         end if create_table
         model = Class.new(Sequel::Model(table_name)) do
           self.raise_on_save_failure = false
-          def self.name; "SequelTest::#{table_name.to_s.capitalize}"; end
+          (class << self; self; end).class_eval do
+            define_method(:name) { "SequelTest::#{table_name.to_s.capitalize}" }
+          end
         end
         model.plugin(:validation_class_methods) if model.respond_to?(:plugin)
         model.plugin(:hook_class_methods) if model.respond_to?(:plugin)
@@ -592,6 +594,28 @@ module SequelTest
     end
   end
   
+  class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model, :initial => :parked)
+      @machine.event :ignite
+      
+      @record = @model.create
+      @record.state_event = 'ignite'
+    end
+    
+    def test_should_include_state_in_changed_attributes
+      assert_equal [:state], @record.changed_columns
+    end
+    
+    def test_should_not_include_state_in_changed_attributes_if_nil
+      @record = @model.create
+      @record.state_event = nil
+      
+      assert_equal [], @record.changed_columns
+    end
+  end
+  
   class MachineWithoutTransactionsTest < BaseTestCase
     def setup
       @model = new_model
@@ -805,13 +829,8 @@ module SequelTest
       callbacks = []
       @machine.before_transition {callbacks << :before}
       @machine.after_transition {callbacks << :after}
-      @machine.after_transition(:include_failures => true) {callbacks << :after_failure}
+      @machine.after_failure {callbacks << :after_failure}
       @machine.around_transition {|block| callbacks << :around_before; block.call; callbacks << :around_after}
-      @machine.around_transition(:include_failures => true) do |block|
-        callbacks << :around_before_failure
-        block.call
-        callbacks << :around_after_failure
-      end
       
       @record = @model.new(:state => 'parked')
       @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
@@ -833,7 +852,7 @@ module SequelTest
     end
     
     def test_should_run_before_callbacks_and_after_callbacks_with_failures
-      assert_equal [:before, :around_before, :around_before_failure, :around_after_failure, :after_failure], @callbacks
+      assert_equal [:before, :around_before, :after_failure], @callbacks
     end
   end
   
@@ -1041,14 +1060,14 @@ module SequelTest
       assert !ran_callback
     end
     
-    def test_should_run_after_callbacks_with_failures_enabled_if_validation_fails
+    def test_should_run_failure_callbacks_if_validation_fails
       @model.class_eval do
         attr_accessor :seatbelt
         validates_presence_of :seatbelt
       end
       
       ran_callback = false
-      @machine.after_transition(:include_failures => true) { ran_callback = true }
+      @machine.after_failure { ran_callback = true }
       
       @record.valid?
       assert ran_callback
@@ -1075,19 +1094,6 @@ module SequelTest
       assert !ran_callback[0]
     end
     
-    def test_should_run_around_callbacks_after_yield_with_failures_enabled_if_validation_fails
-      @model.class_eval do
-        attr_accessor :seatbelt
-        validates_presence_of :seatbelt
-      end
-      
-      ran_callback = [false]
-      @machine.around_transition(:include_failures => true) {|block| block.call; ran_callback[0] = true }
-      
-      @record.valid?
-      assert ran_callback[0]
-    end
-    
     def test_should_not_run_before_transitions_within_transaction
       @machine.before_transition { self.class.create; raise Sequel::Error::Rollback }
       
@@ -1203,21 +1209,21 @@ module SequelTest
     end
     
     if defined?(Sequel::MAJOR) && Sequel::MAJOR >= 3 && Sequel::MINOR >= 7
-      def test_should_not_run_after_callbacks_with_failures_enabled_if_fails
+      def test_should_not_run_failure_callbacks_if_fails
         @model.before_create {|record| false}
         
         ran_callback = false
-        @machine.after_transition(:include_failures => true) { ran_callback = true }
+        @machine.after_failure { ran_callback = true }
         
         @record.save
         assert !ran_callback
       end
     else
-      def test_should_run_after_callbacks_with_failures_enabled_if_fails
+      def test_should_run_failure_callbacks_if_fails
         @model.before_create {|record| false}
         
         ran_callback = false
-        @machine.after_transition(:include_failures => true) { ran_callback = true }
+        @machine.after_failure { ran_callback = true }
         
         @record.save
         assert ran_callback
@@ -1253,28 +1259,6 @@ module SequelTest
       assert ran_callback[0]
     end
     
-    if defined?(Sequel::MAJOR) && Sequel::MAJOR >= 3 && Sequel::MINOR >= 7
-      def test_should_not_run_around_callbacks_after_yield_with_failures_enabled_if_fails
-        @model.before_create {|record| false}
-        
-        ran_callback = [false]
-        @machine.around_transition(:include_failures => true) {|block| block.call; ran_callback[0] = true }
-        
-        @record.save
-        assert !ran_callback[0]
-      end
-    else
-      def test_should_run_around_callbacks_after_yield_with_failures_enabled_if_fails
-        @model.before_create {|record| false}
-        
-        ran_callback = [false]
-        @machine.around_transition(:include_failures => true) {|block| block.call; ran_callback[0] = true }
-        
-        @record.save
-        assert ran_callback[0]
-      end
-    end
-    
     if defined?(Sequel::MAJOR) && (Sequel::MAJOR >= 3 || Sequel::MAJOR == 2 && Sequel::MINOR == 12)
       def test_should_run_after_transitions_within_transaction
         @machine.after_transition { self.class.create; raise Sequel::Error::Rollback }

data/test/unit/integrations_test.rb

@@ -24,6 +24,10 @@ class IntegrationMatcherTest < Test::Unit::TestCase
 end
 
 class IntegrationFinderTest < Test::Unit::TestCase
+  def test_should_find_base
+    assert_equal StateMachine::Integrations::Base, StateMachine::Integrations.find(:base)
+  end
+  
   def test_should_find_active_model
     assert_equal StateMachine::Integrations::ActiveModel, StateMachine::Integrations.find(:active_model)
   end

data/test/unit/invalid_event_test.rb

@@ -1,7 +1,20 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class InvalidEventTest < Test::Unit::TestCase
-  def test_should_exist
-    assert_not_nil StateMachine::InvalidEvent
+  def setup
+    @object = Object.new
+    @invalid_event = StateMachine::InvalidEvent.new(@object, :invalid)
+  end
+  
+  def test_should_have_an_object
+    assert_equal @object, @invalid_event.object
+  end
+  
+  def test_should_have_an_event
+    assert_equal :invalid, @invalid_event.event
+  end
+  
+  def test_should_generate_a_message
+    assert_equal ':invalid is an unknown state machine event', @invalid_event.message
   end
 end

data/test/unit/invalid_parallel_transition_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class InvalidParallelTransitionTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @events = [:ignite, :disable_alarm]
+    
+    @invalid_transition = StateMachine::InvalidParallelTransition.new(@object, @events)
+  end
+  
+  def test_should_have_an_object
+    assert_equal @object, @invalid_transition.object
+  end
+  
+  def test_should_have_events
+    assert_equal @events, @invalid_transition.events
+  end
+end

data/test/unit/invalid_transition_test.rb

@@ -1,7 +1,77 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class InvalidTransitionTest < Test::Unit::TestCase
-  def test_should_exist
-    assert_not_nil StateMachine::InvalidTransition
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @state = @machine.state :parked
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @invalid_transition = StateMachine::InvalidTransition.new(@object, @machine, :ignite)
+  end
+  
+  def test_should_have_an_object
+    assert_equal @object, @invalid_transition.object
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @invalid_transition.machine
+  end
+  
+  def test_should_have_an_event
+    assert_equal :ignite, @invalid_transition.event
+  end
+  
+  def test_should_have_a_qualified_event
+    assert_equal :ignite, @invalid_transition.qualified_event
+  end
+  
+  def test_should_have_a_from_value
+    assert_equal 'parked', @invalid_transition.from
+  end
+  
+  def test_should_have_a_from_name
+    assert_equal :parked, @invalid_transition.from_name
+  end
+  
+  def test_should_have_a_qualified_from_name
+    assert_equal :parked, @invalid_transition.qualified_from_name
+  end
+  
+  def test_should_generate_a_message
+    assert_equal 'Cannot transition state via :ignite from :parked', @invalid_transition.message
+  end
+end
+
+class InvalidTransitionWithNamespaceTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :namespace => 'alarm')
+    @state = @machine.state :active
+    @machine.event :disable
+    
+    @object = @klass.new
+    @object.state = 'active'
+    
+    @invalid_transition = StateMachine::InvalidTransition.new(@object, @machine, :disable)
+  end
+  
+  def test_should_have_an_event
+    assert_equal :disable, @invalid_transition.event
+  end
+  
+  def test_should_have_a_qualified_event
+    assert_equal :disable_alarm, @invalid_transition.qualified_event
+  end
+  
+  def test_should_have_a_from_name
+    assert_equal :active, @invalid_transition.from_name
+  end
+  
+  def test_should_have_a_qualified_from_name
+    assert_equal :alarm_active, @invalid_transition.qualified_from_name
   end
 end

data/test/unit/machine_collection_test.rb

@@ -31,84 +31,42 @@ class MachineCollectionStateInitializationTest < Test::Unit::TestCase
     @object.alarm_state = nil
   end
   
-  def test_should_set_states_if_nil
-    @machines.initialize_states(@object)
+  def test_should_only_initialize_static_states_prior_to_block
+    @machines.initialize_states(@object) do
+      @state_in_block = @object.state
+      @alarm_state_in_block = @object.alarm_state
+    end
     
-    assert_equal 'parked', @object.state
-    assert_equal 'active', @object.alarm_state
+    assert_equal 'parked', @state_in_block
+    assert_nil @alarm_state_in_block
   end
   
-  def test_should_set_states_if_empty
-    @object.state = ''
-    @object.alarm_state = ''
-    @machines.initialize_states(@object)
+  def test_should_only_initialize_dynamic_states_after_block
+    @machines.initialize_states(@object) do
+      @alarm_state_in_block = @object.alarm_state
+    end
     
-    assert_equal 'parked', @object.state
+    assert_nil @alarm_state_in_block
     assert_equal 'active', @object.alarm_state
   end
   
-  def test_should_not_set_states_if_not_empty
-    @object.state = 'idling'
-    @object.alarm_state = 'off'
+  def test_should_initialize_all_states_without_block
     @machines.initialize_states(@object)
     
-    assert_equal 'idling', @object.state
-    assert_equal 'off', @object.alarm_state
-  end
-  
-  def test_should_only_initialize_static_states_if_dynamic_disabled
-    @machines.initialize_states(@object, :dynamic => false)
-    
     assert_equal 'parked', @object.state
-    assert_nil @object.alarm_state
-  end
-  
-  def test_should_only_initialize_dynamic_states_if_dynamic_enabled
-    @machines.initialize_states(@object, :dynamic => true)
-    
-    assert_nil @object.state
     assert_equal 'active', @object.alarm_state
   end
   
-  def test_should_not_set_states_if_ignored
-    @machines.initialize_states(@object, :ignore => [:state, :alarm_state])
-    
+  def test_should_skip_static_states_if_disabled
+    @machines.initialize_states(@object, :static => false)
     assert_nil @object.state
-    assert_nil @object.alarm_state
-  end
-  
-  def test_should_set_states_if_not_ignored_and_nil
-    @machines.initialize_states(@object, :ignore => [])
-    
-    assert_equal 'parked', @object.state
-    assert_equal 'active', @object.alarm_state
-  end
-  
-  def test_should_set_states_if_not_ignored_and_empty
-    @object.state = ''
-    @object.alarm_state = ''
-    @machines.initialize_states(@object, :ignore => [])
-    
-    assert_equal 'parked', @object.state
     assert_equal 'active', @object.alarm_state
   end
   
-  def test_should_set_states_if_not_ignored_and_not_empty
-    @object.state = 'idling'
-    @object.alarm_state = 'inactive'
-    @machines.initialize_states(@object, :ignore => [])
-    
+  def test_should_skip_dynamic_states_if_disabled
+    @machines.initialize_states(@object, :dynamic => false)
     assert_equal 'parked', @object.state
-    assert_equal 'active', @object.alarm_state
-  end
-  
-  def test_should_not_modify_ignore_option
-    ignore = ['state', 'alarm_state']
-    @machines.initialize_states(@object, :ignore => ignore)
-    
-    assert_nil @object.state
     assert_nil @object.alarm_state
-    assert_equal ['state', 'alarm_state'], ignore
   end
 end
 
@@ -147,10 +105,10 @@ class MachineCollectionFireTest < Test::Unit::TestCase
   
   def test_should_raise_exception_if_invalid_event_specified
     exception = assert_raise(StateMachine::InvalidEvent) { @machines.fire_events(@object, :invalid) }
-    assert_equal ':invalid is an unknown state machine event', exception.message
+    assert_equal :invalid, exception.event
     
     exception = assert_raise(StateMachine::InvalidEvent) { @machines.fire_events(@object, :ignite, :invalid) }
-    assert_equal ':invalid is an unknown state machine event', exception.message
+    assert_equal :invalid, exception.event
   end
   
   def test_should_fail_if_any_event_cannot_transition
@@ -165,6 +123,15 @@ class MachineCollectionFireTest < Test::Unit::TestCase
     assert !@object.saved
   end
   
+  def test_should_run_failure_callbacks_if_any_event_cannot_transition
+    @machines[:state].after_failure {@state_failure_run = true}
+    @machines[:alarm_state].after_failure {@alarm_state_failure_run = true}
+    
+    assert !@machines.fire_events(@object, :park, :disable_alarm)
+    assert @state_failure_run
+    assert !@alarm_state_failure_run
+  end
+  
   def test_should_be_successful_if_all_events_transition
     assert @machines.fire_events(@object, :ignite, :disable_alarm)
     assert_equal 'idling', @object.state
@@ -193,6 +160,8 @@ class MachineCollectionFireWithTransactionsTest < Test::Unit::TestCase
     end
     
     StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
       attr_reader :rolled_back
       
       def transaction(object)
@@ -235,6 +204,17 @@ class MachineCollectionFireWithTransactionsTest < Test::Unit::TestCase
     assert_equal 'active', @object.alarm_state
   end
   
+  def test_should_run_failure_callbacks_if_not_successful
+    @object.allow_save = false
+    
+    @machines[:state].after_failure {@state_failure_run = true}
+    @machines[:alarm_state].after_failure {@alarm_state_failure_run = true}
+    
+    assert !@machines.fire_events(@object, :ignite, :disable_alarm)
+    assert @state_failure_run
+    assert @alarm_state_failure_run
+  end
+  
   def teardown
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end
@@ -243,6 +223,8 @@ end
 class MachineCollectionFireWithValidationsTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
       def invalidate(object, attribute, message, values = [])
         (object.errors ||= []) << generate_message(message, values)
       end
@@ -288,6 +270,18 @@ class MachineCollectionFireWithValidationsTest < Test::Unit::TestCase
     assert_equal ['cannot transition via "ignite"', 'cannot transition via "disable"'], @object.errors
   end
   
+  def test_should_run_failure_callbacks_if_no_transitions_exist
+    @object.state = 'idling'
+    @object.alarm_state = 'off'
+    
+    @machines[:state].after_failure {@state_failure_run = true}
+    @machines[:alarm_state].after_failure {@alarm_state_failure_run = true}
+    
+    assert !@machines.fire_events(@object, :ignite, :disable_alarm)
+    assert @state_failure_run
+    assert @alarm_state_failure_run
+  end
+  
   def teardown
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end