aasm 4.5.1 → 5.5.0

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,63 +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
-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/subclassing_multiple_spec.rb

@@ -1,39 +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
-
-end
-

data/spec/unit/subclassing_spec.rb

@@ -1,31 +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
-
-end
-

data/spec/unit/transition_spec.rb

@@ -1,291 +0,0 @@
-require 'spec_helper'
-
-describe 'transitions' do
-
-  it 'should raise an exception when whiny' do
-    process = ProcessWithNewDsl.new
-    expect { process.stop! }.to raise_error do |err|
-      expect(err.class).to eql(AASM::InvalidTransition)
-      expect(err.message).to eql("Event 'stop' cannot transition from 'sleeping'")
-      expect(err.object).to eql(process)
-      expect(err.event_name).to eql(:stop)
-    end
-    expect(process).to be_sleeping
-  end
-
-  it 'should not raise an exception when not whiny' do
-    silencer = Silencer.new
-    expect(silencer.smile!).to be_falsey
-    expect(silencer).to be_silent
-  end
-
-  it 'should not raise an exception when superclass not whiny' do
-    sub = SubClassing.new
-    expect(sub.smile!).to be_falsey
-    expect(sub).to be_silent
-  end
-
-  it 'should not raise an exception when from is nil even if whiny' do
-    silencer = Silencer.new
-    expect(silencer.smile_any!).to be_truthy
-    expect(silencer).to be_smiling
-  end
-
-  it 'should call the block on success' do
-    silencer = Silencer.new
-    success = false
-    expect {
-      silencer.smile_any! do
-        success = true
-      end
-    }.to change { success }.to(true)
-  end
-
-  it 'should not call the block on failure' do
-    silencer = Silencer.new
-    success = false
-    expect {
-      silencer.smile! do
-        success = true
-      end
-    }.not_to change { success }
-  end
-
-end
-
-describe AASM::Core::Transition do
-  let(:state_machine) { AASM::StateMachine.new(:name) }
-  let(:event) { AASM::Core::Event.new(:event, state_machine) }
-
-  it 'should set from, to, and opts attr readers' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(event, opts)
-
-    expect(st.from).to eq(opts[:from])
-    expect(st.to).to eq(opts[:to])
-    expect(st.opts).to eq(opts)
-  end
-
-  it 'should set on_transition with deprecation warning' do
-    opts = {:from => 'foo', :to => 'bar'}
-    st = AASM::Core::Transition.allocate
-    expect(st).to receive(:warn).with('[DEPRECATION] :on_transition is deprecated, use :after instead')
-
-    st.send :initialize, event, opts do
-      guard :gg
-      on_transition :after_callback
-    end
-
-    expect(st.opts[:after]).to eql [:after_callback]
-  end
-
-  it 'should set after and guard from dsl' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(event, opts) do
-      guard :gg
-      after :after_callback
-    end
-
-    expect(st.opts[:guard]).to eql ['g', :gg]
-    expect(st.opts[:after]).to eql [:after_callback] # TODO fix this bad code coupling
-  end
-
-  it 'should pass equality check if from and to are the same' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(event, opts)
-
-    obj = double('object')
-    allow(obj).to receive(:from).and_return(opts[:from])
-    allow(obj).to receive(:to).and_return(opts[:to])
-
-    expect(st).to eq(obj)
-  end
-
-  it 'should fail equality check if from are not the same' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(event, opts)
-
-    obj = double('object')
-    allow(obj).to receive(:from).and_return('blah')
-    allow(obj).to receive(:to).and_return(opts[:to])
-
-    expect(st).not_to eq(obj)
-  end
-
-  it 'should fail equality check if to are not the same' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'g'}
-    st = AASM::Core::Transition.new(event, opts)
-
-    obj = double('object')
-    allow(obj).to receive(:from).and_return(opts[:from])
-    allow(obj).to receive(:to).and_return('blah')
-
-    expect(st).not_to eq(obj)
-  end
-end
-
-describe AASM::Core::Transition, '- when performing guard checks' do
-  let(:state_machine) { AASM::StateMachine.new(:name) }
-  let(:event) { AASM::Core::Event.new(:event, state_machine) }
-
-  it 'should return true of there is no guard' do
-    opts = {:from => 'foo', :to => 'bar'}
-    st = AASM::Core::Transition.new(event, opts)
-
-    expect(st.allowed?(nil)).to be_truthy
-  end
-
-  it 'should call the method on the object if guard is a symbol' do
-    opts = {:from => 'foo', :to => 'bar', :guard => :test}
-    st = AASM::Core::Transition.new(event, opts)
-
-    obj = double('object')
-    expect(obj).to receive(:test)
-
-    expect(st.allowed?(obj)).to be false
-  end
-
-  it 'should call the method on the object if unless is a symbol' do
-    opts = {:from => 'foo', :to => 'bar', :unless => :test}
-    st = AASM::Core::Transition.new(event, opts)
-
-    obj = double('object')
-    expect(obj).to receive(:test)
-
-    expect(st.allowed?(obj)).to be true
-  end
-
-  it 'should call the method on the object if guard is a string' do
-    opts = {:from => 'foo', :to => 'bar', :guard => 'test'}
-    st = AASM::Core::Transition.new(event, opts)
-
-    obj = double('object')
-    expect(obj).to receive(:test)
-
-    expect(st.allowed?(obj)).to be false
-  end
-
-  it 'should call the method on the object if unless is a string' do
-    opts = {:from => 'foo', :to => 'bar', :unless => 'test'}
-    st = AASM::Core::Transition.new(event, opts)
-
-    obj = double('object')
-    expect(obj).to receive(:test)
-
-    expect(st.allowed?(obj)).to be true
-  end
-
-  it 'should call the proc passing the object if the guard is a proc' do
-    opts = {:from => 'foo', :to => 'bar', :guard => Proc.new { test }}
-    st = AASM::Core::Transition.new(event, opts)
-
-    obj = double('object')
-    expect(obj).to receive(:test)
-
-    expect(st.allowed?(obj)).to be false
-  end
-end
-
-describe AASM::Core::Transition, '- when executing the transition with a Proc' do
-  let(:state_machine) { AASM::StateMachine.new(:name) }
-  let(:event) { AASM::Core::Event.new(:event, state_machine) }
-
-  it 'should call a Proc on the object with args' do
-    opts = {:from => 'foo', :to => 'bar', :after => Proc.new {|a| test(a) }}
-    st = AASM::Core::Transition.new(event, opts)
-    args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object', :aasm => 'aasm')
-
-    expect(obj).to receive(:test).with(args)
-
-    st.execute(obj, args)
-  end
-
-  it 'should call a Proc on the object without args' do
-    # in order to test that the Proc has been called, we make sure
-    # that after running the :after callback the prc_object is set
-    prc_object = nil
-    prc = Proc.new { prc_object = self }
-
-    opts = {:from => 'foo', :to => 'bar', :after => prc }
-    st = AASM::Core::Transition.new(event, opts)
-    args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object', :aasm => 'aasm')
-
-    st.execute(obj, args)
-    expect(prc_object).to eql obj
-  end
-end
-
-describe AASM::Core::Transition, '- when executing the transition with an :after method call' do
-  let(:state_machine) { AASM::StateMachine.new(:name) }
-  let(:event) { AASM::Core::Event.new(:event, state_machine) }
-
-  it 'should accept a String for the method name' do
-    opts = {:from => 'foo', :to => 'bar', :after => 'test'}
-    st = AASM::Core::Transition.new(event, opts)
-    args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object', :aasm => 'aasm')
-
-    expect(obj).to receive(:test)
-
-    st.execute(obj, args)
-  end
-
-  it 'should accept a Symbol for the method name' do
-    opts = {:from => 'foo', :to => 'bar', :after => :test}
-    st = AASM::Core::Transition.new(event, opts)
-    args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object', :aasm => 'aasm')
-
-    expect(obj).to receive(:test)
-
-    st.execute(obj, args)
-  end
-
-  it 'should pass args if the target method accepts them' do
-    opts = {:from => 'foo', :to => 'bar', :after => :test}
-    st = AASM::Core::Transition.new(event, opts)
-    args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object', :aasm => 'aasm')
-
-    def obj.test(args)
-      "arg1: #{args[:arg1]} arg2: #{args[:arg2]}"
-    end
-
-    return_value = st.execute(obj, args)
-
-    expect(return_value).to eq('arg1: 1 arg2: 2')
-  end
-
-  it 'should NOT pass args if the target method does NOT accept them' do
-    opts = {:from => 'foo', :to => 'bar', :after => :test}
-    st = AASM::Core::Transition.new(event, opts)
-    args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object', :aasm => 'aasm')
-
-    def obj.test
-      'success'
-    end
-
-    return_value = st.execute(obj, args)
-
-    expect(return_value).to eq('success')
-  end
-
-  it 'should allow accessing the from_state and the to_state' do
-    opts = {:from => 'foo', :to => 'bar', :after => :test}
-    transition = AASM::Core::Transition.new(event, opts)
-    args = {:arg1 => '1', :arg2 => '2'}
-    obj = double('object', :aasm => AASM::InstanceBase.new('object'))
-
-    def obj.test(args)
-      "from: #{aasm.from_state} to: #{aasm.to_state}"
-    end
-
-    return_value = transition.execute(obj, args)
-
-    expect(return_value).to eq('from: foo to: bar')
-  end
-
-end