state_machine 0.7.6 → 0.8.0

data/test/unit/integrations/sequel_test.rb

@@ -28,6 +28,7 @@ begin
             def self.name; 'SequelTest::Foo'; end
           end
           model.plugin(:validation_class_methods) if model.respond_to?(:plugin)
+          model.plugin(:hook_class_methods) if model.respond_to?(:plugin)
           model.class_eval(&block) if block_given?
           model
         end
@@ -184,15 +185,136 @@ begin
       end
     end
     
-    class MachineWithInitialStateTest < BaseTestCase
+    class MachineWithStaticInitialStateTest < BaseTestCase
       def setup
-        @model = new_model
-        @machine = StateMachine::Machine.new(@model, :initial => 'parked')
-        @record = @model.new
+        @model = new_model do
+          attr_accessor :value
+        end
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
       end
       
       def test_should_set_initial_state_on_created_object
-        assert_equal 'parked', @record.state
+        record = @model.new
+        assert_equal 'parked', record.state
+      end
+      
+      def test_should_still_set_attributes
+        record = @model.new(:value => 1)
+        assert_equal 1, record.value
+      end
+      
+      def test_should_still_allow_initialize_blocks
+        block_args = nil
+        record = @model.new do |*args|
+          block_args = args
+        end
+        
+        assert_equal [record], block_args
+      end
+      
+      def test_should_not_have_any_changed_columns
+        record = @model.new
+        assert record.changed_columns.empty?
+      end
+      
+      def test_should_set_attributes_prior_to_after_initialize_hook
+        state = nil
+        @model.class_eval do
+          define_method(:after_initialize) do
+            state = self.state
+          end
+        end
+        @model.new
+        assert_equal 'parked', state
+      end
+      
+      def test_should_set_initial_state_before_setting_attributes
+        @model.class_eval do
+          attr_accessor :state_during_setter
+          
+          define_method(:value=) do |value|
+            self.state_during_setter = state
+          end
+        end
+        
+        record = @model.new(:value => 1)
+        assert_equal 'parked', record.state_during_setter
+      end
+      
+      def test_should_not_set_initial_state_after_already_initialized
+        record = @model.new(:value => 1)
+        assert_equal 'parked', record.state
+        
+        record.state = 'idling'
+        record.set({})
+        assert_equal 'idling', record.state
+      end
+    end
+    
+    class MachineWithDynamicInitialStateTest < BaseTestCase
+      def setup
+        @model = new_model do
+          attr_accessor :value
+        end
+        @machine = StateMachine::Machine.new(@model, :initial => lambda {|object| :parked})
+        @machine.state :parked
+      end
+      
+      def test_should_set_initial_state_on_created_object
+        record = @model.new
+        assert_equal 'parked', record.state
+      end
+      
+      def test_should_still_set_attributes
+        record = @model.new(:value => 1)
+        assert_equal 1, record.value
+      end
+      
+      def test_should_still_allow_initialize_blocks
+        block_args = nil
+        record = @model.new do |*args|
+          block_args = args
+        end
+        
+        assert_equal [record], block_args
+      end
+      
+      def test_should_not_have_any_changed_columns
+        record = @model.new
+        assert record.changed_columns.empty?
+      end
+      
+      def test_should_set_attributes_prior_to_after_initialize_hook
+        state = nil
+        @model.class_eval do
+          define_method(:after_initialize) do
+            state = self.state
+          end
+        end
+        @model.new
+        assert_equal 'parked', state
+      end
+      
+      def test_should_set_initial_state_after_setting_attributes
+        @model.class_eval do
+          attr_accessor :state_during_setter
+          
+          define_method(:value=) do |value|
+            self.state_during_setter = state || 'nil'
+          end
+        end
+        
+        record = @model.new(:value => 1)
+        assert_equal 'nil', record.state_during_setter
+      end
+      
+      def test_should_not_set_initial_state_after_already_initialized
+        record = @model.new(:value => 1)
+        assert_equal 'parked', record.state
+        
+        record.state = 'idling'
+        record.set({})
+        assert_equal 'idling', record.state
       end
     end
     
@@ -279,20 +401,24 @@ begin
     
     class MachineWithCustomAttributeTest < BaseTestCase
       def setup
-        @model = new_model
-        @machine = StateMachine::Machine.new(@model, :status, :attribute => :state)
+        @model = new_model do
+          alias_method :vehicle_status, :state
+          alias_method :vehicle_status=, :state=
+        end
+        
+        @machine = StateMachine::Machine.new(@model, :status, :attribute => :vehicle_status)
         @machine.state :parked
         
         @record = @model.new
       end
       
       def test_should_add_validation_errors_to_custom_attribute
-        @record.state = 'invalid'
+        @record.vehicle_status = 'invalid'
         
         assert !@record.valid?
-        assert_equal ['is invalid'], @record.errors.on(:state)
+        assert_equal ['is invalid'], @record.errors.on(:vehicle_status)
         
-        @record.state = 'parked'
+        @record.vehicle_status = 'parked'
         assert @record.valid?
       end
     end
@@ -389,6 +515,46 @@ begin
       end
     end
     
+    class MachineWithLoopbackTest < BaseTestCase
+      def setup
+        changed_columns = nil
+        
+        @model = new_model do
+          # Simulate timestamps plugin
+          define_method(:before_update) do
+            changed_columns = self.changed_columns.dup
+            
+            super()
+            self.updated_at = Time.now if changed_columns.any?
+          end
+        end
+        
+        DB.alter_table :foo do
+          add_column :updated_at, :datetime
+        end
+        @model.class_eval { get_db_schema(true) }
+        
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.event :park
+        
+        @record = @model.create(:updated_at => Time.now - 1)
+        @timestamp = @record.updated_at
+        
+        @transition = StateMachine::Transition.new(@record, @machine, :park, :parked, :parked)
+        @transition.perform
+        
+        @changed_columns = changed_columns
+      end
+      
+      def test_should_include_state_in_changed_columns
+        assert_equal [:state], @changed_columns
+      end
+      
+      def test_should_update_record
+        assert_not_equal @timestamp, @record.updated_at
+      end
+    end
+    
     class MachineWithValidationsTest < BaseTestCase
       def setup
         @model = new_model
@@ -490,6 +656,109 @@ begin
         @record.valid?
         assert !ran_callback
       end
+      
+      def test_should_not_run_after_callbacks_with_failures_disabled_if_validation_fails
+        @model.class_eval do
+          attr_accessor :seatbelt
+          validates_presence_of :seatbelt
+        end
+        
+        ran_callback = false
+        @machine.after_transition { ran_callback = true }
+        
+        @record.valid?
+        assert !ran_callback
+      end
+      
+      def test_should_run_after_callbacks_with_failures_enabled_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 }
+        
+        @record.valid?
+        assert ran_callback
+      end
+    end
+    
+    class MachineWithEventAttributesOnSaveTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::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 !@record.save
+      end
+      
+      def test_should_fail_if_event_has_no_transition
+        @record.state = 'idling'
+        assert !@record.save
+      end
+      
+      def test_should_be_successful_if_event_has_transition
+        assert @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_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| false}
+        
+        ran_callback = false
+        @machine.after_transition { ran_callback = true }
+        
+        @record.save
+        assert !ran_callback
+      end
+      
+      def test_should_run_after_callbacks_with_failures_enabled_if_fails
+        @model.before_create {|record| false}
+        
+        ran_callback = false
+        @machine.after_transition(:include_failures => true) { ran_callback = true }
+        
+        @record.save
+        assert ran_callback
+      end
     end
     
     class MachineWithEventAttributesOnCustomActionTest < BaseTestCase

data/test/unit/machine_collection_test.rb

@@ -14,37 +14,60 @@ class MachineCollectionStateInitializationTest < Test::Unit::TestCase
   def setup
     @machines = StateMachine::MachineCollection.new
     
-    @klass = Class.new do
-      def initialize(attributes = {})
-        attributes.each do |attribute, value|
-          self.send("#{attribute}=", value)
-        end
-        
-        super()
-      end
-    end
+    @klass = Class.new
     
     @machines[:state] = StateMachine::Machine.new(@klass, :state, :initial => :parked)
-    @machines[:alarm_state] = StateMachine::Machine.new(@klass, :alarm_state, :initial => :active)
+    @machines[:alarm_state] = StateMachine::Machine.new(@klass, :alarm_state, :initial => lambda {|object| :active})
     @machines[:alarm_state].state :active, :value => lambda {'active'}
+    
+    # Prevent the auto-initialization hook from firing
+    @klass.class_eval do
+      def initialize
+      end
+    end
+    
+    @object = @klass.new
+    @object.state = nil
+    @object.alarm_state = nil
   end
   
   def test_should_set_states_if_nil
-    object = @klass.new
-    assert_equal 'parked', object.state
-    assert_equal 'active', object.alarm_state
+    @machines.initialize_states(@object)
+    
+    assert_equal 'parked', @object.state
+    assert_equal 'active', @object.alarm_state
   end
   
   def test_should_set_states_if_empty
-    object = @klass.new(:state => '', :alarm_state => '')
-    assert_equal 'parked', object.state
-    assert_equal 'active', object.alarm_state
+    @object.state = ''
+    @object.alarm_state = ''
+    @machines.initialize_states(@object)
+    
+    assert_equal 'parked', @object.state
+    assert_equal 'active', @object.alarm_state
   end
   
   def test_should_not_set_states_if_not_empty
-    object = @klass.new(:state => 'idling', :alarm_state => 'off')
-    assert_equal 'idling', object.state
-    assert_equal 'off', object.alarm_state
+    @object.state = 'idling'
+    @object.alarm_state = 'off'
+    @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
 end
 

data/test/unit/machine_test.rb

@@ -207,6 +207,10 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(@klass, :initial => :parked)
   end
   
+  def test_should_not_have_dynamic_initial_state
+    assert !@machine.dynamic_initial_state?
+  end
+  
   def test_should_have_an_initial_state
     object = @klass.new
     assert_equal 'parked', @machine.initial_state(object).value
@@ -231,6 +235,20 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
     assert_equal 'idling', object.state
   end
   
+  def test_should_set_initial_state_prior_to_initialization
+    base = Class.new do
+      attr_accessor :state_on_init
+      
+      def initialize
+        self.state_on_init = state
+      end
+    end
+    klass = Class.new(base)
+    machine = StateMachine::Machine.new(klass, :initial => :parked)
+    
+    assert_equal 'parked', klass.new.state_on_init
+  end
+  
   def test_should_be_included_in_known_states
     assert_equal [:parked], @machine.states.keys
   end
@@ -246,6 +264,10 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
     @object = @klass.new
   end
   
+  def test_should_have_dynamic_initial_state
+    assert @machine.dynamic_initial_state?
+  end
+  
   def test_should_use_the_record_for_determining_the_initial_state
     @object.initial_state = :parked
     assert_equal :parked, @machine.initial_state(@object).name
@@ -258,6 +280,21 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
     assert_equal 'default', @object.state
   end
   
+  def test_should_set_initial_state_after_initialization
+    base = Class.new do
+      attr_accessor :state_on_init
+      
+      def initialize
+        self.state_on_init = state
+      end
+    end
+    klass = Class.new(base)
+    machine = StateMachine::Machine.new(klass, :initial => lambda {|object| :parked})
+    machine.state :parked
+    
+    assert_nil klass.new.state_on_init
+  end
+  
   def test_should_not_be_included_in_known_states
     assert_equal [:parked, :idling, :default], @machine.states.map {|state| state.name}
   end
@@ -1375,6 +1412,24 @@ class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
     assert_equal %w(before after), @object.callbacks
   end
   
+  def test_should_allow_multiple_callbacks
+    @machine.before_transition lambda {|object| object.callbacks << 'before1'}, lambda {|object| object.callbacks << 'before2'}
+    @machine.after_transition lambda {|object| object.callbacks << 'after1'}, lambda {|object| object.callbacks << 'after2'}
+    
+    @event.fire(@object)
+    assert_equal %w(before1 before2 after1 after2), @object.callbacks
+  end
+  
+  def test_should_allow_multiple_callbacks_with_requirements
+    @machine.before_transition lambda {|object| object.callbacks << 'before_parked1'}, lambda {|object| object.callbacks << 'before_parked2'}, :from => :parked
+    @machine.before_transition lambda {|object| object.callbacks << 'before_idling1'}, lambda {|object| object.callbacks << 'before_idling2'}, :from => :idling
+    @machine.after_transition lambda {|object| object.callbacks << 'after_parked1'}, lambda {|object| object.callbacks << 'after_parked2'}, :from => :parked
+    @machine.after_transition lambda {|object| object.callbacks << 'after_idling1'}, lambda {|object| object.callbacks << 'after_idling2'}, :from => :idling
+    
+    @event.fire(@object)
+    assert_equal %w(before_parked1 before_parked2 after_parked1 after_parked2), @object.callbacks
+  end
+  
   def test_should_support_from_requirement
     @machine.before_transition :from => :parked, :do => lambda {|object| object.callbacks << :parked}
     @machine.before_transition :from => :idling, :do => lambda {|object| object.callbacks << :idling}