state_machines 0.4.0 → 0.6.0

data/test/unit/machine/machine_with_states_test.rb

@@ -1,55 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithStatesTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @parked, @idling = @machine.state :parked, :idling
-
-    @object = @klass.new
-  end
-
-  def test_should_have_states
-    assert_equal [nil, :parked, :idling], @machine.states.map { |state| state.name }
-  end
-
-  def test_should_allow_state_lookup_by_name
-    assert_equal @parked, @machine.states[:parked]
-  end
-
-  def test_should_allow_state_lookup_by_value
-    assert_equal @parked, @machine.states['parked', :value]
-  end
-
-  def test_should_allow_human_state_name_lookup
-    assert_equal 'parked', @klass.human_state_name(:parked)
-  end
-
-  def test_should_raise_exception_on_invalid_human_state_name_lookup
-    exception = assert_raises(IndexError) { @klass.human_state_name(:invalid) }
-    assert_equal ':invalid is an invalid name', exception.message
-  end
-
-  def test_should_use_stringified_name_for_value
-    assert_equal 'parked', @parked.value
-  end
-
-  def test_should_not_use_custom_matcher
-    assert_nil @parked.matcher
-  end
-
-  def test_should_raise_exception_if_invalid_option_specified
-    exception = assert_raises(ArgumentError) { @machine.state(:first_gear, invalid: true) }
-    assert_equal 'Unknown key: :invalid. Valid keys are: :value, :cache, :if, :human_name', exception.message
-  end
-
-  def test_should_raise_exception_if_conflicting_type_used_for_name
-    exception = assert_raises(ArgumentError) { @machine.state 'first_gear' }
-    assert_equal '"first_gear" state defined as String, :parked defined as Symbol; all states must be consistent', exception.message
-  end
-
-  def test_should_not_raise_exception_if_conflicting_type_is_nil_for_name
-    @machine.state nil
-  end
-end
-

data/test/unit/machine/machine_with_states_with_behaviors_test.rb

@@ -1,23 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithStatesWithBehaviorsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-
-    @parked, @idling = @machine.state :parked, :idling do
-      def speed
-        0
-      end
-    end
-  end
-
-  def test_should_define_behaviors_for_each_state
-    refute_nil @parked.context_methods[:speed]
-    refute_nil @idling.context_methods[:speed]
-  end
-
-  def test_should_define_different_behaviors_for_each_state
-    refute_equal @parked.context_methods[:speed], @idling.context_methods[:speed]
-  end
-end

data/test/unit/machine/machine_with_states_with_custom_human_names_test.rb

@@ -1,18 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithStatesWithCustomHumanNamesTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @state = @machine.state :parked, human_name: 'stopped'
-  end
-
-  def test_should_use_custom_human_name
-    assert_equal 'stopped', @state.human_name
-  end
-
-  def test_should_allow_human_state_name_lookup
-    assert_equal 'stopped', @klass.human_state_name(:parked)
-  end
-end
-

data/test/unit/machine/machine_with_states_with_custom_values_test.rb

@@ -1,21 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithStatesWithCustomValuesTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @state = @machine.state :parked, value: 1
-
-    @object = @klass.new
-    @object.state = 1
-  end
-
-  def test_should_use_custom_value
-    assert_equal 1, @state.value
-  end
-
-  def test_should_allow_lookup_by_custom_value
-    assert_equal @state, @machine.states[1, :value]
-  end
-end
-

data/test/unit/machine/machine_with_states_with_runtime_dependencies_test.rb

@@ -1,19 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithStatesWithRuntimeDependenciesTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked
-  end
-
-  def test_should_not_evaluate_value_during_definition
-    @machine.state :parked, value: ->  { fail ArgumentError }
-  end
-
-  def test_should_not_evaluate_if_not_initial_state
-    @machine.state :parked, value: ->  { fail ArgumentError }
-    @klass.new
-  end
-end
-

data/test/unit/machine/machine_with_static_initial_state_test.rb

@@ -1,49 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithStaticInitialStateTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-  end
-
-  def test_should_not_have_dynamic_initial_state
-    refute @machine.dynamic_initial_state?
-  end
-
-  def test_should_have_an_initial_state
-    object = @klass.new
-    assert_equal 'parked', @machine.initial_state(object).value
-  end
-
-  def test_should_write_to_attribute_when_initializing_state
-    object = @klass.allocate
-    @machine.initialize_state(object)
-    assert_equal 'parked', object.state
-  end
-
-  def test_should_set_initial_on_state_object
-    assert @machine.state(:parked).initial
-  end
-
-  def test_should_set_initial_state_on_created_object
-    assert_equal 'parked', @klass.new.state
-  end
-
-  def test_should_not_initial_state_prior_to_initialization
-    base = Class.new do
-      attr_accessor :state_on_init
-
-      def initialize
-        self.state_on_init = state
-      end
-    end
-    klass = Class.new(base)
-    StateMachines::Machine.new(klass, initial: :parked)
-
-    assert_nil klass.new.state_on_init
-  end
-
-  def test_should_be_included_in_known_states
-    assert_equal [:parked], @machine.states.keys
-  end
-end

data/test/unit/machine/machine_with_superclass_conflicting_helpers_after_definition_test.rb

@@ -1,36 +0,0 @@
-require_relative '../../test_helper'
-require 'stringio'
-
-class MachineWithSuperclassConflictingHelpersAfterDefinitionTest < StateMachinesTest
-  def setup
-    @original_stderr, $stderr = $stderr, StringIO.new
-
-    @superclass = Class.new
-    @klass = Class.new(@superclass)
-
-    @machine = StateMachines::Machine.new(@klass)
-    @machine.state :parked, :idling
-    @machine.event :ignite
-
-    @superclass.class_eval do
-      def state?
-        true
-      end
-    end
-
-    @object = @klass.new
-  end
-
-  def test_should_call_superclass_attribute_predicate_without_arguments
-    assert @object.state?
-  end
-
-  def test_should_define_attribute_predicate_with_arguments
-    refute @object.state?(:parked)
-  end
-
-  def teardown
-    $stderr = @original_stderr
-  end
-end
-

data/test/unit/machine/machine_with_transition_callbacks_test.rb

@@ -1,144 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithTransitionCallbacksTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      attr_accessor :callbacks
-    end
-
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-    @event = @machine.event :ignite do
-      transition parked: :idling
-    end
-
-    @object = @klass.new
-    @object.callbacks = []
-  end
-
-  def test_should_not_raise_exception_if_implicit_option_specified
-    @machine.before_transition invalid: :valid, do: -> {}
-  end
-
-  def test_should_raise_exception_if_method_not_specified
-    exception = assert_raises(ArgumentError) { @machine.before_transition to: :idling }
-    assert_equal 'Method(s) for callback must be specified', exception.message
-  end
-
-  def test_should_invoke_callbacks_during_transition
-    @machine.before_transition lambda { |object| object.callbacks << 'before' }
-    @machine.after_transition lambda { |object| object.callbacks << 'after' }
-    @machine.around_transition lambda { |object, _transition, block| object.callbacks << 'before_around'; block.call; object.callbacks << 'after_around' }
-
-    @event.fire(@object)
-    assert_equal %w(before before_around after_around after), @object.callbacks
-  end
-
-  def test_should_allow_multiple_callbacks
-    @machine.before_transition lambda { |object| object.callbacks << 'before1' }, lambda { |object| object.callbacks << 'before2' }
-    @machine.after_transition lambda { |object| object.callbacks << 'after1' }, lambda { |object| object.callbacks << 'after2' }
-    @machine.around_transition(
-        lambda { |object, _transition, block| object.callbacks << 'before_around1'; block.call; object.callbacks << 'after_around1' },
-        lambda { |object, _transition, block| object.callbacks << 'before_around2'; block.call; object.callbacks << 'after_around2' }
-    )
-
-    @event.fire(@object)
-    assert_equal %w(before1 before2 before_around1 before_around2 after_around2 after_around1 after1 after2), @object.callbacks
-  end
-
-  def test_should_allow_multiple_callbacks_with_requirements
-    @machine.before_transition lambda { |object| object.callbacks << 'before_parked1' }, lambda { |object| object.callbacks << 'before_parked2' }, from: :parked
-    @machine.before_transition lambda { |object| object.callbacks << 'before_idling1' }, lambda { |object| object.callbacks << 'before_idling2' }, from: :idling
-    @machine.after_transition lambda { |object| object.callbacks << 'after_parked1' }, lambda { |object| object.callbacks << 'after_parked2' }, from: :parked
-    @machine.after_transition lambda { |object| object.callbacks << 'after_idling1' }, lambda { |object| object.callbacks << 'after_idling2' }, from: :idling
-    @machine.around_transition(
-        lambda { |object, _transition, block| object.callbacks << 'before_around_parked1'; block.call; object.callbacks << 'after_around_parked1' },
-        lambda { |object, _transition, block| object.callbacks << 'before_around_parked2'; block.call; object.callbacks << 'after_around_parked2' },
-        from: :parked
-    )
-    @machine.around_transition(
-        lambda { |object, _transition, block| object.callbacks << 'before_around_idling1'; block.call; object.callbacks << 'after_around_idling1' },
-        lambda { |object, _transition, block| object.callbacks << 'before_around_idling2'; block.call; object.callbacks << 'after_around_idling2' },
-        from: :idling
-    )
-
-    @event.fire(@object)
-    assert_equal %w(before_parked1 before_parked2 before_around_parked1 before_around_parked2 after_around_parked2 after_around_parked1 after_parked1 after_parked2), @object.callbacks
-  end
-
-  def test_should_support_from_requirement
-    @machine.before_transition from: :parked, do: lambda { |object| object.callbacks << :parked }
-    @machine.before_transition from: :idling, do: lambda { |object| object.callbacks << :idling }
-
-    @event.fire(@object)
-    assert_equal [:parked], @object.callbacks
-  end
-
-  def test_should_support_except_from_requirement
-    @machine.before_transition except_from: :parked, do: lambda { |object| object.callbacks << :parked }
-    @machine.before_transition except_from: :idling, do: lambda { |object| object.callbacks << :idling }
-
-    @event.fire(@object)
-    assert_equal [:idling], @object.callbacks
-  end
-
-  def test_should_support_to_requirement
-    @machine.before_transition to: :parked, do: lambda { |object| object.callbacks << :parked }
-    @machine.before_transition to: :idling, do: lambda { |object| object.callbacks << :idling }
-
-    @event.fire(@object)
-    assert_equal [:idling], @object.callbacks
-  end
-
-  def test_should_support_except_to_requirement
-    @machine.before_transition except_to: :parked, do: lambda { |object| object.callbacks << :parked }
-    @machine.before_transition except_to: :idling, do: lambda { |object| object.callbacks << :idling }
-
-    @event.fire(@object)
-    assert_equal [:parked], @object.callbacks
-  end
-
-  def test_should_support_on_requirement
-    @machine.before_transition on: :park, do: lambda { |object| object.callbacks << :park }
-    @machine.before_transition on: :ignite, do: lambda { |object| object.callbacks << :ignite }
-
-    @event.fire(@object)
-    assert_equal [:ignite], @object.callbacks
-  end
-
-  def test_should_support_except_on_requirement
-    @machine.before_transition except_on: :park, do: lambda { |object| object.callbacks << :park }
-    @machine.before_transition except_on: :ignite, do: lambda { |object| object.callbacks << :ignite }
-
-    @event.fire(@object)
-    assert_equal [:park], @object.callbacks
-  end
-
-  def test_should_support_implicit_requirement
-    @machine.before_transition parked: :idling, do: lambda { |object| object.callbacks << :parked }
-    @machine.before_transition idling: :parked, do: lambda { |object| object.callbacks << :idling }
-
-    @event.fire(@object)
-    assert_equal [:parked], @object.callbacks
-  end
-
-  def test_should_track_states_defined_in_transition_callbacks
-    @machine.before_transition parked: :idling, do: lambda {}
-    @machine.after_transition first_gear: :second_gear, do: lambda {}
-    @machine.around_transition third_gear: :fourth_gear, do: lambda {}
-
-    assert_equal [:parked, :idling, :first_gear, :second_gear, :third_gear, :fourth_gear], @machine.states.map { |state| state.name }
-  end
-
-  def test_should_not_duplicate_states_defined_in_multiple_event_transitions
-    @machine.before_transition parked: :idling, do: lambda {}
-    @machine.after_transition first_gear: :second_gear, do: lambda {}
-    @machine.after_transition parked: :idling, do: lambda {}
-    @machine.around_transition parked: :idling, do: lambda {}
-
-    assert_equal [:parked, :idling, :first_gear, :second_gear], @machine.states.map { |state| state.name }
-  end
-
-  def test_should_define_predicates_for_each_state
-    [:parked?, :idling?].each { |predicate| assert @object.respond_to?(predicate) }
-  end
-end

data/test/unit/machine/machine_with_transitions_test.rb

@@ -1,87 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithTransitionsTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass, initial: :parked)
-  end
-
-  def test_should_require_on_event
-    exception = assert_raises(ArgumentError) { @machine.transition(parked: :idling) }
-    assert_equal 'Must specify :on event', exception.message
-  end
-
-  def test_should_not_allow_except_on_option
-    exception = assert_raises(ArgumentError) { @machine.transition(except_on: :ignite, on: :ignite) }
-    assert_equal 'Unknown key: :except_on. Valid keys are: :from, :to, :except_from, :except_to, :if, :unless', exception.message
-  end
-
-  def test_should_allow_transitioning_without_a_to_state
-    @machine.transition(from: :parked, on: :ignite)
-  end
-
-  def test_should_allow_transitioning_without_a_from_state
-    @machine.transition(to: :idling, on: :ignite)
-  end
-
-  def test_should_allow_except_from_option
-    @machine.transition(except_from: :idling, on: :ignite)
-  end
-
-  def test_should_allow_except_to_option
-    @machine.transition(except_to: :parked, on: :ignite)
-  end
-
-  def test_should_allow_implicit_options
-    branch = @machine.transition(first_gear: :second_gear, on: :shift_up)
-    assert_instance_of StateMachines::Branch, branch
-
-    state_requirements = branch.state_requirements
-    assert_equal 1, state_requirements.length
-
-    assert_instance_of StateMachines::WhitelistMatcher, state_requirements[0][:from]
-    assert_equal [:first_gear], state_requirements[0][:from].values
-    assert_instance_of StateMachines::WhitelistMatcher, state_requirements[0][:to]
-    assert_equal [:second_gear], state_requirements[0][:to].values
-    assert_instance_of StateMachines::WhitelistMatcher, branch.event_requirement
-    assert_equal [:shift_up], branch.event_requirement.values
-  end
-
-  def test_should_allow_multiple_implicit_options
-    branch = @machine.transition(first_gear: :second_gear, second_gear: :third_gear, on: :shift_up)
-
-    state_requirements = branch.state_requirements
-    assert_equal 2, state_requirements.length
-  end
-
-  def test_should_allow_verbose_options
-    branch = @machine.transition(from: :parked, to: :idling, on: :ignite)
-    assert_instance_of StateMachines::Branch, branch
-  end
-
-  def test_should_include_all_transition_states_in_machine_states
-    @machine.transition(parked: :idling, on: :ignite)
-
-    assert_equal [:parked, :idling], @machine.states.map { |state| state.name }
-  end
-
-  def test_should_include_all_transition_events_in_machine_events
-    @machine.transition(parked: :idling, on: :ignite)
-
-    assert_equal [:ignite], @machine.events.map { |event| event.name }
-  end
-
-  def test_should_allow_multiple_events
-    branches = @machine.transition(parked: :ignite, on: [:ignite, :shift_up])
-
-    assert_equal 2, branches.length
-    assert_equal [:ignite, :shift_up], @machine.events.map { |event| event.name }
-  end
-
-  def test_should_not_modify_options
-    options = { parked: :idling, on: :ignite }
-    @machine.transition(options)
-
-    assert_equal options, parked: :idling, on: :ignite
-  end
-end

data/test/unit/machine/machine_without_initialization_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithoutInitializationTest < StateMachinesTest
-  def setup
-    @klass = Class.new do
-      def initialize(attributes = {})
-        attributes.each { |attr, value| send("#{attr}=", value) }
-        super()
-      end
-    end
-
-    @machine = StateMachines::Machine.new(@klass, initial: :parked, initialize: false)
-  end
-
-  def test_should_not_have_an_initial_state
-    object = @klass.new
-    assert_nil object.state
-  end
-
-  def test_should_still_allow_manual_initialization
-    @klass.send(:include, Module.new do
-                          def initialize(_attributes = {})
-                            super()
-                            initialize_state_machines
-                          end
-                        end)
-
-    object = @klass.new
-    assert_equal 'parked', object.state
-  end
-end

data/test/unit/machine/machine_without_initialize_test.rb

@@ -1,14 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithoutInitializeTest < StateMachinesTest
-  def setup
-    klass = Class.new
-    StateMachines::Machine.new(klass, initial: :parked)
-    @object = klass.new
-  end
-
-  def test_should_initialize_state
-    assert_equal 'parked', @object.state
-  end
-end
-

data/test/unit/machine/machine_without_integration_test.rb

@@ -1,31 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithoutIntegrationTest < StateMachinesTest
-  def setup
-    @klass = Class.new
-    @machine = StateMachines::Machine.new(@klass)
-    @object = @klass.new
-  end
-
-  def test_transaction_should_yield
-    @yielded = false
-    @machine.within_transaction(@object) do
-      @yielded = true
-    end
-
-    assert @yielded
-  end
-
-  def test_invalidation_should_do_nothing
-    assert_nil @machine.invalidate(@object, :state, :invalid_transition, [[:event, 'park']])
-  end
-
-  def test_reset_should_do_nothing
-    assert_nil @machine.reset(@object)
-  end
-
-  def test_errors_for_should_be_empty
-    assert_equal '', @machine.errors_for(@object)
-  end
-end
-

data/test/unit/machine_collection/machine_collection_by_default_test.rb

@@ -1,11 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineCollectionByDefaultTest < StateMachinesTest
-  def setup
-    @machines = StateMachines::MachineCollection.new
-  end
-
-  def test_should_not_have_any_machines
-    assert @machines.empty?
-  end
-end

data/test/unit/machine_collection/machine_collection_fire_attributes_with_validations_test.rb

@@ -1,72 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineCollectionFireWithValidationsTest < StateMachinesTest
-  module Custom
-    include StateMachines::Integrations::Base
-
-    def invalidate(object, _attribute, message, values = [])
-      (object.errors ||= []) << generate_message(message, values)
-    end
-
-    def reset(object)
-      object.errors = []
-    end
-  end
-
-  def setup
-    StateMachines::Integrations.register(MachineCollectionFireWithValidationsTest::Custom)
-
-    @klass = Class.new do
-      attr_accessor :errors
-
-      def initialize
-        @errors = []
-        super
-      end
-    end
-
-    @machines = StateMachines::MachineCollection.new
-    @machines[:state] = @state = StateMachines::Machine.new(@klass, :state, initial: :parked, integration: :custom)
-    @state.event :ignite do
-      transition parked: :idling
-    end
-
-    @machines[:alarm_state] = @alarm_state = StateMachines::Machine.new(@klass, :alarm_state, initial: :active, namespace: 'alarm', integration: :custom)
-    @alarm_state.event :disable do
-      transition active: :off
-    end
-
-    @object = @klass.new
-  end
-
-  def test_should_not_invalidate_if_transitions_exist
-    assert @machines.fire_events(@object, :ignite, :disable_alarm)
-    assert_equal [], @object.errors
-  end
-
-  def test_should_invalidate_if_no_transitions_exist
-    @object.state = 'idling'
-    @object.alarm_state = 'off'
-
-    refute @machines.fire_events(@object, :ignite, :disable_alarm)
-    assert_equal ['cannot transition via "ignite"', 'cannot transition via "disable"'], @object.errors
-  end
-
-  def test_should_run_failure_callbacks_if_no_transitions_exist
-    @object.state = 'idling'
-    @object.alarm_state = 'off'
-    @state_failure_run = @alarm_state_failure_run = false
-
-    @machines[:state].after_failure { @state_failure_run = true }
-    @machines[:alarm_state].after_failure { @alarm_state_failure_run = true }
-
-    refute @machines.fire_events(@object, :ignite, :disable_alarm)
-    assert @state_failure_run
-    assert @alarm_state_failure_run
-  end
-
-  def teardown
-    StateMachines::Integrations.reset
-  end
-end
-