aasm 3.0.25 → 3.1.0

data/spec/unit/localizer_spec.rb

@@ -30,11 +30,15 @@ describe 'localized state names' do
   end
 
   it 'should localize' do
-    LocalizerTestModel.aasm.states.detect {|s| s == :opened}.localized_name.should == "It's open now!"
+    state = LocalizerTestModel.aasm.states.detect {|s| s == :opened}
+    expect(state.localized_name).to eq("It's open now!")
+    expect(state.human_name).to eq("It's open now!")
   end
 
   it 'should use fallback' do
-    LocalizerTestModel.aasm.states.detect {|s| s == :closed}.localized_name.should == 'Closed'
+    state = LocalizerTestModel.aasm.states.detect {|s| s == :closed}
+    expect(state.localized_name).to eq('Closed')
+    expect(state.human_name).to eq('Closed')
   end
 end
 
@@ -54,21 +58,21 @@ describe AASM::Localizer, "new style" do
 
   context 'aasm.human_state' do
     it 'should return translated state value' do
-      foo_opened.aasm.human_state.should == "It's open now!"
+      expect(foo_opened.aasm.human_state).to eq("It's open now!")
     end
 
     it 'should return humanized value if not localized' do
-      foo_closed.aasm.human_state.should == "Closed"
+      expect(foo_closed.aasm.human_state).to eq("Closed")
     end
   end
 
   context 'aasm_human_event_name' do
     it 'should return translated event name' do
-      LocalizerTestModel.aasm_human_event_name(:close).should == "Let's close it!"
+      expect(LocalizerTestModel.aasm_human_event_name(:close)).to eq("Let's close it!")
     end
 
     it 'should return humanized event name' do
-      LocalizerTestModel.aasm_human_event_name(:open).should == "Open"
+      expect(LocalizerTestModel.aasm_human_event_name(:open)).to eq("Open")
     end
   end
 end
@@ -89,21 +93,21 @@ describe AASM::Localizer, "deprecated style" do
 
   context 'aasm.human_state' do
     it 'should return translated state value' do
-      foo_opened.aasm.human_state.should == "It's open now!"
+      expect(foo_opened.aasm.human_state).to eq("It's open now!")
     end
 
     it 'should return humanized value if not localized' do
-      foo_closed.aasm.human_state.should == "Closed"
+      expect(foo_closed.aasm.human_state).to eq("Closed")
     end
   end
 
   context 'aasm_human_event_name' do
     it 'should return translated event name' do
-      LocalizerTestModel.aasm_human_event_name(:close).should == "Let's close it!"
+      expect(LocalizerTestModel.aasm_human_event_name(:close)).to eq("Let's close it!")
     end
 
     it 'should return humanized event name' do
-      LocalizerTestModel.aasm_human_event_name(:open).should == "Open"
+      expect(LocalizerTestModel.aasm_human_event_name(:open)).to eq("Open")
     end
   end
 end

data/spec/unit/new_dsl_spec.rb

@@ -5,8 +5,8 @@ describe "the new dsl" do
   let(:process) {ProcessWithNewDsl.new}
 
   it 'should not conflict with other event or state methods' do
-    lambda {ProcessWithNewDsl.state}.should raise_error(RuntimeError, "wrong state method")
-    lambda {ProcessWithNewDsl.event}.should raise_error(RuntimeError, "wrong event method")
+    expect {ProcessWithNewDsl.state}.to raise_error(RuntimeError, "wrong state method")
+    expect {ProcessWithNewDsl.event}.to raise_error(RuntimeError, "wrong event method")
   end
 
 end

data/spec/unit/persistence/active_record_persistence_spec.rb

@@ -9,8 +9,8 @@ load_schema
 
 shared_examples_for "aasm model" do
   it "should include persistence mixins" do
-    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence)
-    klass.included_modules.should be_include(AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
+    expect(klass.included_modules).to be_include(AASM::Persistence::ActiveRecordPersistence)
+    expect(klass.included_modules).to be_include(AASM::Persistence::ActiveRecordPersistence::InstanceMethods)
   end
 end
 
@@ -18,45 +18,45 @@ describe "instance methods" do
   let(:gate) {Gate.new}
 
   it "should respond to aasm persistence methods" do
-    gate.should respond_to(:aasm_read_state)
-    gate.should respond_to(:aasm_write_state)
-    gate.should respond_to(:aasm_write_state_without_persistence)
+    expect(gate).to respond_to(:aasm_read_state)
+    expect(gate).to respond_to(:aasm_write_state)
+    expect(gate).to respond_to(:aasm_write_state_without_persistence)
   end
 
   it "should return the initial state when new and the aasm field is nil" do
-    gate.aasm.current_state.should == :opened
+    expect(gate.aasm.current_state).to eq(:opened)
   end
 
   it "should return the aasm column when new and the aasm field is not nil" do
     gate.aasm_state = "closed"
-    gate.aasm.current_state.should == :closed
+    expect(gate.aasm.current_state).to eq(:closed)
   end
 
   it "should return the aasm column when not new and the aasm_column is not nil" do
-    gate.stub(:new_record?).and_return(false)
+    allow(gate).to receive(:new_record?).and_return(false)
     gate.aasm_state = "state"
-    gate.aasm.current_state.should == :state
+    expect(gate.aasm.current_state).to eq(:state)
   end
 
   it "should allow a nil state" do
-    gate.stub(:new_record?).and_return(false)
+    allow(gate).to receive(:new_record?).and_return(false)
     gate.aasm_state = nil
-    gate.aasm.current_state.should be_nil
+    expect(gate.aasm.current_state).to be_nil
   end
 
   it "should call aasm_ensure_initial_state on validation before create" do
-    gate.should_receive(:aasm_ensure_initial_state).and_return(true)
+    expect(gate).to receive(:aasm_ensure_initial_state).and_return(true)
     gate.valid?
   end
 
   it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-    gate.should_receive(:aasm_ensure_initial_state).and_return(true)
+    expect(gate).to receive(:aasm_ensure_initial_state).and_return(true)
     gate.save(:validate => false)
   end
 
   it "should not call aasm_ensure_initial_state on validation before update" do
-    gate.stub(:new_record?).and_return(false)
-    gate.should_not_receive(:aasm_ensure_initial_state)
+    allow(gate).to receive(:new_record?).and_return(false)
+    expect(gate).not_to receive(:aasm_ensure_initial_state)
     gate.valid?
   end
 
@@ -64,36 +64,36 @@ end
 
 describe 'subclasses' do
   it "should have the same states as its parent class" do
-    DerivateNewDsl.aasm.states.should == SimpleNewDsl.aasm.states
+    expect(DerivateNewDsl.aasm.states).to eq(SimpleNewDsl.aasm.states)
   end
 
   it "should have the same events as its parent class" do
-    DerivateNewDsl.aasm.events.should == SimpleNewDsl.aasm.events
+    expect(DerivateNewDsl.aasm.events).to eq(SimpleNewDsl.aasm.events)
   end
 
   it "should have the same column as its parent even for the new dsl" do
-    SimpleNewDsl.aasm_column.should == :status
-    DerivateNewDsl.aasm_column.should == :status
+    expect(SimpleNewDsl.aasm_column).to eq(:status)
+    expect(DerivateNewDsl.aasm_column).to eq(:status)
   end
 end
 
 describe "named scopes with the new DSL" do
   context "Does not already respond_to? the scope name" do
     it "should add a scope" do
-      SimpleNewDsl.should respond_to(:unknown_scope)
-      SimpleNewDsl.unknown_scope.is_a?(ActiveRecord::Relation).should be_true
+      expect(SimpleNewDsl).to respond_to(:unknown_scope)
+      expect(SimpleNewDsl.unknown_scope.is_a?(ActiveRecord::Relation)).to be_true
     end
   end
 
   context "Already respond_to? the scope name" do
     it "should not add a scope" do
-      SimpleNewDsl.should respond_to(:new)
-      SimpleNewDsl.new.class.should == SimpleNewDsl
+      expect(SimpleNewDsl).to respond_to(:new)
+      expect(SimpleNewDsl.new.class).to eq(SimpleNewDsl)
     end
   end
 
   it "does not create scopes if requested" do
-    NoScope.should_not respond_to(:ignored_scope)
+    expect(NoScope).not_to respond_to(:ignored_scope)
   end
 
 end
@@ -101,8 +101,8 @@ end
 describe 'initial states' do
 
   it 'should support conditions' do
-    Thief.new(:skilled => true).aasm.current_state.should == :rich
-    Thief.new(:skilled => false).aasm.current_state.should == :jailed
+    expect(Thief.new(:skilled => true).aasm.current_state).to eq(:rich)
+    expect(Thief.new(:skilled => false).aasm.current_state).to eq(:jailed)
   end
 end
 
@@ -110,54 +110,54 @@ describe 'transitions with persistence' do
 
   it "should work for valid models" do
     valid_object = Validator.create(:name => 'name')
-    valid_object.should be_sleeping
+    expect(valid_object).to be_sleeping
     valid_object.status = :running
-    valid_object.should be_running
+    expect(valid_object).to be_running
   end
 
   it 'should not store states for invalid models' do
     validator = Validator.create(:name => 'name')
-    validator.should be_valid
-    validator.should be_sleeping
+    expect(validator).to be_valid
+    expect(validator).to be_sleeping
 
     validator.name = nil
-    validator.should_not be_valid
-    validator.run!.should be_false
-    validator.should be_sleeping
+    expect(validator).not_to be_valid
+    expect(validator.run!).to be_false
+    expect(validator).to be_sleeping
 
     validator.reload
-    validator.should_not be_running
-    validator.should be_sleeping
+    expect(validator).not_to be_running
+    expect(validator).to be_sleeping
 
     validator.name = 'another name'
-    validator.should be_valid
-    validator.run!.should be_true
-    validator.should be_running
+    expect(validator).to be_valid
+    expect(validator.run!).to be_true
+    expect(validator).to be_running
 
     validator.reload
-    validator.should be_running
-    validator.should_not be_sleeping
+    expect(validator).to be_running
+    expect(validator).not_to be_sleeping
   end
 
   it 'should store states for invalid models if configured' do
     persistor = InvalidPersistor.create(:name => 'name')
-    persistor.should be_valid
-    persistor.should be_sleeping
+    expect(persistor).to be_valid
+    expect(persistor).to be_sleeping
 
     persistor.name = nil
-    persistor.should_not be_valid
-    persistor.run!.should be_true
-    persistor.should be_running
+    expect(persistor).not_to be_valid
+    expect(persistor.run!).to be_true
+    expect(persistor).to be_running
 
     persistor = InvalidPersistor.find(persistor.id)
     persistor.valid?
-    persistor.should be_valid
-    persistor.should be_running
-    persistor.should_not be_sleeping
+    expect(persistor).to be_valid
+    expect(persistor).to be_running
+    expect(persistor).not_to be_sleeping
 
     persistor.reload
-    persistor.should be_running
-    persistor.should_not be_sleeping
+    expect(persistor).to be_running
+    expect(persistor).not_to be_sleeping
   end
 
   describe 'transactions' do
@@ -165,41 +165,81 @@ describe 'transitions with persistence' do
     let(:transactor) { Transactor.create!(:name => 'transactor', :worker => worker) }
 
     it 'should rollback all changes' do
-      transactor.should be_sleeping
-      worker.status.should == 'sleeping'
+      expect(transactor).to be_sleeping
+      expect(worker.status).to eq('sleeping')
 
-      lambda {transactor.run!}.should raise_error(StandardError, 'failed on purpose')
-      transactor.should be_running
-      worker.reload.status.should == 'sleeping'
+      expect {transactor.run!}.to raise_error(StandardError, 'failed on purpose')
+      expect(transactor).to be_running
+      expect(worker.reload.status).to eq('sleeping')
     end
 
-    it "should rollback all changes in nested transaction" do
-      transactor.should be_sleeping
-      worker.status.should == 'sleeping'
+    context "nested transactions" do
+      it "should rollback all changes in nested transaction" do
+        expect(transactor).to be_sleeping
+        expect(worker.status).to eq('sleeping')
 
-      Worker.transaction do
-        lambda { transactor.run! }.should raise_error(StandardError, 'failed on purpose')
+        Worker.transaction do
+          expect { transactor.run! }.to raise_error(StandardError, 'failed on purpose')
+        end
+
+        expect(transactor).to be_running
+        expect(worker.reload.status).to eq('sleeping')
       end
 
-      transactor.should be_running
-      worker.reload.status.should == 'sleeping'
+      it "should only rollback changes in the main transaction not the nested one" do
+        # change configuration to not require new transaction
+        AASM::StateMachine[Transactor].config.requires_new_transaction = false
+
+        expect(transactor).to be_sleeping
+        expect(worker.status).to eq('sleeping')
+
+        Worker.transaction do
+          expect { transactor.run! }.to raise_error(StandardError, 'failed on purpose')
+        end
+
+        expect(transactor).to be_running
+        expect(worker.reload.status).to eq('running')
+      end
     end
 
     describe "after_commit callback" do
       it "should fire :after_commit if transaction was successful" do
         validator = Validator.create(:name => 'name')
-        validator.should be_sleeping
+        expect(validator).to be_sleeping
         validator.run!
-        validator.should be_running
-        validator.name.should_not == "name"
+        expect(validator).to be_running
+        expect(validator.name).not_to eq("name")
       end
 
       it "should not fire :after_commit if transaction failed" do
         validator = Validator.create(:name => 'name')
-        lambda { validator.fail! }.should raise_error(StandardError, 'failed on purpose')
-        validator.name.should == "name"
+        expect { validator.fail! }.to raise_error(StandardError, 'failed on purpose')
+        expect(validator.name).to eq("name")
       end
 
     end
   end
 end
+
+describe "invalid states with persistence" do
+
+  it "should not store states" do
+    validator = Validator.create(:name => 'name')
+    validator.status = 'invalid_state'
+    expect(validator.save).to be_false
+    expect {validator.save!}.to raise_error(ActiveRecord::RecordInvalid)
+
+    validator.reload
+    expect(validator).to be_sleeping
+  end
+
+  it "should store invalid states if configured" do
+    persistor = InvalidPersistor.create(:name => 'name')
+    persistor.status = 'invalid_state'
+    expect(persistor.save).to be_true
+
+    persistor.reload
+    expect(persistor.status).to eq('invalid_state')
+  end
+
+end

data/spec/unit/persistence/mongoid_persistance_spec.rb

@@ -27,15 +27,15 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
 
       context "Does not already respond_to? the scope name" do
         it "should add a scope" do
-          SimpleMongoid.should respond_to(:unknown_scope)
-          SimpleMongoid.unknown_scope.class.should == Mongoid::Criteria
+          expect(SimpleMongoid).to respond_to(:unknown_scope)
+          expect(SimpleMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
         end
       end
 
       context "Already respond_to? the scope name" do
         it "should not add a scope" do
-          SimpleMongoid.should respond_to(:new)
-          SimpleMongoid.new.class.should == SimpleMongoid
+          expect(SimpleMongoid).to respond_to(:new)
+          expect(SimpleMongoid.new.class).to eq(SimpleMongoid)
         end
       end
 
@@ -45,20 +45,20 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
 
       context "Does not already respond_to? the scope name" do
         it "should add a scope" do
-          SimpleNewDslMongoid.should respond_to(:unknown_scope)
-          SimpleNewDslMongoid.unknown_scope.class.should == Mongoid::Criteria
+          expect(SimpleNewDslMongoid).to respond_to(:unknown_scope)
+          expect(SimpleNewDslMongoid.unknown_scope.class).to eq(Mongoid::Criteria)
         end
       end
 
       context "Already respond_to? the scope name" do
         it "should not add a scope" do
-          SimpleNewDslMongoid.should respond_to(:new)
-          SimpleNewDslMongoid.new.class.should == SimpleNewDslMongoid
+          expect(SimpleNewDslMongoid).to respond_to(:new)
+          expect(SimpleNewDslMongoid.new.class).to eq(SimpleNewDslMongoid)
         end
       end
 
       it "does not create scopes if requested" do
-        NoScopeMongoid.should_not respond_to(:ignored_scope)
+        expect(NoScopeMongoid).not_to respond_to(:ignored_scope)
       end
 
     end
@@ -69,12 +69,12 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
       let!(:model_id) { model._id }
 
       it "should respond to method" do
-        SimpleNewDslMongoid.should respond_to(:find_in_state)
+        expect(SimpleNewDslMongoid).to respond_to(:find_in_state)
       end
 
       it "should find the model when given the correct scope and model id" do
-        SimpleNewDslMongoid.find_in_state(model_id, 'unknown_scope').class.should == SimpleNewDslMongoid
-        SimpleNewDslMongoid.find_in_state(model_id, 'unknown_scope').should == model
+        expect(SimpleNewDslMongoid.find_in_state(model_id, 'unknown_scope').class).to eq(SimpleNewDslMongoid)
+        expect(SimpleNewDslMongoid.find_in_state(model_id, 'unknown_scope')).to eq(model)
       end
 
       it "should raise DocumentNotFound error when given incorrect scope" do
@@ -94,17 +94,17 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
       end
 
       it "should respond to method" do
-        SimpleNewDslMongoid.should respond_to(:count_in_state)
+        expect(SimpleNewDslMongoid).to respond_to(:count_in_state)
       end
 
       it "should return n for a scope with n records persisted" do
-        SimpleNewDslMongoid.count_in_state('unknown_scope').class.should == Fixnum
-        SimpleNewDslMongoid.count_in_state('unknown_scope').should == 3
+        expect(SimpleNewDslMongoid.count_in_state('unknown_scope').class).to eq(Fixnum)
+        expect(SimpleNewDslMongoid.count_in_state('unknown_scope')).to eq(3)
       end
 
       it "should return zero for a scope without records persisted" do
-        SimpleNewDslMongoid.count_in_state('new').class.should == Fixnum
-        SimpleNewDslMongoid.count_in_state('new').should == 0
+        expect(SimpleNewDslMongoid.count_in_state('new').class).to eq(Fixnum)
+        expect(SimpleNewDslMongoid.count_in_state('new')).to eq(0)
       end
 
     end
@@ -117,16 +117,16 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
       end
 
       it "should respond to method" do
-        SimpleNewDslMongoid.should respond_to(:with_state_scope)
+        expect(SimpleNewDslMongoid).to respond_to(:with_state_scope)
       end
 
       it "should correctly process block" do
-        SimpleNewDslMongoid.with_state_scope('unknown_scope') do
+        expect(SimpleNewDslMongoid.with_state_scope('unknown_scope') do
           SimpleNewDslMongoid.count
-        end.should == 3
-        SimpleNewDslMongoid.with_state_scope('new') do
+        end).to eq(3)
+        expect(SimpleNewDslMongoid.with_state_scope('new') do
           SimpleNewDslMongoid.count
-        end.should == 2
+        end).to eq(2)
       end
 
     end
@@ -136,12 +136,12 @@ describe 'mongoid', :if => Gem::Version.create(RUBY_VERSION.dup) >= Gem::Version
       let(:simple) {SimpleNewDslMongoid.new}
 
       it "should call aasm_ensure_initial_state on validation before create" do
-        simple.should_receive(:aasm_ensure_initial_state).and_return(true)
+        expect(simple).to receive(:aasm_ensure_initial_state).and_return(true)
         simple.valid?
       end
 
       it "should call aasm_ensure_initial_state before create, even if skipping validations" do
-        simple.should_receive(:aasm_ensure_initial_state).and_return(true)
+        expect(simple).to receive(:aasm_ensure_initial_state).and_return(true)
         simple.save(:validate => false)
       end
     end

data/spec/unit/simple_example_spec.rb

@@ -20,39 +20,39 @@ describe 'state machine' do
   let(:payment) {Payment.new}
 
   it 'starts with an initial state' do
-    payment.aasm.current_state.should == :initialised
-    payment.should respond_to(:initialised?)
-    payment.should be_initialised
+    expect(payment.aasm.current_state).to eq(:initialised)
+    expect(payment).to respond_to(:initialised?)
+    expect(payment).to be_initialised
   end
 
   it 'allows transitions to other states' do
-    payment.should respond_to(:fill_out)
-    payment.should respond_to(:fill_out!)
+    expect(payment).to respond_to(:fill_out)
+    expect(payment).to respond_to(:fill_out!)
     payment.fill_out!
-    payment.should respond_to(:filled_out?)
-    payment.should be_filled_out
+    expect(payment).to respond_to(:filled_out?)
+    expect(payment).to be_filled_out
 
-    payment.should respond_to(:authorise)
-    payment.should respond_to(:authorise!)
+    expect(payment).to respond_to(:authorise)
+    expect(payment).to respond_to(:authorise!)
     payment.authorise
-    payment.should respond_to(:authorised?)
-    payment.should be_authorised
+    expect(payment).to respond_to(:authorised?)
+    expect(payment).to be_authorised
   end
 
   it 'denies transitions to other states' do
-    lambda {payment.authorise}.should raise_error(AASM::InvalidTransition)
-    lambda {payment.authorise!}.should raise_error(AASM::InvalidTransition)
+    expect {payment.authorise}.to raise_error(AASM::InvalidTransition)
+    expect {payment.authorise!}.to raise_error(AASM::InvalidTransition)
     payment.fill_out
-    lambda {payment.fill_out}.should raise_error(AASM::InvalidTransition)
-    lambda {payment.fill_out!}.should raise_error(AASM::InvalidTransition)
+    expect {payment.fill_out}.to raise_error(AASM::InvalidTransition)
+    expect {payment.fill_out!}.to raise_error(AASM::InvalidTransition)
     payment.authorise
-    lambda {payment.fill_out}.should raise_error(AASM::InvalidTransition)
-    lambda {payment.fill_out!}.should raise_error(AASM::InvalidTransition)
+    expect {payment.fill_out}.to raise_error(AASM::InvalidTransition)
+    expect {payment.fill_out!}.to raise_error(AASM::InvalidTransition)
   end
 
   it 'defines constants for each state name' do
-    Payment::STATE_INITIALISED.should eq(:initialised)
-    Payment::STATE_FILLED_OUT.should eq(:filled_out)
-    Payment::STATE_AUTHORISED.should eq(:authorised)
+    expect(Payment::STATE_INITIALISED).to eq(:initialised)
+    expect(Payment::STATE_FILLED_OUT).to eq(:filled_out)
+    expect(Payment::STATE_AUTHORISED).to eq(:authorised)
   end
 end

data/spec/unit/state_spec.rb

@@ -12,34 +12,34 @@ describe AASM::State do
 
   it 'should set the name' do
     state = new_state
-    state.name.should == :astate
+    expect(state.name).to eq(:astate)
   end
 
   it 'should set the display_name from name' do
-    new_state.display_name.should == 'Astate'
+    expect(new_state.display_name).to eq('Astate')
   end
 
   it 'should set the display_name from options' do
-    new_state(:display => "A State").display_name.should == 'A State'
+    expect(new_state(:display => "A State").display_name).to eq('A State')
   end
 
   it 'should set the options and expose them as options' do
-    new_state.options.should == @options
+    expect(new_state.options).to eq(@options)
   end
 
   it 'should be equal to a symbol of the same name' do
-    new_state.should == :astate
+    expect(new_state).to eq(:astate)
   end
 
   it 'should be equal to a State of the same name' do
-    new_state.should == new_state
+    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')
-    record.should_receive(:foo)
+    expect(record).to receive(:foo)
 
     state.fire_callbacks(:entering, record)
   end
@@ -48,7 +48,7 @@ describe AASM::State do
     state = new_state(:entering => 'foo')
 
     record = double('record')
-    record.should_receive(:foo)
+    expect(record).to receive(:foo)
 
     state.fire_callbacks(:entering, record)
   end
@@ -57,10 +57,10 @@ describe AASM::State do
     state = new_state(:entering => [:a, :b, "c", lambda {|r| r.foobar }])
 
     record = double('record')
-    record.should_receive(:a)
-    record.should_receive(:b)
-    record.should_receive(:c)
-    record.should_receive(:foobar)
+    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
@@ -69,9 +69,9 @@ describe AASM::State do
     state = new_state(:entering => [:a, :b, :c])
 
     record = double('record')
-    record.should_receive(:a)
-    record.should_receive(:b).and_throw(:halt_aasm_chain)
-    record.should_not_receive(:c)
+    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
@@ -80,7 +80,7 @@ describe AASM::State do
     state = new_state(:entering => Proc.new {|r| r.foobar})
 
     record = double('record')
-    record.should_receive(:foobar)
+    expect(record).to receive(:foobar)
 
     state.fire_callbacks(:entering, record)
   end