state_machine 1.1.2 → 1.2.0

data/test/unit/event_collection_test.rb

@@ -2,8 +2,10 @@ require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
 class EventCollectionByDefaultTest < Test::Unit::TestCase
   def setup
-    @machine = StateMachine::Machine.new(Class.new)
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
     @events = StateMachine::EventCollection.new(@machine)
+    @object = @klass.new
   end
   
   def test_should_not_have_any_nodes

data/test/unit/event_test.rb

@@ -376,11 +376,6 @@ class EventTransitionsTest < Test::Unit::TestCase
     assert_equal [:ignite], branch.event_requirement.values
   end
   
-  def test_should_not_allow_except_to_option
-    exception = assert_raise(ArgumentError) {@event.transition(:except_to => :parked)}
-    assert_equal 'Invalid key(s): except_to', exception.message
-  end
-  
   def test_should_not_allow_except_on_option
     exception = assert_raise(ArgumentError) {@event.transition(:except_on => :ignite)}
     assert_equal 'Invalid key(s): except_on', exception.message
@@ -398,6 +393,10 @@ class EventTransitionsTest < Test::Unit::TestCase
     assert_nothing_raised {@event.transition(:except_from => :idling)}
   end
   
+  def test_should_allow_except_to_option
+    assert_nothing_raised {@event.transition(:except_to => :idling)}
+  end
+
   def test_should_allow_transitioning_from_a_single_state
     assert @event.transition(:parked => :idling)
   end
@@ -405,6 +404,10 @@ class EventTransitionsTest < Test::Unit::TestCase
   def test_should_allow_transitioning_from_multiple_states
     assert @event.transition([:parked, :idling] => :idling)
   end
+
+  def test_should_allow_transitions_to_multiple_states
+    assert @event.transition(:parked => [:parked, :idling])
+  end
   
   def test_should_have_transitions
     branch = @event.transition(:to => :idling)
@@ -775,6 +778,150 @@ class EventWithTransitionWithNilToStateTest < Test::Unit::TestCase
   end
 end
 
+class EventWithTransitionWithLoopbackStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked
+    
+    @machine.events << @event = StateMachine::Event.new(@machine, :park)
+    @event.transition(:from => :parked, :to => StateMachine::LoopbackMatcher.instance)
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
+  end
+  
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
+    assert_not_nil transition
+    assert_equal 'parked', transition.from
+    assert_equal 'parked', transition.to
+    assert_equal :park, 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 'parked', @object.state
+  end
+end
+
+class EventWithTransitionWithBlacklistedToStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @machine.state :parked, :idling, :first_gear, :second_gear
+    
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
+    @event.transition(:from => :parked, :to => StateMachine::BlacklistMatcher.new([:parked, :idling]))
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
+  end
+  
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
+    assert_not_nil transition
+    assert_equal 'parked', transition.from
+    assert_equal 'first_gear', transition.to
+    assert_equal :ignite, transition.event
+  end
+  
+  def test_should_allow_loopback_first_when_possible
+    @event.transition(:from => :second_gear, :to => StateMachine::BlacklistMatcher.new([:parked, :idling]))
+    @object.state = 'second_gear'
+
+    transition = @event.transition_for(@object)
+    assert_not_nil transition
+    assert_equal 'second_gear', transition.from
+    assert_equal 'second_gear', transition.to
+    assert_equal :ignite, transition.event
+  end
+
+  def test_should_allow_specific_transition_selection_using_to
+    transition = @event.transition_for(@object, :from => :parked, :to => :second_gear)
+    
+    assert_not_nil transition
+    assert_equal 'parked', transition.from
+    assert_equal 'second_gear', transition.to
+    assert_equal :ignite, transition.event
+  end
+
+  def test_should_not_allow_transition_selection_if_not_matching
+    transition = @event.transition_for(@object, :from => :parked, :to => :parked)
+    assert_nil transition
+  end
+
+  def test_should_fire
+    assert @event.fire(@object)
+  end
+  
+  def test_should_change_the_current_state
+    @event.fire(@object)
+    assert_equal 'first_gear', @object.state
+  end
+end
+
+class EventWithTransitionWithWhitelistedToStateTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @machine.state :parked, :idling, :first_gear, :second_gear
+    
+    @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
+    @event.transition(:from => :parked, :to => StateMachine::WhitelistMatcher.new([:first_gear, :second_gear]))
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
+  end
+  
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
+    assert_not_nil transition
+    assert_equal 'parked', transition.from
+    assert_equal 'first_gear', transition.to
+    assert_equal :ignite, transition.event
+  end
+  
+  def test_should_allow_specific_transition_selection_using_to
+    transition = @event.transition_for(@object, :from => :parked, :to => :second_gear)
+    
+    assert_not_nil transition
+    assert_equal 'parked', transition.from
+    assert_equal 'second_gear', transition.to
+    assert_equal :ignite, transition.event
+  end
+
+  def test_should_not_allow_transition_selection_if_not_matching
+    transition = @event.transition_for(@object, :from => :parked, :to => :parked)
+    assert_nil transition
+  end
+
+  def test_should_fire
+    assert @event.fire(@object)
+  end
+  
+  def test_should_change_the_current_state
+    @event.fire(@object)
+    assert_equal 'first_gear', @object.state
+  end
+end
+
 class EventWithMultipleTransitionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -783,7 +930,7 @@ class EventWithMultipleTransitionsTest < Test::Unit::TestCase
     
     @machine.events << @event = StateMachine::Event.new(@machine, :ignite)
     @event.transition(:idling => :idling)
-    @event.transition(:parked => :idling) # This one should get used
+    @event.transition(:parked => :idling)
     @event.transition(:parked => :parked)
     
     @object = @klass.new
@@ -973,6 +1120,7 @@ class EventWithMarshallingTest < Test::Unit::TestCase
   
   def test_should_marshal_during_action
     @klass.class_eval do
+      remove_method :save
       def save
         Marshal.dump(self)
       end
@@ -1002,25 +1150,47 @@ begin
       @machine = StateMachine::Machine.new(Class.new, :initial => :parked)
       @machine.other_states(*states)
       
-      graph = GraphViz.new('G')
-      states.each {|state| graph.add_node(state.to_s)}
+      @graph = StateMachine::Graph.new('test')
+      states.each {|state| @graph.add_nodes(state.to_s)}
       
       @machine.events << @event = StateMachine::Event.new(@machine , :park)
       @event.transition :parked => :idling
       @event.transition :first_gear => :parked
       @event.transition :except_from => :parked, :to => :parked
       
-      @edges = @event.draw(graph)
+      @event.draw(@graph)
     end
     
     def test_should_generate_edges_for_each_transition
-      assert_equal 4, @edges.size
+      assert_equal 4, @graph.edge_count
     end
     
     def test_should_use_event_name_for_edge_label
-      assert_equal 'park', @edges.first['label'].to_s.gsub('"', '')
+      assert_equal 'park', @graph.get_edge_at_index(0)['label'].to_s.gsub('"', '')
+    end
+  end
+  
+  class EventDrawingWithHumanNameTest < Test::Unit::TestCase
+    def setup
+      states = [:parked, :idling]
+      
+      @machine = StateMachine::Machine.new(Class.new, :initial => :parked)
+      @machine.other_states(*states)
+      
+      graph = StateMachine::Graph.new('test')
+      states.each {|state| graph.add_nodes(state.to_s)}
+      
+      @machine.events << @event = StateMachine::Event.new(@machine , :park, :human_name => 'Park')
+      @event.transition :parked => :idling
+      
+      @event.draw(graph, :human_name => true)
+      @edge = graph.get_edge_at_index(0)
+    end
+    
+    def test_should_use_event_human_name_for_edge_label
+      assert_equal 'Park', @edge['label'].to_s.gsub('"', '')
     end
   end
 rescue LoadError
-  $stderr.puts 'Skipping GraphViz StateMachine::Event tests. `gem install ruby-graphviz` >= v0.9.0 and try again.'
+  $stderr.puts 'Skipping GraphViz StateMachine::Event tests. `gem install ruby-graphviz` >= v0.9.17 and try again.'
 end unless ENV['TRAVIS']

data/test/unit/graph_test.rb

@@ -0,0 +1,98 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+begin
+  # Load library
+  require 'graphviz'
+  
+  class GraphDefaultTest < Test::Unit::TestCase
+    def setup
+      @graph = StateMachine::Graph.new('test')
+    end
+    
+    def test_should_have_a_default_font
+      assert_equal 'Arial', @graph.font
+    end
+    
+    def test_should_use_current_directory_for_filepath
+      assert_equal './test.png', @graph.file_path
+    end
+    
+    def test_should_have_a_default_file_format
+      assert_equal 'png', @graph.file_format
+    end
+    
+    def test_should_have_a_default_orientation
+      assert_equal 'TB', @graph[:rankdir].source
+    end
+  end
+  
+  class GraphNodesTest < Test::Unit::TestCase
+    def setup
+      @graph = StateMachine::Graph.new('test')
+      @node = @graph.add_nodes('parked', :shape => 'ellipse')
+    end
+    
+    def test_should_return_generated_node
+      assert_not_nil @node
+    end
+    
+    def test_should_use_specified_name
+      assert_equal @node, @graph.get_node('parked')
+    end
+    
+    def test_should_use_specified_options
+      assert_equal 'ellipse', @node['shape'].to_s.gsub('"', '')
+    end
+    
+    def test_should_set_default_font
+      assert_equal 'Arial', @node['fontname'].to_s.gsub('"', '')
+    end
+  end
+  
+  class GraphEdgesTest < Test::Unit::TestCase
+    def setup
+      @graph = StateMachine::Graph.new('test')
+      @graph.add_nodes('parked', :shape => 'ellipse')
+      @graph.add_nodes('idling', :shape => 'ellipse')
+      @edge = @graph.add_edges('parked', 'idling', :label => 'ignite')
+    end
+    
+    def test_should_return_generated_edge
+      assert_not_nil @edge
+    end
+    
+    def test_should_use_specified_nodes
+      assert_equal 'parked', @edge.node_one(false)
+      assert_equal 'idling', @edge.node_two(false)
+    end
+    
+    def test_should_use_specified_options
+      assert_equal 'ignite', @edge['label'].to_s.gsub('"', '')
+    end
+    
+    def test_should_set_default_font
+      assert_equal 'Arial', @edge['fontname'].to_s.gsub('"', '')
+    end
+  end
+  
+  class GraphOutputTest < Test::Unit::TestCase
+    def setup
+      @graph_name = "test_#{rand(1000000)}"
+      @graph = StateMachine::Graph.new(@graph_name)
+      @graph.add_nodes('parked', :shape => 'ellipse')
+      @graph.add_nodes('idling', :shape => 'ellipse')
+      @graph.add_edges('parked', 'idling', :label => 'ignite')
+      @graph.output
+    end
+    
+    def test_should_save_file
+      assert File.exist?("./#{@graph_name}.png")
+    end
+    
+    def teardown
+      FileUtils.rm Dir["./#{@graph_name}.png"]
+    end
+  end
+rescue LoadError
+  $stderr.puts 'Skipping GraphViz StateMachine::Graph tests. `gem install ruby-graphviz` >= v0.9.17 and try again.'
+end unless ENV['TRAVIS']

data/test/unit/integrations/active_model_test.rb

@@ -1,7 +1,12 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
 require 'active_model'
-require 'active_model/observing'
+if defined?(ActiveModel::VERSION) && ActiveModel::VERSION::MAJOR >= 4
+  require 'rails/observers/active_model/active_model'
+  require 'active_model/mass_assignment_security'
+else
+  require 'active_model/observing'
+end
 require 'active_support/all'
 
 module ActiveModelTest
@@ -15,9 +20,9 @@ module ActiveModelTest
         # Simple ActiveModel superclass
         parent = Class.new do
           def self.model_attribute(name)
-            define_method(name) { instance_variable_get("@#{name}") }
+            define_method(name) { instance_variable_defined?("@#{name}") ? instance_variable_get("@#{name}") : nil }
             define_method("#{name}=") do |value|
-              send("#{name}_will_change!") if self.class <= ActiveModel::Dirty && value != instance_variable_get("@#{name}")
+              send("#{name}_will_change!") if self.class <= ActiveModel::Dirty && value != send(name)
               instance_variable_set("@#{name}", value)
             end
           end
@@ -92,7 +97,7 @@ module ActiveModelTest
     end
     
     def test_should_have_no_defaults
-      assert_equal e = {}, StateMachine::Integrations::ActiveModel.defaults
+      assert_equal({}, StateMachine::Integrations::ActiveModel.defaults)
     end
     
     def test_should_have_a_locale_path
@@ -186,8 +191,7 @@ module ActiveModelTest
     end
     
     def test_should_raise_exception_for_predicate_without_parameters
-      exception = assert_raise(ArgumentError) { @record.state? }
-      assert_equal 'wrong number of arguments (1 for 2)', exception.message
+      assert_raise(ArgumentError) { @record.state? }
     end
     
     def test_should_return_false_for_predicate_if_does_not_match_current_value
@@ -232,7 +236,7 @@ module ActiveModelTest
     def setup
       @model = new_model
       @machine = StateMachine::Machine.new(@model, :initial => :parked, :integration => :active_model)
-      @machine.state nil, :idling
+      @machine.state :idling
     end
     
     def test_should_allow_nil_initial_state_when_static
@@ -513,11 +517,21 @@ module ActiveModelTest
     def test_should_run_around_callbacks
       before_called = false
       after_called = false
-      @machine.around_transition {|block| before_called = true; block.call; after_called = true}
+      ensure_called = 0
+      @machine.around_transition do |block|
+        before_called = true
+        begin
+          block.call
+        ensure
+          ensure_called += 1
+        end
+        after_called = true
+      end
       
       @transition.perform
       assert before_called
       assert after_called
+      assert_equal ensure_called, 1
     end
     
     def test_should_include_transition_states_in_known_states
@@ -584,7 +598,7 @@ module ActiveModelTest
   end
   
   class MachineWithFailedAfterCallbacksTest < BaseTestCase
-     def setup
+    def setup
       @callbacks = []
       
       @model = new_model
@@ -727,6 +741,40 @@ module ActiveModelTest
     end
   end
   
+  class ObserverUpdateTest < BaseTestCase
+    def setup
+      @model = new_model { include ActiveModel::Observing }
+      @machine = StateMachine::Machine.new(@model)
+      @machine.state :parked, :idling
+      @machine.event :ignite
+      
+      @record = @model.new(:state => 'parked')
+      @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
+      
+      @observer_update = StateMachine::Integrations::ActiveModel::ObserverUpdate.new(:before_transition, @record, @transition)
+    end
+    
+    def test_should_have_method
+      assert_equal :before_transition, @observer_update.method
+    end
+    
+    def test_should_have_object
+      assert_equal @record, @observer_update.object
+    end
+    
+    def test_should_have_transition
+      assert_equal @transition, @observer_update.transition
+    end
+    
+    def test_should_include_object_and_transition_in_args
+      assert_equal [@record, @transition], @observer_update.args
+    end
+    
+    def test_should_use_record_class_as_class
+      assert_equal @model, @observer_update.class
+    end
+  end
+  
   class MachineWithObserversTest < BaseTestCase
     def setup
       @model = new_model { include ActiveModel::Observing }
@@ -750,7 +798,6 @@ module ActiveModelTest
         :before_transition
       ]
       
-      notified = false
       observer = new_observer(@model) do
         callbacks.each do |callback|
           define_method(callback) do |*args|
@@ -765,6 +812,31 @@ module ActiveModelTest
       assert_equal callbacks, instance.notifications
     end
     
+    def test_should_call_no_transition_callbacks_when_observers_disabled
+      return unless ActiveModel::VERSION::MAJOR >= 3 && ActiveModel::VERSION::MINOR >= 1
+      
+      callbacks = [
+        :before_ignite,
+        :before_transition
+      ]
+      
+      observer = new_observer(@model) do
+        callbacks.each do |callback|
+          define_method(callback) do |*args|
+            notifications << callback
+          end
+        end
+      end
+      
+      instance = observer.instance
+      
+      @model.observers.disable(observer) do
+        @transition.perform
+      end
+      
+      assert_equal [], instance.notifications
+    end
+    
     def test_should_pass_record_and_transition_to_before_callbacks
       observer = new_observer(@model) do
         def before_transition(*args)
@@ -809,7 +881,6 @@ module ActiveModelTest
         :before_transition_state_from_nil
       ]
       
-      notified = false
       observer = new_observer(@model) do
         callbacks.each do |callback|
           define_method(callback) do |*args|
@@ -833,7 +904,6 @@ module ActiveModelTest
         :before_transition_state_to_nil
       ]
       
-      notified = false
       observer = new_observer(@model) do
         callbacks.each do |callback|
           define_method(callback) do |*args|