state_machines 0.5.0 → 0.10.0

data/test/unit/machine/machine_with_helpers_test.rb

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

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

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

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

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

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

@@ -1,72 +0,0 @@
-require_relative '../../test_helper'
-
-class MachineWithIntegrationTest < StateMachinesTest
-
-  module Custom
-    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
-
-  def setup
-    StateMachines::Integrations.register(MachineWithIntegrationTest::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
-  end
-end

data/test/unit/machine/machine_with_multiple_events_test.rb

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

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

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

data/test/unit/machine/machine_with_other_states.rb

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

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

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

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

data/test/unit/machine/machine_with_state_matchers_test.rb

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

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