state_machine 1.1.2 → 1.2.0

data/test/unit/integrations_test.rb

@@ -2,7 +2,10 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class IntegrationMatcherTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new
+    superclass = Class.new
+    self.class.const_set('Vehicle', superclass)
+    
+    @klass = Class.new(superclass)
   end
   
   def test_should_return_nil_if_no_match_found
@@ -13,20 +16,39 @@ class IntegrationMatcherTest < Test::Unit::TestCase
     integration = Module.new do
       include StateMachine::Integrations::Base
       
-      def self.available?
-        true
+      def self.matching_ancestors
+        ['IntegrationMatcherTest::Vehicle']
       end
+    end
+    StateMachine::Integrations.const_set('Custom', integration)
+    
+    assert_equal integration, StateMachine::Integrations.match(@klass)
+  ensure
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+  
+  def test_should_return_nil_if_no_match_found_with_ancestors
+    assert_nil StateMachine::Integrations.match_ancestors(['IntegrationMatcherTest::Fake'])
+  end
+  
+  def test_should_return_integration_class_if_match_found_with_ancestors
+    integration = Module.new do
+      include StateMachine::Integrations::Base
       
-      def self.matches?(klass)
-        true
+      def self.matching_ancestors
+        ['IntegrationMatcherTest::Vehicle']
       end
     end
     StateMachine::Integrations.const_set('Custom', integration)
     
-    assert_equal integration, StateMachine::Integrations.match(@klass)
+    assert_equal integration, StateMachine::Integrations.match_ancestors(['IntegrationMatcherTest::Fake', 'IntegrationMatcherTest::Vehicle'])
   ensure
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end
+  
+  def teardown
+    self.class.send(:remove_const, 'Vehicle')
+  end
 end
 
 class IntegrationFinderTest < Test::Unit::TestCase

data/test/unit/machine_collection_test.rb

@@ -67,10 +67,10 @@ class MachineCollectionStateInitializationTest < Test::Unit::TestCase
     assert_equal 'active', @object.alarm_state
   end
   
-  def test_should_initialize_existing_static_states_by_default
+  def test_should_not_initialize_existing_static_states_by_default
     @object.state = 'idling'
     @machines.initialize_states(@object)
-    assert_equal 'parked', @object.state
+    assert_equal 'idling', @object.state
   end
   
   def test_should_initialize_existing_static_states_if_forced
@@ -164,6 +164,8 @@ class MachineCollectionFireTest < Test::Unit::TestCase
   end
   
   def test_should_run_failure_callbacks_if_any_event_cannot_transition
+    @state_failure_run = @alarm_state_failure_run = false
+    
     @machines[:state].after_failure {@state_failure_run = true}
     @machines[:alarm_state].after_failure {@alarm_state_failure_run = true}
     
@@ -246,6 +248,7 @@ class MachineCollectionFireWithTransactionsTest < Test::Unit::TestCase
   
   def test_should_run_failure_callbacks_if_not_successful
     @object.allow_save = false
+    @state_failure_run = @alarm_state_failure_run = false
     
     @machines[:state].after_failure {@state_failure_run = true}
     @machines[:alarm_state].after_failure {@alarm_state_failure_run = true}
@@ -313,6 +316,7 @@ class MachineCollectionFireWithValidationsTest < Test::Unit::TestCase
   def test_should_run_failure_callbacks_if_no_transitions_exist
     @object.state = 'idling'
     @object.alarm_state = 'off'
+    @state_failure_run = @alarm_state_failure_run = false
     
     @machines[:state].after_failure {@state_failure_run = true}
     @machines[:alarm_state].after_failure {@alarm_state_failure_run = true}

data/test/unit/machine_test.rb

@@ -170,7 +170,7 @@ class MachineByDefaultTest < Test::Unit::TestCase
   end
   
   def test_should_extend_owner_class_with_class_methods
-    assert (class << @klass; ancestors; end).include?(StateMachine::ClassMethods)
+    assert((class << @klass; ancestors; end).include?(StateMachine::ClassMethods))
   end
   
   def test_should_include_instance_methods_in_owner_class
@@ -257,13 +257,12 @@ class MachineWithoutInitializationTest < Test::Unit::TestCase
   end
   
   def test_should_still_allow_manual_initialization
-    @klass.class_eval do
+    @klass.send(:include, Module.new do
       def initialize(attributes = {})
-        attributes.each {|attr, value| send("#{attr}=", value)}
         super()
         initialize_state_machines
       end
-    end
+    end)
     
     object = @klass.new
     assert_equal 'parked', object.state
@@ -299,7 +298,7 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
     assert_equal 'parked', @klass.new.state
   end
   
-  def test_should_still_set_initial_state_even_if_not_empty
+  def test_not_set_initial_state_even_if_not_empty
     @klass.class_eval do
       def initialize(attributes = {})
         self.state = 'idling'
@@ -307,7 +306,7 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
       end
     end
     object = @klass.new
-    assert_equal 'parked', object.state
+    assert_equal 'idling', object.state
   end
   
   def test_should_set_initial_state_prior_to_initialization
@@ -319,7 +318,7 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
       end
     end
     klass = Class.new(base)
-    machine = StateMachine::Machine.new(klass, :initial => :parked)
+    StateMachine::Machine.new(klass, :initial => :parked)
     
     assert_equal 'parked', klass.new.state_on_init
   end
@@ -438,7 +437,7 @@ class MachineStateInitializationTest < Test::Unit::TestCase
   
   def test_should_write_to_hash_if_specified
     @machine.initialize_state(@object, :to => hash = {})
-    assert_equal expected = {'state' => 'parked'}, hash
+    assert_equal({'state' => 'parked'}, hash)
   end
   
   def test_should_not_write_to_object_if_writing_to_hash
@@ -511,61 +510,65 @@ class MachineWithCustomIntegrationTest < Test::Unit::TestCase
     integration = Module.new do
       include StateMachine::Integrations::Base
       
-      def self.available?
-        true
-      end
-      
-      def self.matches?(klass)
-        true
+      def self.matching_ancestors
+        ['MachineWithCustomIntegrationTest::Vehicle']
       end
     end
     
     StateMachine::Integrations.const_set('Custom', integration)
+    
+    superclass = Class.new
+    self.class.const_set('Vehicle', superclass)
+    
+    @klass = Class.new(superclass)
   end
   
   def test_should_be_extended_by_the_integration_if_explicit
-    machine = StateMachine::Machine.new(Class.new, :integration => :custom)
-    assert (class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+    machine = StateMachine::Machine.new(@klass, :integration => :custom)
+    assert((class << machine; ancestors; end).include?(StateMachine::Integrations::Custom))
   end
   
   def test_should_not_be_extended_by_the_integration_if_implicit_but_not_available
     StateMachine::Integrations::Custom.class_eval do
-      def self.available?
-        false
+      class << self; remove_method :matching_ancestors; end
+      def self.matching_ancestors
+        []
       end
     end
     
-    machine = StateMachine::Machine.new(Class.new)
-    assert !(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+    machine = StateMachine::Machine.new(@klass)
+    assert(!(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom))
   end
 
   def test_should_not_be_extended_by_the_integration_if_implicit_but_not_matched
     StateMachine::Integrations::Custom.class_eval do
-      def self.matches?(klass)
-        false
+      class << self; remove_method :matching_ancestors; end
+      def self.matching_ancestors
+        []
       end
     end
     
-    machine = StateMachine::Machine.new(Class.new)
-    assert !(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+    machine = StateMachine::Machine.new(@klass)
+    assert(!(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom))
   end
 
   def test_should_be_extended_by_the_integration_if_implicit_and_available_and_matches
-    machine = StateMachine::Machine.new(Class.new)
-    assert (class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+    machine = StateMachine::Machine.new(@klass)
+    assert((class << machine; ancestors; end).include?(StateMachine::Integrations::Custom))
   end
 
   def test_should_not_be_extended_by_the_integration_if_nil
-    machine = StateMachine::Machine.new(Class.new, :integration => nil)
-    assert !(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+    machine = StateMachine::Machine.new(@klass, :integration => nil)
+    assert(!(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom))
   end
   
   def test_should_not_be_extended_by_the_integration_if_false
-    machine = StateMachine::Machine.new(Class.new, :integration => false)
-    assert !(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+    machine = StateMachine::Machine.new(@klass, :integration => false)
+    assert(!(class << machine; ancestors; end).include?(StateMachine::Integrations::Custom))
   end
   
   def teardown
+    self.class.send(:remove_const, 'Vehicle')
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end
 end
@@ -653,11 +656,11 @@ class MachineWithActionUndefinedTest < Test::Unit::TestCase
   end
   
   def test_should_define_an_event_transition_attribute_reader
-    assert @object.respond_to?(:state_event_transition)
+    assert @object.respond_to?(:state_event_transition, true)
   end
   
   def test_should_define_an_event_transition_attribute_writer
-    assert @object.respond_to?(:state_event_transition=)
+    assert @object.respond_to?(:state_event_transition=, true)
   end
   
   def test_should_not_define_action
@@ -689,11 +692,11 @@ class MachineWithActionDefinedInClassTest < Test::Unit::TestCase
   end
   
   def test_should_define_an_event_transition_attribute_reader
-    assert @object.respond_to?(:state_event_transition)
+    assert @object.respond_to?(:state_event_transition, true)
   end
   
   def test_should_define_an_event_transition_attribute_writer
-    assert @object.respond_to?(:state_event_transition=)
+    assert @object.respond_to?(:state_event_transition=, true)
   end
   
   def test_should_not_define_action
@@ -729,11 +732,11 @@ class MachineWithActionDefinedInIncludedModuleTest < Test::Unit::TestCase
   end
   
   def test_should_define_an_event_transition_attribute_reader
-    assert @object.respond_to?(:state_event_transition)
+    assert @object.respond_to?(:state_event_transition, true)
   end
   
   def test_should_define_an_event_transition_attribute_writer
-    assert @object.respond_to?(:state_event_transition=)
+    assert @object.respond_to?(:state_event_transition=, true)
   end
   
   def test_should_define_action
@@ -770,11 +773,11 @@ class MachineWithActionDefinedInSuperclassTest < Test::Unit::TestCase
   end
   
   def test_should_define_an_event_transition_attribute_reader
-    assert @object.respond_to?(:state_event_transition)
+    assert @object.respond_to?(:state_event_transition, true)
   end
   
   def test_should_define_an_event_transition_attribute_writer
-    assert @object.respond_to?(:state_event_transition=)
+    assert @object.respond_to?(:state_event_transition=, true)
   end
   
   def test_should_define_action
@@ -812,11 +815,11 @@ class MachineWithPrivateActionTest < Test::Unit::TestCase
   end
   
   def test_should_define_an_event_transition_attribute_reader
-    assert @object.respond_to?(:state_event_transition)
+    assert @object.respond_to?(:state_event_transition, true)
   end
   
   def test_should_define_an_event_transition_attribute_writer
-    assert @object.respond_to?(:state_event_transition=)
+    assert @object.respond_to?(:state_event_transition=, true)
   end
   
   def test_should_define_action
@@ -875,17 +878,28 @@ class MachineWithCustomPluralTest < Test::Unit::TestCase
     end
     
     StateMachine::Integrations.const_set('Custom', @integration)
-    @machine = StateMachine::Machine.new(Class.new, :integration => :custom, :plural => 'staties')
   end
   
   def test_should_define_a_singular_and_plural_with_scope
+    StateMachine::Machine.new(Class.new, :integration => :custom, :plural => 'staties')
     assert_equal %w(with_state with_staties), @integration.with_scopes
   end
   
   def test_should_define_a_singular_and_plural_without_scope
+    StateMachine::Machine.new(Class.new, :integration => :custom, :plural => 'staties')
     assert_equal %w(without_state without_staties), @integration.without_scopes
   end
   
+  def test_should_define_single_with_scope_if_singular_same_as_plural
+    StateMachine::Machine.new(Class.new, :integration => :custom, :plural => 'state')
+    assert_equal %w(with_state), @integration.with_scopes
+  end
+  
+  def test_should_define_single_without_scope_if_singular_same_as_plural
+    StateMachine::Machine.new(Class.new, :integration => :custom, :plural => 'state')
+    assert_equal %w(without_state), @integration.without_scopes
+  end
+  
   def teardown
     StateMachine::Integrations.send(:remove_const, 'Custom')
   end
@@ -1561,7 +1575,7 @@ class MachineWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
     assert_equal :human_state_event_name, @klass.human_state_event_name
   end
   
-  def test_should_not_redefine_attribute_writer
+  def test_should_not_redefine_attribute_reader
     assert_equal 'parked', @object.state
   end
   
@@ -1609,8 +1623,8 @@ class MachineWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
       'Instance method "state_name"',
       'Instance method "human_state_name"',
       'Class method "with_state"',
-      'Class method "without_state"',
       'Class method "with_states"',
+      'Class method "without_state"',
       'Class method "without_states"'
     ].map {|method| "#{method} is already defined in #{@superclass.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n"}.join
     
@@ -1734,7 +1748,7 @@ class MachineWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
     assert_equal :human_state_event_name, @klass.human_state_event_name
   end
   
-  def test_should_not_redefine_attribute_writer
+  def test_should_not_redefine_attribute_reader
     assert_equal 'parked', @object.state
   end
   
@@ -1975,8 +1989,9 @@ end
 class MachineWithCustomInitializeTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
-      def initialize
-        initialize_state_machines
+      def initialize(state = nil, options = {})
+        @state = state
+        initialize_state_machines(options)
       end
     end
     @machine = StateMachine::Machine.new(@klass, :initial => :parked)
@@ -1986,6 +2001,12 @@ class MachineWithCustomInitializeTest < Test::Unit::TestCase
   def test_should_initialize_state
     assert_equal 'parked', @object.state
   end
+  
+  def test_should_allow_custom_options
+    @machine.state :idling
+    @object = @klass.new('idling', :static => :force)
+    assert_equal 'parked', @object.state
+  end
 end
 
 class MachinePersistenceTest < Test::Unit::TestCase
@@ -2389,7 +2410,7 @@ class MachineWithEventMatchersTest < Test::Unit::TestCase
   end
   
   def test_should_track_referenced_events
-    event = @machine.event(StateMachine::BlacklistMatcher.new([:park]))
+    @machine.event(StateMachine::BlacklistMatcher.new([:park]))
     assert_equal [:park], @machine.events.map {|event| event.name}
   end
   
@@ -2484,11 +2505,6 @@ class MachineWithTransitionsTest < Test::Unit::TestCase
     assert_equal 'Must specify :on event', exception.message
   end
   
-  def test_should_not_allow_except_to_option
-    exception = assert_raise(ArgumentError) {@machine.transition(:except_to => :parked, :on => :ignite)}
-    assert_equal 'Invalid key(s): except_to', exception.message
-  end
-  
   def test_should_not_allow_except_on_option
     exception = assert_raise(ArgumentError) {@machine.transition(:except_on => :ignite, :on => :ignite)}
     assert_equal 'Invalid key(s): except_on', exception.message
@@ -2506,6 +2522,10 @@ class MachineWithTransitionsTest < Test::Unit::TestCase
     assert_nothing_raised {@machine.transition(:except_from => :idling, :on => :ignite)}
   end
   
+  def test_should_allow_except_to_option
+    assert_nothing_raised {@machine.transition(:except_to => :parked, :on => :ignite)}
+  end
+  
   def test_should_allow_implicit_options
     branch = @machine.transition(:first_gear => :second_gear, :on => :shift_up)
     assert_instance_of StateMachine::Branch, branch
@@ -2551,6 +2571,13 @@ class MachineWithTransitionsTest < Test::Unit::TestCase
     assert_equal 2, branches.length
     assert_equal [:ignite, :shift_up], @machine.events.map {|event| event.name}
   end
+  
+  def test_should_not_modify_options
+    options = {:parked => :idling, :on => :ignite}
+    @machine.transition(options)
+    
+    assert_equal options, {:parked => :idling, :on => :ignite}
+  end
 end
 
 class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
@@ -3157,7 +3184,7 @@ class MachineFinderWithExistingMachineOnSuperclassTest < Test::Unit::TestCase
   end
   
   def test_should_use_the_same_integration
-    assert (class << @machine; ancestors; end).include?(StateMachine::Integrations::Custom)
+    assert((class << @machine; ancestors; end).include?(StateMachine::Integrations::Custom))
   end
   
   def teardown
@@ -3188,7 +3215,7 @@ begin
   class MachineDrawingTest < Test::Unit::TestCase
     def setup
       @klass = Class.new do
-        def self.name; 'Vehicle'; end
+        def self.name; @name ||= "Vehicle_#{rand(1000000)}"; end
       end
       @machine = StateMachine::Machine.new(@klass, :initial => :parked)
       @machine.event :ignite do
@@ -3201,23 +3228,27 @@ begin
     end
     
     def test_should_save_file_with_class_name_by_default
-      graph = @machine.draw
-      assert File.exists?('./Vehicle_state.png')
+      @machine.draw
+      assert File.exists?("./#{@klass.name}_state.png")
     end
     
     def test_should_allow_base_name_to_be_customized
-      graph = @machine.draw(:name => 'machine')
-      assert File.exists?('./machine.png')
+      name = "machine_#{rand(1000000)}"
+      @machine.draw(:name => name)
+      @path = "./#{name}.png"
+      assert File.exists?(@path)
     end
     
     def test_should_allow_format_to_be_customized
-      graph = @machine.draw(:format => 'jpg')
-      assert File.exists?('./Vehicle_state.jpg')
+      @machine.draw(:format => 'jpg')
+      @path = "./#{@klass.name}_state.jpg"
+      assert File.exists?(@path)
     end
     
     def test_should_allow_path_to_be_customized
-      graph = @machine.draw(:path => "#{File.dirname(__FILE__)}/")
-      assert File.exists?("#{File.dirname(__FILE__)}/Vehicle_state.png")
+      @machine.draw(:path => "#{File.dirname(__FILE__)}/")
+      @path = "#{File.dirname(__FILE__)}/#{@klass.name}_state.png"
+      assert File.exists?(@path)
     end
     
     def test_should_allow_orientation_to_be_landscape
@@ -3230,15 +3261,30 @@ begin
       assert_equal 'TB', graph['rankdir'].to_s.gsub('"', '')
     end
     
+    if Constants::RGV_VERSION != '0.9.0'
+      def test_should_allow_human_names_to_be_displayed
+        @machine.event :ignite, :human_name => 'Ignite'
+        @machine.state :parked, :human_name => 'Parked'
+        @machine.state :idling, :human_name => 'Idling'
+        graph = @machine.draw(:human_names => true)
+        
+        parked_node = graph.get_node('parked')
+        assert_equal 'Parked', parked_node['label'].to_s.gsub('"', '')
+        
+        idling_node = graph.get_node('idling')
+        assert_equal 'Idling', idling_node['label'].to_s.gsub('"', '')
+      end
+    end
+    
     def teardown
-      FileUtils.rm Dir["{.,#{File.dirname(__FILE__)}}/*.{png,jpg}"]
+      FileUtils.rm Dir[@path || "./#{@klass.name}_state.png"]
     end
   end
   
   class MachineDrawingWithIntegerStatesTest < Test::Unit::TestCase
     def setup
       @klass = Class.new do
-        def self.name; 'Vehicle'; end
+        def self.name; @name ||= "Vehicle_#{rand(1000000)}"; end
       end
       @machine = StateMachine::Machine.new(@klass, :state_id, :initial => :parked)
       @machine.event :ignite do
@@ -3258,16 +3304,18 @@ begin
     end
     
     def test_should_draw_machine
-      assert File.exist?('./Vehicle_state_id.png')
-    ensure
-      FileUtils.rm('./Vehicle_state_id.png')
+      assert File.exist?("./#{@klass.name}_state_id.png")
+    end
+    
+    def teardown
+      FileUtils.rm Dir["./#{@klass.name}_state_id.png"]
     end
   end
   
   class MachineDrawingWithNilStatesTest < Test::Unit::TestCase
     def setup
       @klass = Class.new do
-        def self.name; 'Vehicle'; end
+        def self.name; @name ||= "Vehicle_#{rand(1000000)}"; end
       end
       @machine = StateMachine::Machine.new(@klass, :initial => :parked)
       @machine.event :ignite do
@@ -3286,16 +3334,18 @@ begin
     end
     
     def test_should_draw_machine
-      assert File.exist?('./Vehicle_state.png')
-    ensure
-      FileUtils.rm('./Vehicle_state.png')
+      assert File.exist?("./#{@klass.name}_state.png")
+    end
+    
+    def teardown
+      FileUtils.rm Dir["./#{@klass.name}_state.png"]
     end
   end
   
   class MachineDrawingWithDynamicStatesTest < Test::Unit::TestCase
     def setup
       @klass = Class.new do
-        def self.name; 'Vehicle'; end
+        def self.name; @name ||= "Vehicle_#{rand(1000000)}"; end
       end
       @machine = StateMachine::Machine.new(@klass, :initial => :parked)
       @machine.event :activate do
@@ -3314,16 +3364,18 @@ begin
     end
     
     def test_should_draw_machine
-      assert File.exist?('./Vehicle_state.png')
-    ensure
-      FileUtils.rm('./Vehicle_state.png')
+      assert File.exist?("./#{@klass.name}_state.png")
+    end
+    
+    def teardown
+      FileUtils.rm Dir["./#{@klass.name}_state.png"]
     end
   end
   
   class MachineClassDrawingTest < Test::Unit::TestCase
     def setup
       @klass = Class.new do
-        def self.name; 'Vehicle'; end
+        def self.name; @name ||= "Vehicle_#{rand(1000000)}"; end
       end
       @machine = StateMachine::Machine.new(@klass)
       @machine.event :ignite do
@@ -3339,17 +3391,17 @@ begin
     def test_should_load_files
       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.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")
+      assert File.exist?("#{File.dirname(__FILE__)}/#{Switch.name}_state.jpg")
+    end
+    
+    def teardown
+      FileUtils.rm Dir["{.,#{File.dirname(__FILE__)}}/#{Switch.name}_state.{jpg,png}"]
     end
   end
 rescue LoadError
-  $stderr.puts 'Skipping GraphViz StateMachine::Machine tests. `gem install ruby-graphviz` >= v0.9.0 and try again.'
+  $stderr.puts 'Skipping GraphViz StateMachine::Machine tests. `gem install ruby-graphviz` >= v0.9.17 and try again.'
 end unless ENV['TRAVIS']