aasm 3.0.26 → 3.1.0

data/spec/unit/callbacks_spec.rb

@@ -4,15 +4,15 @@ describe 'callbacks for the new DSL' do
   let(:callback) {CallbackNewDsl.new}
 
   it "be called in order" do
-    callback.should_receive(:exit_open).once.ordered
-    callback.should_receive(:before).once.ordered
-    callback.should_receive(:before_exit_open).once.ordered                   # these should be before the state changes
-    callback.should_receive(:before_enter_closed).once.ordered
-    callback.should_receive(:enter_closed).once.ordered
-    callback.should_receive(:aasm_write_state).once.ordered.and_return(true)  # this is when the state changes
-    callback.should_receive(:after_exit_open).once.ordered                    # these should be after the state changes
-    callback.should_receive(:after_enter_closed).once.ordered
-    callback.should_receive(:after).once.ordered
+    expect(callback).to receive(:exit_open).once.ordered
+    expect(callback).to receive(:before).once.ordered
+    expect(callback).to receive(:before_exit_open).once.ordered                   # these should be before the state changes
+    expect(callback).to receive(:before_enter_closed).once.ordered
+    expect(callback).to receive(:enter_closed).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                    # these should be after the state changes
+    expect(callback).to receive(:after_enter_closed).once.ordered
+    expect(callback).to receive(:after).once.ordered
 
     callback.close!
   end
@@ -35,20 +35,20 @@ describe 'event callbacks' do
     it "should run error_callback if an exception is raised and error_callback defined" do
       def @foo.error_callback(e); end
 
-      @foo.stub(:enter).and_raise(e=StandardError.new)
-      @foo.should_receive(:error_callback).with(e)
+      allow(@foo).to receive(:enter).and_raise(e=StandardError.new)
+      expect(@foo).to receive(:error_callback).with(e)
 
       @foo.safe_close!
     end
 
     it "should raise NoMethodError if exceptionis raised and error_callback is declared but not defined" do
-      @foo.stub(:enter).and_raise(StandardError)
-      lambda{@foo.safe_close!}.should raise_error(NoMethodError)
+      allow(@foo).to receive(: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
-        @foo.stub(:enter).and_raise("Cannot enter safe")
-        lambda{@foo.close!}.should raise_error(StandardError, "Cannot enter safe")
+        allow(@foo).to receive(:enter).and_raise("Cannot enter safe")
+        expect{@foo.close!}.to raise_error(StandardError, "Cannot enter safe")
     end
   end
 
@@ -59,18 +59,18 @@ describe 'event callbacks' do
     end
 
     it 'should call it for successful bang fire' do
-      @foo.should_receive(:aasm_event_fired).with(:close, :open, :closed)
+      expect(@foo).to receive(:aasm_event_fired).with(:close, :open, :closed)
       @foo.close!
     end
 
     it 'should call it for successful non-bang fire' do
-      @foo.should_receive(:aasm_event_fired)
+      expect(@foo).to receive(:aasm_event_fired)
       @foo.close
     end
 
     it 'should not call it for failing bang fire' do
-      @foo.aasm.stub(:set_current_state_with_persistence).and_return(false)
-      @foo.should_not_receive(:aasm_event_fired)
+      allow(@foo.aasm).to receive(:set_current_state_with_persistence).and_return(false)
+      expect(@foo).not_to receive(:aasm_event_fired)
       @foo.close!
     end
   end
@@ -82,18 +82,18 @@ describe 'event callbacks' do
     end
 
     it 'should call it when transition failed for bang fire' do
-      @foo.should_receive(:aasm_event_failed).with(:null, :open)
-      lambda {@foo.null!}.should raise_error(AASM::InvalidTransition)
+      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
-      @foo.should_receive(:aasm_event_failed).with(:null, :open)
-      lambda {@foo.null}.should raise_error(AASM::InvalidTransition)
+      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
-      @foo.aasm.stub(:set_current_state_with_persistence).and_return(false)
-      @foo.should_receive(:aasm_event_failed)
+      allow(@foo.aasm).to receive(:set_current_state_with_persistence).and_return(false)
+      expect(@foo).to receive(:aasm_event_failed)
       @foo.close!
     end
   end

data/spec/unit/complex_example_spec.rb

@@ -4,12 +4,12 @@ describe 'on initialization' do
   let(:auth) {AuthMachine.new}
 
   it 'should be in the pending state' do
-    auth.aasm.current_state.should == :pending
+    expect(auth.aasm.current_state).to eq(:pending)
   end
 
   it 'should have an activation code' do
-    auth.has_activation_code?.should be_true
-    auth.activation_code.should_not be_nil
+    expect(auth.has_activation_code?).to be_true
+    expect(auth.activation_code).not_to be_nil
   end
 end
 
@@ -19,26 +19,26 @@ describe 'when being unsuspended' do
   it 'should be able to be unsuspended' do
     auth.activate!
     auth.suspend!
-    auth.may_unsuspend?.should be_true
+    expect(auth.may_unsuspend?).to be_true
   end
 
   it 'should not be able to be unsuspended into active' do
     auth.suspend!
-    auth.may_unsuspend?(:active).should_not be_true
+    expect(auth.may_unsuspend?(:active)).not_to be_true
   end
 
   it 'should be able to be unsuspended into active if polite' do
     auth.suspend!
-    auth.may_wait?(:waiting, :please).should be_true
+    expect(auth.may_wait?(:waiting, :please)).to be_true
     auth.wait!(nil, :please)
   end
 
   it 'should not be able to be unsuspended into active if not polite' do
     auth.suspend!
-    auth.may_wait?(:waiting).should_not be_true
-    auth.may_wait?(:waiting, :rude).should_not be_true
-    lambda {auth.wait!(nil, :rude)}.should raise_error(AASM::InvalidTransition)
-    lambda {auth.wait!}.should raise_error(AASM::InvalidTransition)
+    expect(auth.may_wait?(:waiting)).not_to be_true
+    expect(auth.may_wait?(:waiting, :rude)).not_to be_true
+    expect {auth.wait!(nil, :rude)}.to raise_error(AASM::InvalidTransition)
+    expect {auth.wait!}.to raise_error(AASM::InvalidTransition)
   end
 
   it 'should not be able to be unpassified' do
@@ -46,8 +46,8 @@ describe 'when being unsuspended' do
     auth.suspend!
     auth.unsuspend!
 
-    auth.may_unpassify?.should_not be_true
-    lambda {auth.unpassify!}.should raise_error(AASM::InvalidTransition)
+    expect(auth.may_unpassify?).not_to be_true
+    expect {auth.unpassify!}.to raise_error(AASM::InvalidTransition)
   end
 
   it 'should be active if previously activated' do
@@ -55,14 +55,14 @@ describe 'when being unsuspended' do
     auth.suspend!
     auth.unsuspend!
 
-    auth.aasm.current_state.should == :active
+    expect(auth.aasm.current_state).to eq(:active)
   end
 
   it 'should be pending if not previously activated, but an activation code is present' do
     auth.suspend!
     auth.unsuspend!
 
-    auth.aasm.current_state.should == :pending
+    expect(auth.aasm.current_state).to eq(:pending)
   end
 
   it 'should be passive if not previously activated and there is no activation code' do
@@ -70,6 +70,6 @@ describe 'when being unsuspended' do
     auth.suspend!
     auth.unsuspend!
 
-    auth.aasm.current_state.should == :passive
+    expect(auth.aasm.current_state).to eq(:passive)
   end
 end

data/spec/unit/event_spec.rb

@@ -10,27 +10,27 @@ describe 'adding an event' do
   end
 
   it 'should set the name' do
-    event.name.should == :close_order
+    expect(event.name).to eq(:close_order)
   end
 
   it 'should set the success callback' do
-    event.options[:success].should == :success_callback
+    expect(event.options[:success]).to eq(:success_callback)
   end
 
   it 'should set the after callback' do
-    event.options[:after].should == [:after_callback]
+    expect(event.options[:after]).to eq([:after_callback])
   end
 
   it 'should set the before callback' do
-    event.options[:before].should == [:before_callback]
+    expect(event.options[:before]).to eq([:before_callback])
   end
 
   it 'should create transitions' do
     transitions = event.transitions
-    transitions[0].from.should == :open
-    transitions[0].to.should == :closed
-    transitions[1].from.should == :received
-    transitions[1].to.should == :closed
+    expect(transitions[0].from).to eq(:open)
+    expect(transitions[0].to).to eq(:closed)
+    expect(transitions[1].from).to eq(:received)
+    expect(transitions[1].to).to eq(:closed)
   end
 end
 
@@ -42,19 +42,19 @@ describe 'transition inspection' do
   end
 
   it 'should support inspecting transitions from other states' do
-    event.transitions_from_state(:sleeping).map(&:to).should == [:running]
-    event.transitions_from_state?(:sleeping).should be_true
+    expect(event.transitions_from_state(:sleeping).map(&:to)).to eq([:running])
+    expect(event.transitions_from_state?(:sleeping)).to be_true
 
-    event.transitions_from_state(:cleaning).map(&:to).should == []
-    event.transitions_from_state?(:cleaning).should be_false
+    expect(event.transitions_from_state(:cleaning).map(&:to)).to eq([])
+    expect(event.transitions_from_state?(:cleaning)).to be_false
   end
 
   it 'should support inspecting transitions to other states' do
-    event.transitions_to_state(:running).map(&:from).should == [:sleeping]
-    event.transitions_to_state?(:running).should be_true
+    expect(event.transitions_to_state(:running).map(&:from)).to eq([:sleeping])
+    expect(event.transitions_to_state?(:running)).to be_true
 
-    event.transitions_to_state(:cleaning).map(&:to).should == []
-    event.transitions_to_state?(:cleaning).should be_false
+    expect(event.transitions_to_state(:cleaning).map(&:to)).to eq([])
+    expect(event.transitions_to_state?(:cleaning)).to be_false
   end
 end
 
@@ -63,7 +63,7 @@ describe 'firing an event' do
     obj = double('object', :aasm => double('aasm', :current_state => 'open'))
 
     event = AASM::Event.new(:event)
-    event.fire(obj).should be_nil
+    expect(event.fire(obj)).to be_nil
   end
 
   it 'should return the state of the first matching transition it finds' do
@@ -73,7 +73,7 @@ describe 'firing an event' do
 
     obj = double('object', :aasm => double('aasm', :current_state => :open))
 
-    event.fire(obj).should == :closed
+    expect(event.fire(obj)).to eq(:closed)
   end
 
   it 'should call the guard with the params passed in' do
@@ -82,9 +82,9 @@ describe 'firing an event' do
     end
 
     obj = double('object', :aasm => double('aasm', :current_state => :open))
-    obj.should_receive(:guard_fn).with('arg1', 'arg2').and_return(true)
+    expect(obj).to receive(:guard_fn).with('arg1', 'arg2').and_return(true)
 
-    event.fire(obj, nil, 'arg1', 'arg2').should == :closed
+    expect(event.fire(obj, nil, 'arg1', 'arg2')).to eq(:closed)
   end
 
 end
@@ -101,7 +101,7 @@ describe 'should fire callbacks' do
       }
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:symbol_success_callback)
+      expect(model).to receive(:symbol_success_callback)
       model.with_symbol!
     end
 
@@ -115,7 +115,7 @@ describe 'should fire callbacks' do
       }
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:string_success_callback)
+      expect(model).to receive(:string_success_callback)
       model.with_string!
     end
 
@@ -129,8 +129,8 @@ describe 'should fire callbacks' do
       }
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:success_callback1)
-      model.should_receive(:success_callback2)
+      expect(model).to receive(:success_callback1)
+      expect(model).to receive(:success_callback2)
       model.with_array!
     end
 
@@ -144,9 +144,9 @@ describe 'should fire callbacks' do
       }
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:success_callback1)
-      model.should_receive(:success_callback2)
-      model.should_receive(:proc_success_callback)
+      expect(model).to receive(:success_callback1)
+      expect(model).to receive(:success_callback2)
+      expect(model).to receive(:proc_success_callback)
       model.with_array_including_procs!
     end
 
@@ -160,7 +160,7 @@ describe 'should fire callbacks' do
       }
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:proc_success_callback)
+      expect(model).to receive(:proc_success_callback)
       model.with_proc!
     end
   end
@@ -182,9 +182,9 @@ describe 'should fire callbacks' do
       end
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:do_one_thing_after).once.ordered
-      model.should_receive(:do_another_thing_after_too).once.ordered
-      model.should_receive(:do_third_thing_at_last).once.ordered
+      expect(model).to receive(:do_one_thing_after).once.ordered
+      expect(model).to receive(:do_another_thing_after_too).once.ordered
+      expect(model).to receive(:do_third_thing_at_last).once.ordered
       model.with_afters!
     end
   end
@@ -203,7 +203,7 @@ describe 'should fire callbacks' do
       end
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:do_something_before).once
+      expect(model).to receive(:do_something_before).once
       model.before_as_proc!
     end
   end
@@ -221,8 +221,8 @@ describe 'should fire callbacks' do
     end
 
     model = ThisNameBetterNotBeInUse.new
-    model.should_receive(:do_something_before).once.ordered
-    model.should_receive(:do_something_after).once.ordered
+    expect(model).to receive(:do_something_before).once.ordered
+    expect(model).to receive(:do_something_after).once.ordered
     model.in_right_order!
   end
 end
@@ -232,40 +232,40 @@ describe 'parametrised events' do
 
   it 'should transition to specified next state (sleeping to showering)' do
     pe.wakeup!(:showering)
-    pe.aasm.current_state.should == :showering
+    expect(pe.aasm.current_state).to eq(:showering)
   end
 
   it 'should transition to specified next state (sleeping to working)' do
     pe.wakeup!(:working)
-    pe.aasm.current_state.should == :working
+    expect(pe.aasm.current_state).to eq(:working)
   end
 
   it 'should transition to default (first or showering) state' do
     pe.wakeup!
-    pe.aasm.current_state.should == :showering
+    expect(pe.aasm.current_state).to eq(:showering)
   end
 
   it 'should transition to default state when on_transition invoked' do
     pe.dress!(nil, 'purple', 'dressy')
-    pe.aasm.current_state.should == :working
+    expect(pe.aasm.current_state).to eq(:working)
   end
 
   it 'should call on_transition method with args' do
     pe.wakeup!(:showering)
-    pe.should_receive(:wear_clothes).with('blue', 'jeans')
+    expect(pe).to receive(:wear_clothes).with('blue', 'jeans')
     pe.dress!(:working, 'blue', 'jeans')
   end
 
   it 'should call on_transition proc' do
     pe.wakeup!(:showering)
-    pe.should_receive(:wear_clothes).with('purple', 'slacks')
+    expect(pe).to receive(:wear_clothes).with('purple', 'slacks')
     pe.dress!(:dating, 'purple', 'slacks')
   end
 
   it 'should call on_transition with an array of methods' do
     pe.wakeup!(:showering)
-    pe.should_receive(:condition_hair)
-    pe.should_receive(:fix_hair)
+    expect(pe).to receive(:condition_hair)
+    expect(pe).to receive(:fix_hair)
     pe.dress!(:prettying_up)
   end
 end
@@ -274,9 +274,9 @@ 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
-    foo.should be_open
+    expect(foo).to be_open
 
-    foo.should_receive(:aasm_write_state_without_persistence)
+    expect(foo).to receive(:aasm_write_state_without_persistence)
     foo.close
   end
 end

data/spec/unit/guard_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe "per-transition guards" do
+  let(:guardian) { Guardian.new }
+
+  it "allows the transition if the guard succeeds" do
+    expect { guardian.use_one_guard_that_succeeds! }.to_not raise_error
+    expect(guardian).to be_beta
+  end
+
+  it "stops the transition if the guard fails" do
+    expect { guardian.use_one_guard_that_fails! }.to raise_error(AASM::InvalidTransition)
+    expect(guardian).to be_alpha
+  end
+
+  it "allows the transition if all guards succeeds" do
+    expect { guardian.use_guards_that_succeed! }.to_not raise_error
+    expect(guardian).to be_beta
+  end
+
+  it "stops the transition if the first guard fails" do
+    expect { guardian.use_guards_where_the_first_fails! }.to raise_error(AASM::InvalidTransition)
+    expect(guardian).to be_alpha
+  end
+
+  it "stops the transition if the second guard fails" do
+    expect { guardian.use_guards_where_the_second_fails! }.to raise_error(AASM::InvalidTransition)
+    expect(guardian).to be_alpha
+  end
+end
+
+describe "event guards" do
+  let(:guardian) { Guardian.new }
+
+  it "allows the transition if the event guards succeed" do
+    expect { guardian.use_event_guards_that_succeed! }.to_not raise_error
+    expect(guardian).to be_beta
+  end
+
+  it "allows the transition if the event and transition guards succeed" do
+    expect { guardian.use_event_and_transition_guards_that_succeed! }.to_not raise_error
+    expect(guardian).to be_beta
+  end
+
+  it "stops the transition if the first event guard fails" do
+    expect { guardian.use_event_guards_where_the_first_fails! }.to raise_error(AASM::InvalidTransition)
+    expect(guardian).to be_alpha
+  end
+
+  it "stops the transition if the second event guard fails" do
+    expect { guardian.use_event_guards_where_the_second_fails! }.to raise_error(AASM::InvalidTransition)
+    expect(guardian).to be_alpha
+  end
+
+  it "stops the transition if the transition guard fails" do
+    expect { guardian.use_event_and_transition_guards_where_third_fails! }.to raise_error(AASM::InvalidTransition)
+    expect(guardian).to be_alpha
+  end
+
+end