state_machine 1.0.1 → 1.0.2

data/test/unit/integrations/mongo_mapper_test.rb

@@ -1,19 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
-# Load library
-require 'rubygems'
-
-if ENV['VERSION']
-  if Gem::Version.new(ENV['VERSION']) >= Gem::Version.new('0.9.0')
-    gem 'activesupport', '~>3.0'
-    require 'active_support'
-  elsif Gem::Version.new(ENV['VERSION']) <= Gem::Version.new('0.7.0') || !Gem.available?('>=0.7.0')
-    gem 'activesupport', '~>2.3'
-    require 'active_support'
-  end
-end
-
-gem 'mongo_mapper', ENV['VERSION'] ? "=#{ENV['VERSION']}" : '>=0.5.5'
 require 'mongo_mapper'
 
 # Establish database connection
@@ -297,6 +283,33 @@ module MongoMapperTest
     end
   end
   
+  class MachineWithConflictingStateNameTest < BaseTestCase
+    def setup
+      require 'stringio'
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model
+    end
+    
+    def test_should_output_warning_with_same_machine_name
+      @machine = StateMachine::Machine.new(@model)
+      @machine.state :state
+      
+      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
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+    end
+  end
+  
   class MachineWithColumnStateAttributeTest < BaseTestCase
     def setup
       @model = new_model
@@ -421,6 +434,25 @@ module MongoMapperTest
     end
   end
   
+  class MachineWithCustomAttributeTest < BaseTestCase
+    def setup
+      require 'stringio'
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model, :public_state, :attribute => :state)
+      @record = @model.new
+    end
+    
+    def test_should_not_delegate_attribute_predicate_with_different_attribute
+      assert_raise(ArgumentError) { @record.public_state? }
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+    end
+  end
+  
   class MachineWithInitializedStateTest < BaseTestCase
     def setup
       @model = new_model
@@ -1606,6 +1638,6 @@ module MongoMapperTest
       end
     end
   else
-    $stderr.puts 'Skipping MongoMapper I18n tests. `gem install mongo_mapper` >= v0.9.0 and try again.'
+    $stderr.puts 'Skipping MongoMapper I18n tests.'
   end
 end

data/test/unit/integrations/mongoid_test.rb

@@ -1,9 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
-# Load library
-require 'rubygems'
-
-gem 'mongoid', ENV['VERSION'] ? "=#{ENV['VERSION']}" : '>=2.0.0'
 require 'mongoid'
 
 # Establish database connection
@@ -273,6 +269,33 @@ module MongoidTest
     end
   end
   
+  class MachineWithConflictingStateNameTest < BaseTestCase
+    def setup
+      require 'stringio'
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model
+    end
+    
+    def test_should_output_warning_with_same_machine_name
+      @machine = StateMachine::Machine.new(@model)
+      @machine.state :state
+      
+      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
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+    end
+  end
+  
   class MachineWithColumnStateAttributeTest < BaseTestCase
     def setup
       @model = new_model
@@ -403,6 +426,25 @@ module MongoidTest
     end
   end
   
+  class MachineWithCustomAttributeTest < BaseTestCase
+    def setup
+      require 'stringio'
+      @original_stderr, $stderr = $stderr, StringIO.new
+      
+      @model = new_model
+      @machine = StateMachine::Machine.new(@model, :public_state, :attribute => :state)
+      @record = @model.new
+    end
+    
+    def test_should_not_delegate_attribute_predicate_with_different_attribute
+      assert_raise(ArgumentError) { @record.public_state? }
+    end
+    
+    def teardown
+      $stderr = @original_stderr
+    end
+  end
+  
   class MachineWithInitializedStateTest < BaseTestCase
     def setup
       @model = new_model
@@ -538,7 +580,7 @@ module MongoidTest
     end
     
     def test_should_track_attribute_changes
-      assert_equal %w(parked parked), @record.changes['state']
+      assert_equal %w(parked parked), @record.send(:attribute_change, 'state')
     end
   end
   
@@ -592,7 +634,7 @@ module MongoidTest
     end
     
     def test_should_track_attribute_changes
-      assert_equal %w(parked parked), @record.changes['status']
+      assert_equal %w(parked parked), @record.send(:attribute_change, 'status')
     end
   end
   
@@ -611,12 +653,12 @@ module MongoidTest
     end
     
     def test_should_track_attribute_change
-      assert_equal %w(parked parked), @record.changes['state']
+      assert_equal %w(parked parked), @record.send(:attribute_change, 'state')
     end
     
     def test_should_not_reset_changes_on_multiple_changes
       @record.state_event = 'ignite'
-      assert_equal %w(parked parked), @record.changes['state']
+      assert_equal %w(parked parked), @record.send(:attribute_change, 'state')
     end
     
     def test_should_not_include_state_in_changed_attributes_if_nil

data/test/unit/integrations/sequel_test.rb

@@ -1,9 +1,5 @@
 require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 
-# Load library
-require 'rubygems'
-
-gem 'sequel', ENV['VERSION'] ? "=#{ENV['VERSION']}" : '>=2.8.0'
 require 'sequel'
 require 'logger'
 
@@ -19,12 +15,20 @@ module SequelTest
       # Creates a new Sequel model (and the associated table)
       def new_model(create_table = :foo, &block)
         table_name = create_table || :foo
+        table_identifier = ::Sequel::SQL::Identifier.new(table_name)
+        
+        if !defined?(Sequel::VERSION) || Gem::Version.new(::Sequel::VERSION) <= Gem::Version.new('3.26.0')
+          class << table_identifier
+            alias_method :original_to_s, :to_s
+            def to_s(*args); args.empty? ? inspect : original_to_s(*args); end
+          end
+        end
         
-        DB.create_table!(::Sequel::SQL::Identifier.new(table_name)) do
+        DB.create_table!(table_identifier) do
           primary_key :id
           column :state, :string
         end if create_table
-        model = Class.new(Sequel::Model(DB[::Sequel::SQL::Identifier.new(table_name)])) do
+        model = Class.new(Sequel::Model(DB[table_identifier])) do
           self.raise_on_save_failure = false
           (class << self; self; end).class_eval do
             define_method(:name) { "SequelTest::#{table_name.to_s.capitalize}" }

data/test/unit/machine_test.rb

@@ -1068,7 +1068,7 @@ class MachineWithHelpersTest < Test::Unit::TestCase
   end
   
   def test_should_throw_exception_with_invalid_scope
-    assert_raise(RUBY_VERSION < '1.9' ? IndexError : KeyError) { @machine.define_helper(:invalid, :state) {} }
+    assert_raise(RUBY_VERSION < '1.9' ? IndexError : KeyError) { @machine.define_helper(:invalid, :park) {} }
   end
 end
 
@@ -1081,37 +1081,37 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
   
   def test_should_not_redefine_existing_public_methods
     @klass.class_eval do
-      def state
-        'parked'
+      def park
+        true
       end
     end
     
-    @machine.define_helper(:instance, :state) {}
-    assert_equal 'parked', @object.state
+    @machine.define_helper(:instance, :park) {}
+    assert_equal true, @object.park
   end
   
   def test_should_not_redefine_existing_protected_methods
     @klass.class_eval do
       protected
-        def state
-          'parked'
+        def park
+          true
         end
     end
     
-    @machine.define_helper(:instance, :state) {}
-    assert_equal 'parked', @object.send(:state)
+    @machine.define_helper(:instance, :park) {}
+    assert_equal true, @object.send(:park)
   end
   
   def test_should_not_redefine_existing_private_methods
     @klass.class_eval do
       private
-        def state
-          'parked'
+        def park
+          true
         end
     end
     
-    @machine.define_helper(:instance, :state) {}
-    assert_equal 'parked', @object.send(:state)
+    @machine.define_helper(:instance, :park) {}
+    assert_equal true, @object.send(:park)
   end
   
   def test_should_warn_if_defined_in_superclass
@@ -1213,33 +1213,45 @@ class MachineWithInstanceHelpersTest < Test::Unit::TestCase
   end
   
   def test_should_define_nonexistent_methods
-    @machine.define_helper(:instance, :state) {'parked'}
-    assert_equal 'parked', @object.state
+    @machine.define_helper(:instance, :park) {false}
+    assert_equal false, @object.park
+  end
+  
+  def test_should_warn_if_defined_multiple_times
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    @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
+  ensure
+    $stderr = @original_stderr
   end
   
   def test_should_pass_context_as_arguments
     helper_args = nil
-    @machine.define_helper(:instance, :state) {|*args| helper_args = args}
-    @object.state
+    @machine.define_helper(:instance, :park) {|*args| helper_args = args}
+    @object.park
     assert_equal 2, helper_args.length
     assert_equal [@machine, @object], helper_args
   end
   
   def test_should_pass_method_arguments_through
     helper_args = nil
-    @machine.define_helper(:instance, :state) {|*args| helper_args = args}
-    @object.state(1, 2, 3)
+    @machine.define_helper(:instance, :park) {|*args| helper_args = args}
+    @object.park(1, 2, 3)
     assert_equal 5, helper_args.length
     assert_equal [@machine, @object, 1, 2, 3], helper_args
   end
   
   def test_should_allow_string_evaluation
     @machine.define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
-      def state
-        'parked'
+      def park
+        false
       end
     end_eval
-    assert_equal 'parked', @object.state
+    assert_equal false, @object.park
   end
 end
 
@@ -1387,6 +1399,18 @@ class MachineWithClassHelpersTest < Test::Unit::TestCase
     assert_equal [], @klass.states
   end
   
+  def test_should_warn_if_defined_multiple_times
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    @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
+  ensure
+    $stderr = @original_stderr
+  end
+  
   def test_should_pass_context_as_arguments
     helper_args = nil
     @machine.define_helper(:class, :states) {|*args| helper_args = args}
@@ -1808,6 +1832,40 @@ class MachineWithConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithSuperclassConflictingHelpersAfterDefinitionTest < Test::Unit::TestCase
+  def setup
+    require 'stringio'
+    @original_stderr, $stderr = $stderr, StringIO.new
+    
+    @superclass = Class.new
+    @klass = Class.new(@superclass)
+    
+    @machine = StateMachine::Machine.new(@klass)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+    
+    @superclass.class_eval do
+      def state?
+        true
+      end
+    end
+    
+    @object = @klass.new
+  end
+  
+  def test_should_call_superclass_attribute_predicate_without_arguments
+    assert @object.state?
+  end
+  
+  def test_should_define_attribute_predicate_with_arguments
+    assert !@object.state?(:parked)
+  end
+  
+  def teardown
+    $stderr = @original_stderr
+  end
+end
+
 class MachineWithoutInitializeTest < Test::Unit::TestCase
   def setup
     @klass = Class.new
@@ -2288,6 +2346,86 @@ class MachineWithMultipleEventsTest < Test::Unit::TestCase
   end
 end
 
+class MachineWithTransitionsTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+  end
+  
+  def test_should_require_on_event
+    exception = assert_raise(ArgumentError) { @machine.transition(:parked => :idling) }
+    assert_equal 'Must specify :on event', exception.message
+  end
+  
+  def test_should_not_allow_except_to_option
+    exception = assert_raise(ArgumentError) {@machine.transition(:except_to => :parked, :on => :ignite)}
+    assert_equal 'Invalid key(s): except_to', exception.message
+  end
+  
+  def test_should_not_allow_except_on_option
+    exception = assert_raise(ArgumentError) {@machine.transition(:except_on => :ignite, :on => :ignite)}
+    assert_equal 'Invalid key(s): except_on', exception.message
+  end
+  
+  def test_should_allow_transitioning_without_a_to_state
+    assert_nothing_raised {@machine.transition(:from => :parked, :on => :ignite)}
+  end
+  
+  def test_should_allow_transitioning_without_a_from_state
+    assert_nothing_raised {@machine.transition(:to => :idling, :on => :ignite)}
+  end
+  
+  def test_should_allow_except_from_option
+    assert_nothing_raised {@machine.transition(:except_from => :idling, :on => :ignite)}
+  end
+  
+  def test_should_allow_implicit_options
+    branch = @machine.transition(:first_gear => :second_gear, :on => :shift_up)
+    assert_instance_of StateMachine::Branch, branch
+    
+    state_requirements = branch.state_requirements
+    assert_equal 1, state_requirements.length
+    
+    assert_instance_of StateMachine::WhitelistMatcher, state_requirements[0][:from]
+    assert_equal [:first_gear], state_requirements[0][:from].values
+    assert_instance_of StateMachine::WhitelistMatcher, state_requirements[0][:to]
+    assert_equal [:second_gear], state_requirements[0][:to].values
+    assert_instance_of StateMachine::WhitelistMatcher, branch.event_requirement
+    assert_equal [:shift_up], branch.event_requirement.values
+  end
+  
+  def test_should_allow_multiple_implicit_options
+    branch = @machine.transition(:first_gear => :second_gear, :second_gear => :third_gear, :on => :shift_up)
+    
+    state_requirements = branch.state_requirements
+    assert_equal 2, state_requirements.length
+  end
+  
+  def test_should_allow_verbose_options
+    branch = @machine.transition(:from => :parked, :to => :idling, :on => :ignite)
+    assert_instance_of StateMachine::Branch, branch
+  end
+  
+  def test_should_include_all_transition_states_in_machine_states
+    @machine.transition(:parked => :idling, :on => :ignite)
+    
+    assert_equal [:parked, :idling], @machine.states.map {|state| state.name}
+  end
+  
+  def test_should_include_all_transition_events_in_machine_events
+    @machine.transition(:parked => :idling, :on => :ignite)
+    
+    assert_equal [:ignite], @machine.events.map {|event| event.name}
+  end
+  
+  def test_should_allow_multiple_events
+    branches = @machine.transition(:parked => :ignite, :on => [:ignite, :shift_up])
+    
+    assert_equal 2, branches.length
+    assert_equal [:ignite, :shift_up], @machine.events.map {|event| event.name}
+  end
+end
+
 class MachineWithTransitionCallbacksTest < Test::Unit::TestCase
   def setup
     @klass = Class.new do
@@ -2588,6 +2726,51 @@ class MachineWithExistingMachinesWithSameAttributesOnOwnerClassTest < Test::Unit
     @object.park
     assert_equal 'parked', @object.state
   end
+  
+  def test_should_copy_new_states_to_sibling_machines
+    @first_gear = @machine.state :first_gear
+    assert_equal @first_gear, @second_machine.state(:first_gear)
+    
+    @second_gear = @second_machine.state :second_gear
+    assert_equal @second_gear, @machine.state(:second_gear)
+  end
+  
+  def test_should_copy_all_existing_states_to_new_machines
+    third_machine = StateMachine::Machine.new(@klass, :protected_state, :attribute => :state)
+    
+    assert_equal @machine.state(:parked), third_machine.state(:parked)
+    assert_equal @machine.state(:idling), third_machine.state(:idling)
+  end
+end
+
+class MachineWithExistingMachinesWithSameAttributesOnOwnerSubclassTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
+    @second_machine = StateMachine::Machine.new(@klass, :public_state, :initial => :idling, :attribute => :state)
+    
+    @subclass = Class.new(@klass)
+    @object = @subclass.new
+  end
+  
+  def test_should_not_copy_sibling_machines_to_subclass_after_initialization
+    @subclass.state_machine(:state) {}
+    assert_equal @klass.state_machine(:public_state), @subclass.state_machine(:public_state)
+  end
+  
+  def test_should_copy_sibling_machines_to_subclass_after_new_state
+    subclass_machine = @subclass.state_machine(:state) {}
+    subclass_machine.state :first_gear
+    assert_not_equal @klass.state_machine(:public_state), @subclass.state_machine(:public_state)
+  end
+  
+  def test_should_copy_new_states_to_sibling_machines
+    subclass_machine = @subclass.state_machine(:state) {}
+    @first_gear = subclass_machine.state :first_gear
+    
+    second_subclass_machine = @subclass.state_machine(:public_state)
+    assert_equal @first_gear, second_subclass_machine.state(:first_gear)
+  end
 end
 
 class MachineWithNamespaceTest < Test::Unit::TestCase
@@ -2869,8 +3052,6 @@ end
 
 begin
   # Load library
-  require 'rubygems'
-  gem 'ruby-graphviz', '>=0.9.0'
   require 'graphviz'
   
   class MachineDrawingTest < Test::Unit::TestCase
@@ -3040,4 +3221,4 @@ begin
   end
 rescue LoadError
   $stderr.puts 'Skipping GraphViz StateMachine::Machine tests. `gem install ruby-graphviz` >= v0.9.0 and try again.'
-end
+end unless ENV['TRAVIS']