/test/unit/machine_test.rb

Large files files are truncated, but you can click here to view the full file

require File.expand_path(File.dirname(__FILE__) + '/../test_helper')

class MachineByDefaultTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
    @object = @klass.new
  end
  
  def test_should_have_an_owner_class
    assert_equal @klass, @machine.owner_class
  end
  
  def test_should_have_a_name
    assert_equal :state, @machine.name
  end
  
  def test_should_have_an_attribute
    assert_equal :state, @machine.attribute
  end
  
  def test_should_prefix_custom_attributes_with_attribute
    assert_equal :state_event, @machine.attribute(:event)
  end
  
  def test_should_have_an_initial_state
    assert_not_nil @machine.initial_state(@object)
  end
  
  def test_should_have_a_nil_initial_state
    assert_nil @machine.initial_state(@object).value
  end
  
  def test_should_not_have_any_events
    assert !@machine.events.any?
  end
  
  def test_should_not_have_any_before_callbacks
    assert @machine.callbacks[:before].empty?
  end
  
  def test_should_not_have_any_after_callbacks
    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
  
  def test_should_use_tranactions
    assert_equal true, @machine.use_transactions
  end
  
  def test_should_not_have_a_namespace
    assert_nil @machine.namespace
  end
  
  def test_should_have_a_nil_state
    assert_equal [nil], @machine.states.keys
  end
  
  def test_should_set_initial_on_nil_state
    assert @machine.state(nil).initial
  end
  
  def test_should_generate_default_messages
    assert_equal 'is invalid', @machine.generate_message(:invalid)
    assert_equal 'cannot transition when parked', @machine.generate_message(:invalid_event, [[:state, :parked]])
    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
  
  def test_should_not_be_extended_by_the_active_record_integration
    assert !(class << @machine; ancestors; end).include?(StateMachine::Integrations::ActiveRecord)
  end
  
  def test_should_not_be_extended_by_the_datamapper_integration
    assert !(class << @machine; ancestors; end).include?(StateMachine::Integrations::DataMapper)
  end
  
  def test_should_not_be_extended_by_the_mongo_mapper_integration
    assert !(class << @machine; ancestors; end).include?(StateMachine::Integrations::MongoMapper)
  end
  
  def test_should_not_be_extended_by_the_sequel_integration
    assert !(class << @machine; ancestors; end).include?(StateMachine::Integrations::Sequel)
  end
  
  def test_should_define_a_reader_attribute_for_the_attribute
    assert @object.respond_to?(:state)
  end
  
  def test_should_define_a_writer_attribute_for_the_attribute
    assert @object.respond_to?(:state=)
  end
  
  def test_should_define_a_predicate_for_the_attribute
    assert @object.respond_to?(:state?)
  end
  
  def test_should_define_a_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
  
  def test_should_define_a_transition_reader_for_the_attribute
    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
  
  def test_should_not_define_an_event_attribute_writer
    assert !@object.respond_to?(:state_event=)
  end
  
  def test_should_not_define_an_event_transition_attribute_reader
    assert !@object.respond_to?(:state_event_transition)
  end
  
  def test_should_not_define_an_event_transition_attribute_writer
    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
  
  def test_should_not_define_singular_without_scope
    assert !@klass.respond_to?(:without_state)
  end
  
  def test_should_not_define_plural_with_scope
    assert !@klass.respond_to?(:with_states)
  end
  
  def test_should_not_define_plural_without_scope
    assert !@klass.respond_to?(:without_states)
  end
  
  def test_should_extend_owner_class_with_class_methods
    assert (class << @klass; ancestors; end).include?(StateMachine::ClassMethods)
  end
  
  def test_should_include_instance_methods_in_owner_class
    assert @klass.included_modules.include?(StateMachine::InstanceMethods)
  end
  
  def test_should_define_state_machines_reader
    expected = {:state => @machine}
    assert_equal expected, @klass.state_machines
  end
end

class MachineWithCustomNameTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass, :status)
    @object = @klass.new
  end
  
  def test_should_use_custom_name
    assert_equal :status, @machine.name
  end
  
  def test_should_use_custom_name_for_attribute
    assert_equal :status, @machine.attribute
  end
  
  def test_should_prefix_custom_attributes_with_custom_name
    assert_equal :status_event, @machine.attribute(:event)
  end
  
  def test_should_define_a_reader_attribute_for_the_attribute
    assert @object.respond_to?(:status)
  end
  
  def test_should_define_a_writer_attribute_for_the_attribute
    assert @object.respond_to?(:status=)
  end
  
  def test_should_define_a_predicate_for_the_attribute
    assert @object.respond_to?(:status?)
  end
  
  def test_should_define_a_name_reader_for_the_attribute
    assert @object.respond_to?(:status_name)
  end
  
  def test_should_define_an_event_reader_for_the_attribute
    assert @object.respond_to?(:status_events)
  end
  
  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 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
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
  end
  
  def test_should_not_have_dynamic_initial_state
    assert !@machine.dynamic_initial_state?
  end
  
  def test_should_have_an_initial_state
    object = @klass.new
    assert_equal 'parked', @machine.initial_state(object).value
  end
  
  def test_should_write_to_attribute_when_initializing_state
    object = @klass.allocate
    @machine.initialize_state(object)
    assert_equal 'parked', object.state
  end
  
  def test_should_set_initial_on_state_object
    assert @machine.state(:parked).initial
  end
  
  def test_should_set_initial_state_on_created_object
    assert_equal 'parked', @klass.new.state
  end
  
  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_set_initial_state_prior_to_initialization
    base = Class.new do
      attr_accessor :state_on_init
      
      def initialize
        self.state_on_init = state
      end
    end
    klass = Class.new(base)
    machine = StateMachine::Machine.new(klass, :initial => :parked)
    
    assert_equal 'parked', klass.new.state_on_init
  end
  
  def test_should_be_included_in_known_states
    assert_equal [:parked], @machine.states.keys
  end
end

class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
  def setup
    @klass = Class.new do
      attr_accessor :initial_state
    end
    @machine = StateMachine::Machine.new(@klass, :initial => lambda {|object| object.initial_state || :default})
    @machine.state :parked, :idling, :default
    @object = @klass.new
  end
  
  def test_should_have_dynamic_initial_state
    assert @machine.dynamic_initial_state?
  end
  
  def test_should_use_the_record_for_determining_the_initial_state
    @object.initial_state = :parked
    assert_equal :parked, @machine.initial_state(@object).name
    
    @object.initial_state = :idling
    assert_equal :idling, @machine.initial_state(@object).name
  end
  
  def test_should_write_to_attribute_when_initializing_state
    object = @klass.allocate
    object.initial_state = :parked
    @machine.initialize_state(object)
    assert_equal 'parked', object.state
  end
  
  def test_should_set_initial_state_on_created_object
    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
      
      def initialize
        self.state_on_init = state
      end
    end
    klass = Class.new(base)
    machine = StateMachine::Machine.new(klass, :initial => lambda {|object| :parked})
    machine.state :parked
    
    assert_nil klass.new.state_on_init
  end
  
  def test_should_not_be_included_in_known_states
    assert_equal [:parked, :idling, :default], @machine.states.map {|state| state.name}
  end
end

class MachineStateInitializationTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass, :state, :initial => :parked, :initialize => false)
    
    @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
  
  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
  def setup
    @machine = StateMachine::Machine.new(Class.new, :action => :save)
  end
  
  def test_should_use_the_custom_action
    assert_equal :save, @machine.action
  end
end

class MachineWithNilActionTest < Test::Unit::TestCase
  def setup
    integration = Module.new do
      include StateMachine::Integrations::Base
      
      @defaults = {:action => :save}
    end
    StateMachine::Integrations.const_set('Custom', integration)
    @machine = StateMachine::Machine.new(Class.new, :action => nil, :integration => :custom)
  end
  
  def test_should_have_a_nil_action
    assert_nil @machine.action
  end
  
  def teardown
    StateMachine::Integrations.send(:remove_const, 'Custom')
  end
end

class MachineWithoutIntegrationTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
    @object = @klass.new
  end
  
  def test_transaction_should_yield
    @yielded = false
    @machine.within_transaction(@object) do
      @yielded = true
    end
    
    assert @yielded
  end
  
  def test_invalidation_should_do_nothing
    assert_nil @machine.invalidate(@object, :state, :invalid_transition, [[:event, 'park']])
  end
  
  def test_reset_should_do_nothing
    assert_nil @machine.reset(@object)
  end
end

class MachineWithCustomIntegrationTest < Test::Unit::TestCase
  def setup
    integration = Module.new do
      include StateMachine::Integrations::Base
      
      def self.available?
        true
      end
      
      def self.matches?(klass)
        true
      end
    end
    
    StateMachine::Integrations.const_set('Custom', integration)
  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)
  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
      end
    end
    
    machine = StateMachine::Machine.new(Class.new)
    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
      end
    end
    
    machine = StateMachine::Machine.new(Class.new)
    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)
  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)
  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)
  end
  
  def teardown
    StateMachine::Integrations.send(:remove_const, 'Custom')
  end
end

class MachineWithIntegrationTest < Test::Unit::TestCase
  def setup
    StateMachine::Integrations.const_set('Custom', Module.new do  
      include StateMachine::Integrations::Base
      
      @defaults = {:action => :save, :use_transactions => false}
          
      attr_reader :initialized, :with_scopes, :without_scopes, :ran_transaction
      
      def after_initialize
        @initialized = true
      end
      
      def create_with_scope(name)
        (@with_scopes ||= []) << name
        lambda {}
      end
      
      def create_without_scope(name)
        (@without_scopes ||= []) << name
        lambda {}
      end
      
      def transaction(object)
        @ran_transaction = true
        yield
      end
    end)
    
    @machine = StateMachine::Machine.new(Class.new, :integration => :custom)
  end
  
  def test_should_call_after_initialize_hook
    assert @machine.initialized
  end
  
  def test_should_use_the_default_action
    assert_equal :save, @machine.action
  end
  
  def test_should_use_the_custom_action_if_specified
    machine = StateMachine::Machine.new(Class.new, :integration => :custom, :action => :save!)
    assert_equal :save!, machine.action
  end
  
  def test_should_use_the_default_use_transactions
    assert_equal false, @machine.use_transactions
  end
  
  def test_should_use_the_custom_use_transactions_if_specified
    machine = StateMachine::Machine.new(Class.new, :integration => :custom, :use_transactions => true)
    assert_equal true, machine.use_transactions
  end
  
  def test_should_define_a_singular_and_plural_with_scope
    assert_equal %w(with_state with_states), @machine.with_scopes
  end
  
  def test_should_define_a_singular_and_plural_without_scope
    assert_equal %w(without_state without_states), @machine.without_scopes
  end
  
  def teardown
    StateMachine::Integrations.send(:remove_const, 'Custom')
  end
end

class MachineWithActionUndefinedTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass, :action => :save)
    @object = @klass.new
  end
  
  def test_should_define_an_event_attribute_reader
    assert @object.respond_to?(:state_event)
  end
  
  def test_should_define_an_event_attribute_writer
    assert @object.respond_to?(:state_event=)
  end
  
  def test_should_define_an_event_transition_attribute_reader
    assert @object.respond_to?(:state_event_transition)
  end
  
  def test_should_define_an_event_transition_attribute_writer
    assert @object.respond_to?(:state_event_transition=)
  end
  
  def test_should_not_define_action
    assert !@object.respond_to?(:save)
  end
  
  def test_should_not_mark_action_hook_as_defined
    assert !@machine.action_hook?
  end
end

class MachineWithActionDefinedInClassTest < Test::Unit::TestCase
  def setup
    @klass = Class.new do
      def save
      end
    end
    
    @machine = StateMachine::Machine.new(@klass, :action => :save)
    @object = @klass.new
  end
  
  def test_should_define_an_event_attribute_reader
    assert @object.respond_to?(:state_event)
  end
  
  def test_should_define_an_event_attribute_writer
    assert @object.respond_to?(:state_event=)
  end
  
  def test_should_define_an_event_transition_attribute_reader
    assert @object.respond_to?(:state_event_transition)
  end
  
  def test_should_define_an_event_transition_attribute_writer
    assert @object.respond_to?(:state_event_transition=)
  end
  
  def test_should_not_define_action
    assert !@klass.ancestors.any? {|ancestor| ancestor != @klass && ancestor.method_defined?(:save)}
  end
  
  def test_should_not_mark_action_hook_as_defined
    assert !@machine.action_hook?
  end
end

class MachineWithActionDefinedInIncludedModuleTest < Test::Unit::TestCase
  def setup
    @mod = mod = Module.new do
      def save
      end
    end
    
    @klass = Class.new do
      include mod
    end
    
    @machine = StateMachine::Machine.new(@klass, :action => :save)
    @object = @klass.new
  end
  
  def test_should_define_an_event_attribute_reader
    assert @object.respond_to?(:state_event)
  end
  
  def test_should_define_an_event_attribute_writer
    assert @object.respond_to?(:state_event=)
  end
  
  def test_should_define_an_event_transition_attribute_reader
    assert @object.respond_to?(:state_event_transition)
  end
  
  def test_should_define_an_event_transition_attribute_writer
    assert @object.respond_to?(:state_event_transition=)
  end
  
  def test_should_define_action
    assert @klass.ancestors.any? {|ancestor| ![@klass, @mod].include?(ancestor) && ancestor.method_defined?(:save)}
  end
  
  def test_should_keep_action_public
    assert @klass.public_method_defined?(:save)
  end
  
  def test_should_mark_action_hook_as_defined
    assert @machine.action_hook?
  end
end

class MachineWithActionDefinedInSuperclassTest < Test::Unit::TestCase
  def setup
    @superclass = Class.new do
      def save
      end
    end
    @klass = Class.new(@superclass)
    
    @machine = StateMachine::Machine.new(@klass, :action => :save)
    @object = @klass.new
  end
  
  def test_should_define_an_event_attribute_reader
    assert @object.respond_to?(:state_event)
  end
  
  def test_should_define_an_event_attribute_writer
    assert @object.respond_to?(:state_event=)
  end
  
  def test_should_define_an_event_transition_attribute_reader
    assert @object.respond_to?(:state_event_transition)
  end
  
  def test_should_define_an_event_transition_attribute_writer
    assert @object.respond_to?(:state_event_transition=)
  end
  
  def test_should_define_action
    assert @klass.ancestors.any? {|ancestor| ![@klass, @superclass].include?(ancestor) && ancestor.method_defined?(:save)}
  end
  
  def test_should_keep_action_public
    assert @klass.public_method_defined?(:save)
  end
  
  def test_should_mark_action_hook_as_defined
    assert @machine.action_hook?
  end
end

class MachineWithPrivateActionTest < Test::Unit::TestCase
  def setup
    @superclass = Class.new do
      private
      def save
      end
    end
    @klass = Class.new(@superclass)
    
    @machine = StateMachine::Machine.new(@klass, :action => :save)
    @object = @klass.new
  end
  
  def test_should_define_an_event_attribute_reader
    assert @object.respond_to?(:state_event)
  end
  
  def test_should_define_an_event_attribute_writer
    assert @object.respond_to?(:state_event=)
  end
  
  def test_should_define_an_event_transition_attribute_reader
    assert @object.respond_to?(:state_event_transition)
  end
  
  def test_should_define_an_event_transition_attribute_writer
    assert @object.respond_to?(:state_event_transition=)
  end
  
  def test_should_define_action
    assert @klass.ancestors.any? {|ancestor| ![@klass, @superclass].include?(ancestor) && ancestor.private_method_defined?(:save)}
  end
  
  def test_should_keep_action_private
    assert @klass.private_method_defined?(:save)
  end
  
  def test_should_mark_action_hook_as_defined
    assert @machine.action_hook?
  end
end

class MachineWithActionAlreadyOverriddenTest < Test::Unit::TestCase
  def setup
    @superclass = Class.new do
      def save
      end
    end
    @klass = Class.new(@superclass)
    
    StateMachine::Machine.new(@klass, :action => :save)
    @machine = StateMachine::Machine.new(@klass, :status, :action => :save)
    @object = @klass.new
  end
  
  def test_should_not_redefine_action
    assert_equal 1, @klass.ancestors.select {|ancestor| ![@klass, @superclass].include?(ancestor) && ancestor.method_defined?(:save)}.length
  end
  
  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 = []
      
      def create_with_scope(name)
        StateMachine::Integrations::Custom.with_scopes << name
        lambda {}
      end
      
      def create_without_scope(name)
        StateMachine::Integrations::Custom.without_scopes << name
        lambda {}
      end
    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
    assert_equal %w(with_state with_staties), @integration.with_scopes
  end
  
  def test_should_define_a_singular_and_plural_without_scope
    assert_equal %w(without_state without_staties), @integration.without_scopes
  end
  
  def teardown
    StateMachine::Integrations.send(:remove_const, 'Custom')
  end
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
    end
    StateMachine::Integrations.const_set('Custom', @integration)
    
    @klass = Class.new do
      attr_accessor :error
    end
    
    @machine = StateMachine::Machine.new(@klass, :integration => :custom, :messages => {:invalid_transition => 'cannot %s'})
    @machine.state :parked
    
    @object = @klass.new
    @object.state = 'parked'
  end
  
  def test_generate_custom_message
    assert_equal 'cannot park', @machine.generate_message(:invalid_transition, [[:event, :park]])
  end
  
  def test_use_custom_message
    @machine.invalidate(@object, :state, :invalid_transition, [[:event, 'park']])
    assert_equal 'cannot park', @object.error
  end
  
  def teardown
    StateMachine::Integrations.send(:remove_const, 'Custom')
  end
end

class MachineTest < Test::Unit::TestCase
  def test_should_raise_exception_if_invalid_option_specified
    assert_raise(ArgumentError) {StateMachine::Machine.new(Class.new, :invalid => true)}
  end
  
  def test_should_not_raise_exception_if_custom_messages_specified
    assert_nothing_raised {StateMachine::Machine.new(Class.new, :messages => {:invalid_transition => 'custom'})}
  end
  
  def test_should_evaluate_a_block_during_initialization
    called = true
    StateMachine::Machine.new(Class.new) do
      called = respond_to?(:event)
    end
    
    assert called
  end
  
  def test_should_provide_matcher_helpers_during_initialization
    matchers = []
    
    StateMachine::Machine.new(Class.new) do
      matchers = [all, any, same]
    end
    
    assert_equal [StateMachine::AllMatcher.instance, StateMachine::AllMatcher.instance, StateMachine::LoopbackMatcher.instance], matchers
  end
end

class MachineAfterBeingCopiedTest < Test::Unit::TestCase
  def setup
    @machine = StateMachine::Machine.new(Class.new, :state, :initial => :parked)
    @machine.event(:ignite) {}
    @machine.before_transition(lambda {})
    @machine.after_transition(lambda {})
    @machine.around_transition(lambda {})
    @machine.after_failure(lambda {})
    
    @copied_machine = @machine.clone
  end
  
  def test_should_not_have_the_same_collection_of_states
    assert_not_same @copied_machine.states, @machine.states
  end
  
  def test_should_copy_each_state
    assert_not_same @copied_machine.states[:parked], @machine.states[:parked]
  end
  
  def test_should_update_machine_for_each_state
    assert_equal @copied_machine, @copied_machine.states[:parked].machine
  end
  
  def test_should_not_update_machine_for_original_state
    assert_equal @machine, @machine.states[:parked].machine
  end
  
  def test_should_not_have_the_same_collection_of_events
    assert_not_same @copied_machine.events, @machine.events
  end
  
  def test_should_copy_each_event
    assert_not_same @copied_machine.events[:ignite], @machine.events[:ignite]
  end
  
  def test_should_update_machine_for_each_event
    assert_equal @copied_machine, @copied_machine.events[:ignite].machine
  end
  
  def test_should_not_update_machine_for_original_event
    assert_equal @machine, @machine.events[:ignite].machine
  end
  
  def test_should_not_have_the_same_callbacks
    assert_not_same @copied_machine.callbacks, @machine.callbacks
  end
  
  def test_should_not_have_the_same_before_callbacks
    assert_not_same @copied_machine.callbacks[:before], @machine.callbacks[:before]
  end
  
  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
  def setup
    @original_class = Class.new
    @machine = StateMachine::Machine.new(@original_class)
    
    @new_class = Class.new(@original_class)
    @new_machine = @machine.clone
    @new_machine.owner_class = @new_class
    
    @object = @new_class.new
  end
  
  def test_should_update_owner_class
    assert_equal @new_class, @new_machine.owner_class
  end
  
  def test_should_not_change_original_owner_class
    assert_equal @original_class, @machine.owner_class
  end
  
  def test_should_change_the_associated_machine_in_the_new_class
    assert_equal @new_machine, @new_class.state_machines[:state]
  end
  
  def test_should_not_change_the_associated_machine_in_the_original_class
    assert_equal @machine, @original_class.state_machines[:state]
  end
end

class MachineAfterChangingInitialState < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @machine.initial_state = :idling
    
    @object = @klass.new
  end
  
  def test_should_change_the_initial_state
    assert_equal :idling, @machine.initial_state(@object).name
  end
  
  def test_should_include_in_known_states
    assert_equal [:parked, :idling], @machine.states.map {|state| state.name}
  end
  
  def test_should_reset_original_initial_state
    assert !@machine.state(:parked).initial
  end
  
  def test_should_set_new_state_to_initial
    assert @machine.state(:idling).initial
  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
end

class MachineWithInstanceHelpersTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
    @object = @klass.new
  end
  
  def test_should_not_redefine_existing_public_methods
    @klass.class_eval do
      def state
        'parked'
      end
    end
    
    @machine.define_helper(:instance, :state) {}
    assert_equal 'parked', @object.state
  end
  
  def test_should_not_redefine_existing_protected_methods
    @klass.class_eval do
      protected
        def state
          'parked'
        end
    end
    
    @machine.define_helper(:instance, :state) {}
    assert_equal 'parked', @object.send(:state)
  end
  
  def test_should_not_redefine_existing_private_methods
    @klass.class_eval do
      private
        def state
          'parked'
        end
    end
    
    @machine.define_helper(:instance, :state) {}
    assert_equal 'parked', @object.send(:state)
  end
  
  def test_should_define_nonexistent_methods
    @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 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 5, helper_args.length
    assert_equal [@machine, @object, 1, 2, 3], helper_args
  end
  
  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

class MachineWithClassHelpersTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
  end
  
  def test_should_not_redefine_existing_public_methods
    class << @klass
      def states
        []
      end
    end
    
    @machine.define_helper(:class, :states) {}
    assert_equal [], @klass.states
  end
  
  def test_should_not_redefine_existing_protected_methods
    class << @klass
      protected
        def states
          []
        end
    end
    
    @machine.define_helper(:class, :states) {}
    assert_equal [], @klass.send(:states)
  end
  
  def test_should_not_redefine_existing_private_methods
    class << @klass
      private
        def states
          []
        end
    end
    
    @machine.define_helper(:class, :states) {}
    assert_equal [], @klass.send(:states)
  end
  
  def test_should_define_nonexistent_methods
    @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 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 5, helper_args.length
    assert_equal [@machine, @klass, 1, 2, 3], helper_args
  end
  
  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

class MachineWithConflictingHelpersTest < Test::Unit::TestCase
  def setup
    @klass = Class.new do
      def self.with_state
        :with_state
      end
      
      def self.with_states
        :with_states
      end
      
      def self.without_state
        :without_state
      end
      
      def self.without_states
        :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
        'parked'
      end
      
      def state=(value)
        self.status = value
      end
      
      def state?
        true
      end
      
      def state_name
        :parked
      end
      
      def human_state_name
        'parked'
      end
      
      def state_events
        [:ignite]
      end
      
      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
      
      def create_without_scope(name)
        lambda {|klass, values| []}
      end
    end)
    
    @machine = StateMachine::Machine.new(@klass, :integration => :custom)
    @machine.state :parked, :idling
    @machine.event :ignite
    @object = @klass.new
  end
  
  def test_should_not_redefine_singular_with_scope
    assert_equal :with_state, @klass.with_state
  end
  
  def test_should_not_redefine_plural_with_scope
    assert_equal :with_states, @klass.with_states
  end
  
  def test_should_not_redefine_singular_without_scope
    assert_equal :without_state, @klass.without_state
  end
  
  def test_should_not_redefine_plural_without_scope
    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
  
  def test_should_not_redefine_attribute_writer
    @object.state = 'parked'
    assert_equal 'parked', @object.status
  end
  
  def test_should_not_define_attribute_predicate
    assert @object.state?
  end
  
  def test_should_not_redefine_attribute_name_reader
    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
  
  def test_should_not_redefine_attribute_transitions_reader
    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)
        super == []
      end
      
      def self.with_states(*states)
        super == []
      end
      
      def self.without_state(*states)
        super == []
      end
      
      def self.without_states(*states)
        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
        super || 'parked'
      end
      
      def state=(value)
        super
        self.status = value
      end
      
      def state?(state)
        super ? 1 : 0
      end
      
      def state_name
        super == :parked ? 1 : 0
      end
      
      def human_state_name
        super == 'parked' ? 1 : 0
      end
      
      def state_events
        super == []
      end
      
      def state_transitions
        super == []
      end
      
      def state_paths
        super == []
      end
    end
    
    assert_equal true, @klass.with_state
    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
    assert_equal true, @object.state_paths
  end
  
  def teardown
    StateMachine::Integrations.send(:remove_const, 'Custom')
  end
end

class MachineWithoutInitializeTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @object = @klass.new
  end
  
  def test_should_initialize_state
    assert_equal 'parked', @object.state
  end
end

class MachineWithInitializeWithoutSuperTest < Test::Unit::TestCase
  def setup
    @klass = Class.new do
      def initialize
      end
    end
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @object = @klass.new
  end
  
  def test_should_not_initialize_state
    assert_nil @object.state
  end
end

class MachineWithInitializeAndSuperTest < Test::Unit::TestCase
  def setup
    @klass = Class.new do
      def initialize
        super()
      end
    end
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @object = @klass.new
  end
  
  def test_should_initialize_state
    assert_equal 'parked', @object.state
  end
end

class MachineWithInitializeArgumentsAndBlockTest < Test::Unit::TestCase
  def setup
    @superclass = Class.new do
      attr_reader :args
      attr_reader :block_given
      
      def initialize(*args)
        @args = args
        @block_given = block_given?
      end
    end
    @klass = Class.new(@superclass)
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @object = @klass.new(1, 2, 3) {}
  end
  
  def test_should_initialize_state
    assert_equal 'parked', @object.state
  end
  
  def test_should_preserve_arguments
    assert_equal [1, 2, 3], @object.args
  end
  
  def test_should_preserve_block
    assert @object.block_given
  end
end

class MachineWithCustomInitializeTest < Test::Unit::TestCase
  def setup
    @klass = Class.new do
      def initialize
        initialize_state_machines
      end
    end
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @object = @klass.new
  end
  
  def test_should_initialize_state
    assert_equal 'parked', @object.state
  end
end

class MachinePersistenceTest < Test::Unit::TestCase
  def setup
    @klass = Class.new do
      attr_accessor :state_event
    end
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @object = @klass.new
  end
  
  def test_should_allow_reading_state
    assert_equal 'parked', @machine.read(@object, :state)
  end
  
  def test_should_allow_reading_custom_attributes
    assert_nil @machine.read(@object, :event)
    
    @object.state_event = 'ignite'
    assert_equal 'ignite', @machine.read(@object, :event)
  end
  
  def test_should_allow_reading_custom_instance_variables
    @klass.class_eval do
      attr_writer :state_value
    end
    
    @object.state_value = 1
    assert_raise(NoMethodError) { @machine.read(@object, :value) }
    assert_equal 1, @machine.read(@object, :value, true)
  end
  
  def test_should_allow_writing_state
    @machine.write(@object, :state, 'idling')
    assert_equal 'idling', @object.state
  end
  
  def test_should_allow_writing_custom_attributes
    @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


class MachineWithStatesTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
    @parked, @idling = @machine.state :parked, :idling
    
    @object = @klass.new
  end
  
  def test_should_have_states
    assert_equal [nil, :parked, :idling], @machine.states.map {|state| state.name}
  end
  
  def test_should_allow_state_lookup_by_name
    assert_equal @parked, @machine.states[:parked]
  end
  
  def test_should_allow_state_lookup_by_value
    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
  
  def test_should_not_use_custom_matcher
    assert_nil @parked.matcher
  end
  
  def test_should_raise_exception_if_invalid_option_specified
    exception = assert_raise(ArgumentError) {@machine.state(:first_gear, :invalid => true)}
    assert_equal 'Invalid key(s): invalid', exception.message
  end
end

class MachineWithStatesWithCustomValuesTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
    @state = @machine.state :parked, :value => 1
    
    @object = @klass.new
    @object.state = 1
  end
  
  def test_should_use_custom_value
    assert_equal 1, @state.value
  end
  
  def test_should_allow_lookup_by_custom_value
    assert_equal @state, @machine.states[1, :value]
  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
    @machine = StateMachine::Machine.new(@klass)
    @machine.state :parked
  end
  
  def test_should_not_evaluate_value_during_definition
    assert_nothing_raised { @machine.state :parked, :value => lambda {raise ArgumentError} }
  end
  
  def test_should_not_evaluate_if_not_initial_state
    @machine.state :parked, :value => lambda {raise ArgumentError}
    assert_nothing_raised { @klass.new }
  end
end

class MachineWithStateWithMatchersTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
    @state = @machine.state :parked, :if => lambda {|value| !value.nil?}
    
    @object = @klass.new
    @object.state = 1
  end
  
  def test_should_use_custom_matcher
    assert_not_nil @state.matcher
    assert @state.matches?(1)
    assert !@state.matches?(nil)
  end
end

class MachineWithCachedStateTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @state = @machine.state :parked, :value => lambda {Object.new}, :cache => true
    
    @object = @klass.new
  end
  
  def test_should_use_evaluated_value
    assert_instance_of Object, @object.state
  end
  
  def test_use_same_value_across_multiple_objects
    assert_equal @object.state, @klass.new.state
  end
end

class MachineWithStatesWithBehaviorsTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
    
    @parked, @idling = @machine.state :parked, :idling do
      def speed
        0
      end
    end
  end
  
  def test_should_define_behaviors_for_each_state
    assert_not_nil @parked.methods[:speed]
    assert_not_nil @idling.methods[:speed]
  end
  
  def test_should_define_different_behaviors_for_each_state
    assert_not_equal @parked.methods[:speed], @idling.methods[:speed]
  end
end

class MachineWithExistingStateTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
    @state = @machine.state :parked
    @same_state = @machine.state :parked, :value => 1
  end
  
  def test_should_not_create_a_new_state
    assert_same @state, @same_state
  end
  
  def test_should_update_attributes
    assert_equal 1, @state.value
  end
  
  def test_should_no_longer_be_able_to_look_up_state_by_original_value
    assert_nil @machine.states['parked', :value]
  end
  
  def test_should_be_able_to_look_up_state_by_new_value
    assert_equal @state, @machine.states[1, :value]
  end
end

class MachineWithOtherStates < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @parked, @idling = @machine.other_states(:parked, :idling)
  end
  
  def test_should_include_other_states_in_known_states
    assert_equal [@parked, @idling], @machine.states.to_a
  end
  
  def test_should_use_default_value
    assert_equal 'idling', @idling.value
  end
  
  def test_should_not_create_matcher
    assert_nil @idling.matcher
  end
end

class MachineWithEventsTest < Test::Unit::TestCase
  def setup
    @klass = Class.new
    @machine = StateMachine::Machine.new(@klass)
  end
  
  def test_should_return_the_created_event
    assert_instance_of StateMachine::Event, @machine.event(:ignite)
  end
  
  def test_should_create_event_with_given_name
    event = @machine.event(:ignite) {}
    assert_equal :ignite, event.name
  end
  
  def test_should_evaluate_block_within_event_context
    responded = false
    @machine.event :ignite do
      responded = respond_to?(:transition)
    end
    
    assert responded
  end
  
  def test_should_be_aliased_as_on
    event = @machine.on(:ignite) {}
    assert_equal :ignite, event.name
  end
  
  def test_should_have_events
    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
  def setup
    @machine = StateMachine::Machine.new(Class.new)
    @event = @machine.event(:ignite)
    @same_event = @machine.event(:ignite)
  end
  
  def test_should_not_create_new_event
    assert_same @event, @same_event
  end
  
  def test_should_allow_accessing_event_without_block
    assert_equal @event, @machine.event(:ignite)
  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
    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
    @event =…