aasm 3.0.24 → 3.4.0

data/spec/unit/callbacks_spec.rb

@@ -1,36 +1,18 @@
 require 'spec_helper'
 
-describe 'callbacks for the old DSL' do
-  let(:callback) {CallbackOldDsl.new}
-
-  it "should get close callbacks" 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
-
-    callback.close!
-  end
-end
-
 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
@@ -40,8 +22,10 @@ describe 'event callbacks' do
   describe "with an error callback defined" do
     before do
       class Foo
-        aasm_event :safe_close, :success => :success_callback, :error => :error_callback do
-          transitions :to => :closed, :from => [:open]
+        aasm do
+          event :safe_close, :success => :success_callback, :error => :error_callback do
+            transitions :to => :closed, :from => [:open]
+          end
         end
       end
 
@@ -51,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
 
@@ -75,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
@@ -98,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,15 @@ describe 'when being unsuspended' do
     auth.suspend!
     auth.unsuspend!
 
-    auth.aasm_current_state.should == :passive
+    expect(auth.aasm.current_state).to eq(:passive)
   end
+
+  it "should be able to fire known events" do
+    expect(auth.aasm.may_fire_event?(:activate)).to be_true
+  end
+
+  it "should not be able to fire unknown events" do
+    expect(auth.aasm.may_fire_event?(:unknown)).to be_false
+  end
+
 end

data/spec/unit/event_naming_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+class SimpleStateMachine
+  include AASM
+
+  aasm do
+    state :init, :initial => true
+    state :failed
+
+    event :failed do
+      transitions :from => :init, :to => :failed
+    end
+  end
+end
+
+describe "event naming" do
+  let(:state_machine) { SimpleStateMachine.new }
+
+  it "allows an event of failed without blowing the stack" do
+    state_machine.failed
+
+    expect { state_machine.failed }.to raise_error(AASM::InvalidTransition)
+  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.all_transitions
-    transitions[0].from.should == :open
-    transitions[0].to.should == :closed
-    transitions[1].from.should == :received
-    transitions[1].to.should == :closed
+    transitions = event.transitions
+    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,29 +42,45 @@ 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
 
+describe 'transition inspection without from' do
+  let(:event) do
+    AASM::Event.new(:run) do
+      transitions :to => :running
+    end
+  end
+
+  it 'should support inspecting transitions from other states' do
+    expect(event.transitions_from_state(:sleeping).map(&:to)).to eq([:running])
+    expect(event.transitions_from_state?(:sleeping)).to be_true
+
+    expect(event.transitions_from_state(:cleaning).map(&:to)).to eq([:running])
+    expect(event.transitions_from_state?(:cleaning)).to be_true
+  end
+
+end
+
 describe 'firing an event' do
   it 'should return nil if the transitions are empty' do
-    obj = double('object')
-    obj.stub(:aasm_current_state)
+    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
@@ -72,10 +88,9 @@ describe 'firing an event' do
       transitions :to => :closed, :from => [:open, :received]
     end
 
-    obj = double('object')
-    obj.stub(:aasm_current_state).and_return(:open)
+    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
@@ -83,11 +98,10 @@ describe 'firing an event' do
       transitions :to => :closed, :from => [:open, :received], :guard => :guard_fn
     end
 
-    obj = double('object')
-    obj.stub(:aasm_current_state).and_return(:open)
-    obj.should_receive(:guard_fn).with('arg1', 'arg2').and_return(true)
+    obj = double('object', :aasm => double('aasm', :current_state => :open))
+    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
@@ -96,64 +110,74 @@ describe 'should fire callbacks' do
   describe 'success' do
     it "if it's a symbol" do
       ThisNameBetterNotBeInUse.instance_eval {
-        aasm_event :with_symbol, :success => :symbol_success_callback do
-          transitions :to => :symbol, :from => [:initial]
+        aasm do
+          event :with_symbol, :success => :symbol_success_callback do
+            transitions :to => :symbol, :from => [:initial]
+          end
         end
       }
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:symbol_success_callback)
+      expect(model).to receive(:symbol_success_callback)
       model.with_symbol!
     end
 
     it "if it's a string" do
       ThisNameBetterNotBeInUse.instance_eval {
-        aasm_event :with_string, :success => 'string_success_callback' do
-          transitions :to => :string, :from => [:initial]
+        aasm do
+          event :with_string, :success => 'string_success_callback' do
+            transitions :to => :string, :from => [:initial]
+          end
         end
       }
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:string_success_callback)
+      expect(model).to receive(:string_success_callback)
       model.with_string!
     end
 
     it "if passed an array of strings and/or symbols" do
       ThisNameBetterNotBeInUse.instance_eval {
-        aasm_event :with_array, :success => [:success_callback1, 'success_callback2'] do
-          transitions :to => :array, :from => [:initial]
+        aasm do
+          event :with_array, :success => [:success_callback1, 'success_callback2'] do
+            transitions :to => :array, :from => [:initial]
+          end
         end
       }
 
       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
 
     it "if passed an array of strings and/or symbols and/or procs" do
       ThisNameBetterNotBeInUse.instance_eval {
-        aasm_event :with_array_including_procs, :success => [:success_callback1, 'success_callback2', lambda { proc_success_callback }] do
-          transitions :to => :array, :from => [:initial]
+        aasm do
+          event :with_array_including_procs, :success => [:success_callback1, 'success_callback2', lambda { proc_success_callback }] do
+            transitions :to => :array, :from => [:initial]
+          end
         end
       }
 
       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
 
     it "if it's a proc" do
       ThisNameBetterNotBeInUse.instance_eval {
-        aasm_event :with_proc, :success => lambda { proc_success_callback } do
-          transitions :to => :proc, :from => [:initial]
+        aasm do
+          event :with_proc, :success => lambda { proc_success_callback } do
+            transitions :to => :proc, :from => [:initial]
+          end
         end
       }
 
       model = ThisNameBetterNotBeInUse.new
-      model.should_receive(:proc_success_callback)
+      expect(model).to receive(:proc_success_callback)
       model.with_proc!
     end
   end
@@ -161,21 +185,23 @@ describe 'should fire callbacks' do
   describe 'after' do
     it "if they set different ways" do
       ThisNameBetterNotBeInUse.instance_eval do
-        aasm_event :with_afters, :after => :do_one_thing_after do
-          after do
-            do_another_thing_after_too
-          end
-          after do
-            do_third_thing_at_last
+        aasm do
+          event :with_afters, :after => :do_one_thing_after do
+            after do
+              do_another_thing_after_too
+            end
+            after do
+              do_third_thing_at_last
+            end
+            transitions :to => :proc, :from => [:initial]
           end
-          transitions :to => :proc, :from => [:initial]
         end
       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
@@ -183,76 +209,98 @@ describe 'should fire callbacks' do
   describe 'before' do
     it "if it's a proc" do
       ThisNameBetterNotBeInUse.instance_eval do
-        aasm_event :before_as_proc do
-          before do
-            do_something_before
+        aasm do
+          event :before_as_proc do
+            before do
+              do_something_before
+            end
+            transitions :to => :proc, :from => [:initial]
           end
-          transitions :to => :proc, :from => [:initial]
         end
       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
 
   it 'in right order' do
     ThisNameBetterNotBeInUse.instance_eval do
-      aasm_event :in_right_order, :after => :do_something_after do
-        before do
-          do_something_before
+      aasm do
+        event :in_right_order, :after => :do_something_after do
+          before do
+            do_something_before
+          end
+          transitions :to => :proc, :from => [:initial]
         end
-        transitions :to => :proc, :from => [:initial]
       end
     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
 
+describe 'current event' do
+  let(:pe) {ParametrisedEvent.new}
+
+  it 'if no event has been triggered' do
+    expect(pe.aasm.current_event).to be_nil
+  end
+
+  it 'if a event has been triggered' do
+    pe.wakeup
+    expect(pe.aasm.current_event).to eql :wakeup
+  end
+
+  it 'if no event has been triggered' do
+    pe.wakeup!
+    expect(pe.aasm.current_event).to eql :wakeup!
+  end
+end
+
 describe 'parametrised events' do
   let(:pe) {ParametrisedEvent.new}
 
   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
@@ -261,9 +309,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