aasm 4.12.3 → 5.5.0

data/spec/unit/rspec_matcher_spec.rb

@@ -1,79 +0,0 @@
-require 'spec_helper'
-
-describe 'state machine' do
-  let(:simple) { SimpleExample.new }
-  let(:multiple) { SimpleMultipleExample.new }
-
-  describe 'transition_from' do
-    it "works for simple state machines" do
-      expect(simple).to transition_from(:initialised).to(:filled_out).on_event(:fill_out)
-      expect(simple).to_not transition_from(:initialised).to(:authorised).on_event(:fill_out)
-    end
-
-    it "works for multiple state machines" do
-      expect(multiple).to transition_from(:standing).to(:walking).on_event(:walk).on(:move)
-      expect(multiple).to_not transition_from(:standing).to(:running).on_event(:walk).on(:move)
-
-      expect(multiple).to transition_from(:sleeping).to(:processing).on_event(:start).on(:work)
-      expect(multiple).to_not transition_from(:sleeping).to(:sleeping).on_event(:start).on(:work)
-    end
-  end
-
-  describe 'allow_transition_to' do
-    it "works for simple state machines" do
-      expect(simple).to allow_transition_to(:filled_out)
-      expect(simple).to_not allow_transition_to(:authorised)
-    end
-
-    it "works for multiple state machines" do
-      expect(multiple).to allow_transition_to(:walking).on(:move)
-      expect(multiple).to_not allow_transition_to(:standing).on(:move)
-
-      expect(multiple).to allow_transition_to(:processing).on(:work)
-      expect(multiple).to_not allow_transition_to(:sleeping).on(:work)
-    end
-  end
-
-  describe "have_state" do
-    it "works for simple state machines" do
-      expect(simple).to have_state :initialised
-      expect(simple).to_not have_state :filled_out
-      simple.fill_out
-      expect(simple).to have_state :filled_out
-    end
-
-    it "works for multiple state machines" do
-      expect(multiple).to have_state(:standing).on(:move)
-      expect(multiple).to_not have_state(:walking).on(:move)
-      multiple.walk
-      expect(multiple).to have_state(:walking).on(:move)
-
-      expect(multiple).to have_state(:sleeping).on(:work)
-      expect(multiple).to_not have_state(:processing).on(:work)
-      multiple.start
-      expect(multiple).to have_state(:processing).on(:work)
-    end
-  end
-
-  describe "allow_event" do
-    it "works for simple state machines" do
-      expect(simple).to allow_event :fill_out
-      expect(simple).to_not allow_event :authorise
-      simple.fill_out
-      expect(simple).to allow_event :authorise
-    end
-
-    it "works for multiple state machines" do
-      expect(multiple).to allow_event(:walk).on(:move)
-      expect(multiple).to_not allow_event(:hold).on(:move)
-      multiple.walk
-      expect(multiple).to allow_event(:hold).on(:move)
-
-      expect(multiple).to allow_event(:start).on(:work)
-      expect(multiple).to_not allow_event(:stop).on(:work)
-      multiple.start
-      expect(multiple).to allow_event(:stop).on(:work)
-    end
-  end
-
-end

data/spec/unit/simple_custom_example_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-describe 'Custom AASM::Base' do
-  context 'when aasm_with invoked with SimpleCustomExample' do
-    let(:simple_custom) { SimpleCustomExample.new }
-
-    subject do
-      simple_custom.fill_out!
-      simple_custom.authorise
-    end
-
-    it 'has invoked authorizable?' do
-      expect { subject }.to change { simple_custom.authorizable_called }.from(nil).to(true)
-    end
-
-    it 'has invoked fillable?' do
-      expect { subject }.to change { simple_custom.fillable_called }.from(nil).to(true)
-    end
-
-    it 'has two transition counts' do
-      expect { subject }.to change { simple_custom.transition_count }.from(nil).to(2)
-    end
-  end
-
-  context 'when aasm_with invoked with non AASM::Base' do
-    subject do
-      Class.new do
-        include AASM
-
-        aasm :with_klass => String do
-        end
-      end
-    end
-
-    it 'should raise an ArgumentError' do
-      expect { subject }.to raise_error(ArgumentError, 'The class String must inherit from AASM::Base!')
-    end
-  end
-end

data/spec/unit/simple_example_spec.rb

@@ -1,42 +0,0 @@
-require 'spec_helper'
-
-describe 'state machine' do
-  let(:simple) { SimpleExample.new }
-
-  it 'starts with an initial state' do
-    expect(simple.aasm.current_state).to eq(:initialised)
-    expect(simple).to respond_to(:initialised?)
-    expect(simple).to be_initialised
-  end
-
-  it 'allows transitions to other states' do
-    expect(simple).to respond_to(:fill_out)
-    expect(simple).to respond_to(:fill_out!)
-    simple.fill_out!
-    expect(simple).to respond_to(:filled_out?)
-    expect(simple).to be_filled_out
-
-    expect(simple).to respond_to(:authorise)
-    expect(simple).to respond_to(:authorise!)
-    simple.authorise
-    expect(simple).to respond_to(:authorised?)
-    expect(simple).to be_authorised
-  end
-
-  it 'denies transitions to other states' do
-    expect {simple.authorise}.to raise_error(AASM::InvalidTransition)
-    expect {simple.authorise!}.to raise_error(AASM::InvalidTransition)
-    simple.fill_out
-    expect {simple.fill_out}.to raise_error(AASM::InvalidTransition)
-    expect {simple.fill_out!}.to raise_error(AASM::InvalidTransition)
-    simple.authorise
-    expect {simple.fill_out}.to raise_error(AASM::InvalidTransition)
-    expect {simple.fill_out!}.to raise_error(AASM::InvalidTransition)
-  end
-
-  it 'defines constants for each state name' do
-    expect(SimpleExample::STATE_INITIALISED).to eq(:initialised)
-    expect(SimpleExample::STATE_FILLED_OUT).to eq(:filled_out)
-    expect(SimpleExample::STATE_AUTHORISED).to eq(:authorised)
-  end
-end

data/spec/unit/simple_multiple_example_spec.rb

@@ -1,91 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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
-
-  it 'should set the display_name from name' do
-    expect(new_state.display_name).to eq('Astate')
-  end
-
-  it 'should set the display_name from options' do
-    expect(new_state(:display => "A State").display_name).to eq('A State')
-  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)
-  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)
-  end
-end

data/spec/unit/states_on_one_line_example_spec.rb

@@ -1,16 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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