enum_state_machine 0.0.2 → 0.1.0

data/test/unit/integrations/base_test.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../test_helper')
+
+# Load library
+require 'rubygems'
+
+module BaseTest  
+  class IntegrationTest < Test::Unit::TestCase
+    def test_should_have_an_integration_name
+      assert_equal :base, EnumStateMachine::Integrations::Base.integration_name
+    end
+    
+    def test_should_not_be_available
+      assert !EnumStateMachine::Integrations::Base.available?
+    end
+    
+    def test_should_not_have_any_matching_ancestors
+      assert_equal [], EnumStateMachine::Integrations::Base.matching_ancestors
+    end
+    
+    def test_should_not_match_any_classes
+      assert !EnumStateMachine::Integrations::Base.matches?(Class.new)
+    end
+    
+    def test_should_not_have_a_locale_path
+      assert_nil EnumStateMachine::Integrations::Base.locale_path
+    end
+  end
+  
+  class IncludedTest < Test::Unit::TestCase
+    def setup
+      @integration = Module.new
+      EnumStateMachine::Integrations.const_set('Custom', @integration)
+      
+      @integration.class_eval do
+        include EnumStateMachine::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
+      
+      @integration.version '1.0' do
+        def self.active?
+          true
+        end
+        
+        def version1_included?
+          true
+        end
+      end
+      
+      @integration.version '2.0' do
+        def self.active?
+          false
+        end
+        
+        def version2_included?
+          true
+        end
+      end
+      
+      @machine = EnumStateMachine::Machine.new(Class.new, :integration => :custom)
+      assert @machine.version1_included?
+      assert !@machine.version2_included?
+    end
+    
+    def teardown
+      EnumStateMachine::Integrations.send(:remove_const, 'Custom')
+      super
+    end
+  end
+end

data/test/unit/integrations_test.rb

@@ -0,0 +1,71 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class IntegrationMatcherTest < Test::Unit::TestCase
+  def setup
+    superclass = Class.new
+    self.class.const_set('Vehicle', superclass)
+    
+    @klass = Class.new(superclass)
+  end
+  
+  def test_should_return_nil_if_no_match_found
+    assert_nil EnumStateMachine::Integrations.match(@klass)
+  end
+  
+  def test_should_return_integration_class_if_match_found
+    integration = Module.new do
+      include EnumStateMachine::Integrations::Base
+      
+      def self.matching_ancestors
+        ['IntegrationMatcherTest::Vehicle']
+      end
+    end
+    EnumStateMachine::Integrations.const_set('Custom', integration)
+    
+    assert_equal integration, EnumStateMachine::Integrations.match(@klass)
+  ensure
+    EnumStateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+  
+  def test_should_return_nil_if_no_match_found_with_ancestors
+    assert_nil EnumStateMachine::Integrations.match_ancestors(['IntegrationMatcherTest::Fake'])
+  end
+  
+  def test_should_return_integration_class_if_match_found_with_ancestors
+    integration = Module.new do
+      include EnumStateMachine::Integrations::Base
+      
+      def self.matching_ancestors
+        ['IntegrationMatcherTest::Vehicle']
+      end
+    end
+    EnumStateMachine::Integrations.const_set('Custom', integration)
+    
+    assert_equal integration, EnumStateMachine::Integrations.match_ancestors(['IntegrationMatcherTest::Fake', 'IntegrationMatcherTest::Vehicle'])
+  ensure
+    EnumStateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+  
+  def teardown
+    self.class.send(:remove_const, 'Vehicle')
+  end
+end
+
+class IntegrationFinderTest < Test::Unit::TestCase
+  def test_should_find_base
+    assert_equal EnumStateMachine::Integrations::Base, EnumStateMachine::Integrations.find_by_name(:base)
+  end
+  
+  def test_should_find_active_model
+    assert_equal EnumStateMachine::Integrations::ActiveModel, EnumStateMachine::Integrations.find_by_name(:active_model)
+  end
+  
+  def test_should_find_active_record
+    assert_equal EnumStateMachine::Integrations::ActiveRecord, EnumStateMachine::Integrations.find_by_name(:active_record)
+  end
+
+  def test_should_raise_an_exception_if_invalid
+    exception = assert_raise(EnumStateMachine::IntegrationNotFound) { EnumStateMachine::Integrations.find_by_name(:invalid) }
+    assert_equal ':invalid is an invalid integration', exception.message
+  end
+end

data/test/unit/invalid_event_test.rb

@@ -0,0 +1,20 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class InvalidEventTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @invalid_event = EnumStateMachine::InvalidEvent.new(@object, :invalid)
+  end
+  
+  def test_should_have_an_object
+    assert_equal @object, @invalid_event.object
+  end
+  
+  def test_should_have_an_event
+    assert_equal :invalid, @invalid_event.event
+  end
+  
+  def test_should_generate_a_message
+    assert_equal ':invalid is an unknown state machine event', @invalid_event.message
+  end
+end

data/test/unit/invalid_parallel_transition_test.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class InvalidParallelTransitionTest < Test::Unit::TestCase
+  def setup
+    @object = Object.new
+    @events = [:ignite, :disable_alarm]
+    
+    @invalid_transition = EnumStateMachine::InvalidParallelTransition.new(@object, @events)
+  end
+  
+  def test_should_have_an_object
+    assert_equal @object, @invalid_transition.object
+  end
+  
+  def test_should_have_events
+    assert_equal @events, @invalid_transition.events
+  end
+end

data/test/unit/invalid_transition_test.rb

@@ -0,0 +1,115 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class InvalidTransitionTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = EnumStateMachine::Machine.new(@klass)
+    @state = @machine.state :parked
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+    
+    @invalid_transition = EnumStateMachine::InvalidTransition.new(@object, @machine, :ignite)
+  end
+  
+  def test_should_have_an_object
+    assert_equal @object, @invalid_transition.object
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @invalid_transition.machine
+  end
+  
+  def test_should_have_an_event
+    assert_equal :ignite, @invalid_transition.event
+  end
+  
+  def test_should_have_a_qualified_event
+    assert_equal :ignite, @invalid_transition.qualified_event
+  end
+  
+  def test_should_have_a_from_value
+    assert_equal 'parked', @invalid_transition.from
+  end
+  
+  def test_should_have_a_from_name
+    assert_equal :parked, @invalid_transition.from_name
+  end
+  
+  def test_should_have_a_qualified_from_name
+    assert_equal :parked, @invalid_transition.qualified_from_name
+  end
+  
+  def test_should_generate_a_message
+    assert_equal 'Cannot transition state via :ignite from :parked', @invalid_transition.message
+  end
+end
+
+class InvalidTransitionWithNamespaceTest < Test::Unit::TestCase
+  def setup
+    @klass = Class.new
+    @machine = EnumStateMachine::Machine.new(@klass, :namespace => 'alarm')
+    @state = @machine.state :active
+    @machine.event :disable
+    
+    @object = @klass.new
+    @object.state = 'active'
+    
+    @invalid_transition = EnumStateMachine::InvalidTransition.new(@object, @machine, :disable)
+  end
+  
+  def test_should_have_an_event
+    assert_equal :disable, @invalid_transition.event
+  end
+  
+  def test_should_have_a_qualified_event
+    assert_equal :disable_alarm, @invalid_transition.qualified_event
+  end
+  
+  def test_should_have_a_from_name
+    assert_equal :active, @invalid_transition.from_name
+  end
+  
+  def test_should_have_a_qualified_from_name
+    assert_equal :alarm_active, @invalid_transition.qualified_from_name
+  end
+end
+
+class InvalidTransitionWithIntegrationTest < Test::Unit::TestCase
+  def setup
+    EnumStateMachine::Integrations.const_set('Custom', Module.new do
+      include EnumStateMachine::Integrations::Base
+      
+      def errors_for(object)
+        object.errors
+      end
+    end)
+    
+    @klass = Class.new do
+      attr_accessor :errors
+    end
+    @machine = EnumStateMachine::Machine.new(@klass, :integration => :custom)
+    @machine.state :parked
+    @machine.event :ignite
+    
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+  
+  def test_should_generate_a_message_without_reasons_if_empty
+    @object.errors = ''
+    invalid_transition = EnumStateMachine::InvalidTransition.new(@object, @machine, :ignite)
+    assert_equal 'Cannot transition state via :ignite from :parked', invalid_transition.message
+  end
+  
+  def test_should_generate_a_message_with_error_reasons_if_errors_found
+    @object.errors = 'Id is invalid, Name is invalid'
+    invalid_transition = EnumStateMachine::InvalidTransition.new(@object, @machine, :ignite)
+    assert_equal 'Cannot transition state via :ignite from :parked (Reason(s): Id is invalid, Name is invalid)', invalid_transition.message
+  end
+  
+  def teardown
+    EnumStateMachine::Integrations.send(:remove_const, 'Custom')
+  end
+end