state_machines 0.5.0 → 0.10.0

data/test/unit/state_context/state_context_proxy_with_if_condition_test.rb

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

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

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

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

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

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

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

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

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

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

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

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

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

data/test/unit/transition/transition_equality_test.rb

@@ -1,52 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionEqualityTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-
-    @object = @klass.new
-    @object.state = 'parked'
-    @transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-  end
-
-  def test_should_be_equal_with_same_properties
-    transition = StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)
-    assert_equal transition, @transition
-  end
-
-  def test_should_not_be_equal_with_different_machines
-    machine = StateMachines::Machine.new(@klass, :status, namespace: :other)
-    machine.state :parked, :idling
-    machine.event :ignite
-    transition = StateMachines::Transition.new(@object, machine, :ignite, :parked, :idling)
-
-    refute_equal transition, @transition
-  end
-
-  def test_should_not_be_equal_with_different_objects
-    transition = StateMachines::Transition.new(@klass.new, @machine, :ignite, :parked, :idling)
-    refute_equal transition, @transition
-  end
-
-  def test_should_not_be_equal_with_different_event_names
-    @machine.event :park
-    transition = StateMachines::Transition.new(@object, @machine, :park, :parked, :idling)
-    refute_equal transition, @transition
-  end
-
-  def test_should_not_be_equal_with_different_from_state_names
-    @machine.state :first_gear
-    transition = StateMachines::Transition.new(@object, @machine, :ignite, :first_gear, :idling)
-    refute_equal transition, @transition
-  end
-
-  def test_should_not_be_equal_with_different_to_state_names
-    @machine.state :first_gear
-    transition = StateMachines::Transition.new(@object, @machine, :ignite, :idling, :first_gear)
-    refute_equal transition, @transition
-  end
-end

data/test/unit/transition/transition_loopback_test.rb

@@ -1,18 +0,0 @@
-require_relative '../../test_helper'
-
-class TransitionLoopbackTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked
-    @machine.event :park
-
-    @object = @klass.new
-    @object.state = 'parked'
-    @transition = StateMachines::Transition.new(@object, @machine, :park, :parked, :parked)
-  end
-
-  def test_should_be_loopback
-    assert @transition.loopback?
-  end
-end