state_machine 1.0.3 → 1.1.0

data/test/unit/invalid_transition_test.rb

@@ -75,3 +75,41 @@ class InvalidTransitionWithNamespaceTest < Test::Unit::TestCase
     assert_equal :alarm_active, @invalid_transition.qualified_from_name
   end
 end
+
+class InvalidTransitionWithIntegrationTest < Test::Unit::TestCase
+  def setup
+    StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
+      def errors_for(object)
+        object.errors
+      end
+    end)
+    
+    @klass = Class.new do
+      attr_accessor :errors
+    end
+    @machine = StateMachine::Machine.new(@klass, :integration => :custom)
+    @machine.state :parked
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_generate_a_message_without_reasons_if_empty
+    @object.errors = ''
+    invalid_transition = StateMachine::InvalidTransition.new(@object, @machine, :ignite)
+    assert_equal 'Cannot transition state via :ignite from :parked', invalid_transition.message
+  end
+  
+  def test_should_generate_a_message_with_error_reasons_if_errors_found
+    @object.errors = 'Id is invalid, Name is invalid'
+    invalid_transition = StateMachine::InvalidTransition.new(@object, @machine, :ignite)
+    assert_equal 'Cannot transition state via :ignite from :parked (Reason(s): Id is invalid, Name is invalid)', invalid_transition.message
+  end
+  
+  def teardown
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end

data/test/unit/machine_test.rb

@@ -125,6 +125,10 @@ class MachineByDefaultTest < Test::Unit::TestCase
     assert @object.respond_to?(:state_paths)
   end
   
+  def test_should_define_an_event_runner_for_the_attribute
+    assert @object.respond_to?(:fire_state_event)
+  end
+  
   def test_should_not_define_an_event_attribute_reader
     assert !@object.respond_to?(:state_event)
   end
@@ -222,6 +226,10 @@ class MachineWithCustomNameTest < Test::Unit::TestCase
     assert @object.respond_to?(:status_transitions)
   end
   
+  def test_should_define_an_event_runner_for_the_attribute
+    assert @object.respond_to?(:fire_status_event)
+  end
+  
   def test_should_define_a_human_attribute_name_reader_for_the_attribute
     assert @klass.respond_to?(:human_status_name)
   end
@@ -492,6 +500,10 @@ class MachineWithoutIntegrationTest < Test::Unit::TestCase
   def test_reset_should_do_nothing
     assert_nil @machine.reset(@object)
   end
+  
+  def test_errors_for_should_be_empty
+    assert_equal '', @machine.errors_for(@object)
+  end
 end
 
 class MachineWithCustomIntegrationTest < Test::Unit::TestCase
@@ -1500,6 +1512,10 @@ class MachineWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
       def state_paths
         [[{:parked => :idling}]]
       end
+      
+      def fire_state_event
+        true
+      end
     end
     @klass = Class.new(@superclass)
     
@@ -1578,10 +1594,15 @@ class MachineWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
     assert_equal [[{:parked => :idling}]], @object.state_paths
   end
   
+  def test_should_not_redefine_event_runner
+    assert_equal true, @object.fire_state_event
+  end
+  
   def test_should_output_warning
     expected = [
       'Instance method "state_events"',
       'Instance method "state_transitions"',
+      'Instance method "fire_state_event"',
       'Instance method "state_paths"',
       'Class method "human_state_name"',
       'Class method "human_state_event_name"',
@@ -1665,6 +1686,10 @@ class MachineWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
       def state_paths
         [[{:parked => :idling}]]
       end
+      
+      def fire_state_event
+        true
+      end
     end
     
     StateMachine::Integrations.const_set('Custom', Module.new do
@@ -1742,6 +1767,10 @@ class MachineWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
     assert_equal [[{:parked => :idling}]], @object.state_paths
   end
   
+  def test_should_not_redefine_event_runner
+    assert_equal true, @object.fire_state_event
+  end
+  
   def test_should_allow_super_chaining
     @klass.class_eval do
       def self.with_state(*states)
@@ -1801,6 +1830,10 @@ class MachineWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
       def state_paths
         super
       end
+      
+      def fire_state_event(event)
+        super
+      end
     end
     
     assert_equal [], @klass.with_state
@@ -1820,6 +1853,7 @@ class MachineWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
     assert_equal [], @object.state_events
     assert_equal [], @object.state_transitions
     assert_equal [], @object.state_paths
+    assert_equal false, @object.fire_state_event(:ignite)
   end
   
   def test_should_not_output_warning
@@ -2954,6 +2988,10 @@ class MachineWithCustomAttributeTest < Test::Unit::TestCase
     assert @object.respond_to?(:state_paths)
   end
   
+  def test_should_define_an_event_runner_for_the_attribute
+    assert @object.respond_to?(:fire_state_event)
+  end
+  
   def test_should_define_a_human_attribute_name_reader
     assert @klass.respond_to?(:human_state_name)
   end

data/test/unit/state_context_test.rb

@@ -41,11 +41,6 @@ class StateContextTransitionTest < Test::Unit::TestCase
     assert_equal 'Invalid key(s): except_to', exception.message
   end
   
-  def test_should_not_allow_from
-    exception = assert_raise(ArgumentError) { @state_context.transition(:from => :idling) }
-    assert_equal 'Invalid key(s): from', exception.message
-  end
-  
   def test_should_not_allow_except_from
     exception = assert_raise(ArgumentError) { @state_context.transition(:except_from => :idling) }
     assert_equal 'Invalid key(s): except_from', exception.message
@@ -63,15 +58,40 @@ class StateContextTransitionTest < Test::Unit::TestCase
   
   def test_should_require_on_event
     exception = assert_raise(ArgumentError) { @state_context.transition(:to => :idling) }
-    assert_equal 'Must specify :to state and :on event', exception.message
+    assert_equal 'Must specify :on event', exception.message
   end
   
-  def test_should_require_to_state
+  def test_should_not_allow_missing_from_and_to
     exception = assert_raise(ArgumentError) { @state_context.transition(:on => :ignite) }
-    assert_equal 'Must specify :to state and :on event', exception.message
+    assert_equal 'Must specify either :to or :from state', exception.message
+  end
+  
+  def test_should_not_allow_from_and_to
+    exception = assert_raise(ArgumentError) { @state_context.transition(:on => :ignite, :from => :parked, :to => :idling) }
+    assert_equal 'Must specify either :to or :from state', exception.message
+  end
+  
+  def test_should_allow_to_state_if_missing_from_state
+    assert_nothing_raised { @state_context.transition(:on => :park, :from => :parked) }
+  end
+  
+  def test_should_allow_from_state_if_missing_to_state
+    assert_nothing_raised { @state_context.transition(:on => :ignite, :to => :idling) }
+  end
+  
+  def test_should_automatically_set_to_option_with_from_state
+    branch = @state_context.transition(:from => :idling, :on => :park)
+    assert_instance_of StateMachine::Branch, branch
+    
+    state_requirements = branch.state_requirements
+    assert_equal 1, state_requirements.length
+    
+    from_requirement = state_requirements[0][:to]
+    assert_instance_of StateMachine::WhitelistMatcher, from_requirement
+    assert_equal [:parked], from_requirement.values
   end
   
-  def test_should_automatically_set_from_option
+  def test_should_automatically_set_from_option_with_to_state
     branch = @state_context.transition(:to => :idling, :on => :ignite)
     assert_instance_of StateMachine::Branch, branch
     

data/test/unit/state_test.rb

@@ -779,12 +779,32 @@ class StateWithInvalidMethodCallTest < Test::Unit::TestCase
   end
 end
 
-class StateWithValidMethodCallTest < Test::Unit::TestCase
+class StateWithValidMethodCallForDifferentStateTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
     @ancestors = @klass.ancestors
     @machine.states << @state = StateMachine::State.new(@machine, :idling)
+    @state.context do
+      def speed
+        0
+      end
+    end
+    
+    @object = @klass.new
+  end
+  
+  def test_should_call_method_missing_arg
+    assert_equal 1, @state.call(@object, :speed, lambda {1})
+  end
+end
+
+class StateWithValidMethodCallForCurrentStaeTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :idling)
+    @ancestors = @klass.ancestors
+    @state = @machine.state(:idling)
     @state.context do
       def speed(arg = nil)
         block_given? ? [arg, yield] : arg

data/test/unit/transition_collection_test.rb

@@ -1116,7 +1116,6 @@ class TransitionCollectionWithSkippedAfterCallbacksTest < Test::Unit::TestCase
     @machine.state :idling
     @machine.event :ignite
     @machine.after_transition {@ran_after = true}
-    @machine.around_transition {|block| @ran_around_before = true; block.call; @ran_around_after = true}
     
     @object = @klass.new
     
@@ -1134,25 +1133,70 @@ class TransitionCollectionWithSkippedAfterCallbacksTest < Test::Unit::TestCase
     assert !@ran_after
   end
   
-  def test_should_not_run_around_callbacks_after_yield
-    assert !@ran_around_after
-  end
-  
   def test_should_run_after_callbacks_on_subsequent_perform
     StateMachine::TransitionCollection.new([@transition]).perform
     assert @ran_after
   end
-  
-  def test_should_run_around_callbacks_after_yield_on_subsequent_perform
-    StateMachine::TransitionCollection.new([@transition]).perform
-    assert @ran_around_after
+end
+
+if RUBY_PLATFORM != 'java'
+  class TransitionCollectionWithSkippedAfterCallbacksAndAroundCallbacksTest < Test::Unit::TestCase
+    def setup
+      @klass = Class.new
+      
+      @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+      @machine.state :idling
+      @machine.event :ignite
+      @machine.around_transition {|block| @ran_around_before = true; block.call; @ran_around_after = true}
+      
+      @object = @klass.new
+      
+      @transitions = StateMachine::TransitionCollection.new([
+        @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+      ], :after => false)
+      @result = @transitions.perform
+    end
+    
+    def test_should_succeed
+      assert_equal true, @result
+    end
+    
+    def test_should_not_run_around_callbacks_after_yield
+      assert !@ran_around_after
+    end
+    
+    def test_should_run_around_callbacks_after_yield_on_subsequent_perform
+      StateMachine::TransitionCollection.new([@transition]).perform
+      assert @ran_around_after
+    end
+    
+    def test_should_not_rerun_around_callbacks_before_yield_on_subsequent_perform
+      @ran_around_before = false
+      StateMachine::TransitionCollection.new([@transition]).perform
+      
+      assert !@ran_around_before
+    end
   end
-  
-  def test_should_not_rerun_around_callbacks_before_yield_on_subsequent_perform
-    @ran_around_before = false
-    StateMachine::TransitionCollection.new([@transition]).perform
+else
+  class TransitionCollectionWithSkippedAfterCallbacksAndAroundCallbacksTest < Test::Unit::TestCase
+    def setup
+      @klass = Class.new
+      
+      @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+      @machine.state :idling
+      @machine.event :ignite
+      @machine.around_transition {|block| @ran_around_before = true; block.call; @ran_around_after = true}
+      
+      @object = @klass.new
+      
+      @transitions = StateMachine::TransitionCollection.new([
+        @transition = StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)
+      ], :after => false)
+    end
     
-    assert !@ran_around_before
+    def test_should_raise_exception
+      assert_raise(ArgumentError) { @transitions.perform }
+    end
   end
 end
 
@@ -2073,19 +2117,21 @@ class AttributeTransitionCollectionMarshallingTest < Test::Unit::TestCase
     end
   end
   
-  def test_should_marshal_during_around_callbacks_before_yield
-    @machine.around_transition {|object, transition, block| Marshal.dump(object); block.call}
-    assert_nothing_raised do
-      transitions(:after => false).perform { true }
-      transitions.perform { true }
+  if RUBY_PLATFORM != 'java'
+    def test_should_marshal_during_around_callbacks_before_yield
+      @machine.around_transition {|object, transition, block| Marshal.dump(object); block.call}
+      assert_nothing_raised do
+        transitions(:after => false).perform { true }
+        transitions.perform { true }
+      end
     end
-  end
-  
-  def test_should_marshal_during_around_callbacks_after_yield
-    @machine.around_transition {|object, transition, block| block.call; Marshal.dump(object)}
-    assert_nothing_raised do
-      transitions(:after => false).perform { true }
-      transitions.perform { true }
+    
+    def test_should_marshal_during_around_callbacks_after_yield
+      @machine.around_transition {|object, transition, block| block.call; Marshal.dump(object)}
+      assert_nothing_raised do
+        transitions(:after => false).perform { true }
+        transitions.perform { true }
+      end
     end
   end
   

data/test/unit/transition_test.rb

@@ -1209,13 +1209,6 @@ class TransitionWithAfterCallbacksSkippedTest < Test::Unit::TestCase
     assert @run
   end
   
-  def test_should_run_around_callbacks_before_yield
-    @machine.around_transition {|block| @run = true; block.call}
-    
-    assert_equal true, @transition.run_callbacks(:after => false)
-    assert @run
-  end
-  
   def test_should_not_run_after_callbacks
     @machine.after_transition {@run = true}
     
@@ -1223,82 +1216,100 @@ class TransitionWithAfterCallbacksSkippedTest < Test::Unit::TestCase
     assert !@run
   end
   
-  def test_should_not_run_around_callbacks_after_yield
-    @machine.around_transition {|block| block.call; @run = true}
-    
-    assert_equal true, @transition.run_callbacks(:after => false)
-    assert !@run
-  end
-  
-  def test_should_continue_around_transition_execution_on_second_call
-    @callbacks = []
-    @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
-    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
-    @machine.after_transition {@callbacks << :after}
-    
-    assert_equal true, @transition.run_callbacks(:after => false)
-    assert_equal [:before_around_1, :before_around_2], @callbacks
-    
-    assert_equal true, @transition.run_callbacks
-    assert_equal [:before_around_1, :before_around_2, :after_around_2, :after_around_1, :after], @callbacks
-  end
-  
-  def test_should_not_run_further_callbacks_if_halted_during_continue_around_transition
-    @callbacks = []
-    @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
-    @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2; throw :halt}
-    @machine.after_transition {@callbacks << :after}
-    
-    assert_equal true, @transition.run_callbacks(:after => false)
-    assert_equal [:before_around_1, :before_around_2], @callbacks
-    
-    assert_equal true, @transition.run_callbacks
-    assert_equal [:before_around_1, :before_around_2, :after_around_2], @callbacks
-  end
-  
-  def test_should_not_be_able_to_continue_twice
-    @count = 0
-    @machine.around_transition {|block| block.call; @count += 1}
-    @machine.after_transition {@count += 1}
+  if RUBY_PLATFORM != 'java'
+    def test_should_run_around_callbacks_before_yield
+      @machine.around_transition {|block| @run = true; block.call}
+      
+      assert_equal true, @transition.run_callbacks(:after => false)
+      assert @run
+    end
     
-    @transition.run_callbacks(:after => false)
+    def test_should_not_run_around_callbacks_after_yield
+      @machine.around_transition {|block| block.call; @run = true}
+      
+      assert_equal true, @transition.run_callbacks(:after => false)
+      assert !@run
+    end
     
-    2.times do
+    def test_should_continue_around_transition_execution_on_second_call
+      @callbacks = []
+      @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
+      @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
+      @machine.after_transition {@callbacks << :after}
+      
+      assert_equal true, @transition.run_callbacks(:after => false)
+      assert_equal [:before_around_1, :before_around_2], @callbacks
+      
       assert_equal true, @transition.run_callbacks
-      assert_equal 2, @count
+      assert_equal [:before_around_1, :before_around_2, :after_around_2, :after_around_1, :after], @callbacks
     end
-  end
-  
-  def test_should_not_be_able_to_continue_again_after_halted
-    @count = 0
-    @machine.around_transition {|block| block.call; @count += 1; throw :halt}
-    @machine.after_transition {@count += 1}
-    
-    @transition.run_callbacks(:after => false)
     
-    2.times do
+    def test_should_not_run_further_callbacks_if_halted_during_continue_around_transition
+      @callbacks = []
+      @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
+      @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2; throw :halt}
+      @machine.after_transition {@callbacks << :after}
+      
+      assert_equal true, @transition.run_callbacks(:after => false)
+      assert_equal [:before_around_1, :before_around_2], @callbacks
+      
       assert_equal true, @transition.run_callbacks
-      assert_equal 1, @count
+      assert_equal [:before_around_1, :before_around_2, :after_around_2], @callbacks
     end
-  end
-  
-  def test_should_have_access_to_result_after_continued
-    @machine.around_transition {|block| @around_before_result = @transition.result; block.call; @around_after_result = @transition.result}
-    @machine.after_transition {@after_result = @transition.result}
     
-    @transition.run_callbacks(:after => false)
-    @transition.run_callbacks {{:result => 1}}
+    def test_should_not_be_able_to_continue_twice
+      @count = 0
+      @machine.around_transition {|block| block.call; @count += 1}
+      @machine.after_transition {@count += 1}
+      
+      @transition.run_callbacks(:after => false)
+      
+      2.times do
+        assert_equal true, @transition.run_callbacks
+        assert_equal 2, @count
+      end
+    end
     
-    assert_nil @around_before_result
-    assert_equal 1, @around_after_result
-    assert_equal 1, @after_result
-  end
-  
-  def test_should_raise_exceptions_during_around_callbacks_after_yield_in_second_execution
-    @machine.around_transition {|block| block.call; raise ArgumentError}
+    def test_should_not_be_able_to_continue_again_after_halted
+      @count = 0
+      @machine.around_transition {|block| block.call; @count += 1; throw :halt}
+      @machine.after_transition {@count += 1}
+      
+      @transition.run_callbacks(:after => false)
+      
+      2.times do
+        assert_equal true, @transition.run_callbacks
+        assert_equal 1, @count
+      end
+    end
     
-    assert_nothing_raised { @transition.run_callbacks(:after => false) }
-    assert_raise(ArgumentError) { @transition.run_callbacks }
+    def test_should_have_access_to_result_after_continued
+      @machine.around_transition {|block| @around_before_result = @transition.result; block.call; @around_after_result = @transition.result}
+      @machine.after_transition {@after_result = @transition.result}
+      
+      @transition.run_callbacks(:after => false)
+      @transition.run_callbacks {{:result => 1}}
+      
+      assert_nil @around_before_result
+      assert_equal 1, @around_after_result
+      assert_equal 1, @after_result
+    end
+    
+    def test_should_raise_exceptions_during_around_callbacks_after_yield_in_second_execution
+      @machine.around_transition {|block| block.call; raise ArgumentError}
+      
+      assert_nothing_raised { @transition.run_callbacks(:after => false) }
+      assert_raise(ArgumentError) { @transition.run_callbacks }
+    end
+  else
+    def test_should_raise_exception_on_second_call
+      @callbacks = []
+      @machine.around_transition {|block| @callbacks << :before_around_1; block.call; @callbacks << :after_around_1}
+      @machine.around_transition {|block| @callbacks << :before_around_2; block.call; @callbacks << :after_around_2}
+      @machine.after_transition {@callbacks << :after}
+      
+      assert_raise(ArgumentError) { @transition.run_callbacks(:after => false) }
+    end
   end
 end