state_machines 0.5.0 → 0.10.0

data/test/functional/vehicle_idling_test.rb

@@ -1,59 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleIdlingTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-    @vehicle.ignite
-  end
-
-  def test_should_be_in_idling_state
-    assert_equal 'idling', @vehicle.state
-  end
-
-  def test_should_be_idling
-    assert @vehicle.idling?
-  end
-
-  def test_should_have_seatbelt_on
-    assert @vehicle.seatbelt_on
-  end
-
-  def test_should_track_time_elapsed
-    refute_nil @vehicle.time_elapsed
-  end
-
-  def test_should_allow_park
-    assert @vehicle.park
-  end
-
-  def test_should_call_park_with_bang_action
-    class << @vehicle
-      def park
-        super && 1
-      end
-    end
-
-    assert_equal 1, @vehicle.park!
-  end
-
-  def test_should_not_allow_idle
-    refute @vehicle.idle
-  end
-
-  def test_should_allow_shift_up
-    assert @vehicle.shift_up
-  end
-
-  def test_should_not_allow_shift_down
-    refute @vehicle.shift_down
-  end
-
-  def test_should_not_allow_crash
-    refute @vehicle.crash
-  end
-
-  def test_should_not_allow_repair
-    refute @vehicle.repair
-  end
-end

data/test/functional/vehicle_locked_test.rb

@@ -1,29 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleLockedTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-    @vehicle.state = 'locked'
-  end
-
-  def test_should_be_parked_after_park
-    @vehicle.park
-    assert @vehicle.parked?
-  end
-
-  def test_should_be_parked_after_ignite
-    @vehicle.ignite
-    assert @vehicle.parked?
-  end
-
-  def test_should_be_parked_after_shift_up
-    @vehicle.shift_up
-    assert @vehicle.parked?
-  end
-
-  def test_should_be_parked_after_shift_down
-    @vehicle.shift_down
-    assert @vehicle.parked?
-  end
-end

data/test/functional/vehicle_parked_test.rb

@@ -1,53 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleParkedTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-  end
-
-  def test_should_be_in_parked_state
-    assert_equal 'parked', @vehicle.state
-  end
-
-  def test_should_not_have_the_seatbelt_on
-    refute @vehicle.seatbelt_on
-  end
-
-  def test_should_not_allow_park
-    refute @vehicle.park
-  end
-
-  def test_should_allow_ignite
-    assert @vehicle.ignite
-    assert_equal 'idling', @vehicle.state
-  end
-
-  def test_should_not_allow_idle
-    refute @vehicle.idle
-  end
-
-  def test_should_not_allow_shift_up
-    refute @vehicle.shift_up
-  end
-
-  def test_should_not_allow_shift_down
-    refute @vehicle.shift_down
-  end
-
-  def test_should_not_allow_crash
-    refute @vehicle.crash
-  end
-
-  def test_should_not_allow_repair
-    refute @vehicle.repair
-  end
-
-  def test_should_raise_exception_if_repair_not_allowed!
-    exception = assert_raises(StateMachines::InvalidTransition) { @vehicle.repair! }
-    assert_equal @vehicle, exception.object
-    assert_equal Vehicle.state_machine(:state), exception.machine
-    assert_equal :repair, exception.event
-    assert_equal 'parked', exception.from
-  end
-end

data/test/functional/vehicle_repaired_test.rb

@@ -1,20 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleRepairedTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-    @vehicle.ignite
-    @vehicle.shift_up
-    @vehicle.crash
-    @vehicle.repair
-  end
-
-  def test_should_be_in_parked_state
-    assert_equal 'parked', @vehicle.state
-  end
-
-  def test_should_not_have_a_busy_auto_shop
-    assert @vehicle.auto_shop.available?
-  end
-end

data/test/functional/vehicle_second_gear_test.rb

@@ -1,42 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleSecondGearTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-    @vehicle.ignite
-    2.times { @vehicle.shift_up }
-  end
-
-  def test_should_be_in_second_gear_state
-    assert_equal 'second_gear', @vehicle.state
-  end
-
-  def test_should_be_second_gear
-    assert @vehicle.second_gear?
-  end
-
-  def test_should_not_allow_park
-    refute @vehicle.park
-  end
-
-  def test_should_not_allow_idle
-    refute @vehicle.idle
-  end
-
-  def test_should_allow_shift_up
-    assert @vehicle.shift_up
-  end
-
-  def test_should_allow_shift_down
-    assert @vehicle.shift_down
-  end
-
-  def test_should_allow_crash
-    assert @vehicle.crash
-  end
-
-  def test_should_not_allow_repair
-    refute @vehicle.repair
-  end
-end

data/test/functional/vehicle_stalled_test.rb

@@ -1,65 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleStalledTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-    @vehicle.ignite
-    @vehicle.shift_up
-    @vehicle.crash
-  end
-
-  def test_should_be_in_stalled_state
-    assert_equal 'stalled', @vehicle.state
-  end
-
-  def test_should_be_stalled
-    assert @vehicle.stalled?
-  end
-
-  def test_should_be_towed
-    assert @vehicle.auto_shop.busy?
-    assert_equal 1, @vehicle.auto_shop.num_customers
-  end
-
-  def test_should_have_an_increased_insurance_premium
-    assert_equal 150, @vehicle.insurance_premium
-  end
-
-  def test_should_not_allow_park
-    refute @vehicle.park
-  end
-
-  def test_should_allow_ignite
-    assert @vehicle.ignite
-  end
-
-  def test_should_not_change_state_when_ignited
-    assert_equal 'stalled', @vehicle.state
-  end
-
-  def test_should_not_allow_idle
-    refute @vehicle.idle
-  end
-
-  def test_should_now_allow_shift_up
-    refute @vehicle.shift_up
-  end
-
-  def test_should_not_allow_shift_down
-    refute @vehicle.shift_down
-  end
-
-  def test_should_not_allow_crash
-    refute @vehicle.crash
-  end
-
-  def test_should_allow_repair_if_auto_shop_is_busy
-    assert @vehicle.repair
-  end
-
-  def test_should_not_allow_repair_if_auto_shop_is_available
-    @vehicle.auto_shop.fix_vehicle
-    refute @vehicle.repair
-  end
-end

data/test/functional/vehicle_test.rb

@@ -1,20 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-  end
-
-  def test_should_not_allow_access_to_subclass_events
-    refute @vehicle.respond_to?(:reverse)
-  end
-
-  def test_should_have_human_state_names
-    assert_equal 'parked', Vehicle.human_state_name(:parked)
-  end
-
-  def test_should_have_human_state_event_names
-    assert_equal 'park', Vehicle.human_state_event_name(:park)
-  end
-end

data/test/functional/vehicle_third_gear_test.rb

@@ -1,42 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleThirdGearTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-    @vehicle.ignite
-    3.times { @vehicle.shift_up }
-  end
-
-  def test_should_be_in_third_gear_state
-    assert_equal 'third_gear', @vehicle.state
-  end
-
-  def test_should_be_third_gear
-    assert @vehicle.third_gear?
-  end
-
-  def test_should_not_allow_park
-    refute @vehicle.park
-  end
-
-  def test_should_not_allow_idle
-    refute @vehicle.idle
-  end
-
-  def test_should_not_allow_shift_up
-    refute @vehicle.shift_up
-  end
-
-  def test_should_allow_shift_down
-    assert @vehicle.shift_down
-  end
-
-  def test_should_allow_crash
-    assert @vehicle.crash
-  end
-
-  def test_should_not_allow_repair
-    refute @vehicle.repair
-  end
-end

data/test/functional/vehicle_unsaved_test.rb

@@ -1,181 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleUnsavedTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-  end
-
-  def test_should_be_in_parked_state
-    assert_equal 'parked', @vehicle.state
-  end
-
-  def test_should_raise_exception_if_checking_invalid_state
-    assert_raises(IndexError) { @vehicle.state?(:invalid) }
-  end
-
-  def test_should_raise_exception_if_getting_name_of_invalid_state
-    @vehicle.state = 'invalid'
-    assert_raises(ArgumentError) { @vehicle.state_name }
-  end
-
-  def test_should_be_parked
-    assert @vehicle.parked?
-    assert @vehicle.state?(:parked)
-    assert_equal :parked, @vehicle.state_name
-    assert_equal 'parked', @vehicle.human_state_name
-  end
-
-  def test_should_not_be_idling
-    refute @vehicle.idling?
-  end
-
-  def test_should_not_be_first_gear
-    refute @vehicle.first_gear?
-  end
-
-  def test_should_not_be_second_gear
-    refute @vehicle.second_gear?
-  end
-
-  def test_should_not_be_stalled
-    refute @vehicle.stalled?
-  end
-
-  def test_should_not_be_able_to_park
-    refute @vehicle.can_park?
-  end
-
-  def test_should_not_have_a_transition_for_park
-    assert_nil @vehicle.park_transition
-  end
-
-  def test_should_not_allow_park
-    refute @vehicle.park
-  end
-
-  def test_should_be_able_to_ignite
-    assert @vehicle.can_ignite?
-  end
-
-  def test_should_have_a_transition_for_ignite
-    transition = @vehicle.ignite_transition
-    refute_nil transition
-    assert_equal 'parked', transition.from
-    assert_equal 'idling', transition.to
-    assert_equal :ignite, transition.event
-    assert_equal :state, transition.attribute
-    assert_equal @vehicle, transition.object
-  end
-
-  def test_should_have_a_list_of_possible_events
-    assert_equal [:ignite], @vehicle.state_events
-  end
-
-  def test_should_have_a_list_of_possible_transitions
-    assert_equal [{ object: @vehicle, attribute: :state, event: :ignite, from: 'parked', to: 'idling' }], @vehicle.state_transitions.map { |transition| transition.attributes }
-  end
-
-  def test_should_have_a_list_of_possible_paths
-    assert_equal [[
-      StateMachines::Transition.new(@vehicle, Vehicle.state_machine, :ignite, :parked, :idling),
-      StateMachines::Transition.new(@vehicle, Vehicle.state_machine, :shift_up, :idling, :first_gear)
-    ]], @vehicle.state_paths(to: :first_gear)
-  end
-
-  def test_should_allow_generic_event_to_fire
-    assert @vehicle.fire_state_event(:ignite)
-    assert_equal 'idling', @vehicle.state
-  end
-
-  def test_should_pass_arguments_through_to_generic_event_runner
-    @vehicle.fire_state_event(:ignite, 1, 2, 3)
-    assert_equal [1, 2, 3], @vehicle.last_transition_args
-  end
-
-  def test_should_allow_skipping_action_through_generic_event_runner
-    @vehicle.fire_state_event(:ignite, false)
-    assert_equal false, @vehicle.saved
-  end
-
-  def test_should_raise_error_with_invalid_event_through_generic_event_runer
-    assert_raises(IndexError) { @vehicle.fire_state_event(:invalid) }
-  end
-
-  def test_should_allow_ignite
-    assert @vehicle.ignite
-    assert_equal 'idling', @vehicle.state
-  end
-
-  def test_should_allow_ignite_with_skipped_action
-    assert @vehicle.ignite(false)
-    assert @vehicle.new_record?
-  end
-
-  def test_should_allow_ignite_bang
-    assert @vehicle.ignite!
-  end
-
-  def test_should_allow_ignite_bang_with_skipped_action
-    assert @vehicle.ignite!(false)
-    assert @vehicle.new_record?
-  end
-
-  def test_should_be_saved_after_successful_event
-    @vehicle.ignite
-    refute @vehicle.new_record?
-  end
-
-  def test_should_not_allow_idle
-    refute @vehicle.idle
-  end
-
-  def test_should_not_allow_shift_up
-    refute @vehicle.shift_up
-  end
-
-  def test_should_not_allow_shift_down
-    refute @vehicle.shift_down
-  end
-
-  def test_should_not_allow_crash
-    refute @vehicle.crash
-  end
-
-  def test_should_not_allow_repair
-    refute @vehicle.repair
-  end
-
-  def test_should_be_insurance_inactive
-    assert @vehicle.insurance_inactive?
-  end
-
-  def test_should_be_able_to_buy
-    assert @vehicle.can_buy_insurance?
-  end
-
-  def test_should_allow_buying_insurance
-    assert @vehicle.buy_insurance
-  end
-
-  def test_should_allow_buying_insurance_bang
-    assert @vehicle.buy_insurance!
-  end
-
-  def test_should_allow_ignite_buying_insurance_with_skipped_action
-    assert @vehicle.buy_insurance!(false)
-    assert @vehicle.new_record?
-  end
-
-  def test_should_not_be_insurance_active
-    refute @vehicle.insurance_active?
-  end
-
-  def test_should_not_be_able_to_cancel
-    refute @vehicle.can_cancel_insurance?
-  end
-
-  def test_should_not_allow_cancelling_insurance
-    refute @vehicle.cancel_insurance
-  end
-end

data/test/functional/vehicle_with_event_attributes_test.rb

@@ -1,30 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleWithEventAttributesTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-    @vehicle.state_event = 'ignite'
-  end
-
-  def test_should_fail_if_event_is_invalid
-    @vehicle.state_event = 'invalid'
-    refute @vehicle.save
-    assert_equal 'parked', @vehicle.state
-  end
-
-  def test_should_fail_if_event_has_no_transition
-    @vehicle.state_event = 'park'
-    refute @vehicle.save
-    assert_equal 'parked', @vehicle.state
-  end
-
-  def test_should_return_original_action_value_on_success
-    assert_equal @vehicle, @vehicle.save
-  end
-
-  def test_should_transition_state_on_success
-    @vehicle.save
-    assert_equal 'idling', @vehicle.state
-  end
-end

data/test/functional/vehicle_with_parallel_events_test.rb

@@ -1,36 +0,0 @@
-require_relative '../test_helper'
-require_relative '../files/models/vehicle'
-
-class VehicleWithParallelEventsTest < MiniTest::Test
-  def setup
-    @vehicle = Vehicle.new
-  end
-
-  def test_should_fail_if_any_event_cannot_transition
-    refute @vehicle.fire_events(:ignite, :cancel_insurance)
-  end
-
-  def test_should_be_successful_if_all_events_transition
-    assert @vehicle.fire_events(:ignite, :buy_insurance)
-  end
-
-  def test_should_not_save_if_skipping_action
-    assert @vehicle.fire_events(:ignite, :buy_insurance, false)
-    refute @vehicle.saved
-  end
-
-  def test_should_raise_exception_if_any_event_cannot_transition_on_bang
-    exception = assert_raises(StateMachines::InvalidParallelTransition) { @vehicle.fire_events!(:ignite, :cancel_insurance) }
-    assert_equal @vehicle, exception.object
-    assert_equal [:ignite, :cancel_insurance], exception.events
-  end
-
-  def test_should_not_raise_exception_if_all_events_transition_on_bang
-    assert @vehicle.fire_events!(:ignite, :buy_insurance)
-  end
-
-  def test_should_not_save_if_skipping_action_on_bang
-    assert @vehicle.fire_events!(:ignite, :buy_insurance, false)
-    refute @vehicle.saved
-  end
-end

data/test/test_helper.rb

@@ -1,15 +0,0 @@
-require 'state_machines'
-require 'minitest/autorun'
-begin
-  require 'pry-byebug'
-rescue LoadError
-end
-require 'minitest/reporters'
-Minitest::Reporters.use! [Minitest::Reporters::ProgressReporter.new]
-
-class StateMachinesTest < MiniTest::Test
-  def before_setup
-    super
-    StateMachines::Integrations.reset
-  end
-end

data/test/unit/assertions/assert_exclusive_keys_test.rb

@@ -1,22 +0,0 @@
-require_relative '../../test_helper'
-
-class AssertExclusiveKeysTest < StateMachinesTest
-  def test_should_not_raise_exception_if_no_keys_found
-    { on: :park }.assert_exclusive_keys(:only, :except)
-  end
-
-  def test_should_not_raise_exception_if_one_key_found
-    { only: :parked }.assert_exclusive_keys(:only, :except)
-    { except: :parked }.assert_exclusive_keys(:only, :except)
-  end
-
-  def test_should_raise_exception_if_two_keys_found
-    exception = assert_raises(ArgumentError) { { only: :parked, except: :parked }.assert_exclusive_keys(:only, :except) }
-    assert_equal 'Conflicting keys: only, except', exception.message
-  end
-
-  def test_should_raise_exception_if_multiple_keys_found
-    exception = assert_raises(ArgumentError) { { only: :parked, except: :parked, on: :park }.assert_exclusive_keys(:only, :except, :with) }
-    assert_equal 'Conflicting keys: only, except', exception.message
-  end
-end

data/test/unit/assertions/assert_valid_key_test.rb

@@ -1,12 +0,0 @@
-require_relative '../../test_helper'
-
-class AssertValidKeysTest < StateMachinesTest
-  def test_should_not_raise_exception_if_key_is_valid
-    { name: 'foo', value: 'bar' }.assert_valid_keys(:name, :value, :force)
-  end
-
-  def test_should_raise_exception_if_key_is_invalid
-    exception = assert_raises(ArgumentError) { { name: 'foo', value: 'bar', invalid: true }.assert_valid_keys(:name, :value, :force) }
-    assert_equal 'Unknown key: :invalid. Valid keys are: :name, :value, :force', exception.message
-  end
-end

data/test/unit/branch/branch_test.rb

@@ -1,28 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchTest < StateMachinesTest
-  def setup
-    @branch = StateMachines::Branch.new(from: :parked, to: :idling)
-  end
-
-  def test_should_not_raise_exception_if_implicit_option_specified
-    StateMachines::Branch.new(invalid: :valid)
-  end
-
-  def test_should_not_have_an_if_condition
-    assert_nil @branch.if_condition
-  end
-
-  def test_should_not_have_an_unless_condition
-    assert_nil @branch.unless_condition
-  end
-
-  def test_should_have_a_state_requirement
-    assert_equal 1, @branch.state_requirements.length
-  end
-
-  def test_should_raise_an_exception_if_invalid_match_option_specified
-    exception = assert_raises(ArgumentError) { @branch.match(Object.new, invalid: true) }
-    assert_equal 'Unknown key: :invalid. Valid keys are: :from, :to, :on, :guard', exception.message
-  end
-end

data/test/unit/branch/branch_with_conflicting_conditionals_test.rb

@@ -1,27 +0,0 @@
-require_relative '../../test_helper'
-
-class BranchWithConflictingConditionalsTest < StateMachinesTest
-  def setup
-    @object = Object.new
-  end
-
-  def test_should_match_if_if_is_true_and_unless_is_false
-    branch = StateMachines::Branch.new(if: lambda { true }, unless: lambda { false })
-    assert branch.match(@object)
-  end
-
-  def test_should_not_match_if_if_is_false_and_unless_is_true
-    branch = StateMachines::Branch.new(if: lambda { false }, unless: lambda { true })
-    refute branch.match(@object)
-  end
-
-  def test_should_not_match_if_if_is_false_and_unless_is_false
-    branch = StateMachines::Branch.new(if: lambda { false }, unless: lambda { false })
-    refute branch.match(@object)
-  end
-
-  def test_should_not_match_if_if_is_true_and_unless_is_true
-    branch = StateMachines::Branch.new(if: lambda { true }, unless: lambda { true })
-    refute branch.match(@object)
-  end
-end