branston 0.6.1 → 0.6.2

data/lib/branston/vendor/plugins/state_machine/test/unit/condition_proxy_test.rb

@@ -1,328 +0,0 @@
-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/lib/branston/vendor/plugins/state_machine/test/unit/eval_helpers_test.rb

@@ -1,120 +0,0 @@
-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 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 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 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

data/lib/branston/vendor/plugins/state_machine/test/unit/event_collection_test.rb

@@ -1,326 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class EventCollectionByDefaultTest < Test::Unit::TestCase
-  def setup
-    @machine = StateMachine::Machine.new(Class.new)
-    @events = StateMachine::EventCollection.new(@machine)
-  end
-  
-  def test_should_not_have_any_nodes
-    assert_equal 0, @events.length
-  end
-  
-  def test_should_have_a_machine
-    assert_equal @machine, @events.machine
-  end
-  
-  def test_should_not_have_any_valid_events_for_an_object
-    assert @events.valid_for(@object).empty?
-  end
-  
-  def test_should_not_have_any_transitions_for_an_object
-    assert @events.transitions_for(@object).empty?
-  end
-end
-
-class EventCollectionTest < Test::Unit::TestCase
-  def setup
-    machine = StateMachine::Machine.new(Class.new, :namespace => 'alarm')
-    @events = StateMachine::EventCollection.new(machine)
-    
-    @events << @open = StateMachine::Event.new(machine, :enable)
-  end
-  
-  def test_should_index_by_name
-    assert_equal @open, @events[:enable, :name]
-  end
-  
-  def test_should_index_by_name_by_default
-    assert_equal @open, @events[:enable]
-  end
-  
-  def test_should_index_by_qualified_name
-    assert_equal @open, @events[:enable_alarm, :qualified_name]
-  end
-end
-
-class EventCollectionWithEventsWithTransitionsTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
-    @events = StateMachine::EventCollection.new(@machine)
-    
-    @machine.state :idling, :stalled
-    @machine.event :ignite
-    
-    @events << @ignite = StateMachine::Event.new(@machine, :ignite)
-    @ignite.transition :parked => :idling
-    @ignite.transition :stalled => :idling
-  end
-  
-  def test_should_only_include_valid_events_for_an_object
-    object = @klass.new
-    object.state = 'parked'
-    assert_equal [@ignite], @events.valid_for(object)
-    
-    object.state = 'stalled'
-    assert_equal [@ignite], @events.valid_for(object)
-    
-    object.state = 'idling'
-    assert_equal [], @events.valid_for(object)
-  end
-  
-  def test_should_only_include_valid_transitions_for_an_object
-    object = @klass.new
-    object.state = 'parked'
-    assert_equal [{:object => object, :attribute => :state, :event => :ignite, :from => 'parked', :to => 'idling'}], @events.transitions_for(object).map {|transition| transition.attributes}
-    
-    object.state = 'stalled'
-    assert_equal [{:object => object, :attribute => :state, :event => :ignite, :from => 'stalled', :to => 'idling'}], @events.transitions_for(object).map {|transition| transition.attributes}
-    
-    object.state = 'idling'
-    assert_equal [], @events.transitions_for(object)
-  end
-  
-  def test_should_filter_valid_transitions_for_an_object_if_requirements_specified
-    object = @klass.new
-    assert_equal [{:object => object, :attribute => :state, :event => :ignite, :from => 'stalled', :to => 'idling'}], @events.transitions_for(object, :from => :stalled).map {|transition| transition.attributes}
-    assert_equal [], @events.transitions_for(object, :from => :idling).map {|transition| transition.attributes}
-  end
-end
-
-class EventCollectionWithMultipleEventsTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
-    @events = StateMachine::EventCollection.new(@machine)
-    
-    @machine.state :first_gear
-    @machine.event :park, :shift_down
-    
-    @events << @park = StateMachine::Event.new(@machine, :park)
-    @park.transition :first_gear => :parked
-    
-    @events << @shift_down = StateMachine::Event.new(@machine, :shift_down)
-    @shift_down.transition :first_gear => :parked
-  end
-  
-  def test_should_only_include_all_valid_events_for_an_object
-    object = @klass.new
-    object.state = 'first_gear'
-    assert_equal [@park, @shift_down], @events.valid_for(object)
-  end
-end
-
-class EventCollectionWithoutMachineActionTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass, :initial => :parked)
-    @events = StateMachine::EventCollection.new(@machine)
-    
-    @machine.event :ignite
-    @events << StateMachine::Event.new(@machine, :ignite)
-    
-    @object = @klass.new
-  end
-  
-  def test_should_not_have_an_attribute_transition
-    assert_nil @events.attribute_transition_for(@object)
-  end
-end
-
-class EventCollectionAttributeWithMachineActionTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new do
-      def save
-      end
-    end
-    
-    @machine = StateMachine::Machine.new(@klass, :initial => :parked, :action => :save)
-    @events = StateMachine::EventCollection.new(@machine)
-    
-    @machine.event :ignite
-    @machine.state :parked, :idling
-    @events << @ignite = StateMachine::Event.new(@machine, :ignite)
-    
-    @object = @klass.new
-  end
-  
-  def test_should_not_have_transition_if_nil
-    @object.state_event = nil
-    assert_nil @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_not_have_transition_if_empty
-    @object.state_event = ''
-    assert_nil @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_have_invalid_transition_if_invalid_event_specified
-    @object.state_event = 'invalid'
-    assert_equal false, @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_have_invalid_transition_if_event_cannot_be_fired
-    @object.state_event = 'ignite'
-    assert_equal false, @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_have_valid_transition_if_event_can_be_fired
-    @ignite.transition :parked => :idling
-    @object.state_event = 'ignite'
-    
-    assert_instance_of StateMachine::Transition, @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_have_valid_transition_if_already_defined_in_transition_cache
-    @ignite.transition :parked => :idling
-    @object.state_event = nil
-    @object.send(:state_event_transition=, transition = @ignite.transition_for(@object))
-    
-    assert_equal transition, @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_use_transition_cache_if_both_event_and_transition_are_present
-    @ignite.transition :parked => :idling
-    @object.state_event = 'ignite'
-    @object.send(:state_event_transition=, transition = @ignite.transition_for(@object))
-    
-    assert_equal transition, @events.attribute_transition_for(@object)
-  end
-end
-
-class EventCollectionAttributeWithNamespacedMachineTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new do
-      def save
-      end
-    end
-    
-    @machine = StateMachine::Machine.new(@klass, :namespace => 'alarm', :initial => :active, :action => :save)
-    @events = StateMachine::EventCollection.new(@machine)
-    
-    @machine.event :disable
-    @machine.state :active, :off
-    @events << @disable = StateMachine::Event.new(@machine, :disable)
-    
-    @object = @klass.new
-  end
-  
-  def test_should_not_have_transition_if_nil
-    @object.state_event = nil
-    assert_nil @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_have_invalid_transition_if_event_cannot_be_fired
-    @object.state_event = 'disable'
-    assert_equal false, @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_have_valid_transition_if_event_can_be_fired
-    @disable.transition :active => :off
-    @object.state_event = 'disable'
-    
-    assert_instance_of StateMachine::Transition, @events.attribute_transition_for(@object)
-  end
-end
-
-class EventCollectionWithValidationsTest < Test::Unit::TestCase
-  def setup
-    StateMachine::Integrations.const_set('Custom', Module.new do
-      def invalidate(object, attribute, message, values = [])
-        (object.errors ||= []) << generate_message(message, values)
-      end
-      
-      def reset(object)
-        object.errors = []
-      end
-    end)
-    
-    @klass = Class.new do
-      attr_accessor :errors
-      
-      def initialize
-        @errors = []
-        super
-      end
-    end
-    
-    @machine = StateMachine::Machine.new(@klass, :initial => :parked, :action => :save, :integration => :custom)
-    @events = StateMachine::EventCollection.new(@machine)
-    
-    @machine.event :ignite
-    @machine.state :parked, :idling
-    @events << @ignite = StateMachine::Event.new(@machine, :ignite)
-    
-    @object = @klass.new
-  end
-  
-  def test_should_invalidate_if_invalid_event_specified
-    @object.state_event = 'invalid'
-    @events.attribute_transition_for(@object, true)
-    
-    assert_equal ['is invalid'], @object.errors
-  end
-  
-  def test_should_invalidate_if_event_cannot_be_fired
-    @object.state = 'idling'
-    @object.state_event = 'ignite'
-    @events.attribute_transition_for(@object, true)
-    
-    assert_equal ['cannot transition when idling'], @object.errors
-  end
-  
-  def test_should_invalidate_with_friendly_name_if_invalid_event_specified
-    # Add a valid nil state
-    @machine.state nil
-    
-    @object.state = nil
-    @object.state_event = 'ignite'
-    @events.attribute_transition_for(@object, true)
-    
-    assert_equal ['cannot transition when nil'], @object.errors
-  end
-  
-  def test_should_not_invalidate_event_can_be_fired
-    @ignite.transition :parked => :idling
-    @object.state_event = 'ignite'
-    @events.attribute_transition_for(@object, true)
-    
-    assert_equal [], @object.errors
-  end
-  
-  def teardown
-    StateMachine::Integrations.send(:remove_const, 'Custom')
-  end
-end
-
-class EventCollectionWithCustomMachineAttributeTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new do
-      def save
-      end
-    end
-    
-    @machine = StateMachine::Machine.new(@klass, :state, :attribute => :state_id, :initial => :parked, :action => :save)
-    @events = StateMachine::EventCollection.new(@machine)
-    
-    @machine.event :ignite
-    @machine.state :parked, :idling
-    @events << @ignite = StateMachine::Event.new(@machine, :ignite)
-    
-    @object = @klass.new
-  end
-  
-  def test_should_not_have_transition_if_nil
-    @object.state_event = nil
-    assert_nil @events.attribute_transition_for(@object)
-  end
-  
-  def test_should_have_valid_transition_if_event_can_be_fired
-    @ignite.transition :parked => :idling
-    @object.state_event = 'ignite'
-    
-    assert_instance_of StateMachine::Transition, @events.attribute_transition_for(@object)
-  end
-end