state_machines 0.0.2 → 0.1.0

data/test/unit/machine/machine_with_state_matchers_test.rb

@@ -0,0 +1,41 @@
+require_relative '../../test_helper'
+
+class MachineWithStateMatchersTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+  end
+
+  def test_should_empty_array_for_all_matcher
+    assert_equal [], @machine.state(StateMachines::AllMatcher.instance)
+  end
+
+  def test_should_return_referenced_states_for_blacklist_matcher
+    assert_instance_of StateMachines::State, @machine.state(StateMachines::BlacklistMatcher.new([:parked]))
+  end
+
+  def test_should_not_allow_configurations
+    exception = assert_raises(ArgumentError) { @machine.state(StateMachines::BlacklistMatcher.new([:parked]), human_name: 'Parked') }
+    assert_equal 'Cannot configure states when using matchers (using {:human_name=>"Parked"})', exception.message
+  end
+
+  def test_should_track_referenced_states
+    @machine.state(StateMachines::BlacklistMatcher.new([:parked]))
+    assert_equal [nil, :parked], @machine.states.map { |state| state.name }
+  end
+
+  def test_should_eval_context_for_matching_states
+    contexts_run = []
+    @machine.event(StateMachines::BlacklistMatcher.new([:parked])) { contexts_run << name }
+
+    @machine.event :parked
+    assert_equal [], contexts_run
+
+    @machine.event :idling
+    assert_equal [:idling], contexts_run
+
+    @machine.event :first_gear, :second_gear
+    assert_equal [:idling, :first_gear, :second_gear], contexts_run
+  end
+end
+

data/test/unit/machine/machine_with_state_with_matchers_test.rb

@@ -0,0 +1,19 @@
+require_relative '../../test_helper'
+
+class MachineWithStateWithMatchersTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @state = @machine.state :parked, if: ->(value) {!value.nil? }
+
+    @object = @klass.new
+    @object.state = 1
+  end
+
+  def test_should_use_custom_matcher
+    refute_nil @state.matcher
+    assert @state.matches?(1)
+    refute @state.matches?(nil)
+  end
+end
+

data/test/unit/machine/machine_with_states_test.rb

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

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

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

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

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

@@ -0,0 +1,60 @@
+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_not_set_initial_state_even_if_not_empty
+    @klass.class_eval do
+      def initialize(_attributes = {})
+        self.state = 'idling'
+        super()
+      end
+    end
+    object = @klass.new
+    assert_equal 'idling', object.state
+  end
+
+  def test_should_set_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_equal 'parked', 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

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

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

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

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

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

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

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