state_machine 0.10.1 → 0.10.2

data/lib/state_machine/machine_collection.rb

@@ -1,6 +1,10 @@
+require 'state_machine/assertions'
+
 module StateMachine
   # Represents a collection of state machines for a class
   class MachineCollection < Hash
+    include Assertions
+    
     # Initializes the state of each machine in the given object.  This can allow
     # states to be initialized in two groups: static and dynamic.  For example:
     # 
@@ -9,17 +13,28 @@ module StateMachine
     #   end
     # 
     # If no block is provided, then all states will still be initialized.
+    # 
+    # Valid configuration options:
+    # * <tt>:static</tt> - Whether to initialize static states.  If set to
+    #   :force, the state will be initialized regardless of its current value.
+    #   Default is :force.
+    # * <tt>:dynamic</tt> - Whether to initialize dynamic states.  If set to
+    #   :force, the state will be initialized regardless of its current value.
+    #   Default is true.
+    # * <tt>:to</tt> - A hash to write the initialized state to instead of
+    #   writing to the object.  Default is to write directly to the object.
     def initialize_states(object, options = {})
-      options = {:static => true, :dynamic => true}.merge(options)
+      assert_valid_keys(options, :static, :dynamic, :to)
+      options = {:static => :force, :dynamic => true}.merge(options)
       
       each_value do |machine| 
-        machine.initialize_state(object, options) unless machine.dynamic_initial_state?
+        machine.initialize_state(object, :force => options[:static] == :force, :to => options[:to]) unless machine.dynamic_initial_state?
       end if options[:static]
       
       result = yield if block_given?
       
       each_value do |machine|
-        machine.initialize_state(object, options) if machine.dynamic_initial_state?
+        machine.initialize_state(object, :force => options[:dynamic] == :force, :to => options[:to]) if machine.dynamic_initial_state?
       end if options[:dynamic]
       
       result

data/lib/state_machine/state.rb

@@ -190,7 +190,7 @@ module StateMachine
         methods[method.to_sym] = context.instance_method(method)
         
         # Calls the method defined by the current state of the machine
-        context.class_eval <<-end_eval, __FILE__, __LINE__
+        context.class_eval <<-end_eval, __FILE__, __LINE__ + 1
           def #{method}(*args, &block)
             self.class.state_machine(#{machine_name.inspect}).states.match!(self).call(self, #{method.inspect}, lambda {super}, *args, &block)
           end

data/test/unit/integrations/active_model_test.rb

@@ -79,10 +79,6 @@ module ActiveModelTest
       assert StateMachine::Integrations::ActiveModel.matches?(new_model { include ActiveModel::Dirty })
     end
     
-    def test_should_match_if_class_includes_mass_assignment_security_feature
-      assert StateMachine::Integrations::ActiveModel.matches?(new_model { include ActiveModel::MassAssignmentSecurity })
-    end
-    
     def test_should_match_if_class_includes_observing_feature
       assert StateMachine::Integrations::ActiveModel.matches?(new_model { include ActiveModel::Observing })
     end
@@ -186,7 +182,8 @@ module ActiveModelTest
     end
     
     def test_should_raise_exception_for_predicate_without_parameters
-      assert_raise(IndexError) { @record.state? }
+      exception = assert_raise(ArgumentError) { @record.state? }
+      assert_equal 'wrong number of arguments (1 for 2)', exception.message
     end
     
     def test_should_return_false_for_predicate_if_does_not_match_current_value
@@ -234,15 +231,30 @@ module ActiveModelTest
       @machine.state nil, :idling
     end
     
-    def test_should_should_use_initialized_state_when_static
+    def test_should_allow_nil_initial_state_when_static
+      @machine.state nil
+      
       record = @model.new(:state => nil)
       assert_nil record.state
     end
     
-    def test_should_should_not_use_initialized_state_when_dynamic
+    def test_should_allow_nil_initial_state_when_dynamic
+      @machine.state nil
+      
       @machine.initial_state = lambda {:parked}
       record = @model.new(:state => nil)
-      assert_equal 'parked', record.state
+      assert_nil record.state
+    end
+    
+    def test_should_allow_different_initial_state_when_static
+      record = @model.new(:state => 'idling')
+      assert_equal 'idling', record.state
+    end
+    
+    def test_should_allow_different_initial_state_when_dynamic
+      @machine.initial_state = lambda {:parked}
+      record = @model.new(:state => 'idling')
+      assert_equal 'idling', record.state
     end
     
     def test_should_use_default_state_if_protected
@@ -251,7 +263,7 @@ module ActiveModelTest
         attr_protected :state
         
         def initialize(attrs = {})
-          initialize_state_machines(:attributes => attrs) do
+          initialize_state_machines do
             sanitize_for_mass_assignment(attrs).each {|attr, value| send("#{attr}=", value)} if attrs
             @changed_attributes = {}
           end

data/test/unit/integrations/active_record_test.rb

@@ -405,30 +405,33 @@ module ActiveRecordTest
       @record = @model.new
     end
     
-    def test_should_not_define_a_reader_attribute_for_the_attribute
-      assert !@record.respond_to?(:status)
+    def test_should_not_define_a_column_for_the_attribute
+      assert_nil @model.columns_hash['status']
     end
     
-    def test_should_not_define_a_writer_attribute_for_the_attribute
-      assert !@record.respond_to?(:status=)
+    def test_should_define_a_reader_attribute_for_the_attribute
+      assert @record.respond_to?(:status)
     end
     
-    def test_should_define_an_attribute_predicate
-      assert @record.respond_to?(:status?)
+    def test_should_define_a_writer_attribute_for_the_attribute
+      assert @record.respond_to?(:status=)
     end
     
-    def test_should_raise_exception_on_predicate_without_parameters
-      old_verbose, $VERBOSE = $VERBOSE, nil
-      assert_raise(NoMethodError) { @record.status? }
-    ensure
-      $VERBOSE = old_verbose
+    def test_should_define_an_attribute_predicate
+      assert @record.respond_to?(:status?)
     end
   end
   
   class MachineWithNonColumnStateAttributeDefinedTest < BaseTestCase
     def setup
       @model = new_model do
-        attr_accessor :status
+        def status=(value)
+          self['status'] = value
+        end
+        
+        def status
+          self['status']
+        end
       end
       
       @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
@@ -478,15 +481,19 @@ module ActiveRecordTest
     def setup
       @model = new_model
       @machine = StateMachine::Machine.new(@model, :initial => :parked)
-      @machine.state nil, :idling
+      @machine.state :idling
     end
     
     def test_should_allow_nil_initial_state_when_static
+      @machine.state nil
+      
       record = @model.new(:state => nil)
       assert_nil record.state
     end
     
     def test_should_allow_nil_initial_state_when_dynamic
+      @machine.state nil
+      
       @machine.initial_state = lambda {:parked}
       record = @model.new(:state => nil)
       assert_nil record.state

data/test/unit/integrations/data_mapper_test.rb

@@ -339,7 +339,8 @@ module DataMapperTest
     end
     
     def test_should_raise_exception_for_predicate_without_parameters
-      assert_raise(IndexError) { @record.state? }
+      exception = assert_raise(ArgumentError) { @record.state? }
+      assert_equal 'wrong number of arguments (1 for 2)', exception.message
     end
     
     def test_should_return_false_for_predicate_if_does_not_match_current_value
@@ -418,15 +419,19 @@ module DataMapperTest
     def setup
       @resource = new_resource
       @machine = StateMachine::Machine.new(@resource, :initial => :parked)
-      @machine.state nil, :idling
+      @machine.state :idling
     end
     
     def test_should_allow_nil_initial_state_when_static
+      @machine.state nil
+      
       record = @resource.new(:state => nil)
       assert_nil record.state
     end
     
     def test_should_allow_nil_initial_state_when_dynamic
+      @machine.state nil
+      
       @machine.initial_state = lambda {:parked}
       record = @resource.new(:state => nil)
       assert_nil record.state

data/test/unit/integrations/mongo_mapper_test.rb

@@ -413,15 +413,19 @@ module MongoMapperTest
     def setup
       @model = new_model
       @machine = StateMachine::Machine.new(@model, :initial => :parked)
-      @machine.state nil, :idling
+      @machine.state :idling
     end
     
     def test_should_allow_nil_initial_state_when_static
+      @machine.state nil
+      
       record = @model.new(:state => nil)
       assert_nil record.state
     end
     
     def test_should_allow_nil_initial_state_when_dynamic
+      @machine.state nil
+      
       @machine.initial_state = lambda {:parked}
       record = @model.new(:state => nil)
       assert_nil record.state

data/test/unit/integrations/mongoid_test.rb

@@ -3,7 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 # Load library
 require 'rubygems'
 
-gem 'mongoid', ENV['VERSION'] ? "=#{ENV['VERSION']}" : '>=2.0.0.rc.7'
+gem 'mongoid', ENV['VERSION'] ? "=#{ENV['VERSION']}" : '>=2.0.0'
 require 'mongoid'
 
 # Establish database connection
@@ -63,12 +63,12 @@ module MongoidTest
       assert_equal :save, @machine.action
     end
     
-    def test_should_not_have_any_before_callbacks
-      assert_equal 0, @machine.callbacks[:before].size
+    def test_should_create_notifier_before_callback
+      assert_equal 1, @machine.callbacks[:before].size
     end
     
-    def test_should_not_have_any_after_callbacks
-      assert_equal 0, @machine.callbacks[:after].size
+    def test_should_create_notifier_after_callback
+      assert_equal 1, @machine.callbacks[:after].size
     end
   end
   
@@ -339,7 +339,13 @@ module MongoidTest
   class MachineWithNonColumnStateAttributeDefinedTest < BaseTestCase
     def setup
       @model = new_model do
-        attr_accessor :status
+        def status
+          self['status']
+        end
+        
+        def status=(value)
+          self['status'] = value
+        end
       end
       
       @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
@@ -389,15 +395,19 @@ module MongoidTest
     def setup
       @model = new_model
       @machine = StateMachine::Machine.new(@model, :initial => :parked)
-      @machine.state nil, :idling
+      @machine.state :idling
     end
     
     def test_should_allow_nil_initial_state_when_static
+      @machine.state nil
+      
       record = @model.new(:state => nil)
       assert_nil record.state
     end
     
     def test_should_allow_nil_initial_state_when_dynamic
+      @machine.state nil
+      
       @machine.initial_state = lambda {:parked}
       record = @model.new(:state => nil)
       assert_nil record.state
@@ -1345,9 +1355,15 @@ module MongoidTest
       
       MongoidTest.const_set('Foo', @model)
       
-      @subclass = Class.new(@model)
+      @subclass = Class.new(@model) do
+        def self.name
+          'MongoidTest::SubFoo'
+        end
+      end
       @subclass_machine = @subclass.state_machine(:state) {}
       @subclass_machine.state :parked, :idling, :first_gear
+      
+      MongoidTest.const_set('SubFoo', @subclass)
     end
     
     def test_should_only_include_records_with_subclass_states_in_with_scope
@@ -1366,6 +1382,7 @@ module MongoidTest
     end
     
     def teardown
+      MongoidTest.send(:remove_const, 'SubFoo')
       MongoidTest.send(:remove_const, 'Foo')
     end
   end

data/test/unit/integrations/sequel_test.rb

@@ -345,7 +345,8 @@ module SequelTest
     end
     
     def test_should_raise_exception_for_predicate_without_parameters
-      assert_raise(IndexError) { @record.state? }
+      exception = assert_raise(ArgumentError) { @record.state? }
+      assert_equal 'wrong number of arguments (1 for 2)', exception.message
     end
     
     def test_should_return_false_for_predicate_if_does_not_match_current_value
@@ -364,10 +365,9 @@ module SequelTest
   class MachineWithNonColumnStateAttributeUndefinedTest < BaseTestCase
     def setup
       @model = new_model do
-        def initialize
-          # Skip attribute initialization
-          @initialized_state_machines = true
-          super
+        # Prevent attempts to access the status field
+        def method_missing(method, *args)
+          super unless %w(status status=).include?(method.to_s)
         end
       end
       
@@ -417,15 +417,19 @@ module SequelTest
     def setup
       @model = new_model
       @machine = StateMachine::Machine.new(@model, :initial => :parked)
-      @machine.state nil, :idling
+      @machine.state :idling
     end
     
     def test_should_allow_nil_initial_state_when_static
+      @machine.state nil
+      
       record = @model.new(:state => nil)
       assert_nil record.state
     end
     
     def test_should_allow_nil_initial_state_when_dynamic
+      @machine.state nil
+      
       @machine.initial_state = lambda {:parked}
       record = @model.new(:state => nil)
       assert_nil record.state

data/test/unit/machine_collection_test.rb

@@ -31,6 +31,10 @@ class MachineCollectionStateInitializationTest < Test::Unit::TestCase
     @object.alarm_state = nil
   end
   
+  def test_should_raise_exception_if_invalid_option_specified
+    assert_raise(ArgumentError) {@machines.initialize_states(@object, :invalid => true)}
+  end
+  
   def test_should_only_initialize_static_states_prior_to_block
     @machines.initialize_states(@object) do
       @state_in_block = @object.state
@@ -63,11 +67,47 @@ class MachineCollectionStateInitializationTest < Test::Unit::TestCase
     assert_equal 'active', @object.alarm_state
   end
   
+  def test_should_initialize_existing_static_states_by_default
+    @object.state = 'idling'
+    @machines.initialize_states(@object)
+    assert_equal 'parked', @object.state
+  end
+  
+  def test_should_initialize_existing_static_states_if_forced
+    @object.state = 'idling'
+    @machines.initialize_states(@object, :static => :force)
+    assert_equal 'parked', @object.state
+  end
+  
+  def test_should_not_initialize_existing_static_states_if_not_forced
+    @object.state = 'idling'
+    @machines.initialize_states(@object, :static => true)
+    assert_equal 'idling', @object.state
+  end
+  
   def test_should_skip_dynamic_states_if_disabled
     @machines.initialize_states(@object, :dynamic => false)
     assert_equal 'parked', @object.state
     assert_nil @object.alarm_state
   end
+  
+  def test_should_not_initialize_existing_dynamic_states_by_default
+    @object.alarm_state = 'inactive'
+    @machines.initialize_states(@object)
+    assert_equal 'inactive', @object.alarm_state
+  end
+  
+  def test_should_initialize_existing_dynamic_states_if_forced
+    @object.alarm_state = 'inactive'
+    @machines.initialize_states(@object, :dynamic => :force)
+    assert_equal 'active', @object.alarm_state
+  end
+  
+  def test_should_not_initialize_existing_dynamic_states_if_not_forced
+    @object.alarm_state = 'inactive'
+    @machines.initialize_states(@object, :dynamic => true)
+    assert_equal 'inactive', @object.alarm_state
+  end
 end
 
 class MachineCollectionFireTest < Test::Unit::TestCase

data/test/unit/machine_test.rb

@@ -264,13 +264,7 @@ end
 
 class MachineWithStaticInitialStateTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new do
-      def initialize(attributes = {})
-        attributes.each {|attr, value| send("#{attr}=", value)}
-        super()
-      end
-    end
-    
+    @klass = Class.new
     @machine = StateMachine::Machine.new(@klass, :initial => :parked)
   end
   
@@ -293,21 +287,21 @@ class MachineWithStaticInitialStateTest < Test::Unit::TestCase
     assert @machine.state(:parked).initial
   end
   
-  def test_should_set_initial_state_if_existing_is_nil
-    object = @klass.new(:state => nil)
-    assert_equal 'parked', object.state
+  def test_should_set_initial_state_on_created_object
+    assert_equal 'parked', @klass.new.state
   end
   
-  def test_should_set_initial_state_if_existing_is_empty
-    object = @klass.new(:state => '')
+  def test_should_still_set_initial_state_even_if_not_empty
+    @klass.class_eval do
+      def initialize(attributes = {})
+        self.state = 'idling'
+        super()
+      end
+    end
+    object = @klass.new
     assert_equal 'parked', object.state
   end
   
-  def test_should_not_set_initial_state_if_existing_is_not_empty
-    object = @klass.new(:state => 'idling')
-    assert_equal 'idling', object.state
-  end
-  
   def test_should_set_initial_state_prior_to_initialization
     base = Class.new do
       attr_accessor :state_on_init
@@ -360,6 +354,17 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
     assert_equal 'default', @object.state
   end
   
+  def test_should_not_set_initial_state_even_if_not_empty
+    @klass.class_eval do
+      def initialize(attributes = {})
+        self.state = 'parked'
+        super()
+      end
+    end
+    object = @klass.new
+    assert_equal 'parked', object.state
+  end
+  
   def test_should_set_initial_state_after_initialization
     base = Class.new do
       attr_accessor :state_on_init
@@ -383,13 +388,7 @@ 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
+    @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :initialize => false)
     
     @object = @klass.new
     @object.state = nil
@@ -414,6 +413,30 @@ class MachineStateInitializationTest < Test::Unit::TestCase
     
     assert_equal 'idling', @object.state
   end
+  
+  def test_should_set_states_if_not_empty_and_forced
+    @object.state = 'idling'
+    @machine.initialize_state(@object, :force => true)
+    
+    assert_equal 'parked', @object.state
+  end
+  
+  def test_should_not_set_state_if_nil_and_nil_is_valid_state
+    @machine.state :initial, :value => nil
+    @machine.initialize_state(@object)
+    
+    assert_nil @object.state
+  end
+  
+  def test_should_write_to_hash_if_specified
+    @machine.initialize_state(@object, :to => hash = {})
+    assert_equal expected = {'state' => 'parked'}, hash
+  end
+  
+  def test_should_not_write_to_object_if_writing_to_hash
+    @machine.initialize_state(@object, :to => {})
+    assert_nil @object.state
+  end
 end
 
 class MachineWithCustomActionTest < Test::Unit::TestCase
@@ -1021,11 +1044,6 @@ class MachineWithHelpersTest < Test::Unit::TestCase
   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
@@ -1079,61 +1097,25 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
     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]
+    assert_equal 2, helper_args.length
+    assert_equal [@machine, @object], helper_args
   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]
+    assert_equal 5, helper_args.length
+    assert_equal [@machine, @object, 1, 2, 3], helper_args
   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
+  def test_should_allow_string_evaluation
+    @machine.define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+      def state
+        'parked'
+      end
+    end_eval
+    assert_equal 'parked', @object.state
   end
 end
 
@@ -1187,59 +1169,25 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
     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]
+    assert_equal 2, helper_args.length
+    assert_equal [@machine, @klass], helper_args
   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]
+    assert_equal 5, helper_args.length
+    assert_equal [@machine, @klass, 1, 2, 3], helper_args
   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
+  def test_should_allow_string_evaluation
+    @machine.define_helper :class, <<-end_eval, __FILE__, __LINE__ + 1
+      def states
+        []
+      end
+    end_eval
+    assert_equal [], @klass.states
   end
 end
 
@@ -2174,37 +2122,6 @@ 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
@@ -2228,7 +2145,7 @@ class MachineWithExistingMachinesWithSameAttributesOnOwnerClassTest < Test::Unit
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass, :initial => :parked)
-    @second_machine = StateMachine::Machine.new(@klass, :public_state, :attribute => :state)
+    @second_machine = StateMachine::Machine.new(@klass, :public_state, :initial => :idling, :attribute => :state)
     @object = @klass.new
   end
   
@@ -2237,10 +2154,30 @@ class MachineWithExistingMachinesWithSameAttributesOnOwnerClassTest < Test::Unit
     assert_equal expected, @klass.state_machines
   end
   
-  def test_should_initialize_based_on_first_available_initial_state
+  def test_should_write_to_state_only_once
+    @klass.class_eval do
+      attr_reader :write_count
+      
+      def state=(value)
+        @write_count ||= 0
+        @write_count += 1
+      end
+    end
+    object = @klass.new
+    
+    assert_equal 1, object.write_count
+  end
+  
+  def test_should_initialize_based_on_first_machine
     assert_equal 'parked', @object.state
   end
   
+  def test_should_not_allow_second_machine_to_initialize_state
+    @object.state = nil
+    @second_machine.initialize_state(@object)
+    assert_nil @object.state
+  end
+  
   def test_should_allow_transitions_on_both_machines
     @machine.event :ignite do
       transition :parked => :idling