transitions 1.0.0 → 1.0.1

data/test/machine/test_available_states_listing.rb

@@ -1,24 +0,0 @@
-require 'helper'
-
-class Bender
-  include Transitions
-
-  state_machine do
-    state :drinking
-    state :smoking
-    state :gambling
-
-    event :cough do
-      transitions from: :smoking, to: :gambling
-    end
-  end
-end
-
-class TestAvailableStatesListing < Test::Unit::TestCase
-  test 'available_states should return the states for the state machine' do
-    assert_equal [:drinking, :gambling, :smoking], Bender.available_states
-  end
-  test 'available_events should return the events for the state machine' do
-    assert_equal [:cough], Bender.available_events
-  end
-end

data/test/machine/test_fire_event_machine.rb

@@ -1,29 +0,0 @@
-require 'helper'
-require_relative './machine_template'
-
-class TestFireEventMachine < Test::Unit::TestCase
-  def setup
-    @record  = MachineTestSubject.new
-    @machine = MachineTestSubject.get_state_machine
-    @event   = @machine.events_for(@record.current_state).first
-    assert_not_nil @event
-  end
-
-  test 'fire_event returns true if state transition was successful' do
-    @machine.stubs(:transition_to_new_state).returns(:closed)
-
-    assert_equal true, @machine.fire_event(@event, @record, false)
-  end
-
-  test 'fire_event returns false if state transition was unsuccessful' do
-    @machine.stubs(:transition_to_new_state).returns(false)
-
-    assert_equal false, @machine.fire_event(@event, @record, false)
-  end
-
-  test 'fire_event returns false if state transition raises' do
-    @machine.stubs(:transition_to_new_state).raises(StandardError)
-
-    assert_equal false, @machine.fire_event(@event, @record, false)
-  end
-end

data/test/machine/test_machine.rb

@@ -1,66 +0,0 @@
-require 'helper'
-
-class MachineTestSubject
-  include Transitions
-
-  state_machine initial: :closed do
-    state :open
-    state :closed
-
-    event :shutdown do
-      transitions from: :open, to: :closed
-    end
-
-    event :timeout do
-      transitions from: :open, to: :closed
-    end
-
-    event :restart do
-      transitions from: :closed, to: :open, guard: :restart_allowed?
-    end
-  end
-
-  def restart_allowed?(allowed = true)
-    allowed
-  end
-end
-
-class TransitionsMachineTest < Test::Unit::TestCase
-  test 'sets #initial_state from :initial option' do
-    assert_equal :closed, MachineTestSubject.get_state_machine.initial_state
-  end
-
-  test '`get_state_machine` returns Transitions::Machine' do
-    assert_kind_of Transitions::Machine, MachineTestSubject.get_state_machine
-  end
-
-  test 'finds events for given state' do
-    events = MachineTestSubject.get_state_machine.events_for(:open)
-    assert events.include?(:shutdown)
-    assert events.include?(:timeout)
-  end
-
-  test 'knows all available transitions for current state' do
-    machine = MachineTestSubject.new
-    assert_equal [:restart], machine.available_transitions
-    machine.restart
-    assert_equal [:shutdown, :timeout], machine.available_transitions
-  end
-
-  test 'knows that it can use a transition when it is available' do
-    machine = MachineTestSubject.new
-    machine.restart
-    assert machine.can_transition?(:shutdown)
-  end
-
-  test "knows that it can't use a transition when it is unavailable" do
-    machine = MachineTestSubject.new
-    assert machine.cant_transition?(:shutdown)
-  end
-
-  test "knows that it can't transition to a state denied by a guard" do
-    machine = MachineTestSubject.new
-    assert machine.can_execute_restart? true
-    refute machine.can_execute_restart? false
-  end
-end

data/test/state/test_state.rb

@@ -1,71 +0,0 @@
-require 'helper'
-
-class TestState < Test::Unit::TestCase
-  def setup
-    machine = Class.new do
-      include Transitions
-      state_machine do
-      end
-    end.get_state_machine
-    state_name = :astate
-    @options = { machine: machine, custom_key: :my_key }
-    @state   = Transitions::State.new(state_name, @options)
-  end
-
-  def new_state_name
-    Random.alphanumeric(16)
-  end
-
-  test 'sets the name' do
-    assert_equal :astate, @state.name
-  end
-
-  test 'sets the display_name from name' do
-    assert_equal 'Astate', @state.display_name
-  end
-
-  test 'sets the display_name from options' do
-    assert_equal 'A State', Transitions::State.new(new_state_name, @options.merge(display: 'A State')).display_name
-  end
-
-  test 'sets the options and expose them as options' do
-    @options.delete(:machine)
-    state = Transitions::State.new new_state_name, @options
-    assert_equal @options, state.options
-  end
-
-  test 'equals a symbol of the same name' do
-    assert_equal @state, :astate
-  end
-
-  test 'equals a State of the same name' do
-    assert_equal @state, @state
-  end
-
-  test 'should send a message to the record for an action if the action is present as a symbol' do
-    state = Transitions::State.new new_state_name, @options.merge(entering: :foo)
-
-    record = stub
-    record.expects(:foo)
-
-    state.call_action(:entering, record)
-  end
-
-  test 'should send a message to the record for an action if the action is present as a string' do
-    state = Transitions::State.new new_state_name, @options.merge(entering: 'foo')
-
-    record = stub
-    record.expects(:foo)
-
-    state.call_action(:entering, record)
-  end
-
-  test 'should call a proc, passing in the record for an action if the action is present' do
-    state = Transitions::State.new new_state_name, @options.merge(entering: proc(&:foobar))
-
-    record = stub
-    record.expects(:foobar)
-
-    state.call_action(:entering, record)
-  end
-end

data/test/state/test_state_predicate_method.rb

@@ -1,32 +0,0 @@
-require 'helper'
-
-class Bus
-  include Transitions
-
-  state_machine do
-    state :parking
-  end
-end
-
-class TestStatePredicateMethod < Test::Unit::TestCase
-  def setup
-    @bus = Bus.new
-  end
-
-  test 'should generate predicate methods for states' do
-    assert_true @bus.respond_to?(:parking?)
-    assert_true @bus.send(:parking?)
-  end
-
-  test 'should raise `InvalidMethodOverride` if we try to overwrite existing methods' do
-    assert_raise(Transitions::InvalidMethodOverride) do
-      Class.new do
-        include Transitions
-
-        state_machine do
-          state :frozen
-        end
-      end
-    end
-  end
-end

data/test/state_transition/test_state_transition.rb

@@ -1,45 +0,0 @@
-require 'helper'
-
-class TestStateTransition < Test::Unit::TestCase
-  test 'should set from, to, and opts attr readers' do
-    opts = { from: 'foo', to: 'bar', guard: 'g' }
-    st = Transitions::StateTransition.new(opts)
-
-    assert_equal opts[:from], st.from
-    assert_equal opts[:to],   st.to
-    assert_equal opts,        st.options
-  end
-
-  test 'should pass equality check if from and to are the same' do
-    opts = { from: 'foo', to: 'bar', guard: 'g' }
-    st = Transitions::StateTransition.new(opts)
-
-    obj = stub
-    obj.stubs(:from).returns(opts[:from])
-    obj.stubs(:to).returns(opts[:to])
-
-    assert_equal st, obj
-  end
-
-  test 'should fail equality check if from are not the same' do
-    opts = { from: 'foo', to: 'bar', guard: 'g' }
-    st = Transitions::StateTransition.new(opts)
-
-    obj = stub
-    obj.stubs(:from).returns('blah')
-    obj.stubs(:to).returns(opts[:to])
-
-    assert_not_equal st, obj
-  end
-
-  test 'should fail equality check if to are not the same' do
-    opts = { from: 'foo', to: 'bar', guard: 'g' }
-    st = Transitions::StateTransition.new(opts)
-
-    obj = stub
-    obj.stubs(:from).returns(opts[:from])
-    obj.stubs(:to).returns('blah')
-
-    assert_not_equal st, obj
-  end
-end

data/test/state_transition/test_state_transition_event_failed_callback.rb

@@ -1,36 +0,0 @@
-require 'helper'
-
-class Car
-  include Transitions
-
-  state_machine do
-    state :parked
-    state :driving
-    state :switched_off
-
-    event :start_driving do
-      transitions from: :parked, to: :driving
-    end
-
-    event :switch_off_engine do
-      transitions from: :parked, to: :switched_off
-    end
-  end
-end
-
-class TestStateTransitionEventFailedCallback < Test::Unit::TestCase
-  def setup
-    @car = Car.new
-  end
-
-  test "should execute the event_failed_callback and don't raise error if callback is defined" do
-    @car.start_driving
-    @car.expects(:event_failed).with(:switch_off_engine)
-    @car.switch_off_engine
-  end
-
-  test "should just re-raise any error on transition if the event_failed_callback isn't defined" do
-    @car.start_driving
-    assert_raise(Transitions::InvalidTransition) { @car.switch_off_engine }
-  end
-end

data/test/state_transition/test_state_transition_event_fired_callback.rb

@@ -1,44 +0,0 @@
-require 'helper'
-
-class Car
-  include Transitions
-
-  state_machine do
-    state :parked
-    state :driving
-
-    event :start_driving do
-      transitions from: :parked, to: :driving
-    end
-  end
-end
-
-class TestStateTransitionEventFiredCallback < Test::Unit::TestCase
-  def setup
-    @car = Car.new
-  end
-
-  test 'should execute the event_fired callback after successfull event execution if it callback is defined' do
-    @car.stubs(:event_fired)
-    @car.expects(:event_fired).with(:parked, :driving, :start_driving).once
-
-    @car.start_driving!
-  end
-
-  test 'should not execute the event_fired callback after successfull event execution if it callback is not defined' do
-    pend 'Test fails right now although functionality is working as expected'
-    # This test fails right now even though it works as expected in the console.
-    # The reason for this is, that mocha's `expects` does a little bit more than just set up an expectation,
-    # it actually defines this method if it doesn't exist or at least it overwrites respond_to?
-    #   @car.respond_to?(:event_fired)
-    # returns false before the `expects` call, but true after.
-    # Hence, this test fails.
-    # Something like
-    #   @car.instance_eval { undef :event_fired }
-    # doesn't work either, probably because expects just overwrites respond_to?
-    # but does not define the method
-    # How to fix?
-    @car.expects(:event_fired).never
-    @car.start_driving!
-  end
-end

data/test/state_transition/test_state_transition_guard_check.rb

@@ -1,66 +0,0 @@
-require 'helper'
-
-class TestStateTransitionGuardCheck < Test::Unit::TestCase
-  args = [:foo, 'bar']
-
-  test 'should return true of there is no guard' do
-    opts = { from: 'foo', to: 'bar' }
-    st = Transitions::StateTransition.new(opts)
-
-    assert st.executable?(nil, *args)
-  end
-
-  test 'should call the method on the object if guard is a symbol' do
-    opts = { from: 'foo', to: 'bar', guard: :test_guard }
-    st = Transitions::StateTransition.new(opts)
-
-    obj = stub
-    obj.expects(:test_guard).with(*args)
-
-    st.executable?(obj, *args)
-  end
-
-  test 'should call the method on the object if guard is a string' do
-    opts = { from: 'foo', to: 'bar', guard: 'test_guard' }
-    st = Transitions::StateTransition.new(opts)
-
-    obj = stub
-    obj.expects(:test_guard).with(*args)
-
-    st.executable?(obj, *args)
-  end
-
-  test 'should call the proc passing the object if the guard is a proc' do
-    opts = { from: 'foo', to: 'bar', guard: proc { |o, *args| o.test_guard(*args) } }
-    st = Transitions::StateTransition.new(opts)
-
-    obj = stub
-    obj.expects(:test_guard).with(*args)
-
-    st.executable?(obj, *args)
-  end
-
-  test 'should call the callable passing the object if the guard responds to #call' do
-    callable = Object.new
-    callable.define_singleton_method(:call) { |obj, *args| obj.test_guard(*args) }
-
-    opts = { from: 'foo', to: 'bar', guard: callable }
-    st = Transitions::StateTransition.new(opts)
-
-    obj = stub
-    obj.expects(:test_guard).with(*args)
-
-    st.executable?(obj, *args)
-  end
-
-  test 'should call the method on the object if guard is a symbol' do
-    opts = { from: 'foo', to: 'bar', guard: [:test_guard, :test_another_guard] }
-    st = Transitions::StateTransition.new(opts)
-
-    obj = stub
-    obj.expects(:test_guard).with(*args).returns(true)
-    obj.expects(:test_another_guard).with(*args).returns(true)
-
-    assert st.executable?(obj, *args)
-  end
-end

data/test/state_transition/test_state_transition_on_transition_callback.rb

@@ -1,48 +0,0 @@
-require 'helper'
-
-class Truck
-  include Transitions
-  attr_reader :test_recorder
-
-  def initialize
-    @test_recorder = []
-  end
-
-  state_machine do
-    state :parked
-    state :running
-    state :driving
-
-    event :turn_key do
-      transitions from: :parked, to: :running, on_transition: :start_engine
-    end
-
-    event :start_driving do
-      transitions from: :parked, to: :driving, on_transition: [:start_engine, :loosen_handbrake, :push_gas_pedal]
-    end
-  end
-
-  %w(start_engine loosen_handbrake push_gas_pedal).each do |m|
-    define_method(m) { @test_recorder << m }
-  end
-end
-
-class TestStateTransitionCallbacks < Test::Unit::TestCase
-  test "should execute callback defined via 'on_transition'" do
-    truck = Truck.new
-    truck.expects(:start_engine)
-    truck.turn_key!
-  end
-
-  test "should execute multiple callbacks defined via 'on_transition' in the same order they were defined" do
-    # This test requires some explanation: We started out with something like this:
-    #   truck.expects(:start_engine).in_sequence(on_transition_sequence)
-    # Which, after a while (don't ask me why) caused some weird problems and seemed to fail randomly.
-    # Hence the workaround below.
-
-    truck = Truck.new
-
-    truck.start_driving!
-    assert_equal truck.test_recorder, [:start_engine, :loosen_handbrake, :push_gas_pedal].map(&:to_s)
-  end
-end