state_machine 0.9.2 → 0.9.3

data/test/unit/integrations/active_record_test.rb

@@ -56,6 +56,13 @@ module ActiveRecordTest
             @notifications = []
           end
         end
+        
+        (class << observer; self; end).class_eval do
+          define_method(:name) do
+            "#{model.name}Observer"
+          end
+        end
+        
         observer.observe(model)
         observer.class_eval(&block) if block_given?
         observer
@@ -127,6 +134,18 @@ module ActiveRecordTest
     end
   end
   
+  class MachineWithStatesTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @machine.state :first_gear
+    end
+    
+    def test_should_humanize_name
+      assert_equal 'first gear', @machine.state(:first_gear).human_name
+    end
+  end
+  
   class MachineWithStaticInitialStateTest < BaseTestCase
     def setup
       @model = new_model do
@@ -281,6 +300,18 @@ module ActiveRecordTest
     end
   end
   
+  class MachineWithEventsTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @machine.event :shift_up
+    end
+    
+    def test_should_humanize_name
+      assert_equal 'shift up', @machine.event(:shift_up).human_name
+    end
+  end
+  
   class MachineWithColumnDefaultTest < BaseTestCase
     def setup
       @model = new_model do
@@ -904,7 +935,7 @@ module ActiveRecordTest
       I18n.backend = I18n::Backend::Simple.new if Object.const_defined?(:I18n)
       @record.state = 'parked'
       
-      @machine.invalidate(@record, :state, :invalid_transition, [[:event, :park]])
+      @machine.invalidate(@record, :state, :invalid_transition, [[:event, 'park']])
       assert_equal ['State cannot transition via "park"'], @record.errors.full_messages
     end
     
@@ -1732,7 +1763,7 @@ module ActiveRecordTest
       
       def test_should_use_defaults
         I18n.backend.store_translations(:en, {
-          :activerecord => {:errors => {:messages => {:invalid_transition => 'cannot {{event}}'}}}
+          :activerecord => {:errors => {:messages => {:invalid_transition => "cannot #{interpolation_key('event')}"}}}
         })
         
         machine = StateMachine::Machine.new(@model)
@@ -1741,13 +1772,13 @@ module ActiveRecordTest
         
         record = @model.new(:state => 'idling')
         
-        machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
+        machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
         assert_equal ['State cannot ignite'], record.errors.full_messages
       end
       
       def test_should_allow_customized_error_key
         I18n.backend.store_translations(:en, {
-          :activerecord => {:errors => {:messages => {:bad_transition => 'cannot {{event}}'}}}
+          :activerecord => {:errors => {:messages => {:bad_transition => "cannot #{interpolation_key('event')}"}}}
         })
         
         machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => :bad_transition})
@@ -1755,17 +1786,17 @@ module ActiveRecordTest
         
         record = @model.new(:state => 'idling')
         
-        machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
+        machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
         assert_equal ['State cannot ignite'], record.errors.full_messages
       end
       
       def test_should_allow_customized_error_string
-        machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => 'cannot {{event}}'})
+        machine = StateMachine::Machine.new(@model, :messages => {:invalid_transition => "cannot #{interpolation_key('event')}"})
         machine.state :parked, :idling
         
         record = @model.new(:state => 'idling')
         
-        machine.invalidate(record, :state, :invalid_transition, [[:event, :ignite]])
+        machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
         assert_equal ['State cannot ignite'], record.errors.full_messages
       end
       
@@ -1774,11 +1805,10 @@ module ActiveRecordTest
           :activerecord => {:state_machines => {:'active_record_test/foo' => {:state => {:states => {:parked => 'shutdown'}}}}}
         })
         
-        machine = StateMachine::Machine.new(@model, :initial => :parked)
-        record = @model.new
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked
         
-        machine.invalidate(record, :event, :invalid_event, [[:state, :parked]])
-        assert_equal ['State event cannot transition when shutdown'], record.errors.full_messages
+        assert_equal 'shutdown', machine.state(:parked).human_name
       end
       
       def test_should_allow_customized_state_key_scoped_to_machine
@@ -1786,11 +1816,10 @@ module ActiveRecordTest
           :activerecord => {:state_machines => {:state => {:states => {:parked => 'shutdown'}}}}
         })
         
-        machine = StateMachine::Machine.new(@model, :initial => :parked)
-        record = @model.new
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked
         
-        machine.invalidate(record, :event, :invalid_event, [[:state, :parked]])
-        assert_equal ['State event cannot transition when shutdown'], record.errors.full_messages
+        assert_equal 'shutdown', machine.state(:parked).human_name
       end
       
       def test_should_allow_customized_state_key_unscoped
@@ -1798,11 +1827,10 @@ module ActiveRecordTest
           :activerecord => {:state_machines => {:states => {:parked => 'shutdown'}}}
         })
         
-        machine = StateMachine::Machine.new(@model, :initial => :parked)
-        record = @model.new
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked
         
-        machine.invalidate(record, :event, :invalid_event, [[:state, :parked]])
-        assert_equal ['State event cannot transition when shutdown'], record.errors.full_messages
+        assert_equal 'shutdown', machine.state(:parked).human_name
       end
       
       def test_should_allow_customized_event_key_scoped_to_class_and_machine
@@ -1812,10 +1840,8 @@ module ActiveRecordTest
         
         machine = StateMachine::Machine.new(@model)
         machine.event :park
-        record = @model.new
         
-        machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
-        assert_equal ['State cannot transition via "stop"'], record.errors.full_messages
+        assert_equal 'stop', machine.event(:park).human_name
       end
       
       def test_should_allow_customized_event_key_scoped_to_machine
@@ -1825,10 +1851,8 @@ module ActiveRecordTest
         
         machine = StateMachine::Machine.new(@model)
         machine.event :park
-        record = @model.new
         
-        machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
-        assert_equal ['State cannot transition via "stop"'], record.errors.full_messages
+        assert_equal 'stop', machine.event(:park).human_name
       end
       
       def test_should_allow_customized_event_key_unscoped
@@ -1838,20 +1862,55 @@ module ActiveRecordTest
         
         machine = StateMachine::Machine.new(@model)
         machine.event :park
-        record = @model.new
         
-        machine.invalidate(record, :state, :invalid_transition, [[:event, :park]])
-        assert_equal ['State cannot transition via "stop"'], record.errors.full_messages
+        assert_equal 'stop', machine.event(:park).human_name
       end
       
       def test_should_only_add_locale_once_in_load_path
-        assert_equal 1, I18n.load_path.select {|path| path =~ %r{state_machine/integrations/active_record/locale\.rb$}}.length
+        assert_equal 1, I18n.load_path.select {|path| path =~ %r{active_record/locale\.rb$}}.length
         
         # Create another ActiveRecord model that will triger the i18n feature
         new_model
         
-        assert_equal 1, I18n.load_path.select {|path| path =~ %r{state_machine/integrations/active_record/locale\.rb$}}.length
+        assert_equal 1, I18n.load_path.select {|path| path =~ %r{active_record/locale\.rb$}}.length
+      end
+      
+      def test_should_add_locale_to_beginning_of_load_path
+        @original_load_path = I18n.load_path
+        I18n.backend = I18n::Backend::Simple.new
+        
+        app_locale = File.dirname(__FILE__) + '/../../files/en.yml'
+        default_locale = File.dirname(__FILE__) + '/../../../lib/state_machine/integrations/active_record/locale.rb'
+        I18n.load_path = [app_locale]
+        
+        StateMachine::Machine.new(@model)
+        
+        assert_equal [default_locale, app_locale].map {|path| File.expand_path(path)}, I18n.load_path.map {|path| File.expand_path(path)}
+      ensure
+        I18n.load_path = @original_load_path
+      end
+      
+      def test_should_prefer_other_locales_first
+        @original_load_path = I18n.load_path
+        I18n.backend = I18n::Backend::Simple.new
+        I18n.load_path = [File.dirname(__FILE__) + '/../../files/en.yml']
+        
+        machine = StateMachine::Machine.new(@model)
+        machine.state :parked, :idling
+        machine.event :ignite
+        
+        record = @model.new(:state => 'idling')
+        
+        machine.invalidate(record, :state, :invalid_transition, [[:event, 'ignite']])
+        assert_equal ['State cannot transition'], record.errors.full_messages
+      ensure
+        I18n.load_path = @original_load_path
       end
+      
+      private
+        def interpolation_key(key)
+          !defined?(I18n::VERSION) || I18n::VERSION < '0.4.0' ? "{{#{key}}}" : "%{#{key}}"
+        end
     end
   else
     $stderr.puts 'Skipping ActiveRecord I18n tests. `gem install active_record` >= v2.2.0 and try again.'

data/test/unit/integrations/data_mapper_test.rb

@@ -114,6 +114,18 @@ module DataMapperTest
     end
   end
   
+  class MachineWithStatesTest < BaseTestCase
+    def setup
+      @resource = new_resource
+      @machine = StateMachine::Machine.new(@resource)
+      @machine.state :first_gear
+    end
+    
+    def test_should_humanize_name
+      assert_equal 'first gear', @machine.state(:first_gear).human_name
+    end
+  end
+  
   class MachineWithStaticInitialStateTest < BaseTestCase
     def setup
       @resource = new_resource do
@@ -254,6 +266,18 @@ module DataMapperTest
     end
   end
   
+  class MachineWithEventsTest < BaseTestCase
+    def setup
+      @resource = new_resource
+      @machine = StateMachine::Machine.new(@resource)
+      @machine.event :shift_up
+    end
+    
+    def test_should_humanize_name
+      assert_equal 'shift up', @machine.event(:shift_up).human_name
+    end
+  end
+  
   class MachineWithColumnDefaultTest < BaseTestCase
     def setup
       @resource = new_resource do
@@ -896,7 +920,7 @@ module DataMapperTest
       def test_should_invalidate_using_errors
         @record.state = 'parked'
         
-        @machine.invalidate(@record, :state, :invalid_transition, [[:event, :park]])
+        @machine.invalidate(@record, :state, :invalid_transition, [[:event, 'park']])
         assert_equal ['cannot transition via "park"'], @record.errors.on(:state)
       end
       

data/test/unit/integrations/mongo_mapper_test.rb

@@ -87,6 +87,18 @@ module MongoMapperTest
     end
   end
   
+  class MachineWithStatesTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @machine.state :first_gear
+    end
+    
+    def test_should_humanize_name
+      assert_equal 'first gear', @machine.state(:first_gear).human_name
+    end
+  end
+  
   class MachineWithStaticInitialStateTest < BaseTestCase
     def setup
       @model = new_model do
@@ -221,6 +233,18 @@ module MongoMapperTest
     end
   end
   
+  class MachineWithEventsTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @machine.event :shift_up
+    end
+    
+    def test_should_humanize_name
+      assert_equal 'shift up', @machine.event(:shift_up).human_name
+    end
+  end
+  
   class MachineWithColumnDefaultTest < BaseTestCase
     def setup
       @model = new_model do
@@ -792,7 +816,7 @@ module MongoMapperTest
     def test_should_invalidate_using_errors
       @record.state = 'parked'
       
-      @machine.invalidate(@record, :state, :invalid_transition, [[:event, :park]])
+      @machine.invalidate(@record, :state, :invalid_transition, [[:event, 'park']])
       assert_equal ['State cannot transition via "park"'], @record.errors.full_messages
     end
     
@@ -1268,7 +1292,7 @@ module MongoMapperTest
       parked = @model.create :state => 'parked'
       idling = @model.create :state => 'idling'
       
-      assert_equal [parked], @model.with_state(:parked)
+      assert_equal [parked], @model.with_state(:parked).to_a
     end
     
     def test_should_create_plural_with_scope
@@ -1279,7 +1303,7 @@ module MongoMapperTest
       parked = @model.create :state => 'parked'
       idling = @model.create :state => 'idling'
       
-      assert_equal [parked, idling], @model.with_states(:parked, :idling)
+      assert_equal [parked, idling], @model.with_states(:parked, :idling).to_a
     end
     
     def test_should_create_singular_without_scope
@@ -1290,7 +1314,7 @@ module MongoMapperTest
       parked = @model.create :state => 'parked'
       idling = @model.create :state => 'idling'
       
-      assert_equal [parked], @model.without_state(:idling)
+      assert_equal [parked], @model.without_state(:idling).to_a
     end
     
     def test_should_create_plural_without_scope
@@ -1302,7 +1326,16 @@ module MongoMapperTest
       idling = @model.create :state => 'idling'
       first_gear = @model.create :state => 'first_gear'
       
-      assert_equal [parked, idling], @model.without_states(:first_gear)
+      assert_equal [parked, idling], @model.without_states(:first_gear).to_a
+    end
+    
+    if defined?(MongoMapper::Version) && MongoMapper::Version >= '0.8.0'
+      def test_should_allow_chaining_scopes
+        parked = @model.create :state => 'parked'
+        idling = @model.create :state => 'idling'
+        
+        assert_equal [idling], @model.without_state(:parked).with_state(:idling).all
+      end
     end
   end
   
@@ -1320,7 +1353,7 @@ module MongoMapperTest
       parked = @subclass.create :state => 'parked'
       idling = @subclass.create :state => 'idling'
       
-      assert_equal [parked, idling], @subclass.with_states(:parked, :idling)
+      assert_equal [parked, idling], @subclass.with_states(:parked, :idling).to_a
     end
     
     def test_should_only_include_records_without_subclass_states_in_without_scope
@@ -1328,7 +1361,7 @@ module MongoMapperTest
       idling = @subclass.create :state => 'idling'
       first_gear = @subclass.create :state => 'first_gear'
       
-      assert_equal [parked, idling], @subclass.without_states(:first_gear)
+      assert_equal [parked, idling], @subclass.without_states(:first_gear).to_a
     end
   end
   

data/test/unit/integrations/sequel_test.rb

@@ -92,6 +92,18 @@ module SequelTest
     end
   end
   
+  class MachineWithStatesTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @machine.state :first_gear
+    end
+    
+    def test_should_humanize_name
+      assert_equal 'first gear', @machine.state(:first_gear).human_name
+    end
+  end
+  
   class MachineWithStaticInitialStateTest < BaseTestCase
     def setup
       @model = new_model do
@@ -259,6 +271,18 @@ module SequelTest
     end
   end
   
+  class MachineWithEventsTest < BaseTestCase
+    def setup
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model)
+      @machine.event :shift_up
+    end
+    
+    def test_should_humanize_name
+      assert_equal 'shift up', @machine.event(:shift_up).human_name
+    end
+  end
+  
   class MachineWithColumnDefaultTest < BaseTestCase
     def setup
       @model = new_model
@@ -861,7 +885,7 @@ module SequelTest
     def test_should_invalidate_using_errors
       @record.state = 'parked'
       
-      @machine.invalidate(@record, :state, :invalid_transition, [[:event, :park]])
+      @machine.invalidate(@record, :state, :invalid_transition, [[:event, 'park']])
       assert_equal ['cannot transition via "park"'], @record.errors.on(:state)
     end
     

data/test/unit/machine_collection_test.rb

@@ -285,7 +285,7 @@ class MachineCollectionFireWithValidationsTest < Test::Unit::TestCase
     @object.alarm_state = 'off'
     
     assert !@machines.fire_events(@object, :ignite, :disable_alarm)
-    assert_equal ['cannot transition via "ignite"', 'cannot transition via "disable_alarm"'], @object.errors
+    assert_equal ['cannot transition via "ignite"', 'cannot transition via "disable"'], @object.errors
   end
   
   def teardown

data/test/unit/machine_test.rb

@@ -129,6 +129,14 @@ class MachineByDefaultTest < Test::Unit::TestCase
     assert !@object.respond_to?(:state_event_transition=)
   end
   
+  def test_should_define_a_human_attribute_name_reader_for_the_attribute
+    assert @klass.respond_to?(:human_state_name)
+  end
+  
+  def test_should_define_a_human_event_name_reader_for_the_attribute
+    assert @klass.respond_to?(:human_state_event_name)
+  end
+  
   def test_should_not_define_singular_with_scope
     assert !@klass.respond_to?(:with_state)
   end
@@ -201,6 +209,14 @@ class MachineWithCustomNameTest < Test::Unit::TestCase
   def test_should_define_a_transition_reader_for_the_attribute
     assert @object.respond_to?(:status_transitions)
   end
+  
+  def test_should_define_a_human_attribute_name_reader_for_the_attribute
+    assert @klass.respond_to?(:human_status_name)
+  end
+  
+  def test_should_define_a_human_event_name_reader_for_the_attribute
+    assert @klass.respond_to?(:human_status_event_name)
+  end
 end
 
 class MachineWithStaticInitialStateTest < Test::Unit::TestCase
@@ -367,7 +383,7 @@ class MachineWithoutIntegrationTest < Test::Unit::TestCase
   end
   
   def test_invalidation_should_do_nothing
-    assert_nil @machine.invalidate(@object, :state, :invalid_transition, [[:event, :park]])
+    assert_nil @machine.invalidate(@object, :state, :invalid_transition, [[:event, 'park']])
   end
   
   def test_reset_should_do_nothing
@@ -754,7 +770,7 @@ class MachineWithCustomInvalidationTest < Test::Unit::TestCase
   end
   
   def test_use_custom_message
-    @machine.invalidate(@object, :state, :invalid_transition, [[:event, :park]])
+    @machine.invalidate(@object, :state, :invalid_transition, [[:event, 'park']])
     assert_equal 'cannot park', @object.error
   end
   
@@ -1017,6 +1033,14 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
         :without_states
       end
       
+      def self.human_state_name
+        :human_state_name
+      end
+      
+      def self.human_state_event_name
+        :human_state_event_name
+      end
+      
       attr_accessor :status
       
       def state
@@ -1035,6 +1059,10 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
         :parked
       end
       
+      def human_state_name
+        'parked'
+      end
+      
       def state_events
         [:ignite]
       end
@@ -1056,6 +1084,7 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
     
     @machine = StateMachine::Machine.new(@klass, :integration => :custom)
     @machine.state :parked, :idling
+    @machine.event :ignite
     @object = @klass.new
   end
   
@@ -1075,6 +1104,14 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
     assert_equal :without_states, @klass.without_states
   end
   
+  def test_should_not_redefine_human_attribute_name_reader
+    assert_equal :human_state_name, @klass.human_state_name
+  end
+  
+  def test_should_not_redefine_human_event_name_reader
+    assert_equal :human_state_event_name, @klass.human_state_event_name
+  end
+  
   def test_should_not_redefine_attribute_writer
     assert_equal 'parked', @object.state
   end
@@ -1092,6 +1129,10 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
     assert_equal :parked, @object.state_name
   end
   
+  def test_should_not_redefine_attribute_human_name_reader
+    assert_equal 'parked', @object.human_state_name
+  end
+  
   def test_should_not_redefine_attribute_events_reader
     assert_equal [:ignite], @object.state_events
   end
@@ -1118,6 +1159,14 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
         super == []
       end
       
+      def self.human_state_name(state)
+        super == 'parked'
+      end
+      
+      def self.human_state_event_name(event)
+        super == 'ignite'
+      end
+      
       attr_accessor :status
       
       def state
@@ -1137,6 +1186,10 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
         super == :parked ? 1 : 0
       end
       
+      def human_state_name
+        super == 'parked' ? 1 : 0
+      end
+      
       def state_events
         super == []
       end
@@ -1150,12 +1203,15 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
     assert_equal true, @klass.with_states
     assert_equal true, @klass.without_state
     assert_equal true, @klass.without_states
+    assert_equal true, @klass.human_state_name(:parked)
+    assert_equal true, @klass.human_state_event_name(:ignite)
     
     assert_equal 'parked', @object.state
     @object.state = 'idling'
     assert_equal 'idling', @object.status
     assert_equal 0, @object.state?(:parked)
     assert_equal 0, @object.state_name
+    assert_equal 0, @object.human_state_name
     assert_equal true, @object.state_events
     assert_equal true, @object.state_transitions
   end
@@ -1316,6 +1372,15 @@ class MachineWithStatesTest < Test::Unit::TestCase
     assert_equal @parked, @machine.states['parked', :value]
   end
   
+  def test_should_allow_human_state_name_lookup
+    assert_equal 'parked', @klass.human_state_name(:parked)
+  end
+  
+  def test_should_raise_exception_on_invalid_human_state_name_lookup
+    exception = assert_raise(IndexError) {@klass.human_state_name(:invalid)}
+    assert_equal ':invalid is an invalid name', exception.message
+  end
+  
   def test_should_use_stringified_name_for_value
     assert_equal 'parked', @parked.value
   end
@@ -1349,6 +1414,22 @@ class MachineWithStatesWithCustomValuesTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithStatesWithCustomHumanNamesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @state = @machine.state :parked, :human_name => 'stopped'
+  end
+  
+  def test_should_use_custom_human_name
+    assert_equal 'stopped', @state.human_name
+  end
+  
+  def test_should_allow_human_state_name_lookup
+    assert_equal 'stopped', @klass.human_state_name(:parked)
+  end
+end
+
 class MachineWithStatesWithRuntimeDependenciesTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -1501,6 +1582,16 @@ class MachineWithEventsTest < Test::Unit::TestCase
     event = @machine.event(:ignite)
     assert_equal [event], @machine.events.to_a
   end
+  
+  def test_should_allow_human_state_name_lookup
+    @machine.event(:ignite)
+    assert_equal 'ignite', @klass.human_state_event_name(:ignite)
+  end
+  
+  def test_should_raise_exception_on_invalid_human_state_event_name_lookup
+    exception = assert_raise(IndexError) {@klass.human_state_event_name(:invalid)}
+    assert_equal ':invalid is an invalid name', exception.message
+  end
 end
 
 class MachineWithExistingEventTest < Test::Unit::TestCase
@@ -1519,6 +1610,22 @@ class MachineWithExistingEventTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithEventsWithCustomHumanNamesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = @machine.event(:ignite, :human_name => 'start')
+  end
+  
+  def test_should_use_custom_human_name
+    assert_equal 'start', @event.human_name
+  end
+  
+  def test_should_allow_human_state_name_lookup
+    assert_equal 'start', @klass.human_state_event_name(:ignite)
+  end
+end
+
 class MachineWithEventsWithTransitionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -1882,6 +1989,10 @@ class MachineWithCustomAttributeTest < Test::Unit::TestCase
     assert @object.respond_to?(:state_name)
   end
   
+  def test_should_define_a_human_name_reader_for_the_attribute
+    assert @object.respond_to?(:state_name)
+  end
+  
   def test_should_define_an_event_reader_for_the_attribute
     assert @object.respond_to?(:state_events)
   end
@@ -1890,6 +2001,14 @@ class MachineWithCustomAttributeTest < Test::Unit::TestCase
     assert @object.respond_to?(:state_transitions)
   end
   
+  def test_should_define_a_human_attribute_name_reader
+    assert @klass.respond_to?(:human_state_name)
+  end
+  
+  def test_should_define_a_human_event_name_reader
+    assert @klass.respond_to?(:human_state_event_name)
+  end
+  
   def test_should_define_singular_with_scope
     assert @klass.respond_to?(:with_state)
   end
@@ -2212,14 +2331,14 @@ begin
     end
     
     def test_should_load_files
-      StateMachine::Machine.draw('Switch', :file => "#{File.dirname(__FILE__)}/../classes/switch.rb")
+      StateMachine::Machine.draw('Switch', :file => "#{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__)}/../classes/switch.rb", :path => "#{File.dirname(__FILE__)}/", :format => 'jpg')
+      StateMachine::Machine.draw('Switch', :file => "#{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")