hsume2-state_machine 1.0.1

data/test/unit/condition_proxy_test.rb

@@ -0,0 +1,328 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class Validateable
+  class << self
+    def validate(*args, &block)
+      args << block if block_given?
+      args
+    end
+  end
+end
+
+class ConditionProxyTest < Test::Unit::TestCase
+  def test_should_call_class_with_same_arguments
+    options = {}
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {})
+    validation = condition_proxy.validate(:name, options)
+    
+    assert_equal [:name, options], validation
+  end
+  
+  def test_should_pass_block_through_to_class
+    options = {}
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {})
+    
+    proxy_block = lambda {}
+    validation = condition_proxy.validate(:name, options, &proxy_block)
+    
+    assert_equal [:name, options, proxy_block], validation
+  end
+  
+  def test_should_pass_object_into_proxy_condition
+    condition_args = []
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {|*args| condition_args = args})
+    options = condition_proxy.validate[0]
+    
+    object = Validateable.new
+    options[:if].call(object)
+    
+    assert_equal [object], condition_args
+  end
+  
+  def test_should_evaluate_symbol_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback_called
+      
+      def callback
+        @callback_called = true
+      end
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, :callback)
+    options = condition_proxy.validate[0]
+    
+    object = klass.new
+    options[:if].call(object)
+    
+    assert object.callback_called
+  end
+  
+  def test_should_evaluate_string_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback_called
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, '@callback_called = true')
+    options = condition_proxy.validate[0]
+    
+    object = klass.new
+    options[:if].call(object)
+    
+    assert object.callback_called
+  end
+end
+
+class ConditionProxyWithoutConditionsTest < Test::Unit::TestCase
+  def setup
+    @proxy_result = nil
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    
+    @object = Validateable.new
+    @options = condition_proxy.validate[0]
+  end
+  
+  def test_should_have_options_configuration
+    assert_instance_of Hash, @options
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_proxy_condition_is_false
+    @proxy_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_proxy_condition_is_true
+    @proxy_result = true
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_proxy_condition_is_not_true
+    @proxy_result = 1
+    assert @options[:if].call(@object)
+  end
+end
+
+class ConditionProxyWithIfConditionTest < Test::Unit::TestCase
+  def setup
+    @proxy_result = nil
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    
+    @object = Validateable.new
+    
+    @condition_result = nil
+    @options = condition_proxy.validate(:if => lambda {@condition_result})[0]
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_proxy_condition_is_false
+    @proxy_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_original_condition_is_false
+    @condition_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_proxy_and_original_condition_are_true
+    @proxy_result = true
+    @condition_result = true
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_evaluate_symbol_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
+    options = condition_proxy.validate(:if => :callback)[0]
+    
+    object = klass.new
+    object.callback = false
+    assert !options[:if].call(object)
+    
+    object.callback = true
+    assert options[:if].call(object)
+  end
+  
+  def test_should_evaluate_string_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
+    options = condition_proxy.validate(:if => '@callback')[0]
+    
+    object = klass.new
+    object.callback = false
+    assert !options[:if].call(object)
+    
+    object.callback = true
+    assert options[:if].call(object)
+  end
+end
+
+class ConditionProxyWithMultipleIfConditionsTest < Test::Unit::TestCase
+  def setup
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
+    
+    @object = Validateable.new
+    
+    @first_condition_result = nil
+    @second_condition_result = nil
+    @options = condition_proxy.validate(:if => [lambda {@first_condition_result}, lambda {@second_condition_result}])[0]
+  end
+  
+  def test_should_be_true_if_all_conditions_are_true
+    @first_condition_result = true
+    @second_condition_result = true
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_any_condition_is_false
+    @first_condition_result = true
+    @second_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @first_condition_result = false
+    @second_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+end
+
+class ConditionProxyWithUnlessConditionTest < Test::Unit::TestCase
+  def setup
+    @proxy_result = nil
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {@proxy_result})
+    
+    @object = Validateable.new
+    
+    @condition_result = nil
+    @options = condition_proxy.validate(:unless => lambda {@condition_result})[0]
+  end
+  
+  def test_should_have_if_option
+    assert_not_nil @options[:if]
+  end
+  
+  def test_should_be_false_if_proxy_condition_is_false
+    @proxy_result = false
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_original_condition_is_true
+    @condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_proxy_is_true_and_original_condition_is_false
+    @proxy_result = true
+    @condition_result = false
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_evaluate_symbol_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
+    options = condition_proxy.validate(:unless => :callback)[0]
+    
+    object = klass.new
+    object.callback = true
+    assert !options[:if].call(object)
+    
+    object.callback = false
+    assert options[:if].call(object)
+  end
+  
+  def test_should_evaluate_string_condition
+    klass = Class.new(Validateable) do
+      attr_accessor :callback
+    end
+    
+    condition_proxy = StateMachine::ConditionProxy.new(klass, lambda {true})
+    options = condition_proxy.validate(:unless => '@callback')[0]
+    
+    object = klass.new
+    object.callback = true
+    assert !options[:if].call(object)
+    
+    object.callback = false
+    assert options[:if].call(object)
+  end
+end
+
+class ConditionProxyWithMultipleUnlessConditionsTest < Test::Unit::TestCase
+  def setup
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
+    
+    @object = Validateable.new
+    
+    @first_condition_result = nil
+    @second_condition_result = nil
+    @options = condition_proxy.validate(:unless => [lambda {@first_condition_result}, lambda {@second_condition_result}])[0]
+  end
+  
+  def test_should_be_true_if_all_conditions_are_false
+    @first_condition_result = false
+    @second_condition_result = false
+    assert @options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_any_condition_is_true
+    @first_condition_result = true
+    @second_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @first_condition_result = false
+    @second_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+end
+
+class ConditionProxyWithIfAndUnlessConditionsTest < Test::Unit::TestCase
+  def setup
+    condition_proxy = StateMachine::ConditionProxy.new(Validateable, lambda {true})
+    
+    @object = Validateable.new
+    
+    @if_condition_result = nil
+    @unless_condition_result = nil
+    @options = condition_proxy.validate(:if => lambda {@if_condition_result}, :unless => lambda {@unless_condition_result})[0]
+  end
+  
+  def test_should_be_false_if_if_condition_is_false
+    @if_condition_result = false
+    @unless_condition_result = false
+    assert !@options[:if].call(@object)
+    
+    @if_condition_result = false
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_false_if_unless_condition_is_true
+    @if_condition_result = false
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+    
+    @if_condition_result = true
+    @unless_condition_result = true
+    assert !@options[:if].call(@object)
+  end
+  
+  def test_should_be_true_if_if_condition_is_true_and_unless_condition_is_false
+    @if_condition_result = true
+    @unless_condition_result = false
+    assert @options[:if].call(@object)
+  end
+end

data/test/unit/error_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class ErrorByDefaultTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(@machine)
+  end
+  
+  def test_should_not_have_any_nodes
+    assert_equal 0, @collection.length
+  end
+  
+  def test_should_have_a_machine
+    assert_equal @machine, @collection.machine
+  end
+  
+  def test_should_index_by_name
+    @collection << object = Struct.new(:name).new(:parked)
+    assert_equal object, @collection[:parked]
+  end
+end
+
+class ErrorWithMessageTest < Test::Unit::TestCase
+  def setup
+    @machine = StateMachine::Machine.new(Class.new)
+    @collection = StateMachine::NodeCollection.new(@machine)
+  end
+  
+  def test_should_raise_exception_if_invalid_option_specified
+    exception = assert_raise(ArgumentError) { StateMachine::NodeCollection.new(@machine, :invalid => true) }
+    assert_equal 'Invalid key(s): invalid', exception.message
+  end
+  
+  def test_should_raise_exception_on_lookup_if_invalid_index_specified
+    exception = assert_raise(ArgumentError) { @collection[:something, :invalid] }
+    assert_equal 'Invalid index: :invalid', exception.message
+  end
+  
+  def test_should_raise_exception_on_fetch_if_invalid_index_specified
+    exception = assert_raise(ArgumentError) { @collection.fetch(:something, :invalid) }
+    assert_equal 'Invalid index: :invalid', exception.message
+  end
+end

data/test/unit/eval_helpers_test.rb

@@ -0,0 +1,222 @@
+require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
+
+class EvalHelpersBaseTest < Test::Unit::TestCase
+  include StateMachine::EvalHelpers
+  
+  def default_test
+  end
+end
+
+class EvalHelpersTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_raise_exception_if_method_is_not_symbol_string_or_proc
+    exception = assert_raise(ArgumentError) { evaluate_method(@object, 1) }
+    assert_match /Methods must/, exception.message
+  end
+end
+
+class EvalHelpersSymbolTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def callback
+        true
+      end
+    end
+  end
+  
+  def test_should_call_method_on_object_with_no_arguments
+    assert_equal true, evaluate_method(@object, :callback, 1, 2, 3)
+  end
+end
+
+class EvalHelpersSymbolWithArgumentsTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def callback(*args)
+        args
+      end
+    end
+  end
+  
+  def test_should_call_method_with_all_arguments
+    assert_equal [1, 2, 3], evaluate_method(@object, :callback, 1, 2, 3)
+  end
+end
+
+class EvalHelpersSymbolWithBlockTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def callback
+        yield
+      end
+    end
+  end
+  
+  def test_should_call_method_on_object_with_block
+    assert_equal true, evaluate_method(@object, :callback) { true }
+  end
+end
+
+class EvalHelpersSymbolWithArgumentsAndBlockTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def callback(*args)
+        args << yield
+      end
+    end
+  end
+  
+  def test_should_call_method_on_object_with_all_arguments_and_block
+    assert_equal [1, 2, 3, true], evaluate_method(@object, :callback, 1, 2, 3) { true }
+  end
+end
+
+class EvalHelpersSymbolTaintedMethodTest < EvalHelpersBaseTest
+  def setup
+    class << (@object = Object.new)
+      def callback
+        true
+      end
+      
+      taint
+    end
+  end
+  
+  def test_should_not_raise_security_error
+    assert_nothing_raised { evaluate_method(@object, :callback, 1, 2, 3) }
+  end
+end
+
+class EvalHelpersStringTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_evaluate_string
+    assert_equal 1, evaluate_method(@object, '1')
+  end
+  
+  def test_should_evaluate_string_within_object_context
+    @object.instance_variable_set('@value', 1)
+    assert_equal 1, evaluate_method(@object, '@value')
+  end
+  
+  def test_should_ignore_additional_arguments
+    assert_equal 1, evaluate_method(@object, '1', 2, 3, 4)
+  end
+end
+
+class EvalHelpersStringWithBlockTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+  end
+  
+  def test_should_call_method_on_object_with_block
+    assert_equal 1, evaluate_method(@object, 'yield') { 1 }
+  end
+end
+
+class EvalHelpersProcTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda {|obj| obj}
+  end
+  
+  def test_should_call_proc_with_object_as_argument
+    assert_equal @object, evaluate_method(@object, @proc, 1, 2, 3)
+  end
+end
+
+class EvalHelpersProcWithoutArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda {|*args| args}
+    class << @proc
+      def arity
+        0
+      end
+    end
+  end
+  
+  def test_should_call_proc_with_no_arguments
+    assert_equal [], evaluate_method(@object, @proc, 1, 2, 3)
+  end
+end
+
+class EvalHelpersProcWithArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda {|*args| args}
+  end
+  
+  def test_should_call_method_with_all_arguments
+    assert_equal [@object, 1, 2, 3], evaluate_method(@object, @proc, 1, 2, 3)
+  end
+end
+
+class EvalHelpersProcWithBlockTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda {|obj, block| block.call}
+  end
+  
+  def test_should_call_method_on_object_with_block
+    assert_equal true, evaluate_method(@object, @proc, 1, 2, 3) { true }
+  end
+end
+
+class EvalHelpersProcWithBlockWithoutArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda {|*args| args}
+    class << @proc
+      def arity
+        0
+      end
+    end
+  end
+  
+  def test_should_call_proc_without_arguments
+    block = lambda { true }
+    assert_equal [], evaluate_method(@object, @proc, 1, 2, 3, &block)
+  end
+end
+
+class EvalHelpersProcWithBlockWithoutObjectTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda {|block| [block]}
+  end
+  
+  def test_should_call_proc_with_block_only
+    block = lambda { true }
+    assert_equal [block], evaluate_method(@object, @proc, 1, 2, 3, &block)
+  end
+end
+
+class EvalHelpersProcBlockAndImplicitArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda {|*args| args}
+  end
+  
+  def test_should_call_method_on_object_with_all_arguments_and_block
+    block = lambda { true }
+    assert_equal [@object, 1, 2, 3, block], evaluate_method(@object, @proc, 1, 2, 3, &block)
+  end
+end
+
+class EvalHelpersProcBlockAndExplicitArgumentsTest < EvalHelpersBaseTest
+  def setup
+    @object = Object.new
+    @proc = lambda {|object, arg1, arg2, arg3, block| [object, arg1, arg2, arg3, block]}
+  end
+  
+  def test_should_call_method_on_object_with_all_arguments_and_block
+    block = lambda { true }
+    assert_equal [@object, 1, 2, 3, block], evaluate_method(@object, @proc, 1, 2, 3, &block)
+  end
+end