Axe AM state machine

We're going do it eventually, get it done before 3.0 is final.

5 files changed, 0 insertions, 560 deletions

diff --git a/activemodel/test/cases/state_machine/event_test.rb b/activemodel/test/cases/state_machine/event_test.rb
deleted file mode 100644
index 2a0ef53a3f..0000000000
--- a/activemodel/test/cases/state_machine/event_test.rb
+++ /dev/null
@@ -1,49 +0,0 @@
-require 'cases/helper'
-
-class EventTest < ActiveModel::TestCase
-  def setup
-    @state_name = :close_order
-    @success = :success_callback
-  end
-
-  def new_event
-    @event = ActiveModel::StateMachine::Event.new(nil, @state_name, {:success => @success}) do
-      transitions :to => :closed, :from => [:open, :received]
-    end
-  end
-
-  test 'should set the name' do
-    assert_equal @state_name, new_event.name
-  end
-
-  test 'should set the success option' do
-    assert_equal @success, new_event.success
-  end
-
-  test 'should create StateTransitions' do
-    ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :open)
-    ActiveModel::StateMachine::StateTransition.expects(:new).with(:to => :closed, :from => :received)
-    new_event
-  end
-end
-
-class EventBeingFiredTest < ActiveModel::TestCase
-  test 'should raise an AASM::InvalidTransition error if the transitions are empty' do
-    event = ActiveModel::StateMachine::Event.new(nil, :event)
-
-    assert_raise ActiveModel::StateMachine::InvalidTransition do
-      event.fire(nil)
-    end
-  end
-
-  test 'should return the state of the first matching transition it finds' do
-    event = ActiveModel::StateMachine::Event.new(nil, :event) do
-      transitions :to => :closed, :from => [:open, :received]
-    end
-
-    obj = stub
-    obj.stubs(:current_state).returns(:open)
-
-    assert_equal :closed, event.fire(obj)
-  end
-end
diff --git a/activemodel/test/cases/state_machine/machine_test.rb b/activemodel/test/cases/state_machine/machine_test.rb
deleted file mode 100644
index 2aa954d80c..0000000000
--- a/activemodel/test/cases/state_machine/machine_test.rb
+++ /dev/null
@@ -1,43 +0,0 @@
-require 'cases/helper'
-
-class MachineTestSubject
-  include ActiveModel::StateMachine
-
-  state_machine do
-    state :open
-    state :closed
-  end
-
-  state_machine :initial => :foo do
-    event :shutdown do
-      transitions :from => :open, :to => :closed
-    end
-
-    event :timeout do
-      transitions :from => :open, :to => :closed
-    end
-  end
-
-  state_machine :extra, :initial => :bar do
-  end
-end
-
-class StateMachineMachineTest < ActiveModel::TestCase
-  test "allows reuse of existing machines" do
-    assert_equal 2, MachineTestSubject.state_machines.size
-  end
-
-  test "sets #initial_state from :initial option" do
-    assert_equal :bar, MachineTestSubject.state_machine(:extra).initial_state
-  end
-
-  test "accesses non-default state machine" do
-    assert_kind_of ActiveModel::StateMachine::Machine, MachineTestSubject.state_machine(:extra)
-  end
-
-  test "finds events for given state" do
-    events = MachineTestSubject.state_machine.events_for(:open)
-    assert events.include?(:shutdown)
-    assert events.include?(:timeout)
-  end
-end
diff --git a/activemodel/test/cases/state_machine/state_test.rb b/activemodel/test/cases/state_machine/state_test.rb
deleted file mode 100644
index 527bfd4c04..0000000000
--- a/activemodel/test/cases/state_machine/state_test.rb
+++ /dev/null
@@ -1,72 +0,0 @@
-require 'cases/helper'
-
-class StateTestSubject
-  include ActiveModel::StateMachine
-
-  state_machine do
-  end
-end
-
-class StateTest < ActiveModel::TestCase
-  def setup
-    @state_name = :astate
-    @machine = StateTestSubject.state_machine
-    @options = { :crazy_custom_key => 'key', :machine => @machine }
-  end
-
-  def new_state(options={})
-    ActiveModel::StateMachine::State.new(@state_name, @options.merge(options))
-  end
-
-  test 'sets the name' do
-    assert_equal :astate, new_state.name
-  end
-
-  test 'sets the display_name from name' do
-    assert_equal "Astate", new_state.display_name
-  end
-
-  test 'sets the display_name from options' do
-    assert_equal "A State", new_state(:display => "A State").display_name
-  end
-  
-  test 'sets the options and expose them as options' do
-    @options.delete(:machine)
-    assert_equal @options, new_state.options
-  end
-
-  test 'equals a symbol of the same name' do
-    assert_equal new_state, :astate
-  end
-
-  test 'equals a State of the same name' do
-    assert_equal new_state, new_state
-  end
-
-  test 'should send a message to the record for an action if the action is present as a symbol' do
-    state = new_state(: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 = new_state(: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 = new_state(:entering => Proc.new {|r| r.foobar})
-
-    record = stub
-    record.expects(:foobar)
-  
-    state.call_action(:entering, record)
-  end
-end
diff --git a/activemodel/test/cases/state_machine/state_transition_test.rb b/activemodel/test/cases/state_machine/state_transition_test.rb
deleted file mode 100644
index 17f9d88be7..0000000000
--- a/activemodel/test/cases/state_machine/state_transition_test.rb
+++ /dev/null
@@ -1,84 +0,0 @@
-require 'cases/helper'
-
-class StateTransitionTest < ActiveModel::TestCase
-  test 'should set from, to, and opts attr readers' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = ActiveModel::StateMachine::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 = ActiveModel::StateMachine::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 = ActiveModel::StateMachine::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 = ActiveModel::StateMachine::StateTransition.new(opts)
-
-    obj = stub
-    obj.stubs(:from).returns(opts[:from])
-    obj.stubs(:to).returns('blah')
-
-    assert_not_equal st, obj
-  end
-end
-
-class StateTransitionGuardCheckTest < ActiveModel::TestCase
-  test 'should return true of there is no guard' do
-    opts = {:from => 'foo', :to => 'bar'}
-      st = ActiveModel::StateMachine::StateTransition.new(opts)
-
-    assert st.perform(nil)
-  end
-
-  test 'should call the method on the object if guard is a symbol' do
-    opts = {:from => 'foo', :to => 'bar', :guard => :test_guard}
-    st = ActiveModel::StateMachine::StateTransition.new(opts)
-  
-    obj = stub
-    obj.expects(:test_guard)
-    
-    st.perform(obj)
-  end
-  
-  test 'should call the method on the object if guard is a string' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'test_guard'}
-    st = ActiveModel::StateMachine::StateTransition.new(opts)
-  
-    obj = stub
-    obj.expects(:test_guard)
-    
-    st.perform(obj)
-  end
-  
-  test 'should call the proc passing the object if the guard is a proc' do
-    opts = {:from => 'foo', :to => 'bar', :guard => Proc.new {|o| o.test_guard}}
-    st = ActiveModel::StateMachine::StateTransition.new(opts)
-  
-    obj = stub
-    obj.expects(:test_guard)
-  
-    st.perform(obj)
-  end
-end
diff --git a/activemodel/test/cases/state_machine_test.rb b/activemodel/test/cases/state_machine_test.rb
deleted file mode 100644
index f66299741e..0000000000
--- a/activemodel/test/cases/state_machine_test.rb
+++ /dev/null
@@ -1,312 +0,0 @@
-require 'cases/helper'
-
-class StateMachineSubject
-  include ActiveModel::StateMachine
-
-  state_machine do
-    state :open,   :exit => :exit
-    state :closed, :enter => :enter
-    
-    event :close, :success => :success_callback do
-      transitions :to => :closed, :from => [:open]
-    end
-
-    event :null do
-      transitions :to => :closed, :from => [:open], :guard => :always_false
-    end
-  end
-
-  state_machine :bar do
-    state :read
-    state :ended
-
-    event :foo do
-      transitions :to => :ended, :from => [:read]
-    end
-  end
-
-  def always_false
-    false
-  end
- 
-  def success_callback
-  end
- 
-  def enter
-  end
-  def exit
-  end
-end
-
-class StateMachineSubjectSubclass < StateMachineSubject
-end
-
-class StateMachineClassLevelTest < ActiveModel::TestCase
-  test 'defines a class level #state_machine method on its including class' do
-    assert StateMachineSubject.respond_to?(:state_machine)
-  end
-
-  test 'defines a class level #state_machines method on its including class' do
-    assert StateMachineSubject.respond_to?(:state_machines)
-  end
-
-  test 'class level #state_machine returns machine instance' do
-    assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machine
-  end
-
-  test 'class level #state_machine returns machine instance with given name' do
-    assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machine(:default)
-  end
-
-  test 'class level #state_machines returns hash of machine instances' do
-    assert_kind_of ActiveModel::StateMachine::Machine, StateMachineSubject.state_machines[:default]
-  end
-
-  test "should return a select friendly array of states in the form of [['Friendly name', 'state_name']]" do
-    assert_equal [['Open', 'open'], ['Closed', 'closed']], StateMachineSubject.state_machine.states_for_select
-  end
-end
-
-class StateMachineInstanceLevelTest < ActiveModel::TestCase
-  def setup
-    @foo = StateMachineSubject.new
-  end
- 
-  test 'defines an accessor for the current state' do
-    assert @foo.respond_to?(:current_state)
-  end
- 
-  test 'defines a state querying instance method on including class' do
-    assert @foo.respond_to?(:open?)
-  end
- 
-  test 'defines an event! instance method' do
-    assert @foo.respond_to?(:close!)
-  end
- 
-  test 'defines an event instance method' do
-    assert @foo.respond_to?(:close)
-  end
-end
- 
-class StateMachineInitialStatesTest < ActiveModel::TestCase
-  def setup
-    @foo = StateMachineSubject.new
-  end
- 
-  test 'sets the initial state' do
-    assert_equal :open, @foo.current_state
-  end
- 
-  test '#open? should be initially true' do
-    assert @foo.open?
-  end
-  
-  test '#closed? should be initially false' do
-    assert !@foo.closed?
-  end
- 
-  test 'uses the first state defined if no initial state is given' do
-    assert_equal :read, @foo.current_state(:bar)
-  end
-end
- 
-class StateMachineEventFiringWithPersistenceTest < ActiveModel::TestCase
-  def setup
-    @subj = StateMachineSubject.new
-  end
-
-  test 'updates the current state' do
-    @subj.close!
-
-    assert_equal :closed, @subj.current_state
-  end
-
-  test 'fires the Event' do
-    @subj.class.state_machine.events[:close].expects(:fire).with(@subj)
-    @subj.close!
-  end
-
-  test 'calls the success callback if one was provided' do
-    @subj.expects(:success_callback)
-    @subj.close!
-  end
-
-  test 'attempts to persist if write_state is defined' do
-    def @subj.write_state
-    end
-
-    @subj.expects(:write_state)
-    @subj.close!
-  end
-end
-
-class StateMachineEventFiringWithoutPersistence < ActiveModel::TestCase
-  test 'updates the current state' do
-    subj = StateMachineSubject.new
-    assert_equal :open, subj.current_state
-    subj.close
-    assert_equal :closed, subj.current_state
-  end
-
-  test 'fires the Event' do
-    subj = StateMachineSubject.new
-
-    StateMachineSubject.state_machine.events[:close].expects(:fire).with(subj)
-    subj.close
-  end
-
-  test 'attempts to persist if write_state is defined' do
-    subj = StateMachineSubject.new
-
-    def subj.write_state
-    end
-
-    subj.expects(:write_state_without_persistence)
-
-    subj.close
-  end
-end
-
-class StateMachinePersistenceTest < ActiveModel::TestCase
-  test 'reads the state if it has not been set and read_state is defined' do
-    subj = StateMachineSubject.new
-    def subj.read_state
-    end
-
-    subj.expects(:read_state).with(StateMachineSubject.state_machine)
-
-    subj.current_state
-  end
-end
-
-class StateMachineEventCallbacksTest < ActiveModel::TestCase
-  test 'should call aasm_event_fired if defined and successful for bang fire' do
-    subj = StateMachineSubject.new
-    def subj.aasm_event_fired(from, to)
-    end
-
-    subj.expects(:event_fired)
-
-    subj.close!
-  end
-
-  test 'should call aasm_event_fired if defined and successful for non-bang fire' do
-    subj = StateMachineSubject.new
-    def subj.aasm_event_fired(from, to)
-    end
-
-    subj.expects(:event_fired)
-
-    subj.close
-  end
-
-  test 'should call aasm_event_failed if defined and transition failed for bang fire' do
-    subj = StateMachineSubject.new
-    def subj.event_failed(event)
-    end
-
-    subj.expects(:event_failed)
-
-    subj.null!
-  end
-
-  test 'should call aasm_event_failed if defined and transition failed for non-bang fire' do
-    subj = StateMachineSubject.new
-    def subj.aasm_event_failed(event)
-    end
-
-    subj.expects(:event_failed)
-
-    subj.null
-  end
-end
-
-class StateMachineStateActionsTest < ActiveModel::TestCase
-  test "calls enter when entering state" do
-    subj = StateMachineSubject.new
-    subj.expects(:enter)
-    subj.close
-  end
-
-  test "calls exit when exiting state" do
-    subj = StateMachineSubject.new
-    subj.expects(:exit)
-    subj.close
-  end
-end
-
-class StateMachineInheritanceTest < ActiveModel::TestCase
-  test "has the same states as its parent" do
-    assert_equal StateMachineSubject.state_machine.states, StateMachineSubjectSubclass.state_machine.states
-  end
- 
-  test "has the same events as its parent" do
-    assert_equal StateMachineSubject.state_machine.events, StateMachineSubjectSubclass.state_machine.events
-  end
-end
-
-class StateMachineSubject
-  state_machine :chetan_patil, :initial => :sleeping do
-    state :sleeping
-    state :showering
-    state :working
-    state :dating
- 
-    event :wakeup do
-      transitions :from => :sleeping, :to => [:showering, :working]
-    end
- 
-    event :dress do
-      transitions :from => :sleeping, :to => :working, :on_transition => :wear_clothes
-      transitions :from => :showering, :to => [:working, :dating], :on_transition => Proc.new { |obj, *args| obj.wear_clothes(*args) }
-    end
-  end
- 
-  def wear_clothes(shirt_color, trouser_type)
-  end
-end
-
-class StateMachineWithComplexTransitionsTest < ActiveModel::TestCase
-  def setup
-    @subj = StateMachineSubject.new
-  end
-
-  test 'transitions to specified next state (sleeping to showering)' do
-    @subj.wakeup! :showering
-    
-    assert_equal :showering, @subj.current_state(:chetan_patil)
-  end
- 
-  test 'transitions to specified next state (sleeping to working)' do
-    @subj.wakeup! :working
- 
-    assert_equal :working, @subj.current_state(:chetan_patil)
-  end
- 
-  test 'transitions to default (first or showering) state' do
-    @subj.wakeup!
- 
-    assert_equal :showering, @subj.current_state(:chetan_patil)
-  end
- 
-  test 'transitions to default state when on_transition invoked' do
-    @subj.dress!(nil, 'purple', 'dressy')
- 
-    assert_equal :working, @subj.current_state(:chetan_patil)
-  end
-
-  test 'calls on_transition method with args' do
-    @subj.wakeup! :showering
-
-    @subj.expects(:wear_clothes).with('blue', 'jeans')
-    @subj.dress! :working, 'blue', 'jeans'
-  end
-
-  test 'calls on_transition proc' do
-    @subj.wakeup! :showering
-
-    @subj.expects(:wear_clothes).with('purple', 'slacks')
-    @subj.dress!(:dating, 'purple', 'slacks')
-  end
-end