branston 0.6.1 → 0.6.2

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

@@ -1,37 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class MatcherHelpersAllTest < Test::Unit::TestCase
-  include StateMachine::MatcherHelpers
-  
-  def setup
-    @matcher = all
-  end
-  
-  def test_should_build_an_all_matcher
-    assert_equal StateMachine::AllMatcher.instance, @matcher
-  end
-end
-
-class MatcherHelpersAnyTest < Test::Unit::TestCase
-  include StateMachine::MatcherHelpers
-  
-  def setup
-    @matcher = any
-  end
-  
-  def test_should_build_an_all_matcher
-    assert_equal StateMachine::AllMatcher.instance, @matcher
-  end
-end
-
-class MatcherHelpersSameTest < Test::Unit::TestCase
-  include StateMachine::MatcherHelpers
-  
-  def setup
-    @matcher = same
-  end
-  
-  def test_should_build_a_loopback_matcher
-    assert_equal StateMachine::LoopbackMatcher.instance, @matcher
-  end
-end

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

@@ -1,155 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class MatcherByDefaultTest < Test::Unit::TestCase
-  def setup
-    @matcher = StateMachine::Matcher.new
-  end
-  
-  def test_should_have_no_values
-    assert_equal [], @matcher.values
-  end
-  
-  def test_should_filter_all_values
-    assert_equal [], @matcher.filter([:parked, :idling])
-  end
-end
-
-class MatcherWithValueTest < Test::Unit::TestCase
-  def setup
-    @matcher = StateMachine::Matcher.new(nil)
-  end
-  
-  def test_should_have_values
-    assert_equal [nil], @matcher.values
-  end
-  
-  def test_should_filter_unknown_values
-    assert_equal [nil], @matcher.filter([nil, :parked])
-  end
-end
-
-class MatcherWithMultipleValuesTest < Test::Unit::TestCase
-  def setup
-    @matcher = StateMachine::Matcher.new([:parked, :idling])
-  end
-  
-  def test_should_have_values
-    assert_equal [:parked, :idling], @matcher.values
-  end
-  
-  def test_should_filter_unknown_values
-    assert_equal [:parked], @matcher.filter([:parked, :first_gear])
-  end
-end
-
-class AllMatcherTest < Test::Unit::TestCase
-  def setup
-    @matcher = StateMachine::AllMatcher.instance
-  end
-  
-  def test_should_have_no_values
-    assert_equal [], @matcher.values
-  end
-  
-  def test_should_always_match
-    [nil, :parked, :idling].each {|value| assert @matcher.matches?(value)}
-  end
-  
-  def test_should_not_filter_any_values
-    assert_equal [:parked, :idling], @matcher.filter([:parked, :idling])
-  end
-  
-  def test_should_generate_blacklist_matcher_after_subtraction
-    matcher = @matcher - [:parked, :idling]
-    assert_instance_of StateMachine::BlacklistMatcher, matcher
-    assert_equal [:parked, :idling], matcher.values
-  end
-  
-  def test_should_have_a_description
-    assert_equal 'all', @matcher.description
-  end
-end
-
-class WhitelistMatcherTest < Test::Unit::TestCase
-  def setup
-    @matcher = StateMachine::WhitelistMatcher.new([:parked, :idling])
-  end
-  
-  def test_should_have_values
-    assert_equal [:parked, :idling], @matcher.values
-  end
-  
-  def test_should_filter_unknown_values
-    assert_equal [:parked, :idling], @matcher.filter([:parked, :idling, :first_gear])
-  end
-  
-  def test_should_match_known_values
-    assert @matcher.matches?(:parked)
-  end
-  
-  def test_should_not_match_unknown_values
-    assert !@matcher.matches?(:first_gear)
-  end
-  
-  def test_should_have_a_description
-    assert_equal '[:parked, :idling]', @matcher.description
-    
-    matcher = StateMachine::WhitelistMatcher.new([:parked])
-    assert_equal ':parked', matcher.description
-  end
-end
-
-class BlacklistMatcherTest < Test::Unit::TestCase
-  def setup
-    @matcher = StateMachine::BlacklistMatcher.new([:parked, :idling])
-  end
-  
-  def test_should_have_values
-    assert_equal [:parked, :idling], @matcher.values
-  end
-  
-  def test_should_filter_known_values
-    assert_equal [:first_gear], @matcher.filter([:parked, :idling, :first_gear])
-  end
-  
-  def test_should_match_unknown_values
-    assert @matcher.matches?(:first_gear)
-  end
-  
-  def test_should_not_match_known_values
-    assert !@matcher.matches?(:parked)
-  end
-  
-  def test_should_have_a_description
-    assert_equal 'all - [:parked, :idling]', @matcher.description
-    
-    matcher = StateMachine::BlacklistMatcher.new([:parked])
-    assert_equal 'all - :parked', matcher.description
-  end
-end
-
-class LoopbackMatcherTest < Test::Unit::TestCase
-  def setup
-    @matcher = StateMachine::LoopbackMatcher.instance
-  end
-  
-  def test_should_have_no_values
-    assert_equal [], @matcher.values
-  end
-  
-  def test_should_filter_all_values
-    assert_equal [], @matcher.filter([:parked, :idling])
-  end
-  
-  def test_should_match_if_from_context_is_same
-    assert @matcher.matches?(:parked, :from => :parked)
-  end
-  
-  def test_should_not_match_if_from_context_is_different
-    assert !@matcher.matches?(:parked, :from => :idling)
-  end
-  
-  def test_should_have_a_description
-    assert_equal 'same', @matcher.description
-  end
-end

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

@@ -1,207 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class NodeCollectionByDefaultTest < 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 NodeCollectionTest < 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
-
-class NodeCollectionAfterBeingCopiedTest < Test::Unit::TestCase
-  def setup
-    machine = StateMachine::Machine.new(Class.new)
-    @collection = StateMachine::NodeCollection.new(machine)
-    @collection << @parked = Struct.new(:name).new(:parked)
-    
-    @copied_collection = @collection.dup
-    @copied_collection << @idling = Struct.new(:name).new(:idling)
-  end
-  
-  def test_should_not_modify_the_original_list
-    assert_equal 1, @collection.length
-    assert_equal 2, @copied_collection.length
-  end
-  
-  def test_should_not_modify_the_indices
-    assert_nil @collection[:idling]
-    assert_equal @idling, @copied_collection[:idling]
-  end
-  
-  def test_should_copy_each_node
-    assert_not_same @parked, @copied_collection[:parked]
-  end
-end
-
-class NodeCollectionWithoutIndicesTest < Test::Unit::TestCase
-  def setup
-    machine = StateMachine::Machine.new(Class.new)
-    @collection = StateMachine::NodeCollection.new(machine, :index => {})
-  end
-  
-  def test_should_allow_adding_node
-    @collection << Object.new
-    assert_equal 1, @collection.length
-  end
-  
-  def test_should_not_allow_keys_retrieval
-    exception = assert_raise(ArgumentError) { @collection.keys }
-    assert_equal 'No indices configured', exception.message
-  end
-  
-  def test_should_not_allow_lookup
-    @collection << object = Object.new
-    exception = assert_raise(ArgumentError) { @collection[0] }
-    assert_equal 'No indices configured', exception.message
-  end
-  
-  def test_should_not_allow_fetching
-    @collection << object = Object.new
-    exception = assert_raise(ArgumentError) { @collection.fetch(0) }
-    assert_equal 'No indices configured', exception.message
-  end
-end
-
-class NodeCollectionWithIndicesTest < Test::Unit::TestCase
-  def setup
-    machine = StateMachine::Machine.new(Class.new)
-    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
-    
-    @object = Struct.new(:name, :value).new(:parked, 1)
-    @collection << @object
-  end
-  
-  def test_should_use_first_index_by_default_on_key_retrieval
-    assert_equal [:parked], @collection.keys
-  end
-  
-  def test_should_allow_customizing_index_for_key_retrieval
-    assert_equal [1], @collection.keys(:value)
-  end
-  
-  def test_should_use_first_index_by_default_on_lookup
-    assert_equal @object, @collection[:parked]
-    assert_nil @collection[1]
-  end
-  
-  def test_should_allow_customizing_index_on_lookup
-    assert_equal @object, @collection[1, :value]
-    assert_nil @collection[:parked, :value]
-  end
-  
-  def test_should_use_first_index_by_default_on_fetch
-    assert_equal @object, @collection.fetch(:parked)
-    exception = assert_raise(IndexError) { @collection.fetch(1) }
-    assert_equal '1 is an invalid name', exception.message
-  end
-  
-  def test_should_allow_customizing_index_on_fetch
-    assert_equal @object, @collection.fetch(1, :value)
-    exception = assert_raise(IndexError) { @collection.fetch(:parked, :value) }
-    assert_equal ':parked is an invalid value', exception.message
-  end
-end
-
-class NodeCollectionWithNodesTest < Test::Unit::TestCase
-  def setup
-    machine = StateMachine::Machine.new(Class.new)
-    @collection = StateMachine::NodeCollection.new(machine)
-    
-    @klass = Struct.new(:name, :machine)
-    @parked = @klass.new(:parked, machine)
-    @idling = @klass.new(:idling, machine)
-    
-    @collection << @parked
-    @collection << @idling
-  end
-  
-  def test_should_be_able_to_enumerate
-    order = []
-    @collection.each {|object| order << object}
-    
-    assert_equal [@parked, @idling], order
-  end
-  
-  def test_should_be_able_to_access_by_index
-    assert_equal @parked, @collection.at(0)
-    assert_equal @idling, @collection.at(1)
-  end
-  
-  def test_should_deep_copy_machine_changes
-    new_machine = StateMachine::Machine.new(Class.new)
-    @collection.machine = new_machine
-    
-    assert_equal new_machine, @collection.machine
-    assert_equal new_machine, @parked.machine
-    assert_equal new_machine, @idling.machine
-  end
-end
-
-class NodeCollectionAfterUpdateTest < Test::Unit::TestCase
-  def setup
-    machine = StateMachine::Machine.new(Class.new)
-    @collection = StateMachine::NodeCollection.new(machine, :index => [:name, :value])
-    
-    @klass = Struct.new(:name, :value)
-    @parked = @klass.new(:parked, 1)
-    @idling = @klass.new(:idling, 2)
-    
-    @collection << @parked << @idling
-    
-    @parked.name = :parking
-    @parked.value = 0
-    @collection.update(@parked)
-  end
-  
-  def test_should_not_change_the_index
-    assert_equal @parked, @collection.at(0)
-  end
-  
-  def test_should_not_duplicate_in_the_collection
-    assert_equal 2, @collection.length
-  end
-  
-  def test_should_add_each_indexed_key
-    assert_equal @parked, @collection[:parking]
-    assert_equal @parked, @collection[0, :value]
-  end
-  
-  def test_should_remove_each_old_indexed_key
-    assert_nil @collection[:parked]
-    assert_nil @collection[1, :value]
-  end
-end

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

@@ -1,280 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/../test_helper')
-
-class StateCollectionByDefaultTest < Test::Unit::TestCase
-  def setup
-    @machine = StateMachine::Machine.new(Class.new)
-    @states = StateMachine::StateCollection.new(@machine)
-  end
-  
-  def test_should_not_have_any_nodes
-    assert_equal 0, @states.length
-  end
-  
-  def test_should_have_a_machine
-    assert_equal @machine, @states.machine
-  end
-  
-  def test_should_be_empty_by_priority
-    assert_equal [], @states.by_priority
-  end
-end
-
-class StateCollectionTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass)
-    @states = StateMachine::StateCollection.new(@machine)
-    
-    @states << @nil = StateMachine::State.new(@machine, nil)
-    @states << @parked = StateMachine::State.new(@machine, :parked)
-    @states << @idling = StateMachine::State.new(@machine, :idling)
-    
-    @object = @klass.new
-  end
-  
-  def test_should_index_by_name
-    assert_equal @parked, @states[:parked, :name]
-  end
-  
-  def test_should_index_by_name_by_default
-    assert_equal @parked, @states[:parked]
-  end
-  
-  def test_should_index_by_value
-    assert_equal @parked, @states['parked', :value]
-  end
-  
-  def test_should_not_match_if_value_does_not_match
-    assert !@states.matches?(@object, :parked)
-    assert !@states.matches?(@object, :idling)
-  end
-  
-  def test_should_match_if_value_matches
-    assert @states.matches?(@object, nil)
-  end
-  
-  def test_raise_exception_if_matching_invalid_state
-    assert_raise(IndexError) { @states.matches?(@object, :invalid) }
-  end
-  
-  def test_should_find_state_for_object_if_value_is_known
-    @object.state = 'parked'
-    assert_equal @parked, @states.match(@object)
-  end
-  
-  def test_should_find_bang_state_for_object_if_value_is_known
-    @object.state = 'parked'
-    assert_equal @parked, @states.match!(@object)
-  end
-  
-  def test_should_not_find_state_for_object_with_unknown_value
-    @object.state = 'invalid'
-    assert_nil @states.match(@object)
-  end
-  
-  def test_should_raise_exception_if_finding_bang_state_for_object_with_unknown_value
-    @object.state = 'invalid'
-    exception = assert_raise(ArgumentError) { @states.match!(@object) }
-    assert_equal '"invalid" is not a known state value', exception.message
-  end
-end
-
-class StateCollectionWithCustomStateValuesTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass)
-    @states = StateMachine::StateCollection.new(@machine)
-    
-    @states << @state = StateMachine::State.new(@machine, :parked, :value => 1)
-    
-    @object = @klass.new
-    @object.state = 1
-  end
-  
-  def test_should_match_if_value_matches
-    assert @states.matches?(@object, :parked)
-  end
-  
-  def test_should_not_match_if_value_does_not_match
-    @object.state = 2
-    assert !@states.matches?(@object, :parked)
-  end
-  
-  def test_should_find_state_for_object_if_value_is_known
-    assert_equal @state, @states.match(@object)
-  end
-end
-
-class StateCollectionWithStateMatchersTest < Test::Unit::TestCase
-  def setup
-    @klass = Class.new
-    @machine = StateMachine::Machine.new(@klass)
-    @states = StateMachine::StateCollection.new(@machine)
-    
-    @states << @state = StateMachine::State.new(@machine, :parked, :if => lambda {|value| !value.nil?})
-    
-    @object = @klass.new
-    @object.state = 1
-  end
-  
-  def test_should_match_if_value_matches
-    assert @states.matches?(@object, :parked)
-  end
-  
-  def test_should_not_match_if_value_does_not_match
-    @object.state = nil
-    assert !@states.matches?(@object, :parked)
-  end
-  
-  def test_should_find_state_for_object_if_value_is_known
-    assert_equal @state, @states.match(@object)
-  end
-end
-
-class StateCollectionWithInitialStateTest < Test::Unit::TestCase
-  def setup
-    @machine = StateMachine::Machine.new(Class.new)
-    @states = StateMachine::StateCollection.new(@machine)
-    
-    @states << @parked = StateMachine::State.new(@machine, :parked)
-    @states << @idling = StateMachine::State.new(@machine, :idling)
-    
-    @parked.initial = true
-  end
-  
-  def test_should_order_state_before_transition_states
-    @machine.event :ignite do
-      transition :to => :idling
-    end
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_state_before_states_with_behaviors
-    @idling.context do
-      def speed
-        0
-      end
-    end
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_state_before_other_states
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_state_before_callback_states
-    @machine.before_transition :from => :idling, :do => lambda {}
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-end
-
-class StateCollectionWithStateBehaviorsTest < Test::Unit::TestCase
-  def setup
-    @machine = StateMachine::Machine.new(Class.new)
-    @states = StateMachine::StateCollection.new(@machine)
-    
-    @states << @parked = StateMachine::State.new(@machine, :parked)
-    @states << @idling = StateMachine::State.new(@machine, :idling)
-    
-    @idling.context do
-      def speed
-        0
-      end
-    end
-  end
-  
-  def test_should_order_states_after_initial_state
-    @parked.initial = true
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_states_after_transition_states
-    @machine.event :ignite do
-      transition :from => :parked
-    end
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_states_before_other_states
-    assert_equal [@idling, @parked], @states.by_priority
-  end
-  
-  def test_should_order_state_before_callback_states
-    @machine.before_transition :from => :parked, :do => lambda {}
-    assert_equal [@idling, @parked], @states.by_priority
-  end
-end
-
-class StateCollectionWithEventTransitionsTest < Test::Unit::TestCase
-  def setup
-    @machine = StateMachine::Machine.new(Class.new)
-    @states = StateMachine::StateCollection.new(@machine)
-    
-    @states << @parked = StateMachine::State.new(@machine, :parked)
-    @states << @idling = StateMachine::State.new(@machine, :idling)
-    
-    @machine.event :ignite do
-      transition :to => :idling
-    end
-  end
-  
-  def test_should_order_states_after_initial_state
-    @parked.initial = true
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_states_before_states_with_behaviors
-    @parked.context do
-      def speed
-        0
-      end
-    end
-    assert_equal [@idling, @parked], @states.by_priority
-  end
-  
-  def test_should_order_states_before_other_states
-    assert_equal [@idling, @parked], @states.by_priority
-  end
-  
-  def test_should_order_state_before_callback_states
-    @machine.before_transition :from => :parked, :do => lambda {}
-    assert_equal [@idling, @parked], @states.by_priority
-  end
-end
-
-class StateCollectionWithTransitionCallbacksTest < Test::Unit::TestCase
-  def setup
-    @machine = StateMachine::Machine.new(Class.new)
-    @states = StateMachine::StateCollection.new(@machine)
-    
-    @states << @parked = StateMachine::State.new(@machine, :parked)
-    @states << @idling = StateMachine::State.new(@machine, :idling)
-    
-    @machine.before_transition :to => :idling, :do => lambda {}
-  end
-  
-  def test_should_order_states_after_initial_state
-    @parked.initial = true
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_states_after_transition_states
-    @machine.event :ignite do
-      transition :from => :parked
-    end
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_states_after_states_with_behaviors
-    @parked.context do
-      def speed
-        0
-      end
-    end
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-  
-  def test_should_order_states_after_other_states
-    assert_equal [@parked, @idling], @states.by_priority
-  end
-end