state_machine 0.6.3 → 0.7.0

data/test/unit/machine_test.rb

@@ -39,6 +39,10 @@ class MachineByDefaultTest < Test::Unit::TestCase
     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
@@ -79,6 +83,30 @@ class MachineByDefaultTest < Test::Unit::TestCase
     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_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_not_define_singular_with_scope
     assert !@klass.respond_to?(:with_state)
   end
@@ -135,6 +163,14 @@ class MachineWithCustomAttributeTest < Test::Unit::TestCase
   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
 end
 
 class MachineWithStaticInitialStateTest < Test::Unit::TestCase
@@ -218,9 +254,8 @@ end
 class MachineWithNilActionTest < Test::Unit::TestCase
   def setup
     integration = Module.new do
-      def default_action
-        :save
-      end
+      class << self; attr_reader :defaults; end
+      @defaults = {:action => :save}
     end
     StateMachine::Integrations.const_set('Custom', integration)
     @machine = StateMachine::Machine.new(Class.new, :action => nil, :integration => :custom)
@@ -252,7 +287,7 @@ class MachineWithoutIntegrationTest < Test::Unit::TestCase
   end
   
   def test_invalidation_should_do_nothing
-    assert_nil @machine.invalidate(@object, StateMachine::Event.new(@machine, :park))
+    assert_nil @machine.invalidate(@object, :state, :invalid_transition, [[:event, :park]])
   end
   
   def test_reset_should_do_nothing
@@ -277,37 +312,37 @@ end
 
 class MachineWithIntegrationTest < Test::Unit::TestCase
   def setup
-    @integration = Module.new do
-      class << self; attr_accessor :initialized, :with_scopes, :without_scopes; end
-      @initialized = false
-      @with_scopes = []
-      @without_scopes = []
+    StateMachine::Integrations.const_set('Custom', Module.new do  
+      class << self; attr_reader :defaults; end
+      @defaults = {:action => :save, :use_transactions => false}
+          
+      attr_reader :initialized, :with_scopes, :without_scopes, :ran_transaction
       
       def after_initialize
-        StateMachine::Integrations::Custom.initialized = true
-      end
-      
-      def default_action
-        :save
+        @initialized = true
       end
       
       def create_with_scope(name)
-        StateMachine::Integrations::Custom.with_scopes << name
+        (@with_scopes ||= []) << name
         lambda {}
       end
       
       def create_without_scope(name)
-        StateMachine::Integrations::Custom.without_scopes << name
+        (@without_scopes ||= []) << name
         lambda {}
       end
-    end
+      
+      def transaction(object)
+        @ran_transaction = true
+        yield
+      end
+    end)
     
-    StateMachine::Integrations.const_set('Custom', @integration)
     @machine = StateMachine::Machine.new(Class.new, :integration => :custom)
   end
   
   def test_should_call_after_initialize_hook
-    assert @integration.initialized
+    assert @machine.initialized
   end
   
   def test_should_use_the_default_action
@@ -319,12 +354,21 @@ class MachineWithIntegrationTest < Test::Unit::TestCase
     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), @integration.with_scopes
+    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), @integration.without_scopes
+    assert_equal %w(without_state without_states), @machine.without_scopes
   end
   
   def teardown
@@ -332,6 +376,62 @@ class MachineWithIntegrationTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithActionTest < 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
+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
+end
+
 class MachineWithCustomPluralTest < Test::Unit::TestCase
   def setup
     @integration = Module.new do
@@ -370,8 +470,8 @@ end
 class MachineWithCustomInvalidationTest < Test::Unit::TestCase
   def setup
     @integration = Module.new do
-      def invalidate(object, event)
-        object.error = invalid_message(object, event)
+      def invalidate(object, attribute, message, values = [])
+        object.error = generate_message(message, values)
       end
     end
     StateMachine::Integrations.const_set('Custom', @integration)
@@ -380,7 +480,7 @@ class MachineWithCustomInvalidationTest < Test::Unit::TestCase
       attr_accessor :error
     end
     
-    @machine = StateMachine::Machine.new(@klass, :integration => :custom, :invalid_message => 'cannot %s when %s')
+    @machine = StateMachine::Machine.new(@klass, :integration => :custom, :messages => {:invalid_transition => 'cannot %s'})
     @machine.state :parked
     
     @object = @klass.new
@@ -388,8 +488,8 @@ class MachineWithCustomInvalidationTest < Test::Unit::TestCase
   end
   
   def test_use_custom_message
-    @machine.invalidate(@object, StateMachine::Event.new(@machine, :park))
-    assert_equal 'cannot park when parked', @object.error
+    @machine.invalidate(@object, :state, :invalid_transition, [[:event, :park]])
+    assert_equal 'cannot park', @object.error
   end
   
   def teardown
@@ -402,8 +502,8 @@ class MachineTest < Test::Unit::TestCase
     assert_raise(ArgumentError) {StateMachine::Machine.new(Class.new, :invalid => true)}
   end
   
-  def test_should_not_raise_exception_if_custom_invalid_message_specified
-    assert_nothing_raised {StateMachine::Machine.new(Class.new, :invalid_message => 'custom')}
+  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
@@ -667,6 +767,14 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
       def state_name
         :parked
       end
+      
+      def state_events
+        [:ignite]
+      end
+      
+      def state_transitions
+        [{:parked => :idling}]
+      end
     end
     
     StateMachine::Integrations.const_set('Custom', Module.new do
@@ -717,6 +825,14 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
     assert_equal :parked, @object.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_allow_super_chaining
     @klass.class_eval do
       def self.with_state(*states)
@@ -753,6 +869,14 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
       def state_name
         super == :parked ? 1 : 0
       end
+      
+      def state_events
+        super == []
+      end
+      
+      def state_transitions
+        super == []
+      end
     end
     
     assert_equal true, @klass.with_state
@@ -765,6 +889,8 @@ class MachineWithConflictingHelpersTest < Test::Unit::TestCase
     assert_equal 'idling', @object.status
     assert_equal 0, @object.state?(:parked)
     assert_equal 0, @object.state_name
+    assert_equal true, @object.state_events
+    assert_equal true, @object.state_transitions
   end
   
   def teardown
@@ -860,6 +986,23 @@ class MachineWithCustomInitializeTest < Test::Unit::TestCase
   end
 end
 
+class MachinePersistenceTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @object = @klass.new
+  end
+  
+  def test_should_allow_reading_state
+    assert_equal 'parked', @machine.read(@object)
+  end
+  
+  def test_should_allow_writing_state
+    @machine.write(@object, 'idling')
+    assert_equal 'idling', @object.state
+  end
+end
+
 class MachineWithStatesTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -893,30 +1036,6 @@ class MachineWithStatesTest < Test::Unit::TestCase
     exception = assert_raise(ArgumentError) {@machine.state(:first_gear, :invalid => true)}
     assert_equal 'Invalid key(s): invalid', exception.message
   end
-  
-  def test_should_not_be_in_state_if_value_does_not_match
-    assert !@machine.state?(@object, :parked)
-    assert !@machine.state?(@object, :idling)
-  end
-  
-  def test_should_be_in_state_if_value_matches
-    assert @machine.state?(@object, nil)
-  end
-  
-  def test_raise_exception_if_checking_invalid_state
-    assert_raise(ArgumentError) { @machine.state?(@object, :invalid) }
-  end
-  
-  def test_should_find_state_for_object_if_value_is_known
-    @object.state = 'parked'
-    assert_equal @parked, @machine.state_for(@object)
-  end
-  
-  def test_should_raise_exception_if_finding_state_for_object_with_unknown_value
-    @object.state = 'invalid'
-    exception = assert_raise(ArgumentError) { @machine.state_for(@object) }
-    assert_equal '"invalid" is not a known state value', exception.message
-  end
 end
 
 class MachineWithStatesWithCustomValuesTest < Test::Unit::TestCase
@@ -936,19 +1055,6 @@ class MachineWithStatesWithCustomValuesTest < Test::Unit::TestCase
   def test_should_allow_lookup_by_custom_value
     assert_equal @state, @machine.states[1, :value]
   end
-  
-  def test_should_be_in_state_if_value_matches
-    assert @machine.state?(@object, :parked)
-  end
-  
-  def test_should_not_be_in_state_if_value_does_not_match
-    @object.state = 2
-    assert !@machine.state?(@object, :parked)
-  end
-  
-  def test_should_find_state_for_object_if_value_is_known
-    assert_equal @state, @machine.state_for(@object)
-  end
 end
 
 class MachineWithStateWithMatchersTest < Test::Unit::TestCase
@@ -966,19 +1072,6 @@ class MachineWithStateWithMatchersTest < Test::Unit::TestCase
     assert @state.matches?(1)
     assert !@state.matches?(nil)
   end
-  
-  def test_should_be_in_state_if_value_matches
-    assert @machine.state?(@object, :parked)
-  end
-  
-  def test_should_not_be_in_state_if_value_does_not_match
-    @object.state = nil
-    assert !@machine.state?(@object, :parked)
-  end
-  
-  def test_should_find_state_for_object_if_value_is_known
-    assert_equal @state, @machine.state_for(@object)
-  end
 end
 
 class MachineWithStatesWithBehaviorsTest < Test::Unit::TestCase
@@ -1050,7 +1143,8 @@ end
 
 class MachineWithEventsTest < Test::Unit::TestCase
   def setup
-    @machine = StateMachine::Machine.new(Class.new)
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
   end
   
   def test_should_return_the_created_event
@@ -1309,44 +1403,44 @@ end
 class MachineWithNamespaceTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :namespace => 'car', :initial => :parked) do
-      event :ignite do
-        transition :parked => :idling
+    @machine = StateMachine::Machine.new(@klass, :namespace => 'alarm', :initial => :active) do
+      event :enable do
+        transition :off => :active
       end
       
-      event :park do
-        transition :idling => :parked
+      event :disable do
+        transition :active => :off
       end
     end
     @object = @klass.new
   end
   
   def test_should_namespace_state_predicates
-    [:car_parked?, :car_idling?].each do |name|
+    [:alarm_active?, :alarm_off?].each do |name|
       assert @object.respond_to?(name)
     end
   end
   
   def test_should_namespace_event_checks
-    [:can_ignite_car?, :can_park_car?].each do |name|
+    [:can_enable_alarm?, :can_disable_alarm?].each do |name|
       assert @object.respond_to?(name)
     end
   end
   
   def test_should_namespace_event_transition_readers
-    [:next_ignite_car_transition, :next_park_car_transition].each do |name|
+    [:enable_alarm_transition, :disable_alarm_transition].each do |name|
       assert @object.respond_to?(name)
     end
   end
   
   def test_should_namespace_events
-    [:ignite_car, :park_car].each do |name|
+    [:enable_alarm, :disable_alarm].each do |name|
       assert @object.respond_to?(name)
     end
   end
   
   def test_should_namespace_bang_events
-    [:ignite_car!, :park_car!].each do |name|
+    [:enable_alarm!, :disable_alarm!].each do |name|
       assert @object.respond_to?(name)
     end
   end
@@ -1413,7 +1507,7 @@ class MachineFinderWithExistingMachineOnSuperclassTest < Test::Unit::TestCase
     @base_machine.after_transition(lambda {})
     
     @klass = Class.new(@base_class)
-    @machine = StateMachine::Machine.find_or_create(@klass, :status)
+    @machine = StateMachine::Machine.find_or_create(@klass, :status) {}
   end
   
   def test_should_accept_a_block
@@ -1425,7 +1519,20 @@ class MachineFinderWithExistingMachineOnSuperclassTest < Test::Unit::TestCase
     assert called
   end
   
-  def test_should_create_a_new_machine
+  def test_should_not_create_a_new_machine_if_no_block_or_options
+    machine = StateMachine::Machine.find_or_create(Class.new(@base_class), :status)
+    
+    assert_same machine, @base_machine
+  end
+  
+  def test_should_create_a_new_machine_if_given_options
+    machine = StateMachine::Machine.find_or_create(@klass, :status, :initial => :parked)
+    
+    assert_not_nil machine
+    assert_not_same machine, @base_machine
+  end
+  
+  def test_should_create_a_new_machine_if_given_block
     assert_not_nil @machine
     assert_not_same @machine, @base_machine
   end