aasm 4.2.0 → 4.3.0

data/spec/unit/basic_two_state_machines_example_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe 'on initialization' do
+  let(:example) { BasicTwoStateMachinesExample.new }
+
+  it 'should be in the initial state' do
+    expect(example.aasm(:search).current_state).to eql :initialised
+    expect(example.aasm(:sync).current_state).to eql :unsynced
+  end
+end

data/spec/unit/callback_multiple_spec.rb

@@ -0,0 +1,295 @@
+require 'spec_helper'
+Dir[File.dirname(__FILE__) + "/../models/callbacks/*.rb"].sort.each { |f| require File.expand_path(f) }
+
+describe 'callbacks for the new DSL' do
+
+  it "be called in order" do
+    show_debug_log = false
+
+    callback = Callbacks::BasicMultiple.new(:log => show_debug_log)
+    callback.aasm(:left).current_state
+
+    unless show_debug_log
+      expect(callback).to receive(:before_event).once.ordered
+      expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+      expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
+      expect(callback).to receive(:before_exit_open).once.ordered                   # these should be before the state changes
+      expect(callback).to receive(:exit_open).once.ordered
+      # expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+      # expect(callback).to receive(:transition_guard).once.ordered.and_return(true)
+      expect(callback).to receive(:after_transition).once.ordered
+      expect(callback).to receive(:before_enter_closed).once.ordered
+      expect(callback).to receive(:enter_closed).once.ordered
+      expect(callback).to receive(:aasm_write_state).with(:closed, :left).once.ordered.and_return(true)  # this is when the state changes
+      expect(callback).to receive(:after_exit_open).once.ordered                    # these should be after the state changes
+      expect(callback).to receive(:after_enter_closed).once.ordered
+      expect(callback).to receive(:after_event).once.ordered
+    end
+
+    # puts "------- close!"
+    callback.left_close!
+  end
+
+  it "does not run any state callback if the event guard fails" do
+    callback = Callbacks::BasicMultiple.new(:log => false)
+    callback.aasm(:left).current_state
+
+    expect(callback).to receive(:before_event).once.ordered
+    expect(callback).to receive(:event_guard).once.ordered.and_return(false)
+    expect(callback).to_not receive(:transition_guard)
+    expect(callback).to_not receive(:before_exit_open)
+    expect(callback).to_not receive(:exit_open)
+    expect(callback).to_not receive(:after_transition)
+    expect(callback).to_not receive(:before_enter_closed)
+    expect(callback).to_not receive(:enter_closed)
+    expect(callback).to_not receive(:aasm_write_state)
+    expect(callback).to_not receive(:after_exit_open)
+    expect(callback).to_not receive(:after_enter_closed)
+    expect(callback).to_not receive(:after_event)
+
+    expect {
+      callback.left_close!
+    }.to raise_error(AASM::InvalidTransition)
+  end
+
+  it "handles private callback methods as well" do
+    show_debug_log = false
+
+    callback = Callbacks::PrivateMethodMultiple.new(:log => show_debug_log)
+    callback.aasm(:left).current_state
+
+    # puts "------- close!"
+    expect {
+      callback.close!
+    }.to_not raise_error
+  end
+
+  context "if the transition guard fails" do
+    it "does not run any state callback if guard is defined inline" do
+      show_debug_log = false
+      callback = Callbacks::BasicMultiple.new(:log => show_debug_log, :fail_transition_guard => true)
+      callback.aasm(:left).current_state
+
+      unless show_debug_log
+        expect(callback).to receive(:before_event).once.ordered
+        expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+        expect(callback).to receive(:transition_guard).once.ordered.and_return(false)
+        expect(callback).to_not receive(:before_exit_open)
+        expect(callback).to_not receive(:exit_open)
+        expect(callback).to_not receive(:after_transition)
+        expect(callback).to_not receive(:before_enter_closed)
+        expect(callback).to_not receive(:enter_closed)
+        expect(callback).to_not receive(:aasm_write_state)
+        expect(callback).to_not receive(:after_exit_open)
+        expect(callback).to_not receive(:after_enter_closed)
+        expect(callback).to_not receive(:after_event)
+      end
+
+      expect {
+        callback.left_close!
+      }.to raise_error(AASM::InvalidTransition)
+    end
+
+    it "does not run transition_guard twice for multiple permitted transitions" do
+      show_debug_log = false
+      callback = Callbacks::MultipleTransitionsTransitionGuardMultiple.new(:log => show_debug_log, :fail_transition_guard => true)
+      callback.aasm(:left).current_state
+
+      unless show_debug_log
+        expect(callback).to receive(:before).once.ordered
+        expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+        expect(callback).to receive(:transition_guard).once.ordered.and_return(false)
+        expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+        expect(callback).to receive(:before_exit_open).once.ordered
+        expect(callback).to receive(:exit_open).once.ordered
+        expect(callback).to receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
+        expect(callback).to receive(:after_exit_open).once.ordered
+        expect(callback).to receive(:after).once.ordered
+
+        expect(callback).to_not receive(:transitioning)
+        expect(callback).to_not receive(:before_enter_closed)
+        expect(callback).to_not receive(:enter_closed)
+        expect(callback).to_not receive(:after_enter_closed)
+      end
+
+      callback.close!
+      expect(callback.aasm(:left).current_state).to eql :failed
+    end
+
+    it "does not run any state callback if guard is defined with block" do
+      callback = Callbacks::GuardWithinBlockMultiple.new #(:log => true, :fail_transition_guard => true)
+      callback.aasm(:left).current_state
+
+      expect(callback).to receive(:before).once.ordered
+      expect(callback).to receive(:event_guard).once.ordered.and_return(true)
+      expect(callback).to receive(:transition_guard).once.ordered.and_return(false)
+      expect(callback).to_not receive(:before_exit_open)
+      expect(callback).to_not receive(:exit_open)
+      expect(callback).to_not receive(:transitioning)
+      expect(callback).to_not receive(:before_enter_closed)
+      expect(callback).to_not receive(:enter_closed)
+      expect(callback).to_not receive(:aasm_write_state)
+      expect(callback).to_not receive(:after_exit_open)
+      expect(callback).to_not receive(:after_enter_closed)
+      expect(callback).to_not receive(:after)
+
+      expect {
+        callback.close!
+      }.to raise_error(AASM::InvalidTransition)
+    end
+  end
+
+  it "should properly pass arguments" do
+    cb = Callbacks::WithArgsMultiple.new(:log => false)
+    cb.aasm(:left).current_state
+
+    cb.reset_data
+    cb.close!(:arg1, :arg2)
+    expect(cb.data).to eql 'before(:arg1,:arg2) before_exit_open(:arg1,:arg2) transition_proc(:arg1,:arg2) before_enter_closed(:arg1,:arg2) aasm_write_state after_exit_open(:arg1,:arg2) after_enter_closed(:arg1,:arg2) after(:arg1,:arg2)'
+  end
+
+  it "should call the callbacks given the to-state as argument" do
+    cb = Callbacks::WithStateArgMultiple.new
+    expect(cb).to receive(:before_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:transition_method2).with(:arg1).once.ordered
+    expect(cb).to receive(:after_method).with(:arg1).once.ordered
+    cb.close!(:out_to_lunch, :arg1)
+
+    cb = Callbacks::WithStateArgMultiple.new
+    some_object = double('some object')
+    expect(cb).to receive(:before_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method2).with(some_object).once.ordered
+    expect(cb).to receive(:after_method).with(some_object).once.ordered
+    cb.close!(:out_to_lunch, some_object)
+  end
+
+  it "should call the proper methods just with arguments" do
+    cb = Callbacks::WithStateArgMultiple.new
+    expect(cb).to receive(:before_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).with(:arg1).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:after_method).with(:arg1).once.ordered
+    cb.close!(:arg1)
+
+    cb = Callbacks::WithStateArgMultiple.new
+    some_object = double('some object')
+    expect(cb).to receive(:before_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method).with(some_object).once.ordered
+    expect(cb).to receive(:transition_method).never
+    expect(cb).to receive(:after_method).with(some_object).once.ordered
+    cb.close!(some_object)
+  end
+end # callbacks for the new DSL
+
+describe 'event callbacks' do
+  describe "with an error callback defined" do
+    before do
+      class FooCallbackMultiple
+        # this hack is needed to allow testing of parameters, since RSpec
+        # destroys a method's arity when mocked
+        attr_accessor :data
+
+        aasm(:left) do
+          event :safe_close, :success => :success_callback, :error => :error_callback do
+            transitions :to => :closed, :from => [:open]
+          end
+        end
+      end
+
+      @foo = FooCallbackMultiple.new
+    end
+
+    context "error_callback defined" do
+      it "should run error_callback if an exception is raised" do
+        def @foo.error_callback(e)
+          @data = [e]
+        end
+
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+
+        @foo.safe_close!
+        expect(@foo.data).to eql [e]
+      end
+
+      it "should run error_callback without parameters if callback does not support any" do
+        def @foo.error_callback(e)
+          @data = []
+        end
+
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+
+        @foo.safe_close!('arg1', 'arg2')
+        expect(@foo.data).to eql []
+      end
+
+      it "should run error_callback with parameters if callback supports them" do
+        def @foo.error_callback(e, arg1, arg2)
+          @data = [arg1, arg2]
+        end
+
+        allow(@foo).to receive(:before_enter).and_raise(e = StandardError.new)
+
+        @foo.safe_close!('arg1', 'arg2')
+        expect(@foo.data).to eql ['arg1', 'arg2']
+      end
+    end
+
+    it "should raise NoMethodError if exception is raised and error_callback is declared but not defined" do
+      allow(@foo).to receive(:before_enter).and_raise(StandardError)
+      expect{@foo.safe_close!}.to raise_error(NoMethodError)
+    end
+
+    it "should propagate an error if no error callback is declared" do
+        allow(@foo).to receive(:before_enter).and_raise("Cannot enter safe")
+        expect{@foo.close!}.to raise_error(StandardError, "Cannot enter safe")
+    end
+  end
+
+  describe "with aasm_event_fired defined" do
+    before do
+      @foo = FooMultiple.new
+      def @foo.aasm_event_fired(event, from, to); end
+    end
+
+    it 'should call it for successful bang fire' do
+      expect(@foo).to receive(:aasm_event_fired).with(:close, :open, :closed)
+      @foo.close!
+    end
+
+    it 'should call it for successful non-bang fire' do
+      expect(@foo).to receive(:aasm_event_fired)
+      @foo.close
+    end
+
+    it 'should not call it for failing bang fire' do
+      allow(@foo.aasm(:left)).to receive(:set_current_state_with_persistence).and_return(false)
+      expect(@foo).not_to receive(:aasm_event_fired)
+      @foo.close!
+    end
+  end
+
+  describe "with aasm_event_failed defined" do
+    before do
+      @foo = FooMultiple.new
+      def @foo.aasm_event_failed(event, from); end
+    end
+
+    it 'should call it when transition failed for bang fire' do
+      expect(@foo).to receive(:aasm_event_failed).with(:null, :open)
+      expect {@foo.null!}.to raise_error(AASM::InvalidTransition)
+    end
+
+    it 'should call it when transition failed for non-bang fire' do
+      expect(@foo).to receive(:aasm_event_failed).with(:null, :open)
+      expect {@foo.null}.to raise_error(AASM::InvalidTransition)
+    end
+
+    it 'should not call it if persist fails for bang fire' do
+      allow(@foo.aasm(:left)).to receive(:set_current_state_with_persistence).and_return(false)
+      expect(@foo).to receive(:aasm_event_failed)
+      @foo.close!
+    end
+  end
+
+end # event callbacks

data/spec/unit/callbacks_spec.rb

@@ -52,7 +52,7 @@ describe 'callbacks for the new DSL' do
     }.to raise_error(AASM::InvalidTransition)
   end
 
-  it "it handles private callback methods as well" do
+  it "handles private callback methods as well" do
     show_debug_log = false
 
     callback = Callbacks::PrivateMethod.new(:log => show_debug_log)

data/spec/unit/complex_multiple_example_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe 'on initialization' do
+  let(:auth) {ComplexExampleMultiple.new}
+
+  it 'should be in the initial state' do
+    expect(auth.aasm(:left).current_state).to eq(:pending)
+    expect(auth.aasm(:right).current_state).to eq(:pending)
+  end
+
+  it 'should have an activation code' do
+    expect(auth.has_activation_code?).to be_truthy
+    expect(auth.activation_code).to eq '12'
+  end
+end
+
+describe 'when being unsuspended' do
+  let(:auth) {ComplexExampleMultiple.new}
+
+  it 'should be able to unsuspend' do
+    auth.left_activate!
+    auth.left_suspend!
+    expect(auth.may_left_unsuspend?).to be true
+
+    auth.right_activate!
+    auth.right_suspend!
+    expect(auth.may_right_unsuspend?).to be true
+  end
+
+  it 'should not be able to unsuspend into active' do
+    auth.left_suspend!
+    expect(auth.may_left_unsuspend?(:active)).not_to be true
+
+    auth.right_activate!
+    auth.right_suspend!
+    expect(auth.may_right_unsuspend?(:active)).to be true
+  end
+
+  it 'should be able to wait into waiting if polite' do
+    auth.left_suspend!
+    expect(auth.may_left_wait?(:waiting, :please)).to be true
+    auth.left_wait!(nil, :please)
+
+    auth.right_suspend!
+    expect(auth.may_right_wait?(:waiting)).to be false
+    auth.right_wait!(nil, :please)
+  end
+
+  it 'should not be able to be unsuspended into active if not polite' do
+    auth.left_suspend!
+    expect(auth.may_left_wait?(:waiting)).not_to be true
+    expect(auth.may_left_wait?(:waiting, :rude)).not_to be true
+    expect {auth.left_wait!(nil, :rude)}.to raise_error(AASM::InvalidTransition)
+    expect {auth.left_wait!}.to raise_error(AASM::InvalidTransition)
+  end
+
+  it 'should not be able to be unpassified' do
+    auth.left_activate!
+    auth.left_suspend!
+    auth.left_unsuspend!
+
+    expect(auth.may_left_unpassify?).not_to be true
+    expect {auth.left_unpassify!}.to raise_error(AASM::InvalidTransition)
+  end
+
+  it 'should be active if previously activated' do
+    auth.left_activate!
+    auth.left_suspend!
+    auth.left_unsuspend!
+
+    expect(auth.aasm(:left).current_state).to eq(:active)
+  end
+
+  it 'should be pending if not previously activated, but an activation code is present' do
+    auth.left_suspend!
+    auth.left_unsuspend!
+
+    expect(auth.aasm(:left).current_state).to eq(:pending)
+  end
+
+  it 'should be passive if not previously activated and there is no activation code' do
+    auth.activation_code = nil
+    auth.left_suspend!
+    auth.left_unsuspend!
+
+    expect(auth.aasm(:left).current_state).to eq(:passive)
+  end
+
+  it "should be able to fire known events" do
+    expect(auth.aasm(:left).may_fire_event?(:left_activate)).to be true
+    expect(auth.aasm(:right).may_fire_event?(:right_activate)).to be true
+  end
+
+  it "should not be able to fire unknown events" do
+    expect(auth.aasm(:left).may_fire_event?(:unknown)).to be false
+    expect(auth.aasm(:right).may_fire_event?(:unknown)).to be false
+  end
+
+end

data/spec/unit/edge_cases_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe "edge cases" do
+  describe "for classes with multiple state machines" do
+    it "allows accessing a multiple state machine class without state machine name" do
+      # it's like starting to define a new state machine within the
+      # requested class
+      expect(SimpleMultipleExample.aasm.states.map(&:name)).to be_empty
+    end
+
+    it "do not know yet" do
+      example = ComplexExampleMultiple.new
+      expect { example.aasm.states.inspect }.to raise_error(AASM::UnknownStateMachineError)
+    end
+  end
+end

data/spec/unit/event_multiple_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe 'current event' do
+  let(:pe) {ParametrisedEventMultiple.new}
+
+  it 'if no event has been triggered' do
+    expect(pe.aasm(:left).current_event).to be_nil
+  end
+
+  it 'if a event has been triggered' do
+    pe.wakeup
+    expect(pe.aasm(:left).current_event).to eql :wakeup
+  end
+
+  it 'if no event has been triggered' do
+    pe.wakeup!
+    expect(pe.aasm(:left).current_event).to eql :wakeup!
+  end
+end
+
+describe 'parametrised events' do
+  let(:pe) {ParametrisedEventMultiple.new}
+
+  it 'should transition to specified next state (sleeping to showering)' do
+    pe.wakeup!(:showering)
+    expect(pe.aasm(:left).current_state).to eq(:showering)
+  end
+
+  it 'should transition to specified next state (sleeping to working)' do
+    pe.wakeup!(:working)
+    expect(pe.aasm(:left).current_state).to eq(:working)
+  end
+
+  it 'should transition to default (first or showering) state' do
+    pe.wakeup!
+    expect(pe.aasm(:left).current_state).to eq(:showering)
+  end
+
+  it 'should transition to default state when :after transition invoked' do
+    pe.dress!(nil, 'purple', 'dressy')
+    expect(pe.aasm(:left).current_state).to eq(:working)
+  end
+
+  it 'should call :after transition method with args' do
+    pe.wakeup!(:showering)
+    expect(pe).to receive(:wear_clothes).with('blue', 'jeans')
+    pe.dress!(:working, 'blue', 'jeans')
+  end
+
+  it 'should call :after transition proc' do
+    pe.wakeup!(:showering)
+    expect(pe).to receive(:wear_clothes).with('purple', 'slacks')
+    pe.dress!(:dating, 'purple', 'slacks')
+  end
+
+  it 'should call :after transition with an array of methods' do
+    pe.wakeup!(:showering)
+    expect(pe).to receive(:condition_hair)
+    expect(pe).to receive(:fix_hair)
+    pe.dress!(:prettying_up)
+  end
+end
+
+describe 'event firing without persistence' do
+  it 'should attempt to persist if aasm_write_state is defined' do
+    foo = Foo.new
+    def foo.aasm_write_state; end
+    expect(foo).to be_open
+
+    expect(foo).to receive(:aasm_write_state_without_persistence)
+    foo.close
+  end
+end