state_machine 0.4.0 → 0.4.1

data/test/unit/event_test.rb

@@ -301,6 +301,39 @@ class EventWithTransitionWithoutToStateTest < Test::Unit::TestCase
   end
 end
 
+class EventWithTransitionWithNilToStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @event = StateMachine::Event.new(@machine, 'turn_off')
+    @event.transition(:from => 'off', :to => nil)
+    
+    @object = @klass.new
+    @object.state = 'off'
+  end
+  
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
+  end
+  
+  def test_should_have_a_next_transition
+    transition = @event.next_transition(@object)
+    assert_not_nil transition
+    assert_equal 'off', transition.from
+    assert_equal nil, transition.to
+    assert_equal 'turn_off', transition.event
+  end
+  
+  def test_should_fire
+    assert @event.fire(@object)
+  end
+  
+  def test_should_not_change_the_current_state
+    @event.fire(@object)
+    assert_equal nil, @object.state
+  end
+end
+
 class EventWithTransitionWithDynamicToStateTest < Test::Unit::TestCase
   def setup
     @klass = Class.new

data/test/unit/guard_test.rb

@@ -10,7 +10,7 @@ class GuardTest < Test::Unit::TestCase
   end
   
   def test_should_have_requirements
-    expected = {:to => 'on', :from => 'off'}
+    expected = {:to => %w(on), :from => %w(off)}
     assert_equal expected, @guard.requirements
   end
 end
@@ -40,6 +40,10 @@ class GuardWithToRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:to => 'on')
   end
   
+  def test_should_match_if_not_specified
+    assert @guard.matches?(@object, :from => 'off')
+  end
+  
   def test_should_match_if_included
     assert @guard.matches?(@object, :to => 'on')
   end
@@ -48,6 +52,10 @@ class GuardWithToRequirementTest < Test::Unit::TestCase
     assert !@guard.matches?(@object, :to => 'off')
   end
   
+  def test_should_not_match_if_nil
+    assert !@guard.matches?(@object, :to => nil)
+  end
+  
   def test_should_ignore_from
     assert @guard.matches?(@object, :to => 'on', :from => 'off')
   end
@@ -86,6 +94,10 @@ class GuardWithFromRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:from => 'on')
   end
   
+  def test_should_match_if_not_specified
+    assert @guard.matches?(@object, :to => 'off')
+  end
+  
   def test_should_match_if_included
     assert @guard.matches?(@object, :from => 'on')
   end
@@ -94,6 +106,10 @@ class GuardWithFromRequirementTest < Test::Unit::TestCase
     assert !@guard.matches?(@object, :from => 'off')
   end
   
+  def test_should_not_match_if_nil
+    assert !@guard.matches?(@object, :from => nil)
+  end
+  
   def test_should_ignore_to
     assert @guard.matches?(@object, :from => 'on', :to => 'off')
   end
@@ -132,6 +148,10 @@ class GuardWithOnRequirementTest < Test::Unit::TestCase
     @guard = StateMachine::Guard.new(:on => 'turn_on')
   end
   
+  def test_should_match_if_not_specified
+    assert @guard.matches?(@object, :from => 'off')
+  end
+  
   def test_should_match_if_included
     assert @guard.matches?(@object, :on => 'turn_on')
   end
@@ -140,6 +160,10 @@ class GuardWithOnRequirementTest < Test::Unit::TestCase
     assert !@guard.matches?(@object, :on => 'turn_off')
   end
   
+  def test_should_not_match_if_nil
+    assert !@guard.matches?(@object, :on => nil)
+  end
+  
   def test_should_ignore_to
     assert @guard.matches?(@object, :on => 'turn_on', :to => 'off')
   end
@@ -182,6 +206,10 @@ class GuardWithExceptToRequirementTest < Test::Unit::TestCase
     assert !@guard.matches?(@object, :to => 'off')
   end
   
+  def test_should_match_if_nil
+    assert @guard.matches?(@object, :to => nil)
+  end
+  
   def test_should_ignore_from
     assert @guard.matches?(@object, :except_to => 'off', :from => 'off')
   end
@@ -228,6 +256,10 @@ class GuardWithExceptFromRequirementTest < Test::Unit::TestCase
     assert !@guard.matches?(@object, :from => 'off')
   end
   
+  def test_should_match_if_nil
+    assert @guard.matches?(@object, :from => nil)
+  end
+  
   def test_should_ignore_to
     assert @guard.matches?(@object, :from => 'on', :to => 'off')
   end
@@ -274,6 +306,10 @@ class GuardWithExceptOnRequirementTest < Test::Unit::TestCase
     assert !@guard.matches?(@object, :on => 'turn_off')
   end
   
+  def test_should_match_if_nil
+    assert @guard.matches?(@object, :on => nil)
+  end
+  
   def test_should_ignore_to
     assert @guard.matches?(@object, :on => 'turn_on', :to => 'off')
   end
@@ -371,6 +407,33 @@ class GuardWithDifferentRequirementsTest < Test::Unit::TestCase
   end
 end
 
+class GuardWithNilRequirementsTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @guard = StateMachine::Guard.new(:from => nil, :to => nil)
+  end
+  
+  def test_should_match_empty_query
+    assert @guard.matches?(@object)
+  end
+  
+  def test_should_match_if_all_requirements_match
+    assert @guard.matches?(@object, :from => nil, :to => nil)
+  end
+  
+  def test_should_not_match_if_from_not_included
+    assert !@guard.matches?(@object, :from => 'off')
+  end
+  
+  def test_should_not_match_if_to_not_included
+    assert !@guard.matches?(@object, :to => 'on')
+  end
+  
+  def test_should_include_all_known_states
+    assert_equal [nil], @guard.known_states
+  end
+end
+
 class GuardWithIfConditionalTest < Test::Unit::TestCase
   def setup
     @object = Object.new

data/test/unit/integrations/active_record_test.rb

@@ -190,10 +190,43 @@ begin
       end
     end
     
+    class MachineWithColumnStateAttributeTest < ActiveRecord::TestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :initial => 'off')
+        @machine.other_states('on')
+        @record = @model.new
+      end
+      
+      def test_should_have_an_attribute_predicate
+        assert @record.respond_to?(:state?)
+      end
+      
+      def test_should_test_for_existence_on_predicate_without_parameters
+        assert @record.state?
+        
+        @record.state = nil
+        assert !@record.state?
+      end
+      
+      def test_should_return_false_for_predicate_if_does_not_match_current_value
+        assert !@record.state?('on')
+      end
+      
+      def test_should_return_true_for_predicate_if_matches_current_value
+        assert @record.state?('off')
+      end
+      
+      def test_should_raise_exception_for_predicate_if_invalid_state_specified
+        assert_raise(ArgumentError) { @record.state?('invalid') }
+      end
+    end
+    
     class MachineWithNonColumnStateAttributeTest < ActiveRecord::TestCase
       def setup
         @model = new_model
         @machine = StateMachine::Machine.new(@model, :status, :initial => 'off')
+        @machine.other_states('on')
         @record = @model.new
       end
       
@@ -205,6 +238,29 @@ begin
         assert @record.respond_to?(:status=)
       end
       
+      def test_should_define_an_attribute_predicate
+        assert @record.respond_to?(:status?)
+      end
+      
+      def test_should_raise_exception_on_predicate_without_parameters
+        old_verbose, $VERBOSE = $VERBOSE, nil
+        assert_raise(ArgumentError) { @record.status? }
+      ensure
+        $VERBOSE = old_verbose
+      end
+      
+      def test_should_return_false_for_predicate_if_does_not_match_current_value
+        assert !@record.status?('on')
+      end
+      
+      def test_should_return_true_for_predicate_if_matches_current_value
+        assert @record.status?('off')
+      end
+      
+      def test_should_raise_exception_for_predicate_if_invalid_state_specified
+        assert_raise(ArgumentError) { @record.status?('invalid') }
+      end
+      
       def test_should_set_initial_state_on_created_object
         assert_equal 'off', @record.status
       end
@@ -213,7 +269,7 @@ begin
     class MachineWithCallbacksTest < ActiveRecord::TestCase
       def setup
         @model = new_model
-        @machine = StateMachine::Machine.new(@model)
+        @machine = StateMachine::Machine.new(@model, :initial => 'off')
         @record = @model.new(:state => 'off')
         @transition = StateMachine::Transition.new(@record, @machine, 'turn_on', 'off', 'on')
       end
@@ -285,7 +341,7 @@ begin
       def test_should_include_transition_states_in_known_states
         @machine.before_transition :to => 'error', :do => lambda {}
         
-        assert_equal %w(error), @machine.states.sort
+        assert_equal %w(error off), @machine.states.sort
       end
     end
     

data/test/unit/machine_test.rb

@@ -35,8 +35,8 @@ class MachineByDefaultTest < Test::Unit::TestCase
     assert_nil @machine.action
   end
   
-  def test_should_not_have_any_states
-    assert @machine.states.empty?
+  def test_should_have_a_nil_state
+    assert_equal [nil], @machine.states
   end
   
   def test_should_not_be_extended_by_the_active_record_integration
@@ -158,7 +158,8 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
     @klass = Class.new do
       attr_accessor :initial_state
     end
-    @machine = StateMachine::Machine.new(@klass, :initial => lambda {|object| object.initial_state || 'default'})
+    @initial_state = lambda {|object| object.initial_state || 'default'}
+    @machine = StateMachine::Machine.new(@klass, :initial => @initial_state)
     @object = @klass.new
   end
   
@@ -174,8 +175,8 @@ class MachineWithDynamicInitialStateTest < Test::Unit::TestCase
     assert_equal 'default', @object.state
   end
   
-  def test_should_not_be_included_in_known_states
-    assert_equal [], @machine.states
+  def test_should_be_included_in_known_states
+    assert_equal [@initial_state], @machine.states
   end
 end
 
@@ -228,6 +229,15 @@ 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_evaluate_a_block_during_initialization
+    called = true
+    StateMachine::Machine.new(Class.new) do
+      called = respond_to?(:event)
+    end
+    
+    assert called
+  end
 end
 
 class MachineWithoutIntegrationTest < Test::Unit::TestCase
@@ -822,7 +832,7 @@ end
 class MachineWithEventsWithTransitionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass)
+    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
     @machine.event(:turn_on) do
       transition :to => 'on', :from => 'off'
       transition :to => 'error', :from => 'unknown'
@@ -893,19 +903,34 @@ class MachineWithNumericStatesTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithNilStatesTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.event(:turn_on) do
+      transition :to => 'on', :from => nil
+    end
+  end
+  
+  def test_should_not_redefine_nil_predicate
+    object = @klass.new
+    assert !object.nil?
+    assert !object.respond_to?('?')
+  end
+end
+
 class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
       attr_accessor :callbacks
     end
     
-    @machine = StateMachine::Machine.new(@klass)
+    @machine = StateMachine::Machine.new(@klass, :initial => 'off')
     @event = @machine.event :turn_on do
       transition :to => 'on', :from => 'off'
     end
     
     @object = @klass.new
-    @object.state = 'off'
     @object.callbacks = []
   end
   
@@ -1052,6 +1077,15 @@ class MachineFinderWithoutExistingMachineTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.find_or_create(@klass)
   end
   
+  def test_should_accept_a_block
+    called = false
+    StateMachine::Machine.find_or_create(Class.new) do
+      called = respond_to?(:event)
+    end
+    
+    assert called
+  end
+  
   def test_should_create_a_new_machine
     assert_not_nil @machine
   end
@@ -1068,6 +1102,15 @@ class MachineFinderWithExistingOnSameClassTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.find_or_create(@klass)
   end
   
+  def test_should_accept_a_block
+    called = false
+    StateMachine::Machine.find_or_create(@klass) do
+      called = respond_to?(:event)
+    end
+    
+    assert called
+  end
+  
   def test_should_not_create_a_new_machine
     assert_same @machine, @existing_machine
   end
@@ -1092,6 +1135,15 @@ class MachineFinderWithExistingMachineOnSuperclassTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.find_or_create(@klass, 'status')
   end
   
+  def test_should_accept_a_block
+    called = false
+    StateMachine::Machine.find_or_create(Class.new(@base_class)) do
+      called = respond_to?(:event)
+    end
+    
+    assert called
+  end
+  
   def test_should_create_a_new_machine
     assert_not_nil @machine
     assert_not_same @machine, @base_machine
@@ -1211,14 +1263,33 @@ begin
     end
   end
   
-  class MachineDrawingWithTimeStatesTest < Test::Unit::TestCase
+  class MachineDrawingWithNilStatesTest < Test::Unit::TestCase
+    def setup
+      @klass = Class.new do
+        def self.name; 'Vehicle'; end
+      end
+      @machine = StateMachine::Machine.new(@klass, :activated_at, :initial => 'inactive')
+      @machine.event :activate do
+        transition :from => nil, :to => 'active'
+      end
+      @machine.draw
+    end
+    
+    def test_should_draw_machine
+      assert File.exist?('./Vehicle_activated_at.png')
+    ensure
+      FileUtils.rm('./Vehicle_activated_at.png')
+    end
+  end
+  
+  class MachineDrawingWithDynamicStatesTest < Test::Unit::TestCase
     def setup
       @klass = Class.new do
         def self.name; 'Vehicle'; end
       end
-      @machine = StateMachine::Machine.new(@klass, :activated_at)
+      @machine = StateMachine::Machine.new(@klass, :activated_at, :initial => 'inactive')
       @machine.event :activate do
-        transition :from => nil, :to => lambda {Time.now}
+        transition :from => 'inactive', :to => lambda {Time.now}
       end
       @machine.draw
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: state_machine
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.4.1
 platform: ruby
 authors: 
 - Aaron Pfeifer
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-12-14 00:00:00 -05:00
+date: 2008-12-16 00:00:00 -05:00
 default_executable: 
 dependencies: []