diff options
author | rick <technoweenie@gmail.com> | 2008-06-28 00:55:02 -0700 |
---|---|---|
committer | rick <technoweenie@gmail.com> | 2008-06-28 00:55:02 -0700 |
commit | b9528ad3c5379896b00772cb44faf1db0fd882d7 (patch) | |
tree | 422ae423e519f744d51698d45a6fb931172b9cb2 /activemodel/test/state_machine_test.rb | |
parent | b7c6ceff9a31cc478c4bc89d57980900a775fbed (diff) | |
download | rails-b9528ad3c5379896b00772cb44faf1db0fd882d7.tar.gz rails-b9528ad3c5379896b00772cb44faf1db0fd882d7.tar.bz2 rails-b9528ad3c5379896b00772cb44faf1db0fd882d7.zip |
initial statemachine machine and state classes
Diffstat (limited to 'activemodel/test/state_machine_test.rb')
-rw-r--r-- | activemodel/test/state_machine_test.rb | 335 |
1 files changed, 335 insertions, 0 deletions
diff --git a/activemodel/test/state_machine_test.rb b/activemodel/test/state_machine_test.rb new file mode 100644 index 0000000000..e906744c77 --- /dev/null +++ b/activemodel/test/state_machine_test.rb @@ -0,0 +1,335 @@ +require File.expand_path(File.join(File.dirname(__FILE__), 'test_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 'should define an event! inance method' do + # assert @foo.respond_to?(:close!) + #end +end + +class StateMachineInitialStatesTest < ActiveModel::TestCase + def setup + @foo = StateMachineSubject.new + end + + test 'should set the initial state' do + assert_equal :open, @foo.current_state + end + + #test '#open? should be initially true' do + # @foo.open?.should be_true + #end + # + #test '#closed? should be initially false' do + # @foo.closed?.should be_false + #end + + test 'should use the first state defined if no initial state is given' do + assert_equal :read, @foo.current_state(:bar) + end +end +# +#describe AASM, '- event firing with persistence' do +# it 'should fire the Event' do +# foo = Foo.new +# +# Foo.aasm_events[:close].should_receive(:fire).with(foo) +# foo.close! +# end +# +# it 'should update the current state' do +# foo = Foo.new +# foo.close! +# +# foo.aasm_current_state.should == :closed +# end +# +# it 'should call the success callback if one was provided' do +# foo = Foo.new +# +# foo.should_receive(:success_callback) +# +# foo.close! +# end +# +# it 'should attempt to persist if aasm_write_state is defined' do +# foo = Foo.new +# +# def foo.aasm_write_state +# end +# +# foo.should_receive(:aasm_write_state) +# +# foo.close! +# end +#end +# +#describe AASM, '- event firing without persistence' do +# it 'should fire the Event' do +# foo = Foo.new +# +# Foo.aasm_events[:close].should_receive(:fire).with(foo) +# foo.close +# end +# +# it 'should update the current state' do +# foo = Foo.new +# foo.close +# +# foo.aasm_current_state.should == :closed +# end +# +# it 'should attempt to persist if aasm_write_state is defined' do +# foo = Foo.new +# +# def foo.aasm_write_state +# end +# +# foo.should_receive(:aasm_write_state_without_persistence) +# +# foo.close +# end +#end +# +#describe AASM, '- persistence' do +# it 'should read the state if it has not been set and aasm_read_state is defined' do +# foo = Foo.new +# def foo.aasm_read_state +# end +# +# foo.should_receive(:aasm_read_state) +# +# foo.aasm_current_state +# end +#end +# +#describe AASM, '- getting events for a state' do +# it '#aasm_events_for_current_state should use current state' do +# foo = Foo.new +# foo.should_receive(:aasm_current_state) +# foo.aasm_events_for_current_state +# end +# +# it '#aasm_events_for_current_state should use aasm_events_for_state' do +# foo = Foo.new +# foo.stub!(:aasm_current_state).and_return(:foo) +# foo.should_receive(:aasm_events_for_state).with(:foo) +# foo.aasm_events_for_current_state +# end +#end +# +#describe AASM, '- event callbacks' do +# it 'should call aasm_event_fired if defined and successful for bang fire' do +# foo = Foo.new +# def foo.aasm_event_fired(from, to) +# end +# +# foo.should_receive(:aasm_event_fired) +# +# foo.close! +# end +# +# it 'should call aasm_event_fired if defined and successful for non-bang fire' do +# foo = Foo.new +# def foo.aasm_event_fired(from, to) +# end +# +# foo.should_receive(:aasm_event_fired) +# +# foo.close +# end +# +# it 'should call aasm_event_failed if defined and transition failed for bang fire' do +# foo = Foo.new +# def foo.aasm_event_failed(event) +# end +# +# foo.should_receive(:aasm_event_failed) +# +# foo.null! +# end +# +# it 'should call aasm_event_failed if defined and transition failed for non-bang fire' do +# foo = Foo.new +# def foo.aasm_event_failed(event) +# end +# +# foo.should_receive(:aasm_event_failed) +# +# foo.null +# end +#end +# +#describe AASM, '- state actions' do +# it "should call enter when entering state" do +# foo = Foo.new +# foo.should_receive(:enter) +# +# foo.close +# end +# +# it "should call exit when exiting state" do +# foo = Foo.new +# foo.should_receive(:exit) +# +# foo.close +# end +#end +# +# +class StateMachineInheritanceTest < ActiveModel::TestCase + test "should have the same states as it's parent" do + assert_equal StateMachineSubject.state_machine.states, StateMachineSubjectSubclass.state_machine.states + end + + #test "should have the same events as it's parent" do + # StateMachineSubjectSubclass.aasm_events.should == Bar.aasm_events + #end +end +# +# +#class ChetanPatil +# include AASM +# aasm_initial_state :sleeping +# aasm_state :sleeping +# aasm_state :showering +# aasm_state :working +# aasm_state :dating +# +# aasm_event :wakeup do +# transitions :from => :sleeping, :to => [:showering, :working] +# end +# +# aasm_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 +# +# def wear_clothes(shirt_color, trouser_type) +# end +#end +# +# +#describe ChetanPatil do +# it 'should transition to specified next state (sleeping to showering)' do +# cp = ChetanPatil.new +# cp.wakeup! :showering +# +# cp.aasm_current_state.should == :showering +# end +# +# it 'should transition to specified next state (sleeping to working)' do +# cp = ChetanPatil.new +# cp.wakeup! :working +# +# cp.aasm_current_state.should == :working +# end +# +# it 'should transition to default (first or showering) state' do +# cp = ChetanPatil.new +# cp.wakeup! +# +# cp.aasm_current_state.should == :showering +# end +# +# it 'should transition to default state when on_transition invoked' do +# cp = ChetanPatil.new +# cp.dress!(nil, 'purple', 'dressy') +# +# cp.aasm_current_state.should == :working +# end +# +# it 'should call on_transition method with args' do +# cp = ChetanPatil.new +# cp.wakeup! :showering +# +# cp.should_receive(:wear_clothes).with('blue', 'jeans') +# cp.dress! :working, 'blue', 'jeans' +# end +# +# it 'should call on_transition proc' do +# cp = ChetanPatil.new +# cp.wakeup! :showering +# +# cp.should_receive(:wear_clothes).with('purple', 'slacks') +# cp.dress!(:dating, 'purple', 'slacks') +# end +#end
\ No newline at end of file |