aasm 3.0.24 → 3.1.0

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.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,28 @@ 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 '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 +71,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 +81,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 +93,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 +168,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
+        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
-          after do
-            do_third_thing_at_last
-          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,33 +192,37 @@ 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
@@ -219,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
@@ -261,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

data/spec/unit/initial_state_spec.rb

@@ -5,8 +5,8 @@ class Banker
   aasm do
     state :retired
     state :selling_bad_mortgages
+    initial_state Proc.new { |banker| banker.rich? ? :retired : :selling_bad_mortgages }
   end
-  aasm_initial_state  Proc.new { |banker| banker.rich? ? :retired : :selling_bad_mortgages }
   RICH = 1_000_000
   attr_accessor :balance
   def initialize(balance = 0); self.balance = balance; end
@@ -17,12 +17,11 @@ describe 'initial states' do
   let(:bar) {Bar.new}
 
   it 'should use the first state defined if no initial state is given' do
-    bar.aasm_current_state.should == :read
-    # bar.aasm.current_state.should == :read # not yet supported
+    expect(bar.aasm.current_state).to eq(:read)
   end
 
   it 'should determine initial state from the Proc results' do
-    Banker.new(Banker::RICH - 1).aasm_current_state.should == :selling_bad_mortgages
-    Banker.new(Banker::RICH + 1).aasm_current_state.should == :retired
+    expect(Banker.new(Banker::RICH - 1).aasm.current_state).to eq(:selling_bad_mortgages)
+    expect(Banker.new(Banker::RICH + 1).aasm.current_state).to eq(:retired)
   end
 end

data/spec/unit/inspection_spec.rb

@@ -1,30 +1,17 @@
 require 'spec_helper'
 
 describe 'inspection for common cases' do
-  it 'should support the old DSL' do
-    Foo.should respond_to(:aasm_states)
-    Foo.aasm_states.should include(:open)
-    Foo.aasm_states.should include(:closed)
-
-    Foo.should respond_to(:aasm_initial_state)
-    Foo.aasm_initial_state.should == :open
-
-    Foo.should respond_to(:aasm_events)
-    Foo.aasm_events.should include(:close)
-    Foo.aasm_events.should include(:null)
-  end
-
   it 'should support the new DSL' do
-    Foo.aasm.should respond_to(:states)
-    Foo.aasm.states.should include(:open)
-    Foo.aasm.states.should include(:closed)
+    expect(Foo.aasm).to respond_to(:states)
+    expect(Foo.aasm.states).to include(:open)
+    expect(Foo.aasm.states).to include(:closed)
 
-    Foo.aasm.should respond_to(:initial_state)
-    Foo.aasm.initial_state.should == :open
+    expect(Foo.aasm).to respond_to(:initial_state)
+    expect(Foo.aasm.initial_state).to eq(:open)
 
-    Foo.aasm.should respond_to(:events)
-    Foo.aasm.events.should include(:close)
-    Foo.aasm.events.should include(:null)
+    expect(Foo.aasm).to respond_to(:events)
+    expect(Foo.aasm.events).to include(:close)
+    expect(Foo.aasm.events).to include(:null)
   end
 
   context "instance level inspection" do
@@ -33,77 +20,77 @@ describe 'inspection for common cases' do
 
     it "delivers all states" do
       states = foo.aasm.states
-      states.should include(:open)
-      states.should include(:closed)
+      expect(states).to include(:open)
+      expect(states).to include(:closed)
 
       states = foo.aasm.states(:permissible => true)
-      states.should include(:closed)
-      states.should_not include(:open)
+      expect(states).to include(:closed)
+      expect(states).not_to include(:open)
 
       foo.close
-      foo.aasm.states(:permissible => true).should be_empty
+      expect(foo.aasm.states(:permissible => true)).to be_empty
     end
 
     it "delivers all states for subclasses" do
       states = two.aasm.states
-      states.should include(:open)
-      states.should include(:closed)
-      states.should include(:foo)
+      expect(states).to include(:open)
+      expect(states).to include(:closed)
+      expect(states).to include(:foo)
 
       states = two.aasm.states(:permissible => true)
-      states.should include(:closed)
-      states.should_not include(:open)
+      expect(states).to include(:closed)
+      expect(states).not_to include(:open)
 
       two.close
-      two.aasm.states(:permissible => true).should be_empty
+      expect(two.aasm.states(:permissible => true)).to be_empty
     end
 
     it "delivers all events" do
       events = foo.aasm.events
-      events.should include(:close)
-      events.should include(:null)
+      expect(events).to include(:close)
+      expect(events).to include(:null)
       foo.close
-      foo.aasm.events.should be_empty
+      expect(foo.aasm.events).to be_empty
     end
   end
 
   it 'should list states in the order they have been defined' do
-    Conversation.aasm.states.should == [:needs_attention, :read, :closed, :awaiting_response, :junk]
+    expect(Conversation.aasm.states).to eq([:needs_attention, :read, :closed, :awaiting_response, :junk])
   end
 end
 
 describe "special cases" do
   it "should support valid a state name" do
-    Argument.aasm_states.should include(:invalid)
-    Argument.aasm_states.should include(:valid)
+    expect(Argument.aasm.states).to include(:invalid)
+    expect(Argument.aasm.states).to include(:valid)
 
     argument = Argument.new
-    argument.invalid?.should be_true
-    argument.aasm_current_state.should == :invalid
+    expect(argument.invalid?).to be_true
+    expect(argument.aasm.current_state).to eq(:invalid)
 
     argument.valid!
-    argument.valid?.should be_true
-    argument.aasm_current_state.should == :valid
+    expect(argument.valid?).to be_true
+    expect(argument.aasm.current_state).to eq(:valid)
   end
 end
 
-describe :aasm_states_for_select do
+describe 'aasm.states_for_select' do
   it "should return a select friendly array of states" do
-    Foo.should respond_to(:aasm_states_for_select)
-    Foo.aasm_states_for_select.should == [['Open', 'open'], ['Closed', 'closed']]
+    expect(Foo.aasm).to respond_to(:states_for_select)
+    expect(Foo.aasm.states_for_select).to eq([['Open', 'open'], ['Closed', 'closed']])
   end
 end
 
-describe :aasm_from_states_for_state do
+describe 'aasm.from_states_for_state' do
   it "should return all from states for a state" do
-    AuthMachine.should respond_to(:aasm_from_states_for_state)
-    froms = AuthMachine.aasm_from_states_for_state(:active)
-    [:pending, :passive, :suspended].each {|from| froms.should include(from)}
+    expect(AuthMachine.aasm).to respond_to(:from_states_for_state)
+    froms = AuthMachine.aasm.from_states_for_state(:active)
+    [:pending, :passive, :suspended].each {|from| expect(froms).to include(from)}
   end
 
   it "should return from states for a state for a particular transition only" do
-    froms = AuthMachine.aasm_from_states_for_state(:active, :transition => :unsuspend)
-    [:suspended].each {|from| froms.should include(from)}
+    froms = AuthMachine.aasm.from_states_for_state(:active, :transition => :unsuspend)
+    [:suspended].each {|from| expect(froms).to include(from)}
   end
 end
 
@@ -111,7 +98,7 @@ describe 'permissible events' do
   let(:foo) {Foo.new}
 
   it 'work' do
-    foo.aasm.permissible_events.should include(:close)
-    foo.aasm.permissible_events.should_not include(:null)
+    expect(foo.aasm.permissible_events).to include(:close)
+    expect(foo.aasm.permissible_events).not_to include(:null)
   end
 end