aasm 2.1.1 → 5.2.0

data/spec/unit/simple_multiple_example_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe 'state machine' do
+  let(:simple) { SimpleMultipleExample.new }
+
+  it 'starts with an initial state' do
+    expect(simple.aasm(:move).current_state).to eq(:standing)
+    expect(simple).to respond_to(:standing?)
+    expect(simple).to be_standing
+
+    expect(simple.aasm(:work).current_state).to eq(:sleeping)
+    expect(simple).to respond_to(:sleeping?)
+    expect(simple).to be_sleeping
+  end
+
+  it 'allows transitions to other states' do
+    expect(simple).to respond_to(:walk)
+    expect(simple).to respond_to(:walk!)
+    simple.walk!
+    expect(simple).to respond_to(:walking?)
+    expect(simple).to be_walking
+
+    expect(simple).to respond_to(:run)
+    expect(simple).to respond_to(:run!)
+    simple.run
+    expect(simple).to respond_to(:running?)
+    expect(simple).to be_running
+
+    expect(simple).to respond_to(:start)
+    expect(simple).to respond_to(:start!)
+    simple.start
+    expect(simple).to respond_to(:processing?)
+    expect(simple).to be_processing
+  end
+
+  it 'denies transitions to other states' do
+    expect {simple.hold}.to raise_error(AASM::InvalidTransition)
+    expect {simple.hold!}.to raise_error(AASM::InvalidTransition)
+    simple.walk
+    expect {simple.walk}.to raise_error(AASM::InvalidTransition)
+    expect {simple.walk!}.to raise_error(AASM::InvalidTransition)
+    simple.run
+    expect {simple.walk}.to raise_error(AASM::InvalidTransition)
+    expect {simple.walk!}.to raise_error(AASM::InvalidTransition)
+
+    expect {simple.stop}.to raise_error(AASM::InvalidTransition)
+    expect {simple.stop!}.to raise_error(AASM::InvalidTransition)
+    simple.start
+    expect {simple.start}.to raise_error(AASM::InvalidTransition)
+    expect {simple.start!}.to raise_error(AASM::InvalidTransition)
+    simple.stop
+  end
+
+  it 'defines constants for each state name' do
+    expect(SimpleMultipleExample::STATE_STANDING).to eq(:standing)
+    expect(SimpleMultipleExample::STATE_WALKING).to eq(:walking)
+    expect(SimpleMultipleExample::STATE_RUNNING).to eq(:running)
+
+    expect(SimpleMultipleExample::STATE_SLEEPING).to eq(:sleeping)
+    expect(SimpleMultipleExample::STATE_PROCESSING).to eq(:processing)
+    expect(SimpleMultipleExample::STATE_RUNNING).to eq(:running)
+  end
+
+  context 'triggers binding_events in bindind_state_machine' do
+    it 'does persist' do
+      expect(simple).to be_sleeping
+      expect(simple).to be_answered
+      expect(simple).to receive(:start!).and_call_original
+      simple.ask!
+      expect(simple).to be_asked
+      expect(simple).to be_processing
+      expect(simple).to receive(:stop!).and_call_original
+      simple.answer!
+      expect(simple).to be_sleeping
+      expect(simple).to be_answered
+    end
+
+    it 'does not persist' do
+      expect(simple).to be_sleeping
+      expect(simple).to be_answered
+      expect(simple).to receive(:start).and_call_original
+      simple.ask
+      expect(simple).to be_asked
+      expect(simple).to be_processing
+      expect(simple).to receive(:stop).and_call_original
+      simple.answer
+      expect(simple).to be_sleeping
+      expect(simple).to be_answered
+    end
+  end
+end

data/spec/unit/state_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe AASM::Core::State do
+  let(:state_machine) { AASM::StateMachine.new(:name) }
+
+  before(:each) do
+    @name    = :astate
+    @options = { :crazy_custom_key => 'key' }
+  end
+
+  def new_state(options={})
+    AASM::Core::State.new(@name, Conversation, state_machine, @options.merge(options))
+  end
+
+  it 'should set the name' do
+    state = new_state
+    expect(state.name).to eq(:astate)
+  end
+
+  describe '#display_name' do
+    subject(:display_name) { new_state(options).display_name }
+
+    context 'without options' do
+      let(:options) { {} }
+
+      context 'without I18n' do
+        before { allow(Module).to receive(:const_defined?).with(:I18n).and_return(nil) }
+
+        it 'should set the display_name from name' do
+          expect(display_name).to eq('Astate')
+        end
+      end
+    end
+
+    context 'with :display option' do
+      let(:options) { { display: "A State" } }
+
+      it 'should set the display_name from options' do
+        expect(display_name).to eq('A State')
+      end
+    end
+  end
+
+  it 'should set the options and expose them as options' do
+    expect(new_state.options).to eq(@options)
+  end
+
+  it 'should be equal to a symbol of the same name' do
+    expect(new_state).to eq(:astate)
+  end
+
+  it 'should be equal to a State of the same name' do
+    expect(new_state).to eq(new_state)
+  end
+
+  it '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 = double('record')
+    expect(record).to receive(:foo)
+
+    state.fire_callbacks(:entering, record)
+  end
+
+  it '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 = double('record')
+    expect(record).to receive(:foo)
+
+    state.fire_callbacks(:entering, record)
+  end
+
+  it 'should send a message to the record for each action' do
+    state = new_state(:entering => [:a, :b, "c", lambda {|r| r.foobar }])
+
+    record = double('record')
+    expect(record).to receive(:a)
+    expect(record).to receive(:b)
+    expect(record).to receive(:c)
+    expect(record).to receive(:foobar)
+
+    state.fire_callbacks(:entering, record, record)
+  end
+
+  it "should stop calling actions if one of them raises :halt_aasm_chain" do
+    state = new_state(:entering => [:a, :b, :c])
+
+    record = double('record')
+    expect(record).to receive(:a)
+    expect(record).to receive(:b).and_throw(:halt_aasm_chain)
+    expect(record).not_to receive(:c)
+
+    state.fire_callbacks(:entering, record)
+  end
+
+  it '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 = double('record')
+    expect(record).to receive(:foobar)
+
+    state.fire_callbacks(:entering, record, record)
+  end
+end

data/spec/unit/states_on_one_line_example_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe StatesOnOneLineExample do
+  let(:example) { StatesOnOneLineExample.new }
+  describe 'on initialize' do
+    it 'should be in the initial state' do
+      expect(example.aasm(:one_line).current_state).to eql :initial
+    end
+  end
+
+  describe 'states' do
+    it 'should have all 3 states defined' do
+      expect(example.aasm(:one_line).states.map(&:name)).to eq [:initial, :first, :second]
+    end
+  end
+end

data/spec/unit/subclassing_multiple_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+
+describe 'subclassing with multiple state machines' do
+
+  it 'should have the parent states' do
+    SuperClassMultiple.aasm(:left).states.each do |state|
+      expect(SubClassWithMoreStatesMultiple.aasm(:left).states).to include(state)
+    end
+    expect(SubClassMultiple.aasm(:left).states).to eq(SuperClassMultiple.aasm(:left).states)
+
+    SuperClassMultiple.aasm(:right).states.each do |state|
+      expect(SubClassWithMoreStatesMultiple.aasm(:right).states).to include(state)
+    end
+    expect(SubClassMultiple.aasm(:right).states).to eq(SuperClassMultiple.aasm(:right).states)
+  end
+
+  it 'should not add the child states to the parent machine' do
+    expect(SuperClassMultiple.aasm(:left).states).not_to include(:foo)
+    expect(SuperClassMultiple.aasm(:right).states).not_to include(:archived)
+  end
+
+  it 'should have the same events as its parent' do
+    expect(SubClassMultiple.aasm(:left).events).to eq(SuperClassMultiple.aasm(:left).events)
+    expect(SubClassMultiple.aasm(:right).events).to eq(SuperClassMultiple.aasm(:right).events)
+  end
+
+  it 'should know how to respond to question methods' do
+    expect(SubClassMultiple.new.may_foo?).to be_truthy
+    expect(SubClassMultiple.new.may_close?).to be_truthy
+  end
+
+  it 'should not break if I call methods from super class' do
+    son = SubClassMultiple.new
+    son.update_state
+    expect(son.aasm(:left).current_state).to eq(:ended)
+  end
+
+  it 'should allow the child to modify its left state machine' do
+    son = SubClassMultiple.new
+    expect(son.left_called_after).to eq(nil)
+    expect(son.right_called_after).to eq(nil)
+    son.foo
+    expect(son.left_called_after).to eq(true)
+    expect(son.right_called_after).to eq(nil)
+    global_callbacks = SubClassMultiple.aasm(:left).state_machine.global_callbacks
+    expect(global_callbacks).to_not be_empty
+    expect(global_callbacks[:after_all_transitions]).to eq :left_after_all_event
+  end
+
+  it 'should allow the child to modify its right state machine' do
+    son = SubClassMultiple.new
+    expect(son.right_called_after).to eq(nil)
+    expect(son.left_called_after).to eq(nil)
+    son.close
+    expect(son.right_called_after).to eq(true)
+    expect(son.left_called_after).to eq(nil)
+    global_callbacks = SubClassMultiple.aasm(:right).state_machine.global_callbacks
+    expect(global_callbacks).to_not be_empty
+    expect(global_callbacks[:after_all_transitions]).to eq :right_after_all_event
+  end
+
+  it 'should not modify the parent left state machine' do
+    super_class_event = SuperClassMultiple.aasm(:left).events.select { |event| event.name == :foo }.first
+    expect(super_class_event.options).to be_empty
+    expect(SuperClassMultiple.aasm(:left).state_machine.global_callbacks).to be_empty
+  end
+
+  it 'should not modify the parent right state machine' do
+    super_class_event = SuperClassMultiple.aasm(:right).events.select { |event| event.name == :close }.first
+    expect(super_class_event.options).to be_empty
+    expect(SuperClassMultiple.aasm(:right).state_machine.global_callbacks).to be_empty
+  end
+
+end

data/spec/unit/subclassing_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'subclassing' do
+
+  it 'should have the parent states' do
+    SuperClass.aasm.states.each do |state|
+      expect(SubClassWithMoreStates.aasm.states).to include(state)
+    end
+    expect(SubClass.aasm.states).to eq(SuperClass.aasm.states)
+  end
+
+  it 'should not add the child states to the parent machine' do
+    expect(SuperClass.aasm.states).not_to include(:foo)
+  end
+
+  it 'should have the same events as its parent' do
+    expect(SubClass.aasm.events).to eq(SuperClass.aasm.events)
+  end
+
+  it 'should know how to respond to question methods' do
+    expect(SubClass.new.may_foo?).to be_truthy
+  end
+
+  it 'should not break if I call methods from super class' do
+    son = SubClass.new
+    son.update_state
+    expect(son.aasm.current_state).to eq(:ended)
+  end
+
+  it 'should allow the child to modify its state machine' do
+    son = SubClass.new
+    expect(son.called_after).to eq(nil)
+    son.foo
+    expect(son.called_after).to eq(true)
+    global_callbacks = SubClass.aasm.state_machine.global_callbacks
+    expect(global_callbacks).to_not be_empty
+    expect(global_callbacks[:after_all_transitions]).to eq :after_all_event
+  end
+
+  it 'should not modify the parent state machine' do
+    super_class_event = SuperClass.aasm.events.select { |event| event.name == :foo }.first
+    expect(super_class_event.options).to be_empty
+    expect(SuperClass.aasm.state_machine.global_callbacks).to be_empty
+  end
+
+end

data/spec/unit/timestamps_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'timestamps option' do
+  it 'calls a timestamp setter based on the state name when entering a new state' do
+    object = TimestampsExample.new
+    expect { object.open }.to change { object.opened_at }.from(nil).to(instance_of(::Time))
+  end
+
+  it 'overwrites any previous timestamp if a state is entered repeatedly' do
+    object = TimestampsExample.new
+    object.opened_at = ::Time.new(2000, 1, 1)
+    expect { object.open }.to change { object.opened_at }
+  end
+
+  it 'does nothing if there is no setter matching the new state' do
+    object = TimestampsExample.new
+    expect { object.close }.not_to change { object.closed_at }
+  end
+
+  it 'can be turned off and on' do
+    object = TimestampsExample.new
+    object.class.aasm.state_machine.config.timestamps = false
+    expect { object.open }.not_to change { object.opened_at }
+    object.class.aasm.state_machine.config.timestamps = true
+    expect { object.open }.to change { object.opened_at }
+  end
+
+  it 'calls a timestamp setter when using a named state machine' do
+    object = TimestampsWithNamedMachineExample.new
+    expect { object.open }.to change { object.opened_at }.from(nil).to(instance_of(::Time))
+  end
+end