state_machines 0.0.2 → 0.1.0

data/test/unit/state_collection/state_collection_with_state_matchers_test.rb

@@ -0,0 +1,29 @@
+require_relative '../../test_helper'
+
+class StateCollectionWithStateMatchersTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @state = StateMachines::State.new(@machine, :parked, if: lambda { |value| !value.nil? })
+    @machine.states.concat(@states)
+
+    @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
+    refute @states.matches?(@object, :parked)
+  end
+
+  def test_should_find_state_for_object_if_value_is_known
+    assert_equal @state, @states.match(@object)
+  end
+end
+

data/test/unit/state_collection/state_collection_with_transition_callbacks_test.rb

@@ -0,0 +1,40 @@
+require_relative '../../test_helper'
+
+class StateCollectionWithTransitionCallbacksTest < StateMachinesTest
+  def setup
+    @machine = StateMachines::Machine.new(Class.new)
+    @states = StateMachines::StateCollection.new(@machine)
+
+    @states << @parked = StateMachines::State.new(@machine, :parked)
+    @states << @idling = StateMachines::State.new(@machine, :idling)
+    @machine.states.concat(@states)
+
+    @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
+

data/test/unit/state_context/state_context_proxy_test.rb

@@ -0,0 +1,26 @@
+require_relative '../../test_helper'
+
+class StateContextProxyTest < StateMachinesTest
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachines::Machine.new(@klass, initial: :parked)
+    state = machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(state)
+  end
+
+  def test_should_call_class_with_same_arguments
+    options = {}
+    validation = @state_context.validate(:name, options)
+
+    assert_equal [:name, options], validation
+  end
+
+  def test_should_pass_block_through_to_class
+    options = {}
+    proxy_block = lambda {}
+    validation = @state_context.validate(:name, options, &proxy_block)
+
+    assert_equal [:name, options, proxy_block], validation
+  end
+end

data/test/unit/state_context/state_context_proxy_with_if_and_unless_conditions_test.rb

@@ -0,0 +1,42 @@
+require_relative '../../test_helper'
+
+class StateContextProxyWithIfAndUnlessConditionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachines::Machine.new(@klass, initial: :parked)
+    state = machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(state)
+    @object = @klass.new
+
+    @if_condition_result = nil
+    @unless_condition_result = nil
+    @options = @state_context.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
+    refute @options[:if].call(@object)
+
+    @if_condition_result = false
+    @unless_condition_result = true
+    refute @options[:if].call(@object)
+  end
+
+  def test_should_be_false_if_unless_condition_is_true
+    @if_condition_result = false
+    @unless_condition_result = true
+    refute @options[:if].call(@object)
+
+    @if_condition_result = true
+    @unless_condition_result = true
+    refute @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/state_context/state_context_proxy_with_if_condition_test.rb

@@ -0,0 +1,64 @@
+require_relative '../../test_helper'
+
+class StateContextProxyWithIfConditionTest < StateMachinesTest
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachines::Machine.new(@klass, initial: :parked)
+    state = machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(state)
+    @object = @klass.new
+
+    @condition_result = nil
+    @options = @state_context.validate(if: lambda { @condition_result })[0]
+  end
+
+  def test_should_have_if_option
+    refute_nil @options[:if]
+  end
+
+  def test_should_be_false_if_state_is_different
+    @object.state = nil
+    refute @options[:if].call(@object)
+  end
+
+  def test_should_be_false_if_original_condition_is_false
+    @condition_result = false
+    refute @options[:if].call(@object)
+  end
+
+  def test_should_be_true_if_state_matches_and_original_condition_is_true
+    @condition_result = true
+    assert @options[:if].call(@object)
+  end
+
+  def test_should_evaluate_symbol_condition
+    @klass.class_eval do
+      attr_accessor :callback
+    end
+
+    options = @state_context.validate(if: :callback)[0]
+
+    object = @klass.new
+    object.callback = false
+    refute options[:if].call(object)
+
+    object.callback = true
+    assert options[:if].call(object)
+  end
+
+  def test_should_evaluate_string_condition
+    @klass.class_eval do
+      attr_accessor :callback
+    end
+
+    options = @state_context.validate(if: '@callback')[0]
+
+    object = @klass.new
+    object.callback = false
+    refute options[:if].call(object)
+
+    object.callback = true
+    assert options[:if].call(object)
+  end
+end

data/test/unit/state_context/state_context_proxy_with_multiple_if_conditions_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class StateContextProxyWithMultipleIfConditionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachines::Machine.new(@klass, initial: :parked)
+    state = machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(state)
+    @object = @klass.new
+
+    @first_condition_result = nil
+    @second_condition_result = nil
+    @options = @state_context.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
+    refute @options[:if].call(@object)
+
+    @first_condition_result = false
+    @second_condition_result = true
+    refute @options[:if].call(@object)
+  end
+end

data/test/unit/state_context/state_context_proxy_with_multiple_unless_conditions_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class StateContextProxyWithMultipleUnlessConditionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachines::Machine.new(@klass, initial: :parked)
+    state = machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(state)
+    @object = @klass.new
+
+    @first_condition_result = nil
+    @second_condition_result = nil
+    @options = @state_context.validate(unless: [-> { @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
+    refute @options[:if].call(@object)
+
+    @first_condition_result = false
+    @second_condition_result = true
+    refute @options[:if].call(@object)
+  end
+end

data/test/unit/state_context/state_context_proxy_with_unless_condition_test.rb

@@ -0,0 +1,64 @@
+require_relative '../../test_helper'
+
+class StateContextProxyWithUnlessConditionTest < StateMachinesTest
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachines::Machine.new(@klass, initial: :parked)
+    state = machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(state)
+    @object = @klass.new
+
+    @condition_result = nil
+    @options = @state_context.validate(unless: lambda { @condition_result })[0]
+  end
+
+  def test_should_have_if_option
+    refute_nil @options[:if]
+  end
+
+  def test_should_be_false_if_state_is_different
+    @object.state = nil
+    refute @options[:if].call(@object)
+  end
+
+  def test_should_be_false_if_original_condition_is_true
+    @condition_result = true
+    refute @options[:if].call(@object)
+  end
+
+  def test_should_be_true_if_state_matches_and_original_condition_is_false
+    @condition_result = false
+    assert @options[:if].call(@object)
+  end
+
+  def test_should_evaluate_symbol_condition
+    @klass.class_eval do
+      attr_accessor :callback
+    end
+
+    options = @state_context.validate(unless: :callback)[0]
+
+    object = @klass.new
+    object.callback = true
+    refute options[:if].call(object)
+
+    object.callback = false
+    assert options[:if].call(object)
+  end
+
+  def test_should_evaluate_string_condition
+    @klass.class_eval do
+      attr_accessor :callback
+    end
+
+    options = @state_context.validate(unless: '@callback')[0]
+
+    object = @klass.new
+    object.callback = true
+    refute options[:if].call(object)
+
+    object.callback = false
+    assert options[:if].call(object)
+  end
+end

data/test/unit/state_context/state_context_proxy_without_conditions_test.rb

@@ -0,0 +1,31 @@
+require_relative '../../test_helper'
+
+class StateContextProxyWithoutConditionsTest < StateMachinesTest
+  def setup
+    @klass = Class.new(Validateable)
+    machine = StateMachines::Machine.new(@klass, initial: :parked)
+    state = machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(state)
+    @object = @klass.new
+
+    @options = @state_context.validate[0]
+  end
+
+  def test_should_have_options_configuration
+    assert_instance_of Hash, @options
+  end
+
+  def test_should_have_if_option
+    refute_nil @options[:if]
+  end
+
+  def test_should_be_false_if_state_is_different
+    @object.state = nil
+    refute @options[:if].call(@object)
+  end
+
+  def test_should_be_true_if_state_matches
+    assert @options[:if].call(@object)
+  end
+end

data/test/unit/state_context/state_context_test.rb

@@ -0,0 +1,28 @@
+require_relative '../../test_helper'
+
+class Validateable
+  class << self
+    def validate(*args, &block)
+      args << block if block_given?
+      args
+    end
+  end
+end
+
+class StateContextTest < StateMachinesTest
+  def setup
+    @klass = Class.new(Validateable)
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @state = @machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(@state)
+  end
+
+  def test_should_have_a_machine
+    assert_equal @machine, @state_context.machine
+  end
+
+  def test_should_have_a_state
+    assert_equal @state, @state_context.state
+  end
+end

data/test/unit/state_context/state_context_transition_test.rb

@@ -0,0 +1,104 @@
+require_relative '../../test_helper'
+
+class StateContextTransitionTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @state = @machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(@state)
+  end
+
+  def test_should_not_allow_except_to
+    exception = assert_raises(ArgumentError) { @state_context.transition(except_to: :idling) }
+    assert_equal 'Unknown key: :except_to. Valid keys are: :from, :to, :on, :if, :unless', exception.message
+  end
+
+  def test_should_not_allow_except_from
+    exception = assert_raises(ArgumentError) { @state_context.transition(except_from: :idling) }
+    assert_equal 'Unknown key: :except_from. Valid keys are: :from, :to, :on, :if, :unless', exception.message
+  end
+
+  def test_should_not_allow_implicit_transitions
+    exception = assert_raises(ArgumentError) { @state_context.transition(parked: :idling) }
+    assert_equal 'Unknown key: :parked. Valid keys are: :from, :to, :on, :if, :unless', exception.message
+  end
+
+  def test_should_not_allow_except_on
+    exception = assert_raises(ArgumentError) { @state_context.transition(except_on: :park) }
+    assert_equal 'Unknown key: :except_on. Valid keys are: :from, :to, :on, :if, :unless', exception.message
+  end
+
+  def test_should_require_on_event
+    exception = assert_raises(ArgumentError) { @state_context.transition(to: :idling) }
+    assert_equal 'Must specify :on event', exception.message
+  end
+
+  def test_should_not_allow_missing_from_and_to
+    exception = assert_raises(ArgumentError) { @state_context.transition(on: :ignite) }
+    assert_equal 'Must specify either :to or :from state', exception.message
+  end
+
+  def test_should_not_allow_from_and_to
+    exception = assert_raises(ArgumentError) { @state_context.transition(on: :ignite, from: :parked, to: :idling) }
+    assert_equal 'Must specify either :to or :from state', exception.message
+  end
+
+  def test_should_allow_to_state_if_missing_from_state
+    @state_context.transition(on: :park, from: :parked)
+  end
+
+  def test_should_allow_from_state_if_missing_to_state
+    @state_context.transition(on: :ignite, to: :idling)
+  end
+
+  def test_should_automatically_set_to_option_with_from_state
+    branch = @state_context.transition(from: :idling, on: :park)
+    assert_instance_of StateMachines::Branch, branch
+
+    state_requirements = branch.state_requirements
+    assert_equal 1, state_requirements.length
+
+    from_requirement = state_requirements[0][:to]
+    assert_instance_of StateMachines::WhitelistMatcher, from_requirement
+    assert_equal [:parked], from_requirement.values
+  end
+
+  def test_should_automatically_set_from_option_with_to_state
+    branch = @state_context.transition(to: :idling, on: :ignite)
+    assert_instance_of StateMachines::Branch, branch
+
+    state_requirements = branch.state_requirements
+    assert_equal 1, state_requirements.length
+
+    from_requirement = state_requirements[0][:from]
+    assert_instance_of StateMachines::WhitelistMatcher, from_requirement
+    assert_equal [:parked], from_requirement.values
+  end
+
+  def test_should_allow_if_condition
+    @state_context.transition(to: :idling, on: :park, if: :seatbelt_on?)
+  end
+
+  def test_should_allow_unless_condition
+    @state_context.transition(to: :idling, on: :park, unless: :seatbelt_off?)
+  end
+
+  def test_should_include_all_transition_states_in_machine_states
+    @state_context.transition(to: :idling, on: :ignite)
+
+    assert_equal [:parked, :idling], @machine.states.map { |state| state.name }
+  end
+
+  def test_should_include_all_transition_events_in_machine_events
+    @state_context.transition(to: :idling, on: :ignite)
+
+    assert_equal [:ignite], @machine.events.map { |event| event.name }
+  end
+
+  def test_should_allow_multiple_events
+    @state_context.transition(to: :idling, on: [:ignite, :shift_up])
+
+    assert_equal [:ignite, :shift_up], @machine.events.map { |event| event.name }
+  end
+end

data/test/unit/state_context/state_context_with_matching_transition_test.rb

@@ -0,0 +1,27 @@
+require_relative '../../test_helper'
+
+class StateContextWithMatchingTransitionTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @state = @machine.state :parked
+
+    @state_context = StateMachines::StateContext.new(@state)
+    @state_context.transition(to: :idling, on: :ignite)
+
+    @event = @machine.event(:ignite)
+    @object = @klass.new
+  end
+
+  def test_should_be_able_to_fire
+    assert @event.can_fire?(@object)
+  end
+
+  def test_should_have_a_transition
+    transition = @event.transition_for(@object)
+    refute_nil transition
+    assert_equal 'parked', transition.from
+    assert_equal 'idling', transition.to
+    assert_equal :ignite, transition.event
+  end
+end

data/test/unit/state_machine/state_machine_by_default_test.rb

@@ -0,0 +1,12 @@
+require_relative '../../test_helper'
+
+class StateMachineByDefaultTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = @klass.state_machine
+  end
+
+  def test_should_use_state_attribute
+    assert_equal :state, @machine.attribute
+  end
+end

data/test/unit/state_machine/state_machine_test.rb

@@ -0,0 +1,20 @@
+require_relative '../../test_helper'
+
+class StateMachineTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+  end
+
+  def test_should_allow_state_machines_on_any_class
+    assert @klass.respond_to?(:state_machine)
+  end
+
+  def test_should_evaluate_block_within_machine_context
+    responded = false
+    @klass.state_machine(:state) do
+      responded = respond_to?(:event)
+    end
+
+    assert responded
+  end
+end

data/test/unit/transition/transition_after_being_performed_test.rb

@@ -0,0 +1,48 @@
+require_relative '../../test_helper'
+
+class TransitionAfterBeingPerformedTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_reader :saved, :save_state
+
+      def save
+        @save_state = state
+        @saved = true
+        1
+      end
+    end
+
+    @machine = StateMachines::Machine.new(@klass, action: :save)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @result = @transition.perform
+  end
+
+  def test_should_have_empty_args
+    assert_equal [], @transition.args
+  end
+
+  def test_should_have_a_result
+    assert_equal 1, @transition.result
+  end
+
+  def test_should_be_successful
+    assert_equal true, @result
+  end
+
+  def test_should_change_the_current_state
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_run_the_action
+    assert @object.saved
+  end
+
+  def test_should_run_the_action_after_saving_the_state
+    assert_equal 'idling', @object.save_state
+  end
+end

data/test/unit/transition/transition_after_being_persisted_test.rb

@@ -0,0 +1,46 @@
+require_relative '../../test_helper'
+
+class TransitionAfterBeingPersistedTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, action: :save)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @transition.persist
+  end
+
+  def test_should_update_state_value
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_not_change_from_state
+    assert_equal 'parked', @transition.from
+  end
+
+  def test_should_not_change_to_state
+    assert_equal 'idling', @transition.to
+  end
+
+  def test_should_not_be_able_to_persist_twice
+    @object.state = 'parked'
+    @transition.persist
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_be_able_to_persist_again_after_resetting
+    @object.state = 'parked'
+    @transition.reset
+    @transition.persist
+    assert_equal 'idling', @object.state
+  end
+
+  def test_should_revert_to_from_state_on_rollback
+    @transition.rollback
+    assert_equal 'parked', @object.state
+  end
+end

data/test/unit/transition/transition_after_being_rolled_back_test.rb

@@ -0,0 +1,35 @@
+require_relative '../../test_helper'
+
+class TransitionAfterBeingRolledBackTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, action: :save)
+    @machine.state :parked, :idling
+    @machine.event :ignite
+
+    @object = @klass.new
+    @object.state = 'parked'
+
+    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
+    @object.state = 'idling'
+
+    @transition.rollback
+  end
+
+  def test_should_update_state_value_to_from_state
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_not_change_from_state
+    assert_equal 'parked', @transition.from
+  end
+
+  def test_should_not_change_to_state
+    assert_equal 'idling', @transition.to
+  end
+
+  def test_should_still_be_able_to_persist
+    @transition.persist
+    assert_equal 'idling', @object.state
+  end
+end