state_machine 0.7.5 → 0.7.6

data/test/unit/machine_test.rb

@@ -11,10 +11,18 @@ class MachineByDefaultTest < Test::Unit::TestCase
     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
@@ -143,17 +151,25 @@ class MachineByDefaultTest < Test::Unit::TestCase
   end
 end
 
-class MachineWithCustomAttributeTest < Test::Unit::TestCase
+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_attribute
+  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
@@ -998,21 +1014,46 @@ end
 
 class MachinePersistenceTest < Test::Unit::TestCase
   def setup
-    @klass = Class.new
+    @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)
+    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, 'idling')
+    @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
 end
 
+
 class MachineWithStatesTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -1445,6 +1486,40 @@ class MachineWithExistingMachinesOnOwnerClassTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithExistingMachinesWithSameAttributesOnOwnerClassTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @second_machine = StateMachine::Machine.new(@klass, :public_state, :attribute => :state)
+    @object = @klass.new
+  end
+  
+  def test_should_track_each_state_machine
+    expected = {:state => @machine, :public_state => @second_machine}
+    assert_equal expected, @klass.state_machines
+  end
+  
+  def test_should_initialize_based_on_first_available_initial_state
+    assert_equal 'parked', @object.state
+  end
+  
+  def test_should_allow_transitions_on_both_machines
+    @machine.event :ignite do
+      transition :parked => :idling
+    end
+    
+    @second_machine.event :park do
+      transition :idling => :parked
+    end
+    
+    @object.ignite
+    assert_equal 'idling', @object.state
+    
+    @object.park
+    assert_equal 'parked', @object.state
+  end
+end
+
 class MachineWithNamespaceTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -1491,6 +1566,80 @@ class MachineWithNamespaceTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithCustomAttributeTest < Test::Unit::TestCase
+  def setup
+    StateMachine::Integrations.const_set('Custom', Module.new do  
+      class << self; attr_reader :defaults; end
+      @defaults = {:action => :save, :use_transactions => false}
+      
+      def create_with_scope(name)
+        lambda {}
+      end
+      
+      def create_without_scope(name)
+        lambda {}
+      end
+    end)
+    
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :state, :attribute => :state_id, :initial => :active, :integration => :custom) do
+      event :ignite do
+        transition :parked => :idling
+      end
+    end
+    @object = @klass.new
+  end
+  
+  def test_should_define_a_reader_attribute_for_the_attribute
+    assert @object.respond_to?(:state_id)
+  end
+  
+  def test_should_define_a_writer_attribute_for_the_attribute
+    assert @object.respond_to?(:state_id=)
+  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_singular_with_scope
+    assert @klass.respond_to?(:with_state)
+  end
+  
+  def test_should_define_singular_without_scope
+    assert @klass.respond_to?(:without_state)
+  end
+  
+  def test_should_define_plural_with_scope
+    assert @klass.respond_to?(:with_states)
+  end
+  
+  def test_should_define_plural_without_scope
+    assert @klass.respond_to?(:without_states)
+  end
+  
+  def test_should_define_state_machines_reader
+    expected = {:state => @machine}
+    assert_equal expected, @klass.state_machines
+  end
+  
+  def teardown
+    StateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end
+
 class MachineFinderWithoutExistingMachineTest < Test::Unit::TestCase
   def setup
     @klass = Class.new

data/test/unit/state_test.rb

@@ -258,7 +258,8 @@ class StateWithCachedLambdaValueTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @state = StateMachine::State.new(@machine, :parked, :value => lambda {Object.new}, :cache => true)
+    @dynamic_value = lambda {'value'}
+    @machine.states << @state = StateMachine::State.new(@machine, :parked, :value => @dynamic_value, :cache => true)
   end
   
   def test_should_be_caching
@@ -266,20 +267,27 @@ class StateWithCachedLambdaValueTest < Test::Unit::TestCase
   end
   
   def test_should_evaluate_value
-    assert_instance_of Object, @state.value
+    assert_equal 'value', @state.value
   end
   
   def test_should_only_evaluate_value_once
     value = @state.value
     assert_same value, @state.value
   end
+  
+  def test_should_update_value_index_for_state_collection
+    @state.value
+    assert_equal @state, @machine.states['value', :value]
+    assert_nil @machine.states[@dynamic_value, :value]
+  end
 end
 
 class StateWithoutCachedLambdaValueTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
     @machine = StateMachine::Machine.new(@klass)
-    @state = StateMachine::State.new(@machine, :parked, :value => lambda {Object.new})
+    @dynamic_value = lambda {'value'}
+    @machine.states << @state = StateMachine::State.new(@machine, :parked, :value => @dynamic_value)
   end
   
   def test_should_not_be_caching
@@ -290,6 +298,12 @@ class StateWithoutCachedLambdaValueTest < Test::Unit::TestCase
     value = @state.value
     assert_not_same value, @state.value
   end
+  
+  def test_should_not_update_value_index_for_state_collection
+    @state.value
+    assert_nil @machine.states['value', :value]
+    assert_equal @state, @machine.states[@dynamic_value, :value]
+  end
 end
 
 class StateWithMatcherTest < Test::Unit::TestCase

data/test/unit/transition_test.rb

@@ -197,6 +197,33 @@ class TransitionWithNamespaceTest < Test::Unit::TestCase
   end
 end
 
+class TransitionWithCustomMachineAttributeTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :state, :attribute => :state_id)
+    @machine.state :off, :value => 1
+    @machine.state :active, :value => 2
+    @machine.event :activate
+    
+    @object = @klass.new
+    @object.state_id = 1
+    
+    @transition = StateMachine::Transition.new(@object, @machine, :activate, :off, :active)
+  end
+  
+  def test_should_persist
+    @transition.persist
+    assert_equal 2, @object.state_id
+  end
+  
+  def test_should_rollback
+    @object.state_id = 2
+    @transition.rollback
+    
+    assert_equal 1, @object.state_id
+  end
+end
+
 class TransitionWithActionTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: state_machine
 version: !ruby/object:Gem::Version 
-  version: 0.7.5
+  version: 0.7.6
 platform: ruby
 authors: 
 - Aaron Pfeifer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-25 00:00:00 -04:00
+date: 2009-06-17 00:00:00 -04:00
 default_executable: 
 dependencies: []