state_machine 1.0.2 → 1.0.3

data/test/unit/integrations/mongoid_test.rb

@@ -281,14 +281,14 @@ module MongoidTest
       @machine = StateMachine::Machine.new(@model)
       @machine.state :state
       
-      assert_match /^Instance method "state\?" is already defined in .*, use generic helper instead\.\n$/, $stderr.string
+      assert_match /^Instance method "state\?" is already defined in .*, use generic helper instead.*\n$/, $stderr.string
     end
     
     def test_should_output_warning_with_same_machine_attribute
       @machine = StateMachine::Machine.new(@model, :public_state, :attribute => :state)
       @machine.state :state
       
-      assert_match /^Instance method "state\?" is already defined in .*, use generic helper instead\.\n$/, $stderr.string
+      assert_match /^Instance method "state\?" is already defined in .*, use generic helper instead.*\n$/, $stderr.string
     end
     
     def teardown
@@ -474,7 +474,7 @@ module MongoidTest
     
     def test_should_allow_different_initial_state_when_dynamic
       @machine.initial_state = lambda {:parked}
-      record = @model.new(:state => 'idling')
+      record = silence_warnings { @model.new(:state => 'idling') }
       assert_equal 'idling', record.state
     end
     
@@ -491,7 +491,7 @@ module MongoidTest
   class MachineMultipleTest < BaseTestCase
     def setup
       @model = new_model do
-        key :status, String, :default => 'idling'
+        field :status, :type => String, :default => 'idling'
       end
       @state_machine = StateMachine::Machine.new(@model, :initial => :parked)
       @status_machine = StateMachine::Machine.new(@model, :status, :initial => :idling)
@@ -587,7 +587,7 @@ module MongoidTest
   class MachineWithDirtyAttributesAndCustomAttributeTest < BaseTestCase
     def setup
       @model = new_model do
-        key :status, String, :default => 'idling'
+        field :status, :type => String, :default => 'idling'
       end
       @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
       @machine.event :ignite
@@ -618,7 +618,7 @@ module MongoidTest
   class MachineWithDirtyAttributeAndCustomAttributesDuringLoopbackTest < BaseTestCase
     def setup
       @model = new_model do
-        key :status, String, :default => 'idling'
+        field :status, :type => String, :default => 'idling'
       end
       @machine = StateMachine::Machine.new(@model, :status, :initial => :parked)
       @machine.event :park
@@ -744,6 +744,22 @@ module MongoidTest
       assert_equal self, context
     end
     
+    def test_should_run_after_callbacks_if_model_callback_added_prior_to_state_machine_definition
+      model = new_model do
+        after_save { nil }
+      end
+      machine = StateMachine::Machine.new(model, :initial => :parked)
+      machine.other_states :idling
+      machine.event :ignite
+      after_called = false
+      machine.after_transition {after_called = true}
+      
+      record = model.new(:state => 'parked')
+      transition = StateMachine::Transition.new(record, machine, :ignite, :parked, :idling)
+      transition.perform
+      assert_equal true, after_called
+    end
+    
     def test_should_run_around_callbacks
       before_called = false
       after_called = false
@@ -1371,6 +1387,13 @@ module MongoidTest
       assert_equal [parked, idling], @model.with_states(:parked, :idling).to_a
     end
     
+    def test_should_allow_lookup_by_string_name
+      parked = @model.create :state => 'parked'
+      idling = @model.create :state => 'idling'
+      
+      assert_equal [parked, idling], @model.with_states('parked', 'idling').to_a
+    end
+    
     def test_should_create_singular_without_scope
       assert @model.respond_to?(:without_state)
     end
@@ -1534,6 +1557,17 @@ module MongoidTest
       assert_equal 'shutdown', machine.state(:parked).human_name
     end
     
+    def test_should_allow_customized_state_key_scoped_to_class
+      I18n.backend.store_translations(:en, {
+        :mongoid => {:state_machines => {:'mongoid_test/foo' => {:states => {:parked => 'shutdown'}}}}
+      })
+      
+      machine = StateMachine::Machine.new(@model)
+      machine.state :parked
+      
+      assert_equal 'shutdown', machine.state(:parked).human_name
+    end
+    
     def test_should_allow_customized_state_key_scoped_to_machine
       I18n.backend.store_translations(:en, {
         :mongoid => {:state_machines => {:state => {:states => {:parked => 'shutdown'}}}}
@@ -1556,6 +1590,16 @@ module MongoidTest
       assert_equal 'shutdown', machine.state(:parked).human_name
     end
     
+    def test_should_support_nil_state_key
+      I18n.backend.store_translations(:en, {
+        :mongoid => {:state_machines => {:states => {:nil => 'empty'}}}
+      })
+      
+      machine = StateMachine::Machine.new(@model)
+      
+      assert_equal 'empty', machine.state(nil).human_name
+    end
+    
     def test_should_allow_customized_event_key_scoped_to_class_and_machine
       I18n.backend.store_translations(:en, {
         :mongoid => {:state_machines => {:'mongoid_test/foo' => {:state => {:events => {:park => 'stop'}}}}}
@@ -1567,6 +1611,17 @@ module MongoidTest
       assert_equal 'stop', machine.event(:park).human_name
     end
     
+    def test_should_allow_customized_event_key_scoped_to_class
+      I18n.backend.store_translations(:en, {
+        :mongoid => {:state_machines => {:'mongoid_test/foo' => {:events => {:park => 'stop'}}}}
+      })
+      
+      machine = StateMachine::Machine.new(@model)
+      machine.event :park
+      
+      assert_equal 'stop', machine.event(:park).human_name
+    end
+    
     def test_should_allow_customized_event_key_scoped_to_machine
       I18n.backend.store_translations(:en, {
         :mongoid => {:state_machines => {:state => {:events => {:park => 'stop'}}}}

data/test/unit/integrations/sequel_test.rb

@@ -34,8 +34,6 @@ module SequelTest
             define_method(:name) { "SequelTest::#{table_name.to_s.capitalize}" }
           end
         end
-        model.plugin(:validation_class_methods) if model.respond_to?(:plugin)
-        model.plugin(:hook_class_methods) if model.respond_to?(:plugin)
         model.class_eval(&block) if block_given?
         model
       end
@@ -856,6 +854,7 @@ module SequelTest
   class MachineWithFailedActionTest < BaseTestCase
     def setup
       @model = new_model do
+        plugin(:validation_class_methods) if respond_to?(:plugin)
         validates_each :state do |object, attribute, value|
           object.errors[attribute] << 'is invalid' unless %w(first_gear).include?(value)
         end
@@ -1403,6 +1402,13 @@ module SequelTest
       assert_equal [parked, idling], @model.with_states(:parked, :idling).all
     end
     
+    def test_should_allow_lookup_by_string_name
+      parked = @model.create :state => 'parked'
+      idling = @model.create :state => 'idling'
+      
+      assert_equal [parked, idling], @model.with_states('parked', 'idling').all
+    end
+    
     def test_should_create_singular_without_scope
       assert @model.respond_to?(:without_state)
     end

data/test/unit/machine_test.rb

@@ -1126,7 +1126,7 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(klass)
     
     machine.define_helper(:instance, :park) {}
-    assert_equal "Instance method \"park\" is already defined in #{superclass.to_s}, use generic helper instead.\n", $stderr.string
+    assert_equal "Instance method \"park\" is already defined in #{superclass.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n", $stderr.string
   ensure
     $stderr = @original_stderr
   end
@@ -1147,7 +1147,7 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(klass)
     
     machine.define_helper(:instance, :park) {}
-    assert_equal "Instance method \"park\" is already defined in #{superclass1.to_s}, use generic helper instead.\n", $stderr.string
+    assert_equal "Instance method \"park\" is already defined in #{superclass1.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n", $stderr.string
   ensure
     $stderr = @original_stderr
   end
@@ -1166,7 +1166,7 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(klass)
     
     machine.define_helper(:instance, :park) {}
-    assert_equal "Instance method \"park\" is already defined in #{mod.to_s}, use generic helper instead.\n", $stderr.string
+    assert_equal "Instance method \"park\" is already defined in #{mod.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n", $stderr.string
   ensure
     $stderr = @original_stderr
   end
@@ -1224,7 +1224,7 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
     @machine.define_helper(:instance, :park) {}
     @machine.define_helper(:instance, :park) {}
     
-    assert_equal "Instance method \"park\" is already defined in #{@klass} :state instance helpers, use generic helper instead.\n", $stderr.string
+    assert_equal "Instance method \"park\" is already defined in #{@klass} :state instance helpers, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n", $stderr.string
   ensure
     $stderr = @original_stderr
   end
@@ -1308,7 +1308,7 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(klass)
     
     machine.define_helper(:class, :park) {}
-    assert_equal "Class method \"park\" is already defined in #{superclass.to_s}, use generic helper instead.\n", $stderr.string
+    assert_equal "Class method \"park\" is already defined in #{superclass.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n", $stderr.string
   ensure
     $stderr = @original_stderr
   end
@@ -1329,7 +1329,7 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(klass)
     
     machine.define_helper(:class, :park) {}
-    assert_equal "Class method \"park\" is already defined in #{superclass1.to_s}, use generic helper instead.\n", $stderr.string
+    assert_equal "Class method \"park\" is already defined in #{superclass1.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n", $stderr.string
   ensure
     $stderr = @original_stderr
   end
@@ -1348,7 +1348,7 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(klass)
     
     machine.define_helper(:class, :park) {}
-    assert_equal "Class method \"park\" is already defined in #{mod.to_s}, use generic helper instead.\n", $stderr.string
+    assert_equal "Class method \"park\" is already defined in #{mod.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n", $stderr.string
   ensure
     $stderr = @original_stderr
   end
@@ -1406,7 +1406,7 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
     @machine.define_helper(:class, :states) {}
     @machine.define_helper(:class, :states) {}
     
-    assert_equal "Class method \"states\" is already defined in #{@klass} :state class helpers, use generic helper instead.\n", $stderr.string
+    assert_equal "Class method \"states\" is already defined in #{@klass} :state class helpers, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n", $stderr.string
   ensure
     $stderr = @original_stderr
   end
@@ -1591,7 +1591,7 @@ class MachineWithConflictingHelpersBeforeDefinitionTest < Test::Unit::TestCase
       'Class method "without_state"',
       'Class method "with_states"',
       'Class method "without_states"'
-    ].map {|method| "#{method} is already defined in #{@superclass.to_s}, use generic helper instead.\n"}.join
+    ].map {|method| "#{method} is already defined in #{@superclass.to_s}, use generic helper instead or set StateMachine::Machine.ignore_method_conflicts = true.\n"}.join
     
     assert_equal expected, $stderr.string
   end
@@ -2184,6 +2184,45 @@ class MachineWithExistingStateTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithStateMatchersTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+  end
+  
+  def test_should_empty_array_for_all_matcher
+    assert_equal [], @machine.state(StateMachine::AllMatcher.instance)
+  end
+  
+  def test_should_return_referenced_states_for_blacklist_matcher
+    assert_instance_of StateMachine::State, @machine.state(StateMachine::BlacklistMatcher.new([:parked]))
+  end
+  
+  def test_should_not_allow_configurations
+    exception = assert_raise(ArgumentError) { @machine.state(StateMachine::BlacklistMatcher.new([:parked]), :human_name => 'Parked') }
+    assert_equal 'Cannot configure states when using matchers (using {:human_name=>"Parked"})', exception.message
+  end
+  
+  def test_should_track_referenced_states
+    @machine.state(StateMachine::BlacklistMatcher.new([:parked]))
+    assert_equal [nil, :parked], @machine.states.map {|state| state.name}
+  end
+  
+  def test_should_eval_context_for_matching_states
+    contexts_run = []
+    @machine.event(StateMachine::BlacklistMatcher.new([:parked])) { contexts_run << self.name }
+    
+    @machine.event :parked
+    assert_equal [], contexts_run
+    
+    @machine.event :idling
+    assert_equal [:idling], contexts_run
+    
+    @machine.event :first_gear, :second_gear
+    assert_equal [:idling, :first_gear, :second_gear], contexts_run
+  end
+end
+
 class MachineWithOtherStates < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -2281,6 +2320,45 @@ class MachineWithEventsWithCustomHumanNamesTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithEventMatchersTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass)
+  end
+  
+  def test_should_empty_array_for_all_matcher
+    assert_equal [], @machine.event(StateMachine::AllMatcher.instance)
+  end
+  
+  def test_should_return_referenced_events_for_blacklist_matcher
+    assert_instance_of StateMachine::Event, @machine.event(StateMachine::BlacklistMatcher.new([:park]))
+  end
+  
+  def test_should_not_allow_configurations
+    exception = assert_raise(ArgumentError) { @machine.event(StateMachine::BlacklistMatcher.new([:park]), :human_name => 'Park') }
+    assert_equal 'Cannot configure events when using matchers (using {:human_name=>"Park"})', exception.message
+  end
+  
+  def test_should_track_referenced_events
+    event = @machine.event(StateMachine::BlacklistMatcher.new([:park]))
+    assert_equal [:park], @machine.events.map {|event| event.name}
+  end
+  
+  def test_should_eval_context_for_matching_events
+    contexts_run = []
+    @machine.event(StateMachine::BlacklistMatcher.new([:park])) { contexts_run << self.name }
+    
+    @machine.event :park
+    assert_equal [], contexts_run
+    
+    @machine.event :ignite
+    assert_equal [:ignite], contexts_run
+    
+    @machine.event :shift_up, :shift_down
+    assert_equal [:ignite, :shift_up, :shift_down], contexts_run
+  end
+end
+
 class MachineWithEventsWithTransitionsTest < Test::Unit::TestCase
   def setup
     @klass = Class.new

data/test/unit/node_collection_test.rb

@@ -1,5 +1,15 @@
 require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
 
+class Node < Struct.new(:name, :value, :machine)
+  def name_to_s
+    name.to_s
+  end
+  
+  def context
+    yield
+  end
+end
+
 class NodeCollectionByDefaultTest < Test::Unit::TestCase
   def setup
     @machine = StateMachine::Machine.new(Class.new)
@@ -15,7 +25,7 @@ class NodeCollectionByDefaultTest < Test::Unit::TestCase
   end
   
   def test_should_index_by_name
-    @collection << object = Struct.new(:name).new(:parked)
+    @collection << object = Node.new(:parked)
     assert_equal object, @collection[:parked]
   end
 end
@@ -46,10 +56,15 @@ class NodeCollectionAfterBeingCopiedTest < Test::Unit::TestCase
   def setup
     machine = StateMachine::Machine.new(Class.new)
     @collection = StateMachine::NodeCollection.new(machine)
-    @collection << @parked = Struct.new(:name).new(:parked)
+    @collection << @parked = Node.new(:parked)
+    
+    @contexts_run = contexts_run = []
+    @collection.context([:parked]) {contexts_run << :parked}
+    @contexts_run.clear
     
     @copied_collection = @collection.dup
-    @copied_collection << @idling = Struct.new(:name).new(:idling)
+    @copied_collection << @idling = Node.new(:idling)
+    @copied_collection.context([:first_gear]) {contexts_run << :first_gear}
   end
   
   def test_should_not_modify_the_original_list
@@ -65,6 +80,20 @@ class NodeCollectionAfterBeingCopiedTest < Test::Unit::TestCase
   def test_should_copy_each_node
     assert_not_same @parked, @copied_collection[:parked]
   end
+  
+  def test_should_not_run_contexts
+    assert_equal [], @contexts_run
+  end
+  
+  def test_should_not_modify_contexts
+    @collection << Node.new(:first_gear)
+    assert_equal [], @contexts_run
+  end
+  
+  def test_should_copy_contexts
+    @copied_collection << Node.new(:parked)
+    assert !@contexts_run.empty?
+  end
 end
 
 class NodeCollectionWithoutIndicesTest < Test::Unit::TestCase
@@ -101,7 +130,7 @@ class NodeCollectionWithIndicesTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(Class.new)
     @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
     
-    @object = Struct.new(:name, :value).new(:parked, 1)
+    @object = Node.new(:parked, 1)
     @collection << @object
   end
   
@@ -141,9 +170,8 @@ class NodeCollectionWithNodesTest < Test::Unit::TestCase
     @machine = StateMachine::Machine.new(Class.new)
     @collection = StateMachine::NodeCollection.new(@machine)
     
-    @klass = Struct.new(:name, :machine)
-    @parked = @klass.new(:parked, @machine)
-    @idling = @klass.new(:idling, @machine)
+    @parked = Node.new(:parked, nil, @machine)
+    @idling = Node.new(:idling, nil, @machine)
     
     @collection << @parked
     @collection << @idling
@@ -157,8 +185,8 @@ class NodeCollectionWithNodesTest < Test::Unit::TestCase
   end
   
   def test_should_be_able_to_concatenate_multiple_nodes
-    @first_gear = @klass.new(:first_gear, @machine)
-    @second_gear = @klass.new(:second_gear, @machine)
+    @first_gear = Node.new(:first_gear, nil, @machine)
+    @second_gear = Node.new(:second_gear, nil, @machine)
     @collection.concat([@first_gear, @second_gear])
     
     order = []
@@ -186,9 +214,8 @@ class NodeCollectionAfterUpdateTest < Test::Unit::TestCase
     machine = StateMachine::Machine.new(Class.new)
     @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
     
-    @klass = Struct.new(:name, :value)
-    @parked = @klass.new(:parked, 1)
-    @idling = @klass.new(:idling, 2)
+    @parked = Node.new(:parked, 1)
+    @idling = Node.new(:idling, 2)
     
     @collection << @parked << @idling
     
@@ -215,3 +242,93 @@ class NodeCollectionAfterUpdateTest < Test::Unit::TestCase
     assert_nil @collection[1, :value]
   end
 end
+
+class NodeCollectionWithStringIndexTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :name_to_s, :value])
+    
+    @parked = Node.new(:parked, 1)
+    @collection << @parked
+  end
+  
+  def test_should_index_by_name
+    assert_equal @parked, @collection[:parked]
+  end
+  
+  def test_should_index_by_string_name
+    assert_equal @parked, @collection['parked', :name_to_s]
+  end
+  
+  def test_should_fallback_to_string_index
+    assert_equal @parked, @collection['parked']
+  end
+  
+  def test_should_not_fallback_to_string_index_if_not_available
+    assert_nil @collection['1', :value]
+  end
+end
+
+class NodeCollectionWithPredefinedContextsTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine)
+    
+    @contexts_run = contexts_run = []
+    @collection.context([:parked]) { contexts_run << :parked }
+    @collection.context([:parked]) { contexts_run << :second_parked }
+  end
+  
+  def test_should_run_contexts_in_the_order_defined
+    @collection << Node.new(:parked)
+    assert_equal [:parked, :second_parked], @contexts_run
+  end
+  
+  def test_should_not_run_contexts_if_not_matched
+    @collection << Node.new(:idling)
+    assert_equal [], @contexts_run
+  end
+end
+
+class NodeCollectionWithPostdefinedContextsTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine)
+    @collection << Node.new(:parked)
+  end
+  
+  def test_should_run_context_if_matched
+    contexts_run = []
+    @collection.context([:parked]) { contexts_run << :parked }
+    assert_equal [:parked], contexts_run
+  end
+  
+  def test_should_not_run_contexts_if_not_matched
+    contexts_run = []
+    @collection.context([:idling]) { contexts_run << :idling }
+    assert_equal [], contexts_run
+  end
+end
+
+class NodeCollectionWithMatcherContextsTest < Test::Unit::TestCase
+  def setup
+    machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(machine)
+    @collection << Node.new(:parked)
+  end
+  
+  def test_should_always_run_all_matcher_context
+    contexts_run = []
+    @collection.context([StateMachine::AllMatcher.instance]) { contexts_run << :all }
+    assert_equal [:all], contexts_run
+  end
+  
+  def test_should_only_run_blacklist_matcher_if_not_matched
+    contexts_run = []
+    @collection.context([StateMachine::BlacklistMatcher.new([:parked])]) { contexts_run << :blacklist }
+    assert_equal [], contexts_run
+    
+    @collection << Node.new(:idling)
+    assert_equal [:blacklist], contexts_run
+  end
+end