state_machine 0.9.4 → 0.10.0

data/test/unit/integrations/active_model_test.rb

@@ -14,7 +14,7 @@ module ActiveModelTest
     end
     
     protected
-      # Creates a new ActiveRecord model (and the associated table)
+      # Creates a new ActiveModel model (and the associated table)
       def new_model(&block)
         # Simple ActiveModel superclass
         parent = Class.new do
@@ -58,7 +58,7 @@ module ActiveModelTest
         model
       end
       
-      # Creates a new ActiveRecord observer
+      # Creates a new ActiveModel observer
       def new_observer(model, &block)
         observer = Class.new(ActiveModel::Observer) do
           attr_accessor :notifications
@@ -79,6 +79,10 @@ module ActiveModelTest
       assert StateMachine::Integrations::ActiveModel.matches?(new_model { include ActiveModel::Dirty })
     end
     
+    def test_should_match_if_class_includes_mass_assignment_security_feature
+      assert StateMachine::Integrations::ActiveModel.matches?(new_model { include ActiveModel::MassAssignmentSecurity })
+    end
+    
     def test_should_match_if_class_includes_observing_feature
       assert StateMachine::Integrations::ActiveModel.matches?(new_model { include ActiveModel::Observing })
     end
@@ -240,6 +244,26 @@ module ActiveModelTest
       record = @model.new(:state => nil)
       assert_equal 'parked', record.state
     end
+    
+    def test_should_use_default_state_if_protected
+      @model.class_eval do
+        include ActiveModel::MassAssignmentSecurity
+        attr_protected :state
+        
+        def initialize(attrs = {})
+          initialize_state_machines(:attributes => attrs) do
+            sanitize_for_mass_assignment(attrs).each {|attr, value| send("#{attr}=", value)} if attrs
+            @changed_attributes = {}
+          end
+        end
+      end
+      
+      record = @model.new(:state => 'idling')
+      assert_equal 'parked', record.state
+      
+      record = @model.new(nil)
+      assert_equal 'parked', record.state
+    end
   end
   
   class MachineWithDirtyAttributesTest < BaseTestCase
@@ -356,6 +380,40 @@ module ActiveModelTest
     end
   end
   
+  class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
+    def setup
+      @model = new_model do
+        include ActiveModel::Dirty
+        define_attribute_methods [:state]
+      end
+      @machine = StateMachine::Machine.new(@model, :action => :save, :initial => :parked)
+      @machine.event :ignite
+      
+      @record = @model.create
+      @record.state_event = 'ignite'
+    end
+    
+    def test_should_include_state_in_changed_attributes
+      assert_equal %w(state), @record.changed
+    end
+    
+    def test_should_track_attribute_change
+      assert_equal %w(parked parked), @record.changes['state']
+    end
+    
+    def test_should_not_reset_changes_on_multiple_changes
+      @record.state_event = 'ignite'
+      assert_equal %w(parked parked), @record.changes['state']
+    end
+    
+    def test_should_not_include_state_in_changed_attributes_if_nil
+      @record = @model.create
+      @record.state_event = nil
+      
+      assert_equal [], @record.changed
+    end
+  end
+  
   class MachineWithCallbacksTest < BaseTestCase
     def setup
       @model = new_model
@@ -740,6 +798,48 @@ module ActiveModelTest
     end
   end
   
+  class MachineWithFailureCallbacksTest < 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)
+      
+      @notifications = []
+      
+      # Create callbacks
+      @machine.before_transition {false}
+      @machine.after_failure {@notifications << :callback_after_failure}
+      
+      # Create observer callbacks
+      observer = new_observer(@model) do
+        def after_failure_to_ignite(*args)
+          notifications << :observer_after_failure_ignite
+        end
+        
+        def after_failure_to_transition(*args)
+          notifications << :observer_after_failure_transition
+        end
+      end
+      instance = observer.instance
+      instance.notifications = @notifications
+      
+      @transition.perform
+    end
+    
+    def test_should_invoke_callbacks_in_specific_order
+      expected = [
+        :callback_after_failure,
+        :observer_after_failure_ignite,
+        :observer_after_failure_transition
+      ]
+      
+      assert_equal expected, @notifications
+    end
+  end
+  
   class MachineWithMixedCallbacksTest < BaseTestCase
     def setup
       @model = new_model { include ActiveModel::Observing }
@@ -915,7 +1015,7 @@ module ActiveModelTest
     def test_should_only_add_locale_once_in_load_path
       assert_equal 1, I18n.load_path.select {|path| path =~ %r{active_model/locale\.rb$}}.length
       
-      # Create another ActiveRecord model that will triger the i18n feature
+      # Create another ActiveModel model that will triger the i18n feature
       new_model
       
       assert_equal 1, I18n.load_path.select {|path| path =~ %r{active_model/locale\.rb$}}.length

data/test/unit/integrations/active_record_test.rb

@@ -3,6 +3,7 @@ require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
 # Load library
 require 'rubygems'
 
+gem 'i18n', '<0.5' if ENV['VERSION'] && ENV['VERSION'] >= '2.3.5' && ENV['VERSION'] < '3.0.0'
 gem 'activerecord', ENV['VERSION'] ? "=#{ENV['VERSION']}" : '>=2.0.0'
 require 'active_record'
 
@@ -40,9 +41,12 @@ module ActiveRecordTest
           connection.create_table(table_name, :force => true) {|t| t.string(:state)} if create_table
           set_table_name(table_name.to_s)
           
-          def self.name; "ActiveRecordTest::#{table_name.capitalize}"; end
+          (class << self; self; end).class_eval do
+            define_method(:name) { "ActiveRecordTest::#{table_name.to_s.capitalize}" }
+          end
         end
         model.class_eval(&block) if block_given?
+        model.reset_column_information if create_table
         model
       end
       
@@ -639,6 +643,37 @@ module ActiveRecordTest
         assert_equal %w(parked parked), @record.changes['status']
       end
     end
+    
+    class MachineWithDirtyAttributeAndStateEventsTest < BaseTestCase
+      def setup
+        @model = new_model
+        @machine = StateMachine::Machine.new(@model, :initial => :parked)
+        @machine.event :ignite
+        
+        @record = @model.create
+        @record.state_event = 'ignite'
+      end
+      
+      def test_should_include_state_in_changed_attributes
+        assert_equal %w(state), @record.changed
+      end
+      
+      def test_should_track_attribute_change
+        assert_equal %w(parked parked), @record.changes['state']
+      end
+      
+      def test_should_not_reset_changes_on_multiple_changes
+        @record.state_event = 'ignite'
+        assert_equal %w(parked parked), @record.changes['state']
+      end
+      
+      def test_should_not_include_state_in_changed_attributes_if_nil
+        @record = @model.create
+        @record.state_event = nil
+        
+        assert_equal [], @record.changed
+      end
+    end
   else
     $stderr.puts 'Skipping ActiveRecord Dirty tests. `gem install active_record` >= v2.1.0 and try again.'
   end
@@ -858,13 +893,8 @@ module ActiveRecordTest
       @callbacks = []
       @machine.before_transition {@callbacks << :before}
       @machine.after_transition {@callbacks << :after}
-      @machine.after_transition(:include_failures => true) {@callbacks << :after_failure}
+      @machine.after_failure {@callbacks << :after_failure}
       @machine.around_transition {|block| @callbacks << :around_before; block.call; @callbacks << :around_after}
-      @machine.around_transition(:include_failures => true) do |block|
-        @callbacks << :around_before_failure
-        block.call
-        @callbacks << :around_after_failure
-      end
       
       @record = @model.new(:state => 'parked')
       @transition = StateMachine::Transition.new(@record, @machine, :ignite, :parked, :idling)
@@ -884,7 +914,7 @@ module ActiveRecordTest
     end
     
     def test_should_run_before_callbacks_and_after_callbacks_with_failures
-      assert_equal [:before, :around_before, :around_before_failure, :around_after_failure, :after_failure], @callbacks
+      assert_equal [:before, :around_before, :after_failure], @callbacks
     end
   end
   
@@ -1090,14 +1120,14 @@ module ActiveRecordTest
       assert !ran_callback
     end
     
-    def test_should_run_after_callbacks_with_failures_enabled_if_validation_fails
+    def test_should_run_after_callbacks_if_validation_fails
       @model.class_eval do
         attr_accessor :seatbelt
         validates_presence_of :seatbelt
       end
       
       ran_callback = false
-      @machine.after_transition(:include_failures => true) { ran_callback = true }
+      @machine.after_failure { ran_callback = true }
       
       @record.valid?
       assert ran_callback
@@ -1124,19 +1154,6 @@ module ActiveRecordTest
       assert !ran_callback
     end
     
-    def test_should_run_around_callbacks_after_yield_with_failures_enabled_if_validation_fails
-      @model.class_eval do
-        attr_accessor :seatbelt
-        validates_presence_of :seatbelt
-      end
-      
-      ran_callback = false
-      @machine.around_transition(:include_failures => true) {|block| block.call; ran_callback = true }
-      
-      @record.valid?
-      assert ran_callback
-    end
-    
     def test_should_not_run_before_transitions_within_transaction
       @machine.before_transition { @model.create; raise ActiveRecord::Rollback }
       
@@ -1227,17 +1244,17 @@ module ActiveRecordTest
       assert !ran_callback
     end
     
-    def test_should_run_after_callbacks_with_failures_enabled_if_fails
+    def test_should_run_failure_callbacks__if_fails
       @model.before_create {|record| false}
       
       ran_callback = false
-      @machine.after_transition(:include_failures => true) { ran_callback = true }
+      @machine.after_failure { ran_callback = true }
       
       begin; @record.save; rescue; end
       assert ran_callback
     end
     
-    def test_should_not_run_around_callbacks_with_failures_disabled_if_fails
+    def test_should_not_run_around_callbacks_if_fails
       @model.before_create {|record| false}
       
       ran_callback = false
@@ -1255,16 +1272,6 @@ module ActiveRecordTest
       assert ran_callback
     end
     
-    def test_should_run_around_callbacks_after_yield_with_failures_enabled_if_fails
-      @model.before_create {|record| false}
-      
-      ran_callback = false
-      @machine.around_transition(:include_failures => true) {|block| block.call; ran_callback = true }
-      
-      begin; @record.save; rescue; end
-      assert ran_callback
-    end
-    
     def test_should_run_before_transitions_within_transaction
       @machine.before_transition { @model.create; raise ActiveRecord::Rollback }
       
@@ -1493,24 +1500,21 @@ module ActiveRecordTest
       assert_equal [instance], instance.notifications
     end
     
-    def test_should_use_original_observer_behavior_to_handle_non_state_machine_callbacks
+    def test_should_continue_to_handle_non_state_machine_callbacks
       observer = new_observer(@model) do
         def before_save(object)
+          notifications << [:before_save, @object]
         end
         
         def before_ignite(*args)
-        end
-        
-        def update_without_multiple_args(observed_method, object)
-          notifications << [observed_method, object] if [:before_save, :before_ignite].include?(observed_method)
-          super
+          notifications << :before_ignite
         end
       end
       
       instance = observer.instance
       
       @transition.perform
-      assert_equal [[:before_save, @record]], instance.notifications
+      assert_equal [:before_ignite, [:before_save, @object]], instance.notifications
     end
   end
   
@@ -1549,6 +1553,48 @@ module ActiveRecordTest
     end
   end
   
+  class MachineWithFailureCallbacksTest < BaseTestCase
+    def setup
+      @model = new_model
+      @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)
+      
+      @notifications = []
+      
+      # Create callbacks
+      @machine.before_transition {false}
+      @machine.after_failure {@notifications << :callback_after_failure}
+      
+      # Create observer callbacks
+      observer = new_observer(@model) do
+        def after_failure_to_ignite(*args)
+          notifications << :observer_after_failure_ignite
+        end
+        
+        def after_failure_to_transition(*args)
+          notifications << :observer_after_failure_transition
+        end
+      end
+      instance = observer.instance
+      instance.notifications = @notifications
+      
+      @transition.perform
+    end
+    
+    def test_should_invoke_callbacks_in_specific_order
+      expected = [
+        :callback_after_failure,
+        :observer_after_failure_ignite,
+        :observer_after_failure_transition
+      ]
+      
+      assert_equal expected, @notifications
+    end
+  end
+  
   class MachineWithMixedCallbacksTest < BaseTestCase
     def setup
       @model = new_model
@@ -1756,6 +1802,7 @@ module ActiveRecordTest
         I18n.backend = I18n::Backend::Simple.new
         
         # Initialize the backend
+        StateMachine::Machine.new(new_model)
         I18n.backend.translate(:en, 'activerecord.errors.messages.invalid_transition', :event => 'ignite', :value => 'idling')
         
         @model = new_model

data/test/unit/integrations/base_test.rb

@@ -0,0 +1,87 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+# Load library
+require 'rubygems'
+
+module BaseTest  
+  class IntegrationTest < Test::Unit::TestCase
+    def test_should_not_match_any_classes
+      assert !StateMachine::Integrations::Base.matches?(Class.new)
+    end
+  end
+  
+  class IncludedTest < Test::Unit::TestCase
+    def setup
+      @integration = Module.new
+      StateMachine::Integrations.const_set('Custom', @integration)
+      
+      @integration.class_eval do
+        include StateMachine::Integrations::Base
+      end
+    end
+    
+    def test_should_not_have_any_defaults
+      assert_nil @integration.defaults
+    end
+    
+    def test_should_not_have_any_versions
+      assert_equal [], @integration.versions
+    end
+    
+    def test_should_track_version
+      version1 = @integration.version '1.0' do
+        def self.active?
+          true
+        end
+      end
+      
+      version2 = @integration.version '2.0' do
+        def self.active?
+          false
+        end
+      end
+      
+      assert_equal [version1, version2], @integration.versions
+    end
+    
+    def test_should_allow_active_versions_to_override_default_behavior
+      @integration.class_eval do
+        def version1_included?
+          false
+        end
+        
+        def version2_included?
+          false
+        end
+      end
+      
+      version1 = @integration.version '1.0' do
+        def self.active?
+          true
+        end
+        
+        def version1_included?
+          true
+        end
+      end
+      
+      version2 = @integration.version '2.0' do
+        def self.active?
+          false
+        end
+        
+        def version2_included?
+          true
+        end
+      end
+      
+      @machine = StateMachine::Machine.new(Class.new, :integration => :custom)
+      assert @machine.version1_included?
+      assert !@machine.version2_included?
+    end
+    
+    def teardown
+      StateMachine::Integrations.send(:remove_const, 'Custom')
+    end
+  end
+end