state_machines 0.0.2 → 0.1.0

data/test/unit/machine/machine_with_existing_machines_with_same_attributes_on_owner_subclass_test.rb

@@ -0,0 +1,31 @@
+require_relative '../../test_helper'
+
+class MachineWithExistingMachinesWithSameAttributesOnOwnerSubclassTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @second_machine = StateMachines::Machine.new(@klass, :public_state, initial: :idling, attribute: :state)
+
+    @subclass = Class.new(@klass)
+    @object = @subclass.new
+  end
+
+  def test_should_not_copy_sibling_machines_to_subclass_after_initialization
+    @subclass.state_machine(:state) {}
+    assert_equal @klass.state_machine(:public_state), @subclass.state_machine(:public_state)
+  end
+
+  def test_should_copy_sibling_machines_to_subclass_after_new_state
+    subclass_machine = @subclass.state_machine(:state) {}
+    subclass_machine.state :first_gear
+    refute_equal @klass.state_machine(:public_state), @subclass.state_machine(:public_state)
+  end
+
+  def test_should_copy_new_states_to_sibling_machines
+    subclass_machine = @subclass.state_machine(:state) {}
+    @first_gear = subclass_machine.state :first_gear
+
+    second_subclass_machine = @subclass.state_machine(:public_state)
+    assert_equal @first_gear, second_subclass_machine.state(:first_gear)
+  end
+end

data/test/unit/machine/machine_with_existing_state_test.rb

@@ -0,0 +1,27 @@
+require_relative '../../test_helper'
+
+class MachineWithExistingStateTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @state = @machine.state :parked
+    @same_state = @machine.state :parked, value: 1
+  end
+
+  def test_should_not_create_a_new_state
+    assert_same @state, @same_state
+  end
+
+  def test_should_update_attributes
+    assert_equal 1, @state.value
+  end
+
+  def test_should_no_longer_be_able_to_look_up_state_by_original_value
+    assert_nil @machine.states['parked', :value]
+  end
+
+  def test_should_be_able_to_look_up_state_by_new_value
+    assert_equal @state, @machine.states[1, :value]
+  end
+end
+

data/test/unit/machine/machine_with_failure_callbacks_test.rb

@@ -0,0 +1,48 @@
+require_relative '../../test_helper'
+
+class MachineWithFailureCallbacksTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      attr_accessor :callbacks
+    end
+
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @event = @machine.event :ignite
+
+    @object = @klass.new
+    @object.callbacks = []
+  end
+
+  def test_should_raise_exception_if_implicit_option_specified
+    exception = assert_raises(ArgumentError) { @machine.after_failure invalid: :valid, do: lambda {} }
+    assert_equal 'Unknown key: :invalid. Valid keys are: :on, :do, :if, :unless', exception.message
+  end
+
+  def test_should_raise_exception_if_method_not_specified
+    exception = assert_raises(ArgumentError) { @machine.after_failure on: :ignite }
+    assert_equal 'Method(s) for callback must be specified', exception.message
+  end
+
+  def test_should_invoke_callbacks_during_failed_transition
+    @machine.after_failure lambda { |object| object.callbacks << 'failure' }
+
+    @event.fire(@object)
+    assert_equal %w(failure), @object.callbacks
+  end
+
+  def test_should_allow_multiple_callbacks
+    @machine.after_failure lambda { |object| object.callbacks << 'failure1' }, lambda { |object| object.callbacks << 'failure2' }
+
+    @event.fire(@object)
+    assert_equal %w(failure1 failure2), @object.callbacks
+  end
+
+  def test_should_allow_multiple_callbacks_with_requirements
+    @machine.after_failure lambda { |object| object.callbacks << 'failure_ignite1' }, lambda { |object| object.callbacks << 'failure_ignite2' }, on: :ignite
+    @machine.after_failure lambda { |object| object.callbacks << 'failure_park1' }, lambda { |object| object.callbacks << 'failure_park2' }, on: :park
+
+    @event.fire(@object)
+    assert_equal %w(failure_ignite1 failure_ignite2), @object.callbacks
+  end
+end
+

data/test/unit/machine/machine_with_helpers_test.rb

@@ -0,0 +1,14 @@
+require_relative '../../test_helper'
+
+class MachineWithHelpersTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @object = @klass.new
+  end
+
+  def test_should_throw_exception_with_invalid_scope
+    assert_raises(RUBY_VERSION < '1.9' ? IndexError : KeyError) { @machine.define_helper(:invalid, :park) {} }
+  end
+end
+

data/test/unit/machine/machine_with_initial_state_with_value_and_owner_default.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class MachineWithInitialStateWithValueAndOwnerDefault < StateMachinesTest
+  def setup
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    state_machine_with_defaults = Class.new(StateMachines::Machine) do
+      def owner_class_attribute_default
+        0
+      end
+    end
+    @klass = Class.new
+    @machine = state_machine_with_defaults.new(@klass, initial: :parked) do
+      state :parked, value: 0
+    end
+  end
+
+  def test_should_not_warn_about_wrong_default
+    assert_equal '', $stderr.string
+  end
+
+  def teardown
+    $stderr = @original_stderr
+  end
+end

data/test/unit/machine/machine_with_initialize_and_super_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+
+class MachineWithInitializeAndSuperTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def initialize
+        super()
+      end
+    end
+    @machine = 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_with_initialize_arguments_and_block_test.rb

@@ -0,0 +1,31 @@
+require_relative '../../test_helper'
+
+class MachineWithInitializeArgumentsAndBlockTest < StateMachinesTest
+  def setup
+    @superclass = Class.new do
+      attr_reader :args
+      attr_reader :block_given
+
+      def initialize(*args)
+        @args = args
+        @block_given = block_given?
+      end
+    end
+    @klass = Class.new(@superclass)
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @object = @klass.new(1, 2, 3) {}
+  end
+
+  def test_should_initialize_state
+    assert_equal 'parked', @object.state
+  end
+
+  def test_should_preserve_arguments
+    assert_equal [1, 2, 3], @object.args
+  end
+
+  def test_should_preserve_block
+    assert @object.block_given
+  end
+end
+

data/test/unit/machine/machine_with_initialize_without_super_test.rb

@@ -0,0 +1,17 @@
+require_relative '../../test_helper'
+
+class MachineWithInitializeWithoutSuperTest < StateMachinesTest
+  def setup
+    @klass = Class.new do
+      def initialize
+      end
+    end
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @object = @klass.new
+  end
+
+  def test_should_not_initialize_state
+    assert_nil @object.state
+  end
+end
+

data/test/unit/machine/machine_with_instance_helpers_test.rb

@@ -0,0 +1,179 @@
+require_relative '../../test_helper'
+
+class MachineWithInstanceHelpersTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @object = @klass.new
+  end
+
+  def test_should_not_redefine_existing_public_methods
+    @klass.class_eval do
+      def park
+        true
+      end
+    end
+
+    @machine.define_helper(:instance, :park) {}
+    assert_equal true, @object.park
+  end
+
+  def test_should_not_redefine_existing_protected_methods
+    @klass.class_eval do
+      protected
+      def park
+        true
+      end
+    end
+
+    @machine.define_helper(:instance, :park) {}
+    assert_equal true, @object.send(:park)
+  end
+
+  def test_should_not_redefine_existing_private_methods
+    @klass.class_eval do
+      private
+      def park
+        true
+      end
+    end
+
+    @machine.define_helper(:instance, :park) {}
+    assert_equal true, @object.send(:park)
+  end
+
+  def test_should_warn_if_defined_in_superclass
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    superclass = Class.new do
+      def park
+      end
+    end
+    klass = Class.new(superclass)
+    machine = StateMachines::Machine.new(klass)
+
+    machine.define_helper(:instance, :park) {}
+    assert_equal "Instance method \"park\" is already defined in #{superclass}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+
+  def test_should_warn_if_defined_in_multiple_superclasses
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    superclass1 = Class.new do
+      def park
+      end
+    end
+    superclass2 = Class.new(superclass1) do
+      def park
+      end
+    end
+    klass = Class.new(superclass2)
+    machine = StateMachines::Machine.new(klass)
+
+    machine.define_helper(:instance, :park) {}
+    assert_equal "Instance method \"park\" is already defined in #{superclass1}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+
+  def test_should_warn_if_defined_in_module_prior_to_helper_module
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    mod = Module.new do
+      def park
+      end
+    end
+    klass = Class.new do
+      include mod
+    end
+    machine = StateMachines::Machine.new(klass)
+
+    machine.define_helper(:instance, :park) {}
+    assert_equal "Instance method \"park\" is already defined in #{mod}, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+
+  def test_should_not_warn_if_defined_in_module_after_helper_module
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    klass = Class.new
+    machine = StateMachines::Machine.new(klass)
+
+    mod = Module.new do
+      def park
+      end
+    end
+    klass.class_eval do
+      include mod
+    end
+
+    machine.define_helper(:instance, :park) {}
+    assert_equal '', $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+
+  def test_should_define_if_ignoring_method_conflicts_and_defined_in_superclass
+    @original_stderr, $stderr = $stderr, StringIO.new
+    StateMachines::Machine.ignore_method_conflicts = true
+
+    superclass = Class.new do
+      def park
+      end
+    end
+    klass = Class.new(superclass)
+    machine = StateMachines::Machine.new(klass)
+
+    machine.define_helper(:instance, :park) { true }
+    assert_equal '', $stderr.string
+    assert_equal true, klass.new.park
+  ensure
+    StateMachines::Machine.ignore_method_conflicts = false
+    $stderr = @original_stderr
+  end
+
+  def test_should_define_nonexistent_methods
+    @machine.define_helper(:instance, :park) { false }
+    assert_equal false, @object.park
+  end
+
+  def test_should_warn_if_defined_multiple_times
+    @original_stderr, $stderr = $stderr, StringIO.new
+
+    @machine.define_helper(:instance, :park) {}
+    @machine.define_helper(:instance, :park) {}
+
+    assert_equal "Instance method \"park\" is already defined in #{@klass} :state instance helpers, use generic helper instead or set StateMachines::Machine.ignore_method_conflicts = true.\n", $stderr.string
+  ensure
+    $stderr = @original_stderr
+  end
+
+  def test_should_pass_context_as_arguments
+    helper_args = nil
+    @machine.define_helper(:instance, :park) { |*args| helper_args = args }
+    @object.park
+    assert_equal 2, helper_args.length
+    assert_equal [@machine, @object], helper_args
+  end
+
+  def test_should_pass_method_arguments_through
+    helper_args = nil
+    @machine.define_helper(:instance, :park) { |*args| helper_args = args }
+    @object.park(1, 2, 3)
+    assert_equal 5, helper_args.length
+    assert_equal [@machine, @object, 1, 2, 3], helper_args
+  end
+
+  def test_should_allow_string_evaluation
+    @machine.define_helper :instance, <<-end_eval, __FILE__, __LINE__ + 1
+      def park
+        false
+      end
+    end_eval
+    assert_equal false, @object.park
+  end
+end
+

data/test/unit/machine/machine_with_integration_test.rb

@@ -0,0 +1,71 @@
+require_relative '../../test_helper'
+
+class MachineWithIntegrationTest < StateMachinesTest
+  def setup
+    StateMachines::Integrations.const_set('Custom', Module.new do
+                                                    include StateMachines::Integrations::Base
+
+                                                    @defaults = { action: :save, use_transactions: false }
+
+                                                    attr_reader :initialized, :with_scopes, :without_scopes, :ran_transaction
+
+                                                    def after_initialize
+                                                      @initialized = true
+                                                    end
+
+                                                    def create_with_scope(name)
+                                                      (@with_scopes ||= []) << name
+                                                      lambda {}
+                                                    end
+
+                                                    def create_without_scope(name)
+                                                      (@without_scopes ||= []) << name
+                                                      lambda {}
+                                                    end
+
+                                                    def transaction(_)
+                                                      @ran_transaction = true
+                                                      yield
+                                                    end
+                                                  end)
+    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+
+
+    @machine = StateMachines::Machine.new(Class.new, integration: :custom)
+  end
+
+  def test_should_call_after_initialize_hook
+    assert @machine.initialized
+  end
+
+  def test_should_use_the_default_action
+    assert_equal :save, @machine.action
+  end
+
+  def test_should_use_the_custom_action_if_specified
+    machine = StateMachines::Machine.new(Class.new, integration: :custom, action: :save!)
+    assert_equal :save!, machine.action
+  end
+
+  def test_should_use_the_default_use_transactions
+    assert_equal false, @machine.use_transactions
+  end
+
+  def test_should_use_the_custom_use_transactions_if_specified
+    machine = StateMachines::Machine.new(Class.new, integration: :custom, use_transactions: true)
+    assert_equal true, machine.use_transactions
+  end
+
+  def test_should_define_a_singular_and_plural_with_scope
+    assert_equal %w(with_state with_states), @machine.with_scopes
+  end
+
+  def test_should_define_a_singular_and_plural_without_scope
+    assert_equal %w(without_state without_states), @machine.without_scopes
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end

data/test/unit/machine/machine_with_multiple_events_test.rb

@@ -0,0 +1,32 @@
+require_relative '../../test_helper'
+
+class MachineWithMultipleEventsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @park, @shift_down = @machine.event(:park, :shift_down) do
+      transition first_gear: :parked
+    end
+  end
+
+  def test_should_have_events
+    assert_equal [@park, @shift_down], @machine.events.to_a
+  end
+
+  def test_should_define_transitions_for_each_event
+    [@park, @shift_down].each { |event| assert_equal 1, event.branches.size }
+  end
+
+  def test_should_transition_the_same_for_each_event
+    object = @klass.new
+    object.state = 'first_gear'
+    object.park
+    assert_equal 'parked', object.state
+
+    object = @klass.new
+    object.state = 'first_gear'
+    object.shift_down
+    assert_equal 'parked', object.state
+  end
+end
+

data/test/unit/machine/machine_with_namespace_test.rb

@@ -0,0 +1,48 @@
+require_relative '../../test_helper'
+
+class MachineWithNamespaceTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, namespace: 'alarm', initial: :active) do
+      event :enable do
+        transition off: :active
+      end
+
+      event :disable do
+        transition active: :off
+      end
+    end
+    @object = @klass.new
+  end
+
+  def test_should_namespace_state_predicates
+    [:alarm_active?, :alarm_off?].each do |name|
+      assert @object.respond_to?(name)
+    end
+  end
+
+  def test_should_namespace_event_checks
+    [:can_enable_alarm?, :can_disable_alarm?].each do |name|
+      assert @object.respond_to?(name)
+    end
+  end
+
+  def test_should_namespace_event_transition_readers
+    [:enable_alarm_transition, :disable_alarm_transition].each do |name|
+      assert @object.respond_to?(name)
+    end
+  end
+
+  def test_should_namespace_events
+    [:enable_alarm, :disable_alarm].each do |name|
+      assert @object.respond_to?(name)
+    end
+  end
+
+  def test_should_namespace_bang_events
+    [:enable_alarm!, :disable_alarm!].each do |name|
+      assert @object.respond_to?(name)
+    end
+  end
+end
+

data/test/unit/machine/machine_with_nil_action_test.rb

@@ -0,0 +1,24 @@
+require_relative '../../test_helper'
+
+class MachineWithNilActionTest < StateMachinesTest
+  def setup
+    integration = Module.new do
+      include StateMachines::Integrations::Base
+
+      @defaults = { action: :save }
+    end
+    StateMachines::Integrations.const_set('Custom', integration)
+    StateMachines::Integrations.register(StateMachines::Integrations::Custom)
+
+    @machine = StateMachines::Machine.new(Class.new, action: nil, integration: :custom)
+  end
+
+  def test_should_have_a_nil_action
+    assert_nil @machine.action
+  end
+
+  def teardown
+    StateMachines::Integrations.reset
+    StateMachines::Integrations.send(:remove_const, 'Custom')
+  end
+end

data/test/unit/machine/machine_with_other_states.rb

@@ -0,0 +1,22 @@
+require_relative '../../test_helper'
+
+class MachineWithOtherStates < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass, initial: :parked)
+    @parked, @idling = @machine.other_states(:parked, :idling)
+  end
+
+  def test_should_include_other_states_in_known_states
+    assert_equal [@parked, @idling], @machine.states.to_a
+  end
+
+  def test_should_use_default_value
+    assert_equal 'idling', @idling.value
+  end
+
+  def test_should_not_create_matcher
+    assert_nil @idling.matcher
+  end
+end
+

data/test/unit/machine/machine_with_owner_subclass_test.rb

@@ -0,0 +1,18 @@
+require_relative '../../test_helper'
+
+class MachineWithOwnerSubclassTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @subclass = Class.new(@klass)
+  end
+
+  def test_should_have_a_different_collection_of_state_machines
+    refute_same @klass.state_machines, @subclass.state_machines
+  end
+
+  def test_should_have_the_same_attribute_associated_state_machines
+    assert_equal @klass.state_machines, @subclass.state_machines
+  end
+end
+

data/test/unit/machine/machine_with_paths_test.rb

@@ -0,0 +1,25 @@
+require_relative '../../test_helper'
+
+class MachineWithPathsTest < StateMachinesTest
+  def setup
+    @klass = Class.new
+    @machine = StateMachines::Machine.new(@klass)
+    @machine.event :ignite do
+      transition parked: :idling
+    end
+    @machine.event :shift_up do
+      transition first_gear: :second_gear
+    end
+
+    @object = @klass.new
+    @object.state = 'parked'
+  end
+
+  def test_should_have_paths
+    assert_equal [[StateMachines::Transition.new(@object, @machine, :ignite, :parked, :idling)]], @machine.paths_for(@object)
+  end
+
+  def test_should_allow_requirement_configuration
+    assert_equal [[StateMachines::Transition.new(@object, @machine, :shift_up, :first_gear, :second_gear)]], @machine.paths_for(@object, from: :first_gear)
+  end
+end

data/test/unit/machine/machine_with_private_action_test.rb

@@ -0,0 +1,43 @@
+require_relative '../../test_helper'
+
+class MachineWithPrivateActionTest < StateMachinesTest
+  def setup
+    @superclass = Class.new do
+      private
+      def save
+      end
+    end
+    @klass = Class.new(@superclass)
+
+    @machine = StateMachines::Machine.new(@klass, action: :save)
+    @object = @klass.new
+  end
+
+  def test_should_define_an_event_attribute_reader
+    assert @object.respond_to?(:state_event)
+  end
+
+  def test_should_define_an_event_attribute_writer
+    assert @object.respond_to?(:state_event=)
+  end
+
+  def test_should_define_an_event_transition_attribute_reader
+    assert @object.respond_to?(:state_event_transition, true)
+  end
+
+  def test_should_define_an_event_transition_attribute_writer
+    assert @object.respond_to?(:state_event_transition=, true)
+  end
+
+  def test_should_define_action
+    assert @klass.ancestors.any? { |ancestor| ![@klass, @superclass].include?(ancestor) && ancestor.private_method_defined?(:save) }
+  end
+
+  def test_should_keep_action_private
+    assert @klass.private_method_defined?(:save)
+  end
+
+  def test_should_mark_action_hook_as_defined
+    assert @machine.action_hook?
+  end
+end