shoulda-callback-matchers 1.1.1 → 1.1.2

checksums.yaml

@@ -1,7 +1,7 @@
---- 
-SHA1: 
-  metadata.gz: 1c1f3a238962147de08a5dfe77046fc8d4055901
-  data.tar.gz: 58858d72aadfd5821ec598c795fed09364f9fc89
-SHA512: 
-  metadata.gz: 18ee32dd29e5cffc3937e6bde593a0e30304d13d33c37a4bd90c89056c7553d86d987d0020d5b47651d1d313bdbdf86b6ece185633bcce93ae4ff53a39d9a2d4
-  data.tar.gz: d972b21525d285b2af3d366ae74623f56973ce07a68f338f2c4eb8201456d2fd4be2c3fe6c92e541d457f6942e6552ee389517a42053417325999a33859cf294
+---
+SHA1:
+  metadata.gz: 3f00ef72e66bbe84af996f2f435cb49add03642f
+  data.tar.gz: 5bda94451994d17de1f96eba49790dfe5faef9c4
+SHA512:
+  metadata.gz: 34be6faad876bb3488742d1d6f05524440beb6808862e8b67f860859ed428fd52bbb6c67f1db7e5d4b2fe608a5fd10255406d6e11bb1f92ed2ea40ea9b87741b
+  data.tar.gz: 296cfb37d4c2b111c36de75efe7211476a18ccc4e6107e20bd5c4bd54bdab62d0d0111d66e7c0f2b3ea657944bf70c23d73a5b2b4d7d94d11ca0b1f00dd0ef62

data/.travis.yml

@@ -1,19 +1,28 @@
 rvm:
   - 1.9.3
   - 2.0.0
-  - 2.1.2
+  - 2.1.5
+  - 2.2.0
   - rbx-2
   - jruby-19mode
+  - jruby-20mode
   - jruby-head
 
 script: "bundle exec rspec"
 
 gemfile:
+  - gemfiles/rails_4.2.gemfile
   - gemfiles/rails_4.1.gemfile
   - gemfiles/rails_4.0.gemfile
   - gemfiles/rails_3.2.gemfile
   - gemfiles/rails_3.1.gemfile
 
+
 matrix:
-  allow_failures:
-    - rvm: jruby-head
+  exclude:
+    - rvm: 2.2.0
+      gemfile: gemfiles/rails_4.0.gemfile
+    - rvm: 2.2.0
+      gemfile: gemfiles/rails_3.2.gemfile
+    - rvm: 2.2.0
+      gemfile: gemfiles/rails_3.1.gemfile

data/Appraisals

@@ -1,3 +1,9 @@
+appraise 'rails 4.2' do
+  gem 'rails', '~> 4.2.0'
+  gem 'jquery-rails'
+  gem 'sass-rails', '~> 4.0'
+end
+
 appraise 'rails 4.1' do
   gem 'rails', '~> 4.1.0'
   gem 'jquery-rails'

data/Gemfile

@@ -3,12 +3,14 @@ source 'http://rubygems.org'
 gemspec
 
 # For test Rails application
-gem 'sqlite3', :platform => :ruby
+gem 'sqlite3',                          platform: :ruby
 
 # Can't wrap in platform :jruby do...end block because appraisal doesn't support
 # it
-gem 'activerecord-jdbc-adapter',        :platform => :jruby
-gem 'activerecord-jdbcsqlite3-adapter', :platform => :jruby
-gem 'jdbc-sqlite3',                     :platform => :jruby
-gem 'jruby-openssl',                    :platform => :jruby
-gem 'therubyrhino',                     :platform => :jruby
+gem 'activerecord-jdbc-adapter',        platform: :jruby
+gem 'activerecord-jdbcsqlite3-adapter', platform: :jruby
+gem 'jdbc-sqlite3',                     platform: :jruby
+gem 'jruby-openssl',                    platform: :jruby
+gem 'therubyrhino',                     platform: :jruby
+
+gem 'psych',                            platform: :rbx

data/README.md

@@ -8,60 +8,64 @@ Matchers to test before, after and around hooks(currently supports method and ob
 
 Method Callbacks:
 
-    describe Post do
-      it { should callback(:count_comments).before(:save) }
-      it { should callback(:post_to_twitter).after(:create) }
-      it { should callback(:evaluate_if_should_validate).before(:validation) }
-      it { should callback(:add_some_convenience_accessors).after(:find) }
-			
-			# with conditions
-			
-      it { should callback(:assign_something).before(:create).if(:this_is_true) }
-      it { should callback(:destroy_something_else).before(:destroy).unless(:this_is_true) }
-    end
-    
-    describe User do
-      it { should_not callback(:make_email_validation_ready!).before(:validation).on(:update) }
-      it { should callback(:make_email_validation_ready!).before(:validation).on(:create) }
-      it { should callback(:update_user_count).before(:destroy) }
-    end
+````ruby
+describe Post do
+  it { is_expected.to callback(:count_comments).before(:save) }
+  it { is_expected.to callback(:post_to_twitter).after(:create) }
+  it { is_expected.to callback(:evaluate_if_is_should_validate).before(:validation) }
+  it { is_expected.to callback(:add_some_convenience_accessors).after(:find) }
+
+  # with conditions
+
+  it { is_expected.to callback(:assign_something).before(:create).if(:this_is_true) }
+  it { is_expected.to callback(:destroy_something_else).before(:destroy).unless(:this_is_true) }
+end
+
+describe User do
+  it { is_expected.not_to callback(:make_email_validation_ready!).before(:validation).on(:update) }
+  it { is_expected.to callback(:make_email_validation_ready!).before(:validation).on(:create) }
+  it { is_expected.to callback(:update_user_count).before(:destroy) }
+end
+````
 
 Object Callbacks:
 
-    class CallbackClass
-      def before_save
-        ...
-      end
-			
-      def after_create
-        ...
-      end
-			
-      def before_validation
-        ...
-      end
-			
-      def after_find
-        ...
-      end
-    end
-    
-    describe Post do
-      it { should callback(CallbackClass).before(:save) }
-      it { should callback(CallbackClass).after(:create) }
-      it { should callback(CallbackClass).before(:validation) }
-      it { should callback(CallbackClass).after(:find) }
-			
-			# with conditions
-      it { should callback(CallbackClass).before(:create).if(:this_is_true) }
-      it { should callback(CallbackClass).after(:find).unless(:is_this_true?) }
-    end
-    
-    describe User do
-      it { should_not callback(CallbackClass).before(:validation).on(:update) }
-      it { should callback(CallbackClass).before(:validation).on(:create) }
-      it { should callback(CallbackClass).before(:destroy) }
-    end
+````ruby
+class CallbackClass
+  def before_save
+	...
+  end
+
+  def after_create
+	...
+  end
+
+  def before_validation
+	...
+  end
+
+  def after_find
+	...
+  end
+end
+
+describe Post do
+  it { is_expected.to callback(CallbackClass).before(:save) }
+  it { is_expected.to callback(CallbackClass).after(:create) }
+  it { is_expected.to callback(CallbackClass).before(:validation) }
+  it { is_expected.to callback(CallbackClass).after(:find) }
+
+	# with conditions
+  it { is_expected.to callback(CallbackClass).before(:create).if(:this_is_true) }
+  it { is_expected.to callback(CallbackClass).after(:find).unless(:is_this_true?) }
+end
+
+describe User do
+  it { is_expected.not_to callback(CallbackClass).before(:validation).on(:update) }
+  it { is_expected.to callback(CallbackClass).before(:validation).on(:create) }
+  it { is_expected.to callback(CallbackClass).before(:destroy) }
+end
+````
 
 This will test:
 - the method call
@@ -71,17 +75,21 @@ Either on the model itself or on the callback object. Be aware that obviously th
 
 In Rails 3 or 4 and Bundler, add the following to your Gemfile:
 
-    group :test do
-      gem "shoulda-callback-matchers", "~> 1.0"
-    end
+````ruby
+group :test do
+  gem 'shoulda-callback-matchers', '~> 1.1.1'
+end
+````
 
 This gem uses semantic versioning, so you won't have incompability issues with patches.
 
 rspec-rails needs to be in the development group so that Rails generators work.
 
-    group :development, :test do
-      gem "rspec-rails"
-    end
+````ruby
+group :development, :test do
+  gem "rspec-rails"
+end
+````
 
 Shoulda will automatically include matchers into the appropriate example groups.
 
@@ -92,6 +100,9 @@ Shoulda is maintained and funded by [thoughtbot](http://thoughtbot.com/community
 
 ## Contributors & Contributions
 - @pvertenten (callback objects)
+- @johnnyshields (bugfixes)
+- @esbarango (README updates)
+- @yuku-t (Rails 4.2 Support)
 
 Let's make this gem useful, send me a PR if you've discovered an issue you'd like to fix!
 

data/gemfiles/rails_3.1.gemfile

@@ -8,6 +8,7 @@ gem "activerecord-jdbcsqlite3-adapter", :platform=>:jruby
 gem "jdbc-sqlite3", :platform=>:jruby
 gem "jruby-openssl", :platform=>:jruby
 gem "therubyrhino", :platform=>:jruby
+gem "psych", :platform=>:rbx
 gem "rails", "~> 3.1.0"
 gem "jquery-rails"
 gem "sass-rails"

data/gemfiles/rails_3.2.gemfile

@@ -8,6 +8,7 @@ gem "activerecord-jdbcsqlite3-adapter", :platform=>:jruby
 gem "jdbc-sqlite3", :platform=>:jruby
 gem "jruby-openssl", :platform=>:jruby
 gem "therubyrhino", :platform=>:jruby
+gem "psych", :platform=>:rbx
 gem "rails", "~> 3.2.0"
 gem "jquery-rails"
 gem "sass-rails"

data/gemfiles/rails_4.0.gemfile

@@ -8,6 +8,7 @@ gem "activerecord-jdbcsqlite3-adapter", :platform=>:jruby
 gem "jdbc-sqlite3", :platform=>:jruby
 gem "jruby-openssl", :platform=>:jruby
 gem "therubyrhino", :platform=>:jruby
+gem "psych", :platform=>:rbx
 gem "rails", "~> 4.0.0"
 gem "jquery-rails"
 gem "sass-rails"

data/gemfiles/rails_4.1.gemfile

@@ -8,6 +8,7 @@ gem "activerecord-jdbcsqlite3-adapter", :platform=>:jruby
 gem "jdbc-sqlite3", :platform=>:jruby
 gem "jruby-openssl", :platform=>:jruby
 gem "therubyrhino", :platform=>:jruby
+gem "psych", :platform=>:rbx
 gem "rails", "~> 4.1.0"
 gem "jquery-rails"
 gem "sass-rails", "~> 4.0"

data/gemfiles/rails_4.2.gemfile

@@ -0,0 +1,16 @@
+# This file was generated by Appraisal
+
+source "http://rubygems.org"
+
+gem "sqlite3", :platform=>:ruby
+gem "activerecord-jdbc-adapter", :platform=>:jruby
+gem "activerecord-jdbcsqlite3-adapter", :platform=>:jruby
+gem "jdbc-sqlite3", :platform=>:jruby
+gem "jruby-openssl", :platform=>:jruby
+gem "therubyrhino", :platform=>:jruby
+gem "psych", :platform=>:rbx
+gem "rails", "~> 4.2.0"
+gem "jquery-rails"
+gem "sass-rails", "~> 4.0"
+
+gemspec :path=>"../"

data/lib/shoulda/callback/matchers/active_model.rb

@@ -153,7 +153,7 @@ module Shoulda # :nodoc:
           end
           
           def matches_conditions? callback
-            if rails_4_1?
+            if rails_version >= '4.1'
               !@condition || callback.instance_variable_get(:"@#{@condition_type}").include?(@condition)
             else
               !@condition || callback.options[@condition_type].include?(@condition)
@@ -161,7 +161,7 @@ module Shoulda # :nodoc:
           end
         
           def matches_optional_lifecycle? callback
-            if rails_4_1?
+            if rails_version >= '4.1'
               if_conditions = callback.instance_variable_get(:@if)
               !@optional_lifecycle || if_conditions.include?(lifecycle_context_string) || active_model_proc_matches_optional_lifecycle?(if_conditions)
             else
@@ -178,7 +178,7 @@ module Shoulda # :nodoc:
           end
           
           def lifecycle_context_string
-            if rails_4?
+            if rails_version >= '4.0'
               rails_4_lifecycle_context_string
             else
               rails_3_lifecycle_context_string
@@ -216,7 +216,7 @@ module Shoulda # :nodoc:
           end
           
           def callback_object subject, callback
-            if (rails_3? || rails_4_0?) && !callback.filter.is_a?(Symbol)
+            if (rails_version >= '3.0' && rails_version < '4.1') && !callback.filter.is_a?(Symbol)
               subject.send("#{callback.filter}_object")
             else
               callback.filter

data/lib/shoulda/callback/matchers/integrations/test_unit.rb

@@ -5,7 +5,7 @@ include Shoulda::Callback::Matchers::RailsVersionHelper
 # in environments where test/unit is not required, this is necessary
 unless defined?(Test::Unit::TestCase)
   begin
-    require rails_4_1? ? 'minitest' : 'test/unit/testcase'
+    require rails_version == '4.1' ? 'minitest' : 'test/unit/testcase'
   rescue LoadError
     # silent
   end

data/lib/shoulda/callback/matchers/rails_version_helper.rb

@@ -3,42 +3,44 @@ module Shoulda
   module Callback
     module Matchers
       module RailsVersionHelper
-        def rails_4_1?
-          rails_4? && minor_version_equals?(1)
-        end
-  
-        def rails_4_0?
-          rails_4? && minor_version_equals?(0)
-        end
-  
-        def rails_4?
-          major_version_equals? 4
-        end
-  
-        def rails_3?
-          major_version_equals? 3
-        end
-        
-        private
-        
-        def major_version_equals? number
-          if active_record?
-            ::ActiveRecord::VERSION::MAJOR == number
-          else
-            ::ActiveModel::VERSION::MAJOR == number
+        class RailsVersion
+          %w(< <= > >= ==).each do |operand|
+            define_method operand do |version_string|
+              version_int = convert_str_to_int(version_string)
+              rails_version_int.send(operand, version_int)
+            end
           end
-        end
-        
-        def minor_version_equals? number
-          if active_record?
-            ::ActiveRecord::VERSION::MINOR == number
-          else
-            ::ActiveModel::VERSION::MINOR == number
+
+          private
+
+          def rails_version_int
+            calculate_version_int(rails_major_version, rails_minor_version)
+          end
+
+          def convert_str_to_int(version_string)
+            major, minor = version_string.split('.').map(&:to_i)
+            calculate_version_int(major, minor)
+          end
+
+          def calculate_version_int(major, minor)
+            major * 100 + minor
+          end
+
+          def rails_major_version
+            version_module::MAJOR
+          end
+
+          def rails_minor_version
+            version_module::MINOR
+          end
+
+          def version_module
+            (defined?(::ActiveRecord) ? ::ActiveRecord : ::ActiveModel)::VERSION
           end
         end
-        
-        def active_record?
-          defined?(::ActiveRecord)
+
+        def rails_version
+          @rails_version ||= RailsVersion.new
         end
       end
     end

data/lib/shoulda/callback/matchers/version.rb

@@ -1,7 +1,7 @@
 module Shoulda
   module Callback
     module Matchers
-      VERSION = '1.1.1'.freeze
+      VERSION = '1.1.2'.freeze
     end
   end
 end

data/shoulda-callback-matchers.gemspec

@@ -25,8 +25,8 @@ Gem::Specification.new do |s|
   s.add_development_dependency('bundler',     '>= 1.1')
   s.add_development_dependency('rails',       '>= 3')
   s.add_development_dependency('rake',        '~> 10')
-  s.add_development_dependency('rspec-rails', '~> 2')
-  
+  s.add_development_dependency('rspec-rails', '~> 3')
+
   if RUBY_ENGINE == 'rbx'
     s.add_development_dependency "rubysl", "~> 2"
     s.add_development_dependency "rubysl-test-unit", '~> 2'

data/spec/shoulda/active_model/callback_matcher_spec.rb

@@ -1,7 +1,7 @@
   require 'spec_helper'
 
 describe Shoulda::Callback::Matchers::ActiveModel do
-  
+
   context "invalid use" do
     before do
       @callback_object_class = define_model :callback do
@@ -20,30 +20,30 @@ describe Shoulda::Callback::Matchers::ActiveModel do
         define_method(:shake!){}
         define_method(:dance!){}
       end.new
-      
+
     end
     it "should return a meaningful error when used without a defined lifecycle" do
-      lambda { callback(:dance!).matches? :foo }.should raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
+      expect { callback(:dance!).matches? :foo }.to raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
         "callback dance! can not be tested against an undefined lifecycle, use .before, .after or .around"
     end
     it "should return a meaningful error when used with an optional lifecycle without the original lifecycle being validation" do
-      lambda { callback(:dance!).after(:create).on(:save) }.should raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
+      expect { callback(:dance!).after(:create).on(:save) }.to raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
         "The .on option is only valid for validation, commit, and rollback and cannot be used with create, use with .before(:validation) or .after(:validation)"
     end
     it "should return a meaningful error when used without a defined lifecycle" do
-      lambda { callback(@callback_object_class).matches? :foo }.should raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
+      expect { callback(@callback_object_class).matches? :foo }.to raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
         "callback Callback can not be tested against an undefined lifecycle, use .before, .after or .around"
     end
     it "should return a meaningful error when used with an optional lifecycle without the original lifecycle being validation" do
-      lambda { callback(@callback_object_class).after(:create).on(:save) }.should raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
+      expect { callback(@callback_object_class).after(:create).on(:save) }.to raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
         "The .on option is only valid for validation, commit, and rollback and cannot be used with create, use with .before(:validation) or .after(:validation)"
     end
     it "should return a meaningful error when used with rollback or commit and before" do
-      lambda { callback(@callback_object_class).before(:commit).on(:destroy) }.should raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
+      expect { callback(@callback_object_class).before(:commit).on(:destroy) }.to raise_error Shoulda::Callback::Matchers::ActiveModel::UsageError,
         "Can not callback before or around commit, use after."
     end
   end
-  
+
   [:save, :create, :update, :destroy].each do |lifecycle|
     context "on #{lifecycle}" do
       before do
@@ -52,16 +52,16 @@ describe Shoulda::Callback::Matchers::ActiveModel do
           define_method("after_#{lifecycle}"){}
           define_method("around_#{lifecycle}"){}
         end
-        
+
         callback_object = @callback_object_class.new
-        
+
         @other_callback_object_class = define_model(:other_callback) do
           define_method("after_#{lifecycle}"){}
           define_method("around_#{lifecycle}"){}
         end
 
         other_callback_object = @other_callback_object_class.new
-        
+
         @callback_object_not_found_class = define_model(:callback_not_found) do
           define_method("before_#{lifecycle}"){}
           define_method("after_#{lifecycle}"){}
@@ -74,12 +74,12 @@ describe Shoulda::Callback::Matchers::ActiveModel do
           send(:"after_#{lifecycle}", :shake!, :unless => :evaluates_to_true!)
           send(:"around_#{lifecycle}", :giggle!)
           send(:"before_#{lifecycle}", :wiggle!)
-          
+
           send(:"before_#{lifecycle}", callback_object, :if => :evaluates_to_false!)
           send(:"after_#{lifecycle}", callback_object, :unless => :evaluates_to_true!)
           send(:"around_#{lifecycle}", callback_object)
           send(:"before_#{lifecycle}", other_callback_object)
-          
+
           define_method(:shake!){}
           define_method(:dance!){}
           define_method(:giggle!){}
@@ -87,92 +87,92 @@ describe Shoulda::Callback::Matchers::ActiveModel do
       end
       context "as a simple callback test" do
         it "should find the callback before the fact" do
-          @model.should callback(:dance!).before(lifecycle)
+          expect(@model).to callback(:dance!).before(lifecycle)
         end
         it "should find the callback after the fact" do
-          @model.should callback(:shake!).after(lifecycle)
+          expect(@model).to callback(:shake!).after(lifecycle)
         end
         it "should find the callback around the fact" do
-          @model.should callback(:giggle!).around(lifecycle)
+          expect(@model).to callback(:giggle!).around(lifecycle)
         end
         it "should not find callbacks that are not there" do
-          @model.should_not callback(:scream!).around(lifecycle)
+          expect(@model).not_to callback(:scream!).around(lifecycle)
         end
         it "should not find callback_objects around the fact" do
-          @model.should_not callback(:shake!).around(lifecycle)
+          expect(@model).not_to callback(:shake!).around(lifecycle)
         end
         it "should have a meaningful description" do
           matcher = callback(:dance!).before(lifecycle)
-          matcher.description.should == "callback dance! before #{lifecycle}"
+          expect(matcher.description).to eq("callback dance! before #{lifecycle}")
         end
         it "should find the callback_object before the fact" do
-          @model.should callback(@callback_object_class).before(lifecycle)
+          expect(@model).to callback(@callback_object_class).before(lifecycle)
         end
         it "should find the callback_object after the fact" do
-          @model.should callback(@callback_object_class).after(lifecycle)
+          expect(@model).to callback(@callback_object_class).after(lifecycle)
         end
         it "should find the callback_object around the fact" do
-          @model.should callback(@callback_object_class).around(lifecycle)
+          expect(@model).to callback(@callback_object_class).around(lifecycle)
         end
         it "should not find callbacks that are not there" do
-          @model.should_not callback(@callback_object_not_found_class).around(lifecycle)
+          expect(@model).not_to callback(@callback_object_not_found_class).around(lifecycle)
         end
         it "should not find callback_objects around the fact" do
-          @model.should_not callback(@callback_object_not_found_class).around(lifecycle)
+          expect(@model).not_to callback(@callback_object_not_found_class).around(lifecycle)
         end
         it "should have a meaningful description" do
           matcher = callback(@callback_object_class).before(lifecycle)
-          matcher.description.should == "callback Callback before #{lifecycle}"
+          expect(matcher.description).to eq("callback Callback before #{lifecycle}")
         end
         it "should have a meaningful error if it fails with an inexistent method on a model" do
           matcher = callback(:wiggle!).before(lifecycle)
-          matcher.matches?(@model).should be_false
-          matcher.failure_message.should == "callback wiggle! is listed as a callback before #{lifecycle}, but the model does not respond to wiggle! (using respond_to?(:wiggle!, true)"
+          expect(matcher.matches?(@model)).to eq(false)
+          expect(matcher.failure_message).to eq("callback wiggle! is listed as a callback before #{lifecycle}, but the model does not respond to wiggle! (using respond_to?(:wiggle!, true)")
         end
         it "should have a meaningful error if it fails with an inexistent method on a callback class" do
           matcher = callback(@other_callback_object_class).before(lifecycle)
-          matcher.matches?(@model).should be_false
-          matcher.failure_message.should == "callback OtherCallback is listed as a callback before #{lifecycle}, but the given object does not respond to before_#{lifecycle} (using respond_to?(:before_#{lifecycle}, true)"
+          expect(matcher.matches?(@model)).to eq(false)
+          expect(matcher.failure_message).to eq("callback OtherCallback is listed as a callback before #{lifecycle}, but the given object does not respond to before_#{lifecycle} (using respond_to?(:before_#{lifecycle}, true)")
         end
       end
       context "with conditions" do
         it "should match the if condition" do
-          @model.should callback(:dance!).before(lifecycle).if(:evaluates_to_false!)
+          expect(@model).to callback(:dance!).before(lifecycle).if(:evaluates_to_false!)
         end
         it "should match the unless condition" do
-          @model.should callback(:shake!).after(lifecycle).unless(:evaluates_to_true!)
+          expect(@model).to callback(:shake!).after(lifecycle).unless(:evaluates_to_true!)
         end
         it "should not find callbacks not matching the conditions" do
-          @model.should_not callback(:giggle!).around(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(:giggle!).around(lifecycle).unless(:evaluates_to_false!)
         end
         it "should not find callbacks that are not there entirely" do
-          @model.should_not callback(:scream!).before(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(:scream!).before(lifecycle).unless(:evaluates_to_false!)
         end
         it "should have a meaningful description" do
           matcher = callback(:dance!).after(lifecycle).unless(:evaluates_to_false!)
-          matcher.description.should == "callback dance! after #{lifecycle} unless evaluates_to_false! evaluates to false"
+          expect(matcher.description).to eq("callback dance! after #{lifecycle} unless evaluates_to_false! evaluates to false")
         end
 
         it "should match the if condition" do
-          @model.should callback(@callback_object_class).before(lifecycle).if(:evaluates_to_false!)
+          expect(@model).to callback(@callback_object_class).before(lifecycle).if(:evaluates_to_false!)
         end
         it "should match the unless condition" do
-          @model.should callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_true!)
+          expect(@model).to callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_true!)
         end
         it "should not find callbacks not matching the conditions" do
-          @model.should_not callback(@callback_object_class).around(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(@callback_object_class).around(lifecycle).unless(:evaluates_to_false!)
         end
         it "should not find callbacks that are not there entirely" do
-          @model.should_not callback(@callback_object_not_found_class).before(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(@callback_object_not_found_class).before(lifecycle).unless(:evaluates_to_false!)
         end
         it "should have a meaningful description" do
           matcher = callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_false!)
-          matcher.description.should == "callback Callback after #{lifecycle} unless evaluates_to_false! evaluates to false"
+          expect(matcher.description).to eq("callback Callback after #{lifecycle} unless evaluates_to_false! evaluates to false")
         end
       end
     end
   end
-  
+
   context "on validation" do
     before do
      @callback_object_class = define_model(:callback) do
@@ -211,153 +211,153 @@ describe Shoulda::Callback::Matchers::ActiveModel do
         define_method(:pucker!){}
       end.new
     end
-    
+
     context "as a simple callback test" do
       it "should find the callback before the fact" do
-        @model.should callback(:dance!).before(:validation)
+        expect(@model).to callback(:dance!).before(:validation)
       end
       it "should find the callback after the fact" do
-        @model.should callback(:shake!).after(:validation)
+        expect(@model).to callback(:shake!).after(:validation)
       end
       it "should not find a callback around the fact" do
-        @model.should_not callback(:giggle!).around(:validation)
+        expect(@model).not_to callback(:giggle!).around(:validation)
       end
       it "should not find callbacks that are not there" do
-        @model.should_not callback(:scream!).around(:validation)
+        expect(@model).not_to callback(:scream!).around(:validation)
       end
       it "should have a meaningful description" do
         matcher = callback(:dance!).before(:validation)
-        matcher.description.should == "callback dance! before validation"
+        expect(matcher.description).to eq("callback dance! before validation")
       end
 
       it "should find the callback before the fact" do
-        @model.should callback(@callback_object_class).before(:validation)
+        expect(@model).to callback(@callback_object_class).before(:validation)
       end
       it "should find the callback after the fact" do
-        @model.should callback(@callback_object_class).after(:validation)
+        expect(@model).to callback(@callback_object_class).after(:validation)
       end
       it "should not find a callback around the fact" do
-        @model.should_not callback(@callback_object_class).around(:validation)
+        expect(@model).not_to callback(@callback_object_class).around(:validation)
       end
       it "should not find callbacks that are not there" do
-        @model.should_not callback(@callback_object_not_found_class).around(:validation)
+        expect(@model).not_to callback(@callback_object_not_found_class).around(:validation)
       end
       it "should have a meaningful description" do
         matcher = callback(@callback_object_class).before(:validation)
-        matcher.description.should == "callback Callback before validation"
+        expect(matcher.description).to eq("callback Callback before validation")
       end
     end
-    
+
     context "with additinal lifecycles defined" do
       it "should find the callback before the fact on create" do
-        @model.should callback(:dress!).before(:validation).on(:create)
+        expect(@model).to callback(:dress!).before(:validation).on(:create)
       end
       it "should find the callback after the fact on update" do
-        @model.should callback(:shriek!).after(:validation).on(:update)
+        expect(@model).to callback(:shriek!).after(:validation).on(:update)
       end
       it "should find the callback after the fact on save" do
-        @model.should callback(:pucker!).after(:validation).on(:save)
+        expect(@model).to callback(:pucker!).after(:validation).on(:save)
       end
       it "should not find a callback for pucker! after the fact on update" do
-        @model.should_not callback(:pucker!).after(:validation).on(:update)
+        expect(@model).not_to callback(:pucker!).after(:validation).on(:update)
       end
       it "should have a meaningful description" do
         matcher = callback(:dance!).after(:validation).on(:update)
-        matcher.description.should == "callback dance! after validation on update"
+        expect(matcher.description).to eq("callback dance! after validation on update")
       end
 
       it "should find the callback before the fact on create" do
-        @model.should callback(@callback_object_class).before(:validation).on(:create)
+        expect(@model).to callback(@callback_object_class).before(:validation).on(:create)
       end
       it "should find the callback after the fact on update" do
-        @model.should callback(@callback_object_class).after(:validation).on(:update)
+        expect(@model).to callback(@callback_object_class).after(:validation).on(:update)
       end
       it "should find the callback after the fact on save" do
-        @model.should callback(@callback_object_class2).after(:validation).on(:save)
+        expect(@model).to callback(@callback_object_class2).after(:validation).on(:save)
       end
       it "should not find a callback for Callback after the fact on update" do
-        @model.should_not callback(@callback_object_class2).after(:validation).on(:update)
+        expect(@model).not_to callback(@callback_object_class2).after(:validation).on(:update)
       end
       it "should have a meaningful description" do
         matcher = callback(@callback_object_class).after(:validation).on(:update)
-        matcher.description.should == "callback Callback after validation on update"
+        expect(matcher.description).to eq("callback Callback after validation on update")
       end
     end
-    
+
     context "with conditions" do
       it "should match the if condition" do
-        @model.should callback(:dance!).before(:validation).if(:evaluates_to_false!)
+        expect(@model).to callback(:dance!).before(:validation).if(:evaluates_to_false!)
       end
       it "should match the unless condition" do
-        @model.should callback(:shake!).after(:validation).unless(:evaluates_to_true!)
+        expect(@model).to callback(:shake!).after(:validation).unless(:evaluates_to_true!)
       end
       it "should not find callbacks not matching the conditions" do
-        @model.should_not callback(:giggle!).around(:validation).unless(:evaluates_to_false!)
+        expect(@model).not_to callback(:giggle!).around(:validation).unless(:evaluates_to_false!)
       end
       it "should not find callbacks that are not there entirely" do
-        @model.should_not callback(:scream!).before(:validation).unless(:evaluates_to_false!)
+        expect(@model).not_to callback(:scream!).before(:validation).unless(:evaluates_to_false!)
       end
       it "should have a meaningful description" do
         matcher = callback(:dance!).after(:validation).unless(:evaluates_to_false!)
-        matcher.description.should == "callback dance! after validation unless evaluates_to_false! evaluates to false"
+        expect(matcher.description).to eq("callback dance! after validation unless evaluates_to_false! evaluates to false")
       end
 
       it "should match the if condition" do
-        @model.should callback(@callback_object_class).before(:validation).if(:evaluates_to_false!)
+        expect(@model).to callback(@callback_object_class).before(:validation).if(:evaluates_to_false!)
       end
       it "should match the unless condition" do
-        @model.should callback(@callback_object_class).after(:validation).unless(:evaluates_to_true!)
+        expect(@model).to callback(@callback_object_class).after(:validation).unless(:evaluates_to_true!)
       end
       it "should not find callbacks not matching the conditions" do
-        @model.should_not callback(@callback_object_class).around(:validation).unless(:evaluates_to_false!)
+        expect(@model).not_to callback(@callback_object_class).around(:validation).unless(:evaluates_to_false!)
       end
       it "should not find callbacks that are not there entirely" do
-        @model.should_not callback(@callback_object_not_found_class).before(:validation).unless(:evaluates_to_false!)
+        expect(@model).not_to callback(@callback_object_not_found_class).before(:validation).unless(:evaluates_to_false!)
       end
       it "should have a meaningful description" do
         matcher = callback(@callback_object_class).after(:validation).unless(:evaluates_to_false!)
-        matcher.description.should == "callback Callback after validation unless evaluates_to_false! evaluates to false"
+        expect(matcher.description).to eq("callback Callback after validation unless evaluates_to_false! evaluates to false")
       end
     end
-    
+
     context "with conditions and additional lifecycles" do
       it "should find the callback before the fact on create" do
-        @model.should callback(:dress!).before(:validation).on(:create)
+        expect(@model).to callback(:dress!).before(:validation).on(:create)
       end
       it "should find the callback after the fact on update with the unless condition" do
-        @model.should callback(:shriek!).after(:validation).on(:update).unless(:evaluates_to_true!)
+        expect(@model).to callback(:shriek!).after(:validation).on(:update).unless(:evaluates_to_true!)
       end
       it "should find the callback after the fact on save with the if condition" do
-        @model.should callback(:pucker!).after(:validation).on(:save).if(:evaluates_to_false!)
+        expect(@model).to callback(:pucker!).after(:validation).on(:save).if(:evaluates_to_false!)
       end
       it "should not find a callback for pucker! after the fact on save with the wrong condition" do
-        @model.should_not callback(:pucker!).after(:validation).on(:save).unless(:evaluates_to_false!)
+        expect(@model).not_to callback(:pucker!).after(:validation).on(:save).unless(:evaluates_to_false!)
       end
       it "should have a meaningful description" do
         matcher = callback(:dance!).after(:validation).on(:save).unless(:evaluates_to_false!)
-        matcher.description.should == "callback dance! after validation on save unless evaluates_to_false! evaluates to false"
+        expect(matcher.description).to eq("callback dance! after validation on save unless evaluates_to_false! evaluates to false")
       end
 
       it "should find the callback before the fact on create" do
-        @model.should callback(@callback_object_class).before(:validation).on(:create)
+        expect(@model).to callback(@callback_object_class).before(:validation).on(:create)
       end
       it "should find the callback after the fact on update with the unless condition" do
-        @model.should callback(@callback_object_class).after(:validation).on(:update).unless(:evaluates_to_true!)
+        expect(@model).to callback(@callback_object_class).after(:validation).on(:update).unless(:evaluates_to_true!)
       end
       it "should find the callback after the fact on save with the if condition" do
-        @model.should callback(@callback_object_class2).after(:validation).on(:save).if(:evaluates_to_false!)
+        expect(@model).to callback(@callback_object_class2).after(:validation).on(:save).if(:evaluates_to_false!)
       end
       it "should not find a callback for Callback after the fact on save with the wrong condition" do
-        @model.should_not callback(@callback_object_class).after(:validation).on(:save).unless(:evaluates_to_false!)
+        expect(@model).not_to callback(@callback_object_class).after(:validation).on(:save).unless(:evaluates_to_false!)
       end
       it "should have a meaningful description" do
         matcher = callback(@callback_object_class).after(:validation).on(:save).unless(:evaluates_to_false!)
-        matcher.description.should == "callback Callback after validation on save unless evaluates_to_false! evaluates to false"
+        expect(matcher.description).to eq("callback Callback after validation on save unless evaluates_to_false! evaluates to false")
       end
     end
   end
-  
-  
+
+
   [:rollback, :commit].each do |lifecycle|
     context "on #{lifecycle}" do
       before do
@@ -394,141 +394,141 @@ describe Shoulda::Callback::Matchers::ActiveModel do
           define_method(:pucker!){}
         end.new
       end
-    
-      context "as a simple callback test" do        
+
+      context "as a simple callback test" do
         it "should find the callback after the fact" do
-          @model.should callback(:shake!).after(lifecycle)
+          expect(@model).to callback(:shake!).after(lifecycle)
         end
         it "should not find callbacks that are not there" do
-          @model.should_not callback(:scream!).after(lifecycle)
+          expect(@model).not_to callback(:scream!).after(lifecycle)
         end
         it "should have a meaningful description" do
           matcher = callback(:dance!).after(lifecycle)
-          matcher.description.should == "callback dance! after #{lifecycle}"
+          expect(matcher.description).to eq("callback dance! after #{lifecycle}")
         end
 
         it "should find the callback after the fact" do
-          @model.should callback(@callback_object_class).after(lifecycle)
+          expect(@model).to callback(@callback_object_class).after(lifecycle)
         end
         it "should not find callbacks that are not there" do
-          @model.should_not callback(@callback_object_not_found_class).after(lifecycle)
+          expect(@model).not_to callback(@callback_object_not_found_class).after(lifecycle)
         end
         it "should have a meaningful description" do
           matcher = callback(@callback_object_class).after(lifecycle)
-          matcher.description.should == "callback Callback after #{lifecycle}"
+          expect(matcher.description).to eq("callback Callback after #{lifecycle}")
         end
       end
-    
+
       context "with additinal lifecycles defined" do
         it "should find the callback after the fact on create" do
-          @model.should callback(:dress!).after(lifecycle).on(:create)
+          expect(@model).to callback(:dress!).after(lifecycle).on(:create)
         end
         it "should find the callback after the fact on update" do
-          @model.should callback(:shriek!).after(lifecycle).on(:update)
+          expect(@model).to callback(:shriek!).after(lifecycle).on(:update)
         end
         it "should find the callback after the fact on save" do
-          @model.should callback(:pucker!).after(lifecycle).on(:destroy)
+          expect(@model).to callback(:pucker!).after(lifecycle).on(:destroy)
         end
         it "should not find a callback for pucker! after the fact on update" do
-          @model.should_not callback(:pucker!).after(lifecycle).on(:update)
+          expect(@model).not_to callback(:pucker!).after(lifecycle).on(:update)
         end
         it "should have a meaningful description" do
           matcher = callback(:dance!).after(lifecycle).on(:update)
-          matcher.description.should == "callback dance! after #{lifecycle} on update"
+          expect(matcher.description).to eq("callback dance! after #{lifecycle} on update")
         end
 
         it "should find the callback before the fact on create" do
-          @model.should callback(@callback_object_class).after(lifecycle).on(:create)
+          expect(@model).to callback(@callback_object_class).after(lifecycle).on(:create)
         end
         it "should find the callback after the fact on update" do
-          @model.should callback(@callback_object_class).after(lifecycle).on(:update)
+          expect(@model).to callback(@callback_object_class).after(lifecycle).on(:update)
         end
         it "should find the callback after the fact on save" do
-          @model.should callback(@callback_object_class2).after(lifecycle).on(:destroy)
+          expect(@model).to callback(@callback_object_class2).after(lifecycle).on(:destroy)
         end
         it "should not find a callback for Callback after the fact on update" do
-          @model.should_not callback(@callback_object_class2).after(lifecycle).on(:update)
+          expect(@model).not_to callback(@callback_object_class2).after(lifecycle).on(:update)
         end
         it "should have a meaningful description" do
           matcher = callback(@callback_object_class).after(lifecycle).on(:update)
-          matcher.description.should == "callback Callback after #{lifecycle} on update"
+          expect(matcher.description).to eq("callback Callback after #{lifecycle} on update")
         end
       end
-    
+
       context "with conditions" do
         it "should match the if condition" do
-          @model.should callback(:dance!).after(lifecycle).if(:evaluates_to_false!)
+          expect(@model).to callback(:dance!).after(lifecycle).if(:evaluates_to_false!)
         end
         it "should match the unless condition" do
-          @model.should callback(:shake!).after(lifecycle).unless(:evaluates_to_true!)
+          expect(@model).to callback(:shake!).after(lifecycle).unless(:evaluates_to_true!)
         end
         it "should not find callbacks not matching the conditions" do
-          @model.should_not callback(:giggle!).after(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(:giggle!).after(lifecycle).unless(:evaluates_to_false!)
         end
         it "should not find callbacks that are not there entirely" do
-          @model.should_not callback(:scream!).after(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(:scream!).after(lifecycle).unless(:evaluates_to_false!)
         end
         it "should have a meaningful description" do
           matcher = callback(:dance!).after(lifecycle).unless(:evaluates_to_false!)
-          matcher.description.should == "callback dance! after #{lifecycle} unless evaluates_to_false! evaluates to false"
+          expect(matcher.description).to eq("callback dance! after #{lifecycle} unless evaluates_to_false! evaluates to false")
         end
 
         it "should match the if condition" do
-          @model.should callback(@callback_object_class).after(lifecycle).if(:evaluates_to_false!)
+          expect(@model).to callback(@callback_object_class).after(lifecycle).if(:evaluates_to_false!)
         end
         it "should match the unless condition" do
-          @model.should callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_true!)
+          expect(@model).to callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_true!)
         end
         it "should not find callbacks not matching the conditions" do
-          @model.should_not callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_false!)
         end
         it "should not find callbacks that are not there entirely" do
-          @model.should_not callback(@callback_object_not_found_class).after(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(@callback_object_not_found_class).after(lifecycle).unless(:evaluates_to_false!)
         end
         it "should have a meaningful description" do
           matcher = callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_false!)
-          matcher.description.should == "callback Callback after #{lifecycle} unless evaluates_to_false! evaluates to false"
+          expect(matcher.description).to eq("callback Callback after #{lifecycle} unless evaluates_to_false! evaluates to false")
         end
       end
-    
+
       context "with conditions and additional lifecycles" do
         it "should find the callback before the fact on create" do
-          @model.should callback(:dress!).after(lifecycle).on(:create)
+          expect(@model).to callback(:dress!).after(lifecycle).on(:create)
         end
         it "should find the callback after the fact on update with the unless condition" do
-          @model.should callback(:shriek!).after(lifecycle).on(:update).unless(:evaluates_to_true!)
+          expect(@model).to callback(:shriek!).after(lifecycle).on(:update).unless(:evaluates_to_true!)
         end
         it "should find the callback after the fact on save with the if condition" do
-          @model.should callback(:pucker!).after(lifecycle).on(:destroy).if(:evaluates_to_false!)
+          expect(@model).to callback(:pucker!).after(lifecycle).on(:destroy).if(:evaluates_to_false!)
         end
         it "should not find a callback for pucker! after the fact on save with the wrong condition" do
-          @model.should_not callback(:pucker!).after(lifecycle).on(:destroy).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(:pucker!).after(lifecycle).on(:destroy).unless(:evaluates_to_false!)
         end
         it "should have a meaningful description" do
           matcher = callback(:dance!).after(lifecycle).on(:save).unless(:evaluates_to_false!)
-          matcher.description.should == "callback dance! after #{lifecycle} on save unless evaluates_to_false! evaluates to false"
+          expect(matcher.description).to eq("callback dance! after #{lifecycle} on save unless evaluates_to_false! evaluates to false")
         end
 
         it "should find the callback before the fact on create" do
-          @model.should callback(@callback_object_class).after(lifecycle).on(:create)
+          expect(@model).to callback(@callback_object_class).after(lifecycle).on(:create)
         end
         it "should find the callback after the fact on update with the unless condition" do
-          @model.should callback(@callback_object_class).after(lifecycle).on(:update).unless(:evaluates_to_true!)
+          expect(@model).to callback(@callback_object_class).after(lifecycle).on(:update).unless(:evaluates_to_true!)
         end
         it "should find the callback after the fact on save with the if condition" do
-          @model.should callback(@callback_object_class2).after(lifecycle).on(:destroy).if(:evaluates_to_false!)
+          expect(@model).to callback(@callback_object_class2).after(lifecycle).on(:destroy).if(:evaluates_to_false!)
         end
         it "should not find a callback for Callback after the fact on save with the wrong condition" do
-          @model.should_not callback(@callback_object_class).after(lifecycle).on(:destroy).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(@callback_object_class).after(lifecycle).on(:destroy).unless(:evaluates_to_false!)
         end
         it "should have a meaningful description" do
           matcher = callback(@callback_object_class).after(lifecycle).on(:destroy).unless(:evaluates_to_false!)
-          matcher.description.should == "callback Callback after #{lifecycle} on destroy unless evaluates_to_false! evaluates to false"
+          expect(matcher.description).to eq("callback Callback after #{lifecycle} on destroy unless evaluates_to_false! evaluates to false")
         end
       end
     end
   end
-  
+
   [:initialize, :find, :touch].each do |lifecycle|
     context "on #{lifecycle}" do
       before do
@@ -555,89 +555,89 @@ describe Shoulda::Callback::Matchers::ActiveModel do
           send(:"after_#{lifecycle}", callback_object2, :unless => :evaluates_to_true!)
           define_method(:shake!){}
           define_method(:dance!){}
-          
+
           define_method :evaluates_to_false! do
             false
           end
-          
+
           define_method :evaluates_to_true! do
             true
           end
-          
+
         end.new
       end
-      
+
       context "as a simple callback test" do
         it "should not find a callback before the fact" do
-          @model.should_not callback(:dance!).before(lifecycle)
+          expect(@model).not_to callback(:dance!).before(lifecycle)
         end
         it "should find the callback after the fact" do
-          @model.should callback(:shake!).after(lifecycle)
+          expect(@model).to callback(:shake!).after(lifecycle)
         end
         it "should not find a callback around the fact" do
-          @model.should_not callback(:giggle!).around(lifecycle)
+          expect(@model).not_to callback(:giggle!).around(lifecycle)
         end
         it "should not find callbacks that are not there" do
-          @model.should_not callback(:scream!).around(lifecycle)
+          expect(@model).not_to callback(:scream!).around(lifecycle)
         end
         it "should have a meaningful description" do
           matcher = callback(:dance!).before(lifecycle)
-          matcher.description.should == "callback dance! before #{lifecycle}"
+          expect(matcher.description).to eq("callback dance! before #{lifecycle}")
         end
 
         it "should not find a callback before the fact" do
-          @model.should_not callback(@callback_object_class).before(lifecycle)
+          expect(@model).not_to callback(@callback_object_class).before(lifecycle)
         end
         it "should find the callback after the fact" do
-          @model.should callback(@callback_object_class).after(lifecycle)
+          expect(@model).to callback(@callback_object_class).after(lifecycle)
         end
         it "should not find a callback around the fact" do
-          @model.should_not callback(@callback_object_class).around(lifecycle)
+          expect(@model).not_to callback(@callback_object_class).around(lifecycle)
         end
         it "should not find callbacks that are not there" do
-          @model.should_not callback(@callback_object_not_found_class).around(lifecycle)
+          expect(@model).not_to callback(@callback_object_not_found_class).around(lifecycle)
         end
         it "should have a meaningful description" do
           matcher = callback(@callback_object_class).before(lifecycle)
-          matcher.description.should == "callback Callback before #{lifecycle}"
+          expect(matcher.description).to eq("callback Callback before #{lifecycle}")
         end
       end
-      
+
       context "with conditions" do
         it "should match the if condition" do
-          @model.should callback(:dance!).after(lifecycle).if(:evaluates_to_false!)
+          expect(@model).to callback(:dance!).after(lifecycle).if(:evaluates_to_false!)
         end
         it "should match the unless condition" do
-          @model.should callback(:shake!).after(lifecycle).unless(:evaluates_to_true!)
+          expect(@model).to callback(:shake!).after(lifecycle).unless(:evaluates_to_true!)
         end
         it "should not find callbacks not matching the conditions" do
-          @model.should_not callback(:giggle!).around(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(:giggle!).around(lifecycle).unless(:evaluates_to_false!)
         end
         it "should not find callbacks that are not there entirely" do
-          @model.should_not callback(:scream!).before(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(:scream!).before(lifecycle).unless(:evaluates_to_false!)
         end
         it "should have a meaningful description" do
           matcher = callback(:dance!).after(lifecycle).unless(:evaluates_to_false!)
-          matcher.description.should == "callback dance! after #{lifecycle} unless evaluates_to_false! evaluates to false"
+          expect(matcher.description).to eq("callback dance! after #{lifecycle} unless evaluates_to_false! evaluates to false")
         end
         it "should match the if condition" do
-          @model.should callback(@callback_object_class).after(lifecycle).if(:evaluates_to_false!)
+          expect(@model).to callback(@callback_object_class).after(lifecycle).if(:evaluates_to_false!)
         end
         it "should match the unless condition" do
-          @model.should callback(@callback_object_class2).after(lifecycle).unless(:evaluates_to_true!)
+          expect(@model).to callback(@callback_object_class2).after(lifecycle).unless(:evaluates_to_true!)
         end
         it "should not find callbacks not matching the conditions" do
-          @model.should_not callback(@callback_object_class).around(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(@callback_object_class).around(lifecycle).unless(:evaluates_to_false!)
         end
         it "should not find callbacks that are not there entirely" do
-          @model.should_not callback(@callback_object_not_found_class).before(lifecycle).unless(:evaluates_to_false!)
+          expect(@model).not_to callback(@callback_object_not_found_class).before(lifecycle).unless(:evaluates_to_false!)
         end
         it "should have a meaningful description" do
           matcher = callback(@callback_object_class).after(lifecycle).unless(:evaluates_to_false!)
-          matcher.description.should == "callback Callback after #{lifecycle} unless evaluates_to_false! evaluates to false"
+          expect(matcher.description).to eq("callback Callback after #{lifecycle} unless evaluates_to_false! evaluates to false")
         end
       end
-      
+
     end
   end
 end