state_machine 0.9.4 → 0.10.0

data/test/unit/machine_test.rb

@@ -43,6 +43,10 @@ class MachineByDefaultTest < Test::Unit::TestCase
     assert @machine.callbacks[:after].empty?
   end
   
+  def test_should_not_have_any_failure_callbacks
+    assert @machine.callbacks[:failure].empty?
+  end
+  
   def test_should_not_have_an_action
     assert_nil @machine.action
   end
@@ -69,6 +73,10 @@ class MachineByDefaultTest < Test::Unit::TestCase
     assert_equal 'cannot transition via "park"', @machine.generate_message(:invalid_transition, [[:event, :park]])
   end
   
+  def test_should_not_be_extended_by_the_base_integration
+    assert !(class << @machine; ancestors; end).include?(StateMachine::Integrations::Base)
+  end
+  
   def test_should_not_be_extended_by_the_active_model_integration
     assert !(class << @machine; ancestors; end).include?(StateMachine::Integrations::ActiveModel)
   end
@@ -113,6 +121,10 @@ class MachineByDefaultTest < Test::Unit::TestCase
     assert @object.respond_to?(:state_transitions)
   end
   
+  def test_should_define_a_path_reader_for_the_attribute
+    assert @object.respond_to?(:state_paths)
+  end
+  
   def test_should_not_define_an_event_attribute_reader
     assert !@object.respond_to?(:state_event)
   end
@@ -219,6 +231,37 @@ class MachineWithCustomNameTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithoutInitializationTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      def initialize(attributes = {})
+        attributes.each {|attr, value| send("#{attr}=", value)}
+        super()
+      end
+    end
+    
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked, :initialize => false)
+  end
+  
+  def test_should_not_have_an_initial_state
+    object = @klass.new
+    assert_nil object.state
+  end
+  
+  def test_should_still_allow_manual_initialization
+    @klass.class_eval do
+      def initialize(attributes = {})
+        attributes.each {|attr, value| send("#{attr}=", value)}
+        super()
+        initialize_state_machines
+      end
+    end
+    
+    object = @klass.new
+    assert_equal 'parked', object.state
+  end
+end
+
 class MachineWithStaticInitialStateTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
@@ -337,6 +380,42 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
   end
 end
 
+class MachineStateInitializationTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked)
+    
+    # Prevent the auto-initialization hook from firing
+    @klass.class_eval do
+      def initialize
+      end
+    end
+    
+    @object = @klass.new
+    @object.state = nil
+  end
+  
+  def test_should_set_states_if_nil
+    @machine.initialize_state(@object)
+    
+    assert_equal 'parked', @object.state
+  end
+  
+  def test_should_set_states_if_empty
+    @object.state = ''
+    @machine.initialize_state(@object)
+    
+    assert_equal 'parked', @object.state
+  end
+  
+  def test_should_not_set_states_if_not_empty
+    @object.state = 'idling'
+    @machine.initialize_state(@object)
+    
+    assert_equal 'idling', @object.state
+  end
+end
+
 class MachineWithCustomActionTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new, :action => :save)
@@ -350,7 +429,8 @@ end
 class MachineWithNilActionTest < Test::Unit::TestCase
   def setup
     integration = Module.new do
-      class << self; attr_reader :defaults; end
+      include StateMachine::Integrations::Base
+      
       @defaults = {:action => :save}
     end
     StateMachine::Integrations.const_set('Custom', integration)
@@ -394,6 +474,8 @@ end
 class MachineWithCustomIntegrationTest < Test::Unit::TestCase
   def setup
     integration = Module.new do
+      include StateMachine::Integrations::Base
+      
       def self.matches?(klass)
         true
       end
@@ -430,7 +512,8 @@ end
 class MachineWithIntegrationTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do  
-      class << self; attr_reader :defaults; end
+      include StateMachine::Integrations::Base
+      
       @defaults = {:action => :save, :use_transactions => false}
           
       attr_reader :initialized, :with_scopes, :without_scopes, :ran_transaction
@@ -520,8 +603,8 @@ class MachineWithActionUndefinedTest < Test::Unit::TestCase
     assert !@object.respond_to?(:save)
   end
   
-  def test_should_not_mark_action_helper_as_defined
-    assert !@machine.action_helper_defined?
+  def test_should_not_mark_action_hook_as_defined
+    assert !@machine.action_hook?
   end
 end
 
@@ -556,8 +639,8 @@ class MachineWithActionDefinedInClassTest < Test::Unit::TestCase
     assert !@klass.ancestors.any? {|ancestor| ancestor != @klass && ancestor.method_defined?(:save)}
   end
   
-  def test_should_not_mark_action_helper_as_defined
-    assert !@machine.action_helper_defined?
+  def test_should_not_mark_action_hook_as_defined
+    assert !@machine.action_hook?
   end
 end
 
@@ -600,8 +683,8 @@ class MachineWithActionDefinedInIncludedModuleTest < Test::Unit::TestCase
     assert @klass.public_method_defined?(:save)
   end
   
-  def test_should_mark_action_helper_as_defined
-    assert @machine.action_helper_defined?
+  def test_should_mark_action_hook_as_defined
+    assert @machine.action_hook?
   end
 end
 
@@ -641,8 +724,8 @@ class MachineWithActionDefinedInSuperclassTest < Test::Unit::TestCase
     assert @klass.public_method_defined?(:save)
   end
   
-  def test_should_mark_action_helper_as_defined
-    assert @machine.action_helper_defined?
+  def test_should_mark_action_hook_as_defined
+    assert @machine.action_hook?
   end
 end
 
@@ -683,8 +766,8 @@ class MachineWithPrivateActionTest < Test::Unit::TestCase
     assert @klass.private_method_defined?(:save)
   end
   
-  def test_should_mark_action_helper_as_defined
-    assert @machine.action_helper_defined?
+  def test_should_mark_action_hook_as_defined
+    assert @machine.action_hook?
   end
 end
 
@@ -705,14 +788,16 @@ class MachineWithActionAlreadyOverriddenTest < Test::Unit::TestCase
     assert_equal 1, @klass.ancestors.select {|ancestor| ![@klass, @superclass].include?(ancestor) && ancestor.method_defined?(:save)}.length
   end
   
-  def test_should_mark_action_helper_as_defined
-    assert @machine.action_helper_defined?
+  def test_should_mark_action_hook_as_defined
+    assert @machine.action_hook?
   end
 end
 
 class MachineWithCustomPluralTest < Test::Unit::TestCase
   def setup
     @integration = Module.new do
+      include StateMachine::Integrations::Base
+      
       class << self; attr_accessor :with_scopes, :without_scopes; end
       @with_scopes = []
       @without_scopes = []
@@ -748,6 +833,8 @@ end
 class MachineWithCustomInvalidationTest < Test::Unit::TestCase
   def setup
     @integration = Module.new do
+      include StateMachine::Integrations::Base
+      
       def invalidate(object, attribute, message, values = [])
         object.error = generate_message(message, values)
       end
@@ -815,6 +902,7 @@ class MachineAfterBeingCopiedTest < Test::Unit::TestCase
     @machine.before_transition(lambda {})
     @machine.after_transition(lambda {})
     @machine.around_transition(lambda {})
+    @machine.after_failure(lambda {})
     
     @copied_machine = @machine.clone
   end
@@ -862,6 +950,10 @@ class MachineAfterBeingCopiedTest < Test::Unit::TestCase
   def test_should_not_have_the_same_after_callbacks
     assert_not_same @copied_machine.callbacks[:after], @machine.callbacks[:after]
   end
+  
+  def test_should_not_have_the_same_failure_callbacks
+    assert_not_same @copied_machine.callbacks[:failure], @machine.callbacks[:failure]
+  end
 end
 
 class MachineAfterChangingOwnerClassTest < Test::Unit::TestCase
@@ -919,6 +1011,23 @@ class MachineAfterChangingInitialState < Test::Unit::TestCase
   end
 end
 
+class MachineWithHelpersTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @object = @klass.new
+  end
+  
+  def test_should_throw_exception_with_invalid_scope
+    assert_raise(RUBY_VERSION < '1.9' ? IndexError : KeyError) { @machine.define_helper(:invalid, :state) {} }
+  end
+  
+  def test_should_throw_exception_if_calling_helper_directly_with_invalid_scope
+    @machine.define_helper(:instance, :state) {}
+    assert_raise(RUBY_VERSION < '1.9' ? IndexError : KeyError) { @machine.call_helper(:invalid, :state, lambda {}, @object) }
+  end
+end
+
 class MachineWithInstanceHelpersTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -933,7 +1042,7 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
       end
     end
     
-    @machine.define_instance_method(:state) {}
+    @machine.define_helper(:instance, :state) {}
     assert_equal 'parked', @object.state
   end
   
@@ -945,7 +1054,7 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
         end
     end
     
-    @machine.define_instance_method(:state) {}
+    @machine.define_helper(:instance, :state) {}
     assert_equal 'parked', @object.send(:state)
   end
   
@@ -957,14 +1066,75 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
         end
     end
     
-    @machine.define_instance_method(:state) {}
+    @machine.define_helper(:instance, :state) {}
     assert_equal 'parked', @object.send(:state)
   end
   
   def test_should_define_nonexistent_methods
-    @machine.define_instance_method(:state) {'parked'}
+    @machine.define_helper(:instance, :state) {'parked'}
     assert_equal 'parked', @object.state
   end
+  
+  def test_should_pass_context_as_arguments
+    helper_args = nil
+    @machine.define_helper(:instance, :state) {|*args| helper_args = args}
+    @object.state
+    assert_equal 3, helper_args.length
+    assert_equal [@machine, @object], helper_args[0..1]
+  end
+  
+  def test_should_pass_method_arguments_through
+    helper_args = nil
+    @machine.define_helper(:instance, :state) {|*args| helper_args = args}
+    @object.state(1, 2, 3)
+    assert_equal 6, helper_args.length
+    assert_equal [@machine, @object], helper_args[0..1]
+    assert_equal [1, 2, 3], helper_args[3..5]
+  end
+  
+  def test_should_allow_super_calls
+    @klass = Class.new
+    @klass.class_eval do
+      include(Module.new {
+        def state
+          'original'
+        end
+      })
+    end
+    @machine = StateMachine::Machine.new(@klass)
+    @object = @klass.new
+    
+    @machine.define_helper(:instance, :state) {|machine, object, _super| _super.call}
+    assert_equal 'original', @object.state
+  end
+  
+  def test_should_allow_rewrite_of_super_args
+    @klass = Class.new
+    @klass.class_eval do
+      include(Module.new {
+        def state(value)
+          value
+        end
+      })
+    end
+    @machine = StateMachine::Machine.new(@klass)
+    @object = @klass.new
+    
+    @machine.define_helper(:instance, :state) {|machine, object, _super, *args| _super.call('override')}
+    assert_equal 'override', @object.state(1)
+  end
+  
+  def test_should_throw_exception_if_calling_helper_directly_with_invalid_method
+    assert_raise(RUBY_VERSION < '1.9' ? IndexError : KeyError) { @machine.call_helper(:instance, :invalid, @object, lambda {}) }
+  end
+  
+  def test_should_be_able_to_call_helper_directly
+    helper_args = nil
+    @machine.define_helper(:instance, :state) {|*args| helper_args = args}
+    
+    @machine.call_helper(:instance, :state, @object, _super = lambda {}, 1, 2, 3)
+    assert_equal [@machine, @object, _super, 1, 2, 3], helper_args
+  end
 end
 
 class MachineWithClassHelpersTest < Test::Unit::TestCase
@@ -980,7 +1150,7 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
       end
     end
     
-    @machine.define_class_method(:states) {}
+    @machine.define_helper(:class, :states) {}
     assert_equal [], @klass.states
   end
   
@@ -992,7 +1162,7 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
         end
     end
     
-    @machine.define_class_method(:states) {}
+    @machine.define_helper(:class, :states) {}
     assert_equal [], @klass.send(:states)
   end
   
@@ -1004,14 +1174,73 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
         end
     end
     
-    @machine.define_class_method(:states) {}
+    @machine.define_helper(:class, :states) {}
     assert_equal [], @klass.send(:states)
   end
   
   def test_should_define_nonexistent_methods
-    @machine.define_class_method(:states) {[]}
+    @machine.define_helper(:class, :states) {[]}
     assert_equal [], @klass.states
   end
+  
+  def test_should_pass_context_as_arguments
+    helper_args = nil
+    @machine.define_helper(:class, :states) {|*args| helper_args = args}
+    @klass.states
+    assert_equal 3, helper_args.length
+    assert_equal [@machine, @klass], helper_args[0..1]
+  end
+  
+  def test_should_pass_method_arguments_through
+    helper_args = nil
+    @machine.define_helper(:class, :states) {|*args| helper_args = args}
+    @klass.states(1, 2, 3)
+    assert_equal 6, helper_args.length
+    assert_equal [@machine, @klass], helper_args[0..1]
+    assert_equal [1, 2, 3], helper_args[3..5]
+  end
+  
+  def test_should_allow_super_calls
+    @klass = Class.new
+    @klass.class_eval do
+      extend(Module.new {
+        def states
+          'original'
+        end
+      })
+    end
+    @machine = StateMachine::Machine.new(@klass)
+    
+    @machine.define_helper(:class, :states) {|machine, klass, _super| _super.call}
+    assert_equal 'original', @klass.states
+  end
+  
+  def test_should_allow_rewrite_of_super_args
+    @klass = Class.new
+    @klass.class_eval do
+      extend(Module.new {
+        def states(value)
+          value
+        end
+      })
+    end
+    @machine = StateMachine::Machine.new(@klass)
+    
+    @machine.define_helper(:class, :states) {|machine, klass, _super, *args| _super.call('override')}
+    assert_equal 'override', @klass.states(1)
+  end
+  
+  def test_should_throw_exception_if_calling_helper_directly_with_invalid_method
+    assert_raise(RUBY_VERSION < '1.9' ? IndexError : KeyError) { @machine.call_helper(:class, :invalid, @klass, lambda {}) }
+  end
+  
+  def test_should_be_able_to_call_helper_directly
+    helper_args = nil
+    @machine.define_helper(:class, :states) {|*args| helper_args = args}
+    
+    @machine.call_helper(:class, :states, @klass, _super = lambda {}, 1, 2, 3)
+    assert_equal [@machine, @klass, _super, 1, 2, 3], helper_args
+  end
 end
 
 class MachineWithConflictingHelpersTest < Test::Unit::TestCase
@@ -1070,9 +1299,15 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
       def state_transitions
         [{:parked => :idling}]
       end
+      
+      def state_paths
+        [[{:parked => :idling}]]
+      end
     end
     
     StateMachine::Integrations.const_set('Custom', Module.new do
+      include StateMachine::Integrations::Base
+      
       def create_with_scope(name)
         lambda {|klass, values| []}
       end
@@ -1141,6 +1376,10 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
     assert_equal [{:parked => :idling}], @object.state_transitions
   end
   
+  def test_should_not_redefine_attribute_paths_reader
+    assert_equal [[{:parked => :idling}]], @object.state_paths
+  end
+  
   def test_should_allow_super_chaining
     @klass.class_eval do
       def self.with_state(*states)
@@ -1197,6 +1436,10 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
       def state_transitions
         super == []
       end
+      
+      def state_paths
+        super == []
+      end
     end
     
     assert_equal true, @klass.with_state
@@ -1214,6 +1457,7 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
     assert_equal 0, @object.human_state_name
     assert_equal true, @object.state_events
     assert_equal true, @object.state_transitions
+    assert_equal true, @object.state_paths
   end
   
   def teardown
@@ -1348,6 +1592,16 @@ class MachinePersistenceTest < Test::Unit::TestCase
     @machine.write(@object, :event, 'ignite')
     assert_equal 'ignite', @object.state_event
   end
+  
+  def test_should_allow_writing_custom_instance_variables
+    @klass.class_eval do
+      attr_reader :state_value
+    end
+    
+    assert_raise(NoMethodError) { @machine.write(@object, :value, 1) }
+    assert_equal 1, @machine.write(@object, :value, 1, true)
+    assert_equal 1, @object.state_value
+  end
 end
 
 
@@ -1675,7 +1929,7 @@ class MachineWithMultipleEventsTest < Test::Unit::TestCase
   end
   
   def test_should_define_transitions_for_each_event
-    [@park, @shift_down].each {|event| assert_equal 1, event.guards.size}
+    [@park, @shift_down].each {|event| assert_equal 1, event.branches.size}
   end
   
   def test_should_transition_the_same_for_each_event
@@ -1834,6 +2088,76 @@ class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithFailureCallbacksTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new do
+      attr_accessor :callbacks
+    end
+    
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @event = @machine.event :ignite
+    
+    @object = @klass.new
+    @object.callbacks = []
+  end
+  
+  def test_should_raise_exception_if_implicit_option_specified
+    exception = assert_raise(ArgumentError) {@machine.after_failure :invalid => :valid, :do => lambda {}}
+    assert_equal 'Invalid key(s): invalid', exception.message
+  end
+  
+  def test_should_raise_exception_if_method_not_specified
+    exception = assert_raise(ArgumentError) {@machine.after_failure :on => :ignite}
+    assert_equal 'Method(s) for callback must be specified', exception.message
+  end
+  
+  def test_should_invoke_callbacks_during_failed_transition
+    @machine.after_failure lambda {|object| object.callbacks << 'failure'}
+    
+    @event.fire(@object)
+    assert_equal %w(failure), @object.callbacks
+  end
+  
+  def test_should_allow_multiple_callbacks
+    @machine.after_failure lambda {|object| object.callbacks << 'failure1'}, lambda {|object| object.callbacks << 'failure2'}
+    
+    @event.fire(@object)
+    assert_equal %w(failure1 failure2), @object.callbacks
+  end
+  
+  def test_should_allow_multiple_callbacks_with_requirements
+    @machine.after_failure lambda {|object| object.callbacks << 'failure_ignite1'}, lambda {|object| object.callbacks << 'failure_ignite2'}, :on => :ignite
+    @machine.after_failure lambda {|object| object.callbacks << 'failure_park1'}, lambda {|object| object.callbacks << 'failure_park2'}, :on => :park
+    
+    @event.fire(@object)
+    assert_equal %w(failure_ignite1 failure_ignite2), @object.callbacks
+  end
+end
+
+class MachineWithPathsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+    @machine.event :shift_up do
+      transition :first_gear => :second_gear
+    end
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_have_paths
+    assert_equal [[StateMachine::Transition.new(@object, @machine, :ignite, :parked, :idling)]], @machine.paths_for(@object)
+  end
+  
+  def test_should_allow_requirement_configuration
+    assert_equal [[StateMachine::Transition.new(@object, @machine, :shift_up, :first_gear, :second_gear)]], @machine.paths_for(@object, :from => :first_gear)
+  end
+end
+
 class MachineWithOwnerSubclassTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -1850,6 +2174,37 @@ class MachineWithOwnerSubclassTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithOwnerSubclassHelpersTest < Test::Unit::TestCase
+  def setup
+    @base = Class.new
+    @base_machine = StateMachine::Machine.new(@base)
+    @base_machine.define_helper(:instance, :transition) { :base }
+    
+    @subclass = Class.new(@base)
+    @subclass_machine = @subclass.state_machine {}
+    @subclass_machine.define_helper(:instance, :run) { :subclass }
+    
+    @base_object = @base.new
+    @subclass_object = @subclass.new
+  end
+  
+  def test_should_be_able_to_call_base_helper_on_base
+    assert_equal :base, @base_machine.call_helper(:instance, :transition, @base_object, lambda {})
+  end
+  
+  def test_should_be_able_to_call_base_helper_on_subclass
+    assert_equal :base, @subclass_machine.call_helper(:instance, :transition, @subclass_object, lambda {})
+  end
+  
+  def test_should_not_be_able_to_call_subclass_helper_on_base
+    assert_raise(RUBY_VERSION < '1.9' ? IndexError : KeyError) { @base_machine.call_helper(:instance, :run, @base_object, lambda {}) }
+  end
+  
+  def test_should_be_able_to_call_subclass_helper_on_base
+    assert_equal :subclass, @subclass_machine.call_helper(:instance, :run, @subclass_object, lambda {})
+  end
+end
+
 class MachineWithExistingMachinesOnOwnerClassTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -1952,7 +2307,8 @@ end
 class MachineWithCustomAttributeTest < Test::Unit::TestCase
   def setup
     StateMachine::Integrations.const_set('Custom', Module.new do  
-      class << self; attr_reader :defaults; end
+      include StateMachine::Integrations::Base
+      
       @defaults = {:action => :save, :use_transactions => false}
       
       def create_with_scope(name)
@@ -2001,6 +2357,10 @@ class MachineWithCustomAttributeTest < Test::Unit::TestCase
     assert @object.respond_to?(:state_transitions)
   end
   
+  def test_should_define_a_path_reader_for_the_attribute
+    assert @object.respond_to?(:state_paths)
+  end
+  
   def test_should_define_a_human_attribute_name_reader
     assert @klass.respond_to?(:human_state_name)
   end
@@ -2083,6 +2443,8 @@ end
 class MachineFinderWithExistingMachineOnSuperclassTest < Test::Unit::TestCase
   def setup
     integration = Module.new do
+      include StateMachine::Integrations::Base
+      
       def self.matches?(klass)
         false
       end
@@ -2331,14 +2693,14 @@ begin
     end
     
     def test_should_load_files
-      StateMachine::Machine.draw('Switch', :file => "#{File.dirname(__FILE__)}/../files/switch.rb")
+      StateMachine::Machine.draw('Switch', :file => File.expand_path("#{File.dirname(__FILE__)}/../files/switch.rb"))
       assert defined?(::Switch)
     ensure
       FileUtils.rm('./Switch_state.png')
     end
     
     def test_should_allow_path_and_format_to_be_customized
-      StateMachine::Machine.draw('Switch', :file => "#{File.dirname(__FILE__)}/../files/switch.rb", :path => "#{File.dirname(__FILE__)}/", :format => 'jpg')
+      StateMachine::Machine.draw('Switch', :file => File.expand_path("#{File.dirname(__FILE__)}/../files/switch.rb"), :path => "#{File.dirname(__FILE__)}/", :format => 'jpg')
       assert File.exist?("#{File.dirname(__FILE__)}/Switch_state.jpg")
     ensure
       FileUtils.rm("#{File.dirname(__FILE__)}/Switch_state.jpg")