rmm5t-shoulda 2.0.6 → 2.9.1

data/README.rdoc

@@ -7,14 +7,15 @@ Helpers:: #context and #should give you rSpec like test blocks.
 Macros:: Generate hundreds of lines of Controller and ActiveRecord tests with these powerful macros.
          They get you started quickly, and can help you ensure that your application is conforming to best practices.
 Assertions:: Many common rails testing idioms have been distilled into a set of useful assertions.
+Matchers:: Rspec-compatible matchers providing the same tests as Shoulda macros.
 
 = Usage
 
-=== Context Helpers (ThoughtBot::Shoulda::Context)
+=== Context Helpers (Shoulda::Context)
 
 Stop killing your fingers with all of those underscores...  Name your tests with plain sentences!
 
-  class UserTest << Test::Unit::TestCase
+  class UserTest < Test::Unit::TestCase
     context "A User instance" do
       setup do
         @user = User.find(:first)
@@ -43,7 +44,7 @@ Produces the following test methods:
 
 So readable!
 
-=== ActiveRecord Tests (ThoughtBot::Shoulda::ActiveRecord::Macros)
+=== ActiveRecord Tests (Shoulda::ActiveRecord::Macros)
 
 Quick macro tests for your ActiveRecord associations and validations:
 
@@ -53,10 +54,10 @@ Quick macro tests for your ActiveRecord associations and validations:
     should_belong_to :user
     should_have_many :tags, :through => :taggings
 
-    should_require_unique_attributes :title
-    should_require_attributes :body, :message => /wtf/
-    should_require_attributes :title
-    should_only_allow_numeric_values_for :user_id
+    should_validate_uniqueness_of :title
+    should_validate_presence_of :body, :message => /wtf/
+    should_validate_presence_of :title
+    should_validate_numericality_of :user_id
   end
 
   class UserTest < Test::Unit::TestCase
@@ -66,12 +67,12 @@ Quick macro tests for your ActiveRecord associations and validations:
     should_allow_values_for :email, "a@b.com", "asdf@asdf.com"
     should_ensure_length_in_range :email, 1..100
     should_ensure_value_in_range :age, 1..100
-    should_protect_attributes :password
+    should_not_allow_mass_assignment_of :password
   end
 
 Makes TDD so much easier.
 
-=== Controller Tests (ThoughtBot::Shoulda::Controller::Macros)
+=== Controller Tests (Shoulda::Controller::Macros)
 
 Macros to test the most common controller patterns...
 
@@ -90,7 +91,7 @@ Macros to test the most common controller patterns...
     end
   end
 
-=== Helpful Assertions (ThoughtBot::Shoulda::Assertions)
+=== Helpful Assertions (Shoulda::Assertions)
 
 More to come here, but have fun with what's there.
 
@@ -110,6 +111,33 @@ Any *.rb file under RAILS_ROOT/test/shoulda_macros/ or vendor/(plugins|gems)/gem
     end
   end
 
+= Rails Installation
+
+=== As a Gem
+
+Use this if you prefer to use versioned releases of shoulda.  Specify the gem dependency in your config/environment.rb file:
+
+  Rails::Initializer.run do |config|
+    config.gem "thoughtbot-shoulda", :lib => "shoulda", :source => "http://gems.github.com"
+  end
+
+Then:
+
+  $ rake gems:install
+  $ rake gems:unpack
+
+=== As a Plugin
+
+Use this if you prefer to use the edge version of shoulda:
+
+  $ script/plugin install git://github.com/thoughtbot/shoulda.git
+
+=== As a Plugin (using git submodules)
+
+Use this if you prefer the idea of being able to easily switch between using edge or a tagged version of shoulda:
+
+  $ git submodule add git://github.com/thoughtbot/shoulda.git vendor/plugins/shoulda
+
 = Credits
 
 Shoulda is maintained by {Tammer Saleh}[mailto:tsaleh@thoughtbot.com], and is funded by Thoughtbot[http://www.thoughtbot.com], inc.

data/Rakefile

@@ -2,11 +2,13 @@ require 'rake'
 require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/gempackagetask'
-require 'lib/shoulda/context'
+
+$LOAD_PATH.unshift("lib")
+require 'shoulda'
 load 'tasks/shoulda.rake'
 
 # Test::Unit::UI::VERBOSE
-test_files_pattern = 'test/{unit,functional,other}/**/*_test.rb'
+test_files_pattern = 'test/{unit,functional,other,matchers}/**/*_test.rb'
 Rake::TestTask.new do |t|
   t.libs << 'lib'
   t.pattern = test_files_pattern
@@ -38,7 +40,7 @@ task :default => ['test']
 
 spec = Gem::Specification.new do |s|
   s.name              = "shoulda"
-  s.version           = Thoughtbot::Shoulda::VERSION
+  s.version           = Shoulda::VERSION
   s.summary           = "Making tests easy on the fingers and eyes"
   s.homepage          = "http://thoughtbot.com/projects/shoulda"
   s.rubyforge_project = "shoulda"

data/lib/shoulda.rb

@@ -1,17 +1,9 @@
-require 'shoulda/context'
-require 'shoulda/proc_extensions'
-require 'shoulda/assertions'
-require 'shoulda/macros'
-require 'shoulda/helpers'
-require 'shoulda/rails' if defined? RAILS_ROOT
+module Shoulda
+  VERSION = "2.9.1"
+end
 
-module Test # :nodoc: all
-  module Unit
-    class TestCase
-      extend Thoughtbot::Shoulda
-      include ThoughtBot::Shoulda::Assertions
-      extend ThoughtBot::Shoulda::Macros
-      include ThoughtBot::Shoulda::Helpers
-    end
-  end
+if defined? Spec
+  require 'shoulda/rspec'
+else
+  require 'shoulda/test_unit'
 end

data/lib/shoulda/action_mailer.rb

@@ -4,7 +4,7 @@ require 'shoulda/action_mailer/assertions'
 module Test # :nodoc: all
   module Unit
     class TestCase
-      include ThoughtBot::Shoulda::ActionMailer::Assertions
+      include Shoulda::ActionMailer::Assertions
     end
   end
 end

data/lib/shoulda/action_mailer/assertions.rb

@@ -1,39 +1,38 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module ActionMailer # :nodoc:
-      module Assertions
-        # Asserts that an email was delivered.  Can take a block that can further
-        # narrow down the types of emails you're expecting.
-        #
-        #  assert_sent_email
-        #
-        # Passes if ActionMailer::Base.deliveries has an email
-        #
-        #  assert_sent_email do |email|
-        #    email.subject =~ /hi there/ && email.to.include?('none@none.com')
-        #  end
-        #
-        # Passes if there is an email with subject containing 'hi there' and
-        # 'none@none.com' as one of the recipients.
-        #
-        def assert_sent_email
-          emails = ::ActionMailer::Base.deliveries
-          assert !emails.empty?, "No emails were sent"
-          if block_given?
-            matching_emails = emails.select {|email| yield email }
-            assert !matching_emails.empty?, "None of the emails matched."
-          end
+module Shoulda # :nodoc:
+  module ActionMailer # :nodoc:
+    module Assertions
+      # Asserts that an email was delivered.  Can take a block that can further
+      # narrow down the types of emails you're expecting.
+      #
+      #  assert_sent_email
+      #
+      # Passes if ActionMailer::Base.deliveries has an email
+      #
+      #  assert_sent_email do |email|
+      #    email.subject =~ /hi there/ && email.to.include?('none@none.com')
+      #  end
+      #
+      # Passes if there is an email with subject containing 'hi there' and
+      # 'none@none.com' as one of the recipients.
+      #
+      def assert_sent_email
+        emails = ::ActionMailer::Base.deliveries
+        assert !emails.empty?, "No emails were sent"
+        if block_given?
+          matching_emails = emails.select {|email| yield email }
+          assert !matching_emails.empty?, "None of the emails matched."
         end
+      end
 
-        # Asserts that no ActionMailer mails were delivered
-        #
-        #  assert_did_not_send_email
-        def assert_did_not_send_email
-          msg = "Sent #{::ActionMailer::Base.deliveries.size} emails.\n"
-          ::ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
-          assert ::ActionMailer::Base.deliveries.empty?, msg
-        end
+      # Asserts that no ActionMailer mails were delivered
+      #
+      #  assert_did_not_send_email
+      def assert_did_not_send_email
+        msg = "Sent #{::ActionMailer::Base.deliveries.size} emails.\n"
+        ::ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
+        assert ::ActionMailer::Base.deliveries.empty?, msg
       end
     end
   end
 end
+

data/lib/shoulda/active_record.rb

@@ -1,12 +1,16 @@
 require 'shoulda'
+require 'shoulda/active_record/helpers'
+require 'shoulda/active_record/matchers'
 require 'shoulda/active_record/assertions'
 require 'shoulda/active_record/macros'
 
 module Test # :nodoc: all
   module Unit
     class TestCase
-      include ThoughtBot::Shoulda::ActiveRecord::Assertions
-      extend ThoughtBot::Shoulda::ActiveRecord::Macros
+      include Shoulda::ActiveRecord::Helpers
+      include Shoulda::ActiveRecord::Matchers
+      include Shoulda::ActiveRecord::Assertions
+      extend Shoulda::ActiveRecord::Macros
     end
   end
 end

data/lib/shoulda/active_record/assertions.rb

@@ -1,87 +1,68 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module ActiveRecord # :nodoc:
-      module Assertions
-        # Asserts that the given object can be saved
-        #
-        #  assert_save User.new(params)
-        def assert_save(obj)
-          assert obj.save, "Errors: #{pretty_error_messages obj}"
-          obj.reload
-        end
-
-        # Asserts that the given object is valid
-        #
-        #  assert_valid User.new(params)
-        def assert_valid(obj)
-          assert obj.valid?, "Errors: #{pretty_error_messages obj}"
-        end
-
-        # Asserts that an Active Record model validates with the passed
-        # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
-        # contained within the list of errors for that attribute.
-        #
-        #   assert_good_value(User.new, :email, "user@example.com")
-        #   assert_good_value(User.new, :ssn, "123456789", /length/)
-        #
-        # If a class is passed as the first argument, a new object will be
-        # instantiated before the assertion.  If an instance variable exists with
-        # the same name as the class (underscored), that object will be used
-        # instead.
-        #
-        #   assert_good_value(User, :email, "user@example.com")
-        #
-        #   @product = Product.new(:tangible => false)
-        #   assert_good_value(Product, :price, "0")
-        def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = //)
-          object = get_instance_of(object_or_klass)
-          object.send("#{attribute}=", value)
-          object.valid?
-          assert_does_not_contain(object.errors.on(attribute), error_message_to_avoid, "when set to #{value.inspect}")
-        end
-
-        # Asserts that an Active Record model invalidates the passed
-        # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
-        # contained within the list of errors for that attribute.
-        #
-        #   assert_bad_value(User.new, :email, "invalid")
-        #   assert_bad_value(User.new, :ssn, "123", /length/)
-        #
-        # If a class is passed as the first argument, a new object will be
-        # instantiated before the assertion.  If an instance variable exists with
-        # the same name as the class (underscored), that object will be used
-        # instead.
-        #
-        #   assert_bad_value(User, :email, "invalid")
-        #
-        #   @product = Product.new(:tangible => true)
-        #   assert_bad_value(Product, :price, "0")
-        def assert_bad_value(object_or_klass, attribute, value,
-                             error_message_to_expect = self.class.default_error_message(:invalid))
-          object = get_instance_of(object_or_klass)
-          object.send("#{attribute}=", value)
-          assert !object.valid?, "#{object.class} allowed #{value.inspect} as a value for #{attribute}"
-          assert object.errors.on(attribute), "There are no errors on #{attribute} after being set to #{value.inspect}"
-          assert_contains(object.errors.on(attribute), error_message_to_expect, "when set to #{value.inspect}")
-        end
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Assertions
+      # Asserts that the given object can be saved
+      #
+      #  assert_save User.new(params)
+      def assert_save(obj)
+        assert obj.save, "Errors: #{pretty_error_messages obj}"
+        obj.reload
+      end
 
-        def pretty_error_messages(obj)
-          obj.errors.map do |a, m| 
-            msg = "#{a} #{m}" 
-            msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
-          end
-        end
+      # Asserts that the given object is valid
+      #
+      #  assert_valid User.new(params)
+      def assert_valid(obj)
+        assert obj.valid?, "Errors: #{pretty_error_messages obj}"
+      end
 
-        private
+      # Asserts that an Active Record model validates with the passed
+      # <tt>value</tt> by making sure the <tt>error_message_to_avoid</tt> is not
+      # contained within the list of errors for that attribute.
+      #
+      #   assert_good_value(User.new, :email, "user@example.com")
+      #   assert_good_value(User.new, :ssn, "123456789", /length/)
+      #
+      # If a class is passed as the first argument, a new object will be
+      # instantiated before the assertion.  If an instance variable exists with
+      # the same name as the class (underscored), that object will be used
+      # instead.
+      #
+      #   assert_good_value(User, :email, "user@example.com")
+      #
+      #   @product = Product.new(:tangible => false)
+      #   assert_good_value(Product, :price, "0")
+      def assert_good_value(object_or_klass, attribute, value, error_message_to_avoid = nil)
+        object = get_instance_of(object_or_klass)
+        matcher = allow_value(value).
+                    for(attribute).
+                    with_message(error_message_to_avoid)
+        assert_accepts(matcher, object)
+      end
 
-        def get_instance_of(object_or_klass)
-          if object_or_klass.is_a?(Class)
-            klass = object_or_klass
-            instance_variable_get("@#{klass.to_s.underscore}") || klass.new
-          else
-            object_or_klass
-          end
-        end
+      # Asserts that an Active Record model invalidates the passed
+      # <tt>value</tt> by making sure the <tt>error_message_to_expect</tt> is
+      # contained within the list of errors for that attribute.
+      #
+      #   assert_bad_value(User.new, :email, "invalid")
+      #   assert_bad_value(User.new, :ssn, "123", /length/)
+      #
+      # If a class is passed as the first argument, a new object will be
+      # instantiated before the assertion.  If an instance variable exists with
+      # the same name as the class (underscored), that object will be used
+      # instead.
+      #
+      #   assert_bad_value(User, :email, "invalid")
+      #
+      #   @product = Product.new(:tangible => true)
+      #   assert_bad_value(Product, :price, "0")
+      def assert_bad_value(object_or_klass, attribute, value,
+                           error_message_to_expect = nil)
+        object = get_instance_of(object_or_klass)
+        matcher = allow_value(value).
+                    for(attribute).
+                    with_message(error_message_to_expect)
+        assert_rejects(matcher, object)
       end
     end
   end

data/lib/shoulda/active_record/helpers.rb

@@ -0,0 +1,40 @@
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Helpers
+      def pretty_error_messages(obj) # :nodoc:
+        obj.errors.map do |a, m| 
+          msg = "#{a} #{m}" 
+          msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
+        end
+      end
+
+      def get_instance_of(object_or_klass)
+        if object_or_klass.is_a?(Class)
+          klass = object_or_klass
+          instance_variable_get("@#{instance_variable_name_for(klass)}") || klass.new
+        else
+          object_or_klass
+        end
+      end
+
+      def instance_variable_name_for(klass)
+        klass.to_s.split('::').last.underscore
+      end
+
+      # Helper method that determines the default error message used by Active
+      # Record.  Works for both existing Rails 2.1 and Rails 2.2 with the newly
+      # introduced I18n module used for localization.
+      #
+      #   default_error_message(:blank)
+      #   default_error_message(:too_short, :count => 5)
+      #   default_error_message(:too_long, :count => 60)
+      def default_error_message(key, values = {})
+        if Object.const_defined?(:I18n) # Rails >= 2.2
+          I18n.translate("activerecord.errors.messages.#{key}", values)
+        else # Rails <= 2.1.x
+          ::ActiveRecord::Errors.default_error_messages[key] % values[:count]
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/active_record/macros.rb

@@ -1,713 +1,584 @@
-module ThoughtBot # :nodoc:
-  module Shoulda # :nodoc:
-    module ActiveRecord # :nodoc:
-      module MacroHelpers # :nodoc:
-        # Helper method that determines the default error message used by Active
-        # Record.  Works for both existing Rails 2.1 and Rails 2.2 with the newly
-        # introduced I18n module used for localization.
-        #
-        #   default_error_message(:blank)
-        #   default_error_message(:too_short, :count => 5)
-        #   default_error_message(:too_long, :count => 60)
-        def default_error_message(key, values = {})
-          if Object.const_defined?(:I18n) # Rails >= 2.2
-            I18n.translate("activerecord.errors.messages.#{key}", values)
-          else # Rails <= 2.1.x
-            ::ActiveRecord::Errors.default_error_messages[key] % values[:count]
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    # = Macro test helpers for your active record models
+    #
+    # These helpers will test most of the validations and associations for your ActiveRecord models.
+    #
+    #   class UserTest < Test::Unit::TestCase
+    #     should_validate_presence_of :name, :phone_number
+    #     should_not_allow_values_for :phone_number, "abcd", "1234"
+    #     should_allow_values_for :phone_number, "(123) 456-7890"
+    #
+    #     should_not_allow_mass_assignment_of :password
+    #
+    #     should_have_one :profile
+    #     should_have_many :dogs
+    #     should_have_many :messes, :through => :dogs
+    #     should_belong_to :lover
+    #   end
+    #
+    # For all of these helpers, the last parameter may be a hash of options.
+    #
+    module Macros
+      include Helpers
+      include Matchers
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not present.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.blank')</tt>
+      #
+      # Example:
+      #   should_validate_presence_of :name, :phone_number
+      #
+      def should_validate_presence_of(*attributes)
+        message = get_options!(attributes, :message)
+        klass = model_class
+
+        attributes.each do |attribute|
+          matcher = validate_presence_of(attribute).with_message(message)
+          should matcher.description do
+            assert_accepts(matcher, get_instance_of(klass))
           end
         end
       end
+      
+      # Deprecated. See should_validate_presence_of
+      def should_require_attributes(*attributes)
+        warn "[DEPRECATION] should_require_attributes is deprecated. " <<
+             "Use should_validate_presence_of instead."
+        should_validate_presence_of(*attributes)
+      end
 
-      # = Macro test helpers for your active record models
-      #
-      # These helpers will test most of the validations and associations for your ActiveRecord models.
-      #
-      #   class UserTest < Test::Unit::TestCase
-      #     should_require_attributes :name, :phone_number
-      #     should_not_allow_values_for :phone_number, "abcd", "1234"
-      #     should_allow_values_for :phone_number, "(123) 456-7890"
-      #
-      #     should_protect_attributes :password
+      # Ensures that the model cannot be saved if one of the attributes listed is not unique.
+      # Requires an existing record
       #
-      #     should_have_one :profile
-      #     should_have_many :dogs
-      #     should_have_many :messes, :through => :dogs
-      #     should_belong_to :lover
-      #   end
+      # Options:
+
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.taken')</tt>
+      # * <tt>:scoped_to</tt> - field(s) to scope the uniqueness to.
+      # * <tt>:case_sensitive</tt> - whether or not uniqueness is defined by an
+      #   exact match. Ignored by non-text attributes. Default = <tt>true</tt>
       #
-      # For all of these helpers, the last parameter may be a hash of options.
+      # Examples:
+      #   should_validate_uniqueness_of :keyword, :username
+      #   should_validate_uniqueness_of :name, :message => "O NOES! SOMEONE STOELED YER NAME!"
+      #   should_validate_uniqueness_of :email, :scoped_to => :name
+      #   should_validate_uniqueness_of :address, :scoped_to => [:first_name, :last_name]
+      #   should_validate_uniqueness_of :email, :case_sensitive => false
       #
-      module Macros
-        include MacroHelpers
+      def should_validate_uniqueness_of(*attributes)
+        message, scope, case_sensitive = get_options!(attributes, :message, :scoped_to, :case_sensitive)
+        scope = [*scope].compact
+        case_sensitive = true if case_sensitive.nil?
 
-        # <b>DEPRECATED:</b> Use <tt>fixtures :all</tt> instead
-        #
-        # Loads all fixture files (<tt>test/fixtures/*.yml</tt>)
-        def load_all_fixtures
-          warn "[DEPRECATION] load_all_fixtures is deprecated.  Use `fixtures :all` instead."
-          fixtures :all
-        end
+        klass = model_class
 
-        # Ensures that the model cannot be saved if one of the attributes listed is not present.
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Options:
-        # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.blank')</tt>
-        #
-        # Example:
-        #   should_require_attributes :name, :phone_number
-        #
-        def should_require_attributes(*attributes)
-          message = get_options!(attributes, :message)
-          message ||= default_error_message(:blank)
-          klass = model_class
-
-          attributes.each do |attribute|
-            should "require #{attribute} to be set" do
-              assert_bad_value(klass, attribute, nil, message)
-            end
+        attributes.each do |attribute|
+          matcher = validate_uniqueness_of(attribute).
+            with_message(message).scoped_to(scope)
+          matcher = matcher.case_insensitive unless case_sensitive
+          should matcher.description do
+            assert_accepts(matcher, get_instance_of(klass))
           end
         end
+      end
 
-        # Ensures that the model cannot be saved if one of the attributes listed is not unique.
-        # Requires an existing record
-        #
-        # Options:
-        # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.taken')</tt>
-        # * <tt>:scoped_to</tt> - field(s) to scope the uniqueness to.
-        #
-        # Examples:
-        #   should_require_unique_attributes :keyword, :username
-        #   should_require_unique_attributes :name, :message => "O NOES! SOMEONE STOELED YER NAME!"
-        #   should_require_unique_attributes :email, :scoped_to => :name
-        #   should_require_unique_attributes :address, :scoped_to => [:first_name, :last_name]
-        #
-        def should_require_unique_attributes(*attributes)
-          message, scope = get_options!(attributes, :message, :scoped_to)
-          scope = [*scope].compact
-          message ||= default_error_message(:taken)
-
-          klass = model_class
-          attributes.each do |attribute|
-            attribute = attribute.to_sym
-            should "require unique value for #{attribute}#{" scoped to #{scope.join(', ')}" unless scope.blank?}" do
-              assert existing = klass.find(:first), "Can't find first #{klass}"
-              object = klass.new
-              existing_value = existing.send(attribute)
-
-              if !scope.blank?
-                scope.each do |s|
-                  assert_respond_to object, :"#{s}=", "#{klass.name} doesn't seem to have a #{s} attribute."
-                  object.send("#{s}=", existing.send(s))
-                end
-              end
-              assert_bad_value(object, attribute, existing_value, message)
-
-              # Now test that the object is valid when changing the scoped attribute
-              # TODO:  There is a chance that we could change the scoped field
-              # to a value that's already taken.  An alternative implementation
-              # could actually find all values for scope and create a unique
-              # one.
-              if !scope.blank?
-                scope.each do |s|
-                  # Assume the scope is a foreign key if the field is nil
-                  object.send("#{s}=", existing.send(s).nil? ? 1 : existing.send(s).next)
-                  assert_good_value(object, attribute, existing_value, message)
-                end
-              end
-            end
-          end
-        end
+      # Deprecated. See should_validate_uniqueness_of
+      def should_require_unique_attributes(*attributes)
+        warn "[DEPRECATION] should_require_unique_attributes is deprecated. " <<
+             "Use should_validate_uniqueness_of instead."
+        should_validate_uniqueness_of(*attributes)
+      end
 
-        # Ensures that the attribute cannot be set on mass update.
-        #
-        #   should_protect_attributes :password, :admin_flag
-        #
-        def should_protect_attributes(*attributes)
-          get_options!(attributes)
-          klass = model_class
-
-          attributes.each do |attribute|
-            attribute = attribute.to_sym
-            should "protect #{attribute} from mass updates" do
-              protected = klass.protected_attributes || []
-              accessible = klass.accessible_attributes || []
-
-              assert protected.include?(attribute.to_s) ||
-                (!accessible.empty? && !accessible.include?(attribute.to_s)),
-                     (accessible.empty? ?
-                       "#{klass} is protecting #{protected.to_a.to_sentence}, but not #{attribute}." :
-                       "#{klass} has made #{attribute} accessible")
-            end
-          end
-        end
+      # Ensures that the attribute can be set on mass update.
+      #
+      #   should_allow_mass_assignment_of :first_name, :last_name
+      #
+      def should_allow_mass_assignment_of(*attributes)
+        get_options!(attributes)
+        klass = model_class
 
-        # Ensures that the attribute cannot be changed once the record has been created.
-        #
-        #   should_have_readonly_attributes :password, :admin_flag
-        #
-        def should_have_readonly_attributes(*attributes)
-          get_options!(attributes)
-          klass = model_class
-
-          attributes.each do |attribute|
-            attribute = attribute.to_sym
-            should "make #{attribute} read-only" do
-              readonly = klass.readonly_attributes || []
-
-              assert readonly.include?(attribute.to_s),
-                     (readonly.empty? ?
-                       "#{klass} attribute #{attribute} is not read-only" :
-                       "#{klass} is making #{readonly.to_a.to_sentence} read-only, but not #{attribute}.")
-            end
+        attributes.each do |attribute|
+          matcher = allow_mass_assignment_of(attribute)
+          should matcher.description do
+            assert_accepts matcher, klass.new
           end
         end
+      end
 
-        # Ensures that the attribute cannot be set to the given values
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Options:
-        # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.invalid')</tt>
-        #
-        # Example:
-        #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
-        #
-        def should_not_allow_values_for(attribute, *bad_values)
-          message = get_options!(bad_values, :message)
-          message ||= default_error_message(:invalid)
-          klass = model_class
-          bad_values.each do |v|
-            should "not allow #{attribute} to be set to #{v.inspect}" do
-              assert_bad_value(klass, attribute, v, message)
-            end
-          end
-        end
+      # Ensures that the attribute cannot be set on mass update.
+      #
+      #   should_not_allow_mass_assignment_of :password, :admin_flag
+      #
+      def should_not_allow_mass_assignment_of(*attributes)
+        get_options!(attributes)
+        klass = model_class
 
-        # Ensures that the attribute can be set to the given values.
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Example:
-        #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
-        #
-        def should_allow_values_for(attribute, *good_values)
-          get_options!(good_values)
-          klass = model_class
-          good_values.each do |v|
-            should "allow #{attribute} to be set to #{v.inspect}" do
-              assert_good_value(klass, attribute, v)
-            end
+        attributes.each do |attribute|
+          matcher = allow_mass_assignment_of(attribute)
+          should "not #{matcher.description}" do
+            assert_rejects matcher, klass.new
           end
         end
+      end
 
-        # Ensures that the length of the attribute is in the given range
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Options:
-        # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % range.first</tt>
-        # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_long') % range.last</tt>
-        #
-        # Example:
-        #   should_ensure_length_in_range :password, (6..20)
-        #
-        def should_ensure_length_in_range(attribute, range, opts = {})
-          short_message, long_message = get_options!([opts], :short_message, :long_message)
-          short_message ||= default_error_message(:too_short, :count => range.first)
-          long_message  ||= default_error_message(:too_long, :count => range.last)
-
-          klass = model_class
-          min_length = range.first
-          max_length = range.last
-          same_length = (min_length == max_length)
-
-          if min_length > 0
-            should "not allow #{attribute} to be less than #{min_length} chars long" do
-              min_value = "x" * (min_length - 1)
-              assert_bad_value(klass, attribute, min_value, short_message)
-            end
-          end
-
-          if min_length > 0
-            should "allow #{attribute} to be exactly #{min_length} chars long" do
-              min_value = "x" * min_length
-              assert_good_value(klass, attribute, min_value, short_message)
-            end
-          end
+      # Deprecated. See should_not_allow_mass_assignment_of
+      def should_protect_attributes(*attributes)
+        warn "[DEPRECATION] should_protect_attributes is deprecated. " <<
+             "Use should_not_allow_mass_assignment_of instead."
+        should_not_allow_mass_assignment_of(*attributes)
+      end
 
-          should "not allow #{attribute} to be more than #{max_length} chars long" do
-            max_value = "x" * (max_length + 1)
-            assert_bad_value(klass, attribute, max_value, long_message)
-          end
+      # Ensures that the attribute cannot be changed once the record has been created.
+      #
+      #   should_have_readonly_attributes :password, :admin_flag
+      #
+      def should_have_readonly_attributes(*attributes)
+        get_options!(attributes)
+        klass = model_class
 
-          unless same_length
-            should "allow #{attribute} to be exactly #{max_length} chars long" do
-              max_value = "x" * max_length
-              assert_good_value(klass, attribute, max_value, long_message)
-            end
+        attributes.each do |attribute|
+          matcher = have_readonly_attribute(attribute)
+          should matcher.description do
+            assert_accepts matcher, klass.new
           end
         end
+      end
 
-        # Ensures that the length of the attribute is at least a certain length
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Options:
-        # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % min_length</tt>
-        #
-        # Example:
-        #   should_ensure_length_at_least :name, 3
-        #
-        def should_ensure_length_at_least(attribute, min_length, opts = {})
-          short_message = get_options!([opts], :short_message)
-          short_message ||= default_error_message(:too_short, :count => min_length)
-
-          klass = model_class
-
-          if min_length > 0
-            min_value = "x" * (min_length - 1)
-            should "not allow #{attribute} to be less than #{min_length} chars long" do
-              assert_bad_value(klass, attribute, min_value, short_message)
-            end
-          end
-          should "allow #{attribute} to be at least #{min_length} chars long" do
-            valid_value = "x" * (min_length)
-            assert_good_value(klass, attribute, valid_value, short_message)
+      # Ensures that the attribute cannot be set to the given values
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.invalid')</tt>
+      #
+      # Example:
+      #   should_not_allow_values_for :isbn, "bad 1", "bad 2"
+      #
+      def should_not_allow_values_for(attribute, *bad_values)
+        message = get_options!(bad_values, :message)
+        klass = model_class
+        bad_values.each do |value|
+          matcher = allow_value(value).for(attribute).with_message(message)
+          should "not #{matcher.description}" do
+            assert_rejects matcher, get_instance_of(klass)
           end
         end
+      end
 
-        # Ensures that the length of the attribute is exactly a certain length
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Options:
-        # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % length</tt>
-        #
-        # Example:
-        #   should_ensure_length_is :ssn, 9
-        #
-        def should_ensure_length_is(attribute, length, opts = {})
-          message = get_options!([opts], :message)
-          message ||= default_error_message(:wrong_length, :count => length)
-
-          klass = model_class
-
-          should "not allow #{attribute} to be less than #{length} chars long" do
-            min_value = "x" * (length - 1)
-            assert_bad_value(klass, attribute, min_value, message)
-          end
-
-          should "not allow #{attribute} to be greater than #{length} chars long" do
-            max_value = "x" * (length + 1)
-            assert_bad_value(klass, attribute, max_value, message)
+      # Ensures that the attribute can be set to the given values.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Example:
+      #   should_allow_values_for :isbn, "isbn 1 2345 6789 0", "ISBN 1-2345-6789-0"
+      #
+      def should_allow_values_for(attribute, *good_values)
+        get_options!(good_values)
+        klass = model_class
+        klass = model_class
+        good_values.each do |value|
+          matcher = allow_value(value).for(attribute)
+          should matcher.description do
+            assert_accepts matcher, get_instance_of(klass)
           end
+        end
+      end
 
-          should "allow #{attribute} to be #{length} chars long" do
-            valid_value = "x" * (length)
-            assert_good_value(klass, attribute, valid_value, message)
-          end
+      # Ensures that the length of the attribute is in the given range
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % range.first</tt>
+      # * <tt>:long_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_long') % range.last</tt>
+      #
+      # Example:
+      #   should_ensure_length_in_range :password, (6..20)
+      #
+      def should_ensure_length_in_range(attribute, range, opts = {})
+        short_message, long_message = get_options!([opts], 
+                                                   :short_message,
+                                                   :long_message)
+        klass = model_class
+
+        matcher = ensure_length_of(attribute).
+          is_at_least(range.first).
+          with_short_message(short_message).
+          is_at_most(range.last).
+          with_long_message(long_message)
+
+        should matcher.description do
+          assert_accepts matcher, get_instance_of(klass)
         end
+      end
 
-        # Ensure that the attribute is in the range specified
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Options:
-        # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
-        # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
-        #
-        # Example:
-        #   should_ensure_value_in_range :age, (0..100)
-        #
-        def should_ensure_value_in_range(attribute, range, opts = {})
-          low_message, high_message = get_options!([opts], :low_message, :high_message)
-          low_message  ||= default_error_message(:inclusion)
-          high_message ||= default_error_message(:inclusion)
-
-          klass = model_class
-          min   = range.first
-          max   = range.last
-
-          should "not allow #{attribute} to be less than #{min}" do
-            v = min - 1
-            assert_bad_value(klass, attribute, v, low_message)
-          end
+      # Ensures that the length of the attribute is at least a certain length
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:short_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.too_short') % min_length</tt>
+      #
+      # Example:
+      #   should_ensure_length_at_least :name, 3
+      #
+      def should_ensure_length_at_least(attribute, min_length, opts = {})
+        short_message = get_options!([opts], :short_message)
+        klass = model_class
 
-          should "allow #{attribute} to be #{min}" do
-            v = min
-            assert_good_value(klass, attribute, v, low_message)
-          end
+        matcher = ensure_length_of(attribute).
+          is_at_least(min_length).
+          with_short_message(short_message)
 
-          should "not allow #{attribute} to be more than #{max}" do
-            v = max + 1
-            assert_bad_value(klass, attribute, v, high_message)
-          end
+        should matcher.description do
+          assert_accepts matcher, get_instance_of(klass)
+        end
+      end
 
-          should "allow #{attribute} to be #{max}" do
-            v = max
-            assert_good_value(klass, attribute, v, high_message)
-          end
+      # Ensures that the length of the attribute is exactly a certain length
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.wrong_length') % length</tt>
+      #
+      # Example:
+      #   should_ensure_length_is :ssn, 9
+      #
+      def should_ensure_length_is(attribute, length, opts = {})
+        message = get_options!([opts], :message)
+        klass   = model_class
+        matcher = ensure_length_of(attribute).
+          is_equal_to(length).
+          with_message(message)
+
+        should matcher.description do
+          assert_accepts matcher, get_instance_of(klass)
         end
+      end
 
-        # Ensure that the attribute is numeric
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Options:
-        # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.not_a_number')</tt>
-        #
-        # Example:
-        #   should_only_allow_numeric_values_for :age
-        #
-        def should_only_allow_numeric_values_for(*attributes)
-          message = get_options!(attributes, :message)
-          message ||= default_error_message(:not_a_number)
-          klass = model_class
-          attributes.each do |attribute|
-            attribute = attribute.to_sym
-            should "only allow numeric values for #{attribute}" do
-              assert_bad_value(klass, attribute, "abcd", message)
-            end
-          end
+      # Ensure that the attribute is in the range specified
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:low_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
+      # * <tt>:high_message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.inclusion')</tt>
+      #
+      # Example:
+      #   should_ensure_value_in_range :age, (0..100)
+      #
+      def should_ensure_value_in_range(attribute, range, opts = {})
+        message = get_options!([opts], :message)
+        message ||= default_error_message(:inclusion)
+
+        klass = model_class
+        matcher = ensure_inclusion_of(attribute).
+          in_range(range).
+          with_message(message)
+        should matcher.description do
+          assert_accepts matcher, get_instance_of(klass)
         end
+      end
 
-        # Ensures that the has_many relationship exists.  Will also test that the
-        # associated table has the required columns.  Works with polymorphic
-        # associations.
-        #
-        # Options:
-        # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
-        # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
-        #
-        # Example:
-        #   should_have_many :friends
-        #   should_have_many :enemies, :through => :friends
-        #   should_have_many :enemies, :dependent => :destroy
-        #
-        def should_have_many(*associations)
-          through, dependent = get_options!(associations, :through, :dependent)
-          klass = model_class
-          associations.each do |association|
-            name = "have many #{association}"
-            name += " through #{through}" if through
-            name += " dependent => #{dependent}" if dependent
-            should name do
-              reflection = klass.reflect_on_association(association)
-              assert reflection, "#{klass.name} does not have any relationship to #{association}"
-              assert_equal :has_many, reflection.macro
-
-              if through
-                through_reflection = klass.reflect_on_association(through)
-                assert through_reflection, "#{klass.name} does not have any relationship to #{through}"
-                assert_equal(through, reflection.options[:through])
-              end
-
-              if dependent
-                assert_equal dependent.to_s,
-                             reflection.options[:dependent].to_s,
-                             "#{association} should have #{dependent} dependency"
-              end
-
-              # Check for the existence of the foreign key on the other table
-              unless reflection.options[:through]
-                if reflection.options[:foreign_key]
-                  fk = reflection.options[:foreign_key]
-                elsif reflection.options[:as]
-                  fk = reflection.options[:as].to_s.foreign_key
-                else
-                  fk = reflection.primary_key_name
-                end
-
-                associated_klass_name = (reflection.options[:class_name] || association.to_s.classify)
-                associated_klass = associated_klass_name.constantize
-
-                assert associated_klass.column_names.include?(fk.to_s),
-                       "#{associated_klass.name} does not have a #{fk} foreign key."
-              end
-            end
+      # Ensure that the attribute is numeric
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.not_a_number')</tt>
+      #
+      # Example:
+      #   should_validate_numericality_of :age
+      #
+      def should_validate_numericality_of(*attributes)
+        message = get_options!(attributes, :message)
+        klass = model_class
+        attributes.each do |attribute|
+          matcher = validate_numericality_of(attribute).
+            with_message(message)
+          should matcher.description do
+            assert_accepts matcher, get_instance_of(klass)
           end
         end
+      end
+
+      # Deprecated. See should_validate_uniqueness_of
+      def should_only_allow_numeric_values_for(*attributes)
+        warn "[DEPRECATION] should_only_allow_numeric_values_for is " <<
+             "deprecated. Use should_validate_numericality_of instead."
+        should_validate_numericality_of(*attributes)
+      end
 
-        # Ensure that the has_one relationship exists.  Will also test that the
-        # associated table has the required columns.  Works with polymorphic
-        # associations.
-        #
-        # Options:
-        # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
-        #
-        # Example:
-        #   should_have_one :god # unless hindu
-        #
-        def should_have_one(*associations)
-          dependent = get_options!(associations, :dependent)
-          klass = model_class
-          associations.each do |association|
-            name = "have one #{association}"
-            name += " dependent => #{dependent}" if dependent
-            should name do
-              reflection = klass.reflect_on_association(association)
-              assert reflection, "#{klass.name} does not have any relationship to #{association}"
-              assert_equal :has_one, reflection.macro
-
-              associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
-
-              if reflection.options[:foreign_key]
-                fk = reflection.options[:foreign_key]
-              elsif reflection.options[:as]
-                fk = reflection.options[:as].to_s.foreign_key
-                fk_type = fk.gsub(/_id$/, '_type')
-                assert associated_klass.column_names.include?(fk_type),
-                       "#{associated_klass.name} does not have a #{fk_type} column."
-              else
-                fk = klass.name.foreign_key
-              end
-              assert associated_klass.column_names.include?(fk.to_s),
-                     "#{associated_klass.name} does not have a #{fk} foreign key."
-
-              if dependent
-                assert_equal dependent.to_s,
-                             reflection.options[:dependent].to_s,
-                             "#{association} should have #{dependent} dependency"
-              end
-            end
+      # Ensures that the has_many relationship exists.  Will also test that the
+      # associated table has the required columns.  Works with polymorphic
+      # associations.
+      #
+      # Options:
+      # * <tt>:through</tt> - association name for <tt>has_many :through</tt>
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+      #
+      # Example:
+      #   should_have_many :friends
+      #   should_have_many :enemies, :through => :friends
+      #   should_have_many :enemies, :dependent => :destroy
+      #
+      def should_have_many(*associations)
+        through, dependent = get_options!(associations, :through, :dependent)
+        klass = model_class
+        associations.each do |association|
+          matcher = have_many(association).through(through).dependent(dependent)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
+      end
 
-        # Ensures that the has_and_belongs_to_many relationship exists, and that the join
-        # table is in place.
-        #
-        #   should_have_and_belong_to_many :posts, :cars
-        #
-        def should_have_and_belong_to_many(*associations)
-          get_options!(associations)
-          klass = model_class
-
-          associations.each do |association|
-            should "should have and belong to many #{association}" do
-              reflection = klass.reflect_on_association(association)
-              assert reflection, "#{klass.name} does not have any relationship to #{association}"
-              assert_equal :has_and_belongs_to_many, reflection.macro
-              table = reflection.options[:join_table]
-              assert ::ActiveRecord::Base.connection.tables.include?(table.to_s), "table #{table} doesn't exist"
-            end
+      # Ensure that the has_one relationship exists.  Will also test that the
+      # associated table has the required columns.  Works with polymorphic
+      # associations.
+      #
+      # Options:
+      # * <tt>:dependent</tt> - tests that the association makes use of the dependent option.
+      #
+      # Example:
+      #   should_have_one :god # unless hindu
+      #
+      def should_have_one(*associations)
+        dependent = get_options!(associations, :dependent)
+        klass = model_class
+        associations.each do |association|
+          matcher = have_one(association).dependent(dependent)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
+      end
 
-        # Ensure that the belongs_to relationship exists.
-        #
-        #   should_belong_to :parent
-        #
-        def should_belong_to(*associations)
-          get_options!(associations)
-          klass = model_class
-          associations.each do |association|
-            should "belong_to #{association}" do
-              reflection = klass.reflect_on_association(association)
-              assert reflection, "#{klass.name} does not have any relationship to #{association}"
-              assert_equal :belongs_to, reflection.macro
-
-              unless reflection.options[:polymorphic]
-                associated_klass = (reflection.options[:class_name] || association.to_s.camelize).constantize
-                fk = reflection.options[:foreign_key] || reflection.primary_key_name
-                assert klass.column_names.include?(fk.to_s), "#{klass.name} does not have a #{fk} foreign key."
-              end
-            end
+      # Ensures that the has_and_belongs_to_many relationship exists, and that the join
+      # table is in place.
+      #
+      #   should_have_and_belong_to_many :posts, :cars
+      #
+      def should_have_and_belong_to_many(*associations)
+        get_options!(associations)
+        klass = model_class
+
+        associations.each do |association|
+          matcher = have_and_belong_to_many(association)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
+      end
 
-        # Ensure that the given class methods are defined on the model.
-        #
-        #   should_have_class_methods :find, :destroy
-        #
-        def should_have_class_methods(*methods)
-          get_options!(methods)
-          klass = model_class
-          methods.each do |method|
-            should "respond to class method ##{method}" do
-              assert_respond_to klass, method, "#{klass.name} does not have class method #{method}"
-            end
+      # Ensure that the belongs_to relationship exists.
+      #
+      #   should_belong_to :parent
+      #
+      def should_belong_to(*associations)
+        dependent = get_options!(associations, :dependent)
+        klass = model_class
+        associations.each do |association|
+          matcher = belong_to(association).dependent(dependent)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
+      end
 
-        # Ensure that the given instance methods are defined on the model.
-        #
-        #   should_have_instance_methods :email, :name, :name=
-        #
-        def should_have_instance_methods(*methods)
-          get_options!(methods)
-          klass = model_class
-          methods.each do |method|
-            should "respond to instance method ##{method}" do
-              assert_respond_to klass.new, method, "#{klass.name} does not have instance method #{method}"
-            end
+      # Ensure that the given class methods are defined on the model.
+      #
+      #   should_have_class_methods :find, :destroy
+      #
+      def should_have_class_methods(*methods)
+        get_options!(methods)
+        klass = model_class
+        methods.each do |method|
+          should "respond to class method ##{method}" do
+            assert_respond_to klass, method, "#{klass.name} does not have class method #{method}"
           end
         end
+      end
 
-        # Ensure that the given columns are defined on the models backing SQL table.
-        #
-        #   should_have_db_columns :id, :email, :name, :created_at
-        #
-        def should_have_db_columns(*columns)
-          column_type = get_options!(columns, :type)
-          klass = model_class
-          columns.each do |name|
-            test_name = "have column #{name}"
-            test_name += " of type #{column_type}" if column_type
-            should test_name do
-              column = klass.columns.detect {|c| c.name == name.to_s }
-              assert column, "#{klass.name} does not have column #{name}"
-            end
+      # Ensure that the given instance methods are defined on the model.
+      #
+      #   should_have_instance_methods :email, :name, :name=
+      #
+      def should_have_instance_methods(*methods)
+        get_options!(methods)
+        klass = model_class
+        methods.each do |method|
+          should "respond to instance method ##{method}" do
+            assert_respond_to klass.new, method, "#{klass.name} does not have instance method #{method}"
           end
         end
+      end
 
-        # Ensure that the given column is defined on the models backing SQL table.  The options are the same as
-        # the instance variables defined on the column definition:  :precision, :limit, :default, :null,
-        # :primary, :type, :scale, and :sql_type.
-        #
-        #   should_have_db_column :email, :type => "string", :default => nil,   :precision => nil, :limit    => 255,
-        #                                 :null => true,     :primary => false, :scale     => nil, :sql_type => 'varchar(255)'
-        #
-        def should_have_db_column(name, opts = {})
-          klass = model_class
-          test_name = "have column named :#{name}"
-          test_name += " with options " + opts.inspect unless opts.empty?
-          should test_name do
-            column = klass.columns.detect {|c| c.name == name.to_s }
-            assert column, "#{klass.name} does not have column #{name}"
-            opts.each do |k, v|
-              assert_equal column.instance_variable_get("@#{k}").to_s, v.to_s, ":#{name} column on table for #{klass} does not match option :#{k}"
-            end
+      # Ensure that the given columns are defined on the models backing SQL table.
+      # Also aliased to should_have_index for readability.
+      # Takes the same options available in migrations: 
+      # :type, :precision, :limit, :default, :null, and :scale
+      #
+      # Examples:
+      #
+      #   should_have_db_columns :id, :email, :name, :created_at
+      #
+      #   should_have_db_column :email,  :type => "string", :limit => 255
+      #   should_have_db_column :salary, :decimal, :precision => 15, :scale => 2
+      #   should_have_db_column :admin,  :default => false, :null => false
+      #
+      def should_have_db_columns(*columns)
+        column_type, precision, limit, default, null, scale, sql_type = 
+          get_options!(columns, :type, :precision, :limit,
+                                :default, :null, :scale, :sql_type)
+        klass = model_class
+        columns.each do |name|
+          matcher = have_db_column(name).
+                      of_type(column_type).
+                      with_options(:precision => precision, :limit    => limit,
+                                   :default   => default,   :null     => null,
+                                   :scale     => scale,     :sql_type => sql_type)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
+      end
+      
+      alias_method :should_have_db_column, :should_have_db_columns
 
-        # Ensures that there are DB indices on the given columns or tuples of columns.
-        # Also aliased to should_have_index for readability
-        #
-        #   should_have_indices :email, :name, [:commentable_type, :commentable_id]
-        #   should_have_index :age
-        #
-        def should_have_indices(*columns)
-          table = model_class.table_name
-          indices = ::ActiveRecord::Base.connection.indexes(table).map(&:columns)
-
-          columns.each do |column|
-            should "have index on #{table} for #{column.inspect}" do
-              columns = [column].flatten.map(&:to_s)
-              assert_contains(indices, columns)
-            end
+      # Ensures that there are DB indices on the given columns or tuples of columns.
+      # Also aliased to should_have_index for readability
+      #
+      # Options:
+      # * <tt>:unique</tt> - whether or not the index has a unique
+      #   constraint. Use <tt>true</tt> to explicitly test for a unique
+      #   constraint.  Use <tt>false</tt> to explicitly test for a non-unique
+      #   constraint. Use <tt>nil</tt> if you don't care whether the index is
+      #   unique or not.  Default = <tt>nil</tt>
+      #
+      # Examples:
+      #
+      #   should_have_indices :email, :name, [:commentable_type, :commentable_id]
+      #   should_have_index :age
+      #   should_have_index :ssn, :unique => true
+      #
+      def should_have_indices(*columns)
+        unique = get_options!(columns, :unique)
+        klass  = model_class
+        
+        columns.each do |column|
+          matcher = have_index(column).unique(unique)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
+      end
 
-        alias_method :should_have_index, :should_have_indices
-
-        # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
-        #
-        # If an instance variable has been created in the setup named after the
-        # model being tested, then this method will use that.  Otherwise, it will
-        # create a new instance to test against.
-        #
-        # Options:
-        # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
-        #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.accepted')</tt>
-        #
-        # Example:
-        #   should_require_acceptance_of :eula
-        #
-        def should_require_acceptance_of(*attributes)
-          message = get_options!(attributes, :message)
-          message ||= default_error_message(:accepted)
-          klass = model_class
-
-          attributes.each do |attribute|
-            should "require #{attribute} to be accepted" do
-              assert_bad_value(klass, attribute, false, message)
-            end
+      alias_method :should_have_index, :should_have_indices
+
+      # Ensures that the model cannot be saved if one of the attributes listed is not accepted.
+      #
+      # If an instance variable has been created in the setup named after the
+      # model being tested, then this method will use that.  Otherwise, it will
+      # create a new instance to test against.
+      #
+      # Options:
+      # * <tt>:message</tt> - value the test expects to find in <tt>errors.on(:attribute)</tt>.
+      #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.accepted')</tt>
+      #
+      # Example:
+      #   should_validate_acceptance_of :eula
+      #
+      def should_validate_acceptance_of(*attributes)
+        message = get_options!(attributes, :message)
+        klass = model_class
+
+        attributes.each do |attribute|
+          matcher = validate_acceptance_of(attribute).with_message(message)
+          should matcher.description do
+            assert_accepts matcher, get_instance_of(klass)
           end
         end
+      end
 
-        # Ensures that the model has a method named scope_name that returns a NamedScope object with the
-        # proxy options set to the options you supply.  scope_name can be either a symbol, or a method
-        # call which will be evaled against the model.  The eval'd method call has access to all the same
-        # instance variables that a should statement would.
-        #
-        # Options: Any of the options that the named scope would pass on to find.
-        #
-        # Example:
-        #
-        #   should_have_named_scope :visible, :conditions => {:visible => true}
-        #
-        # Passes for
-        #
-        #   named_scope :visible, :conditions => {:visible => true}
-        #
-        # Or for
-        #
-        #   def self.visible
-        #     scoped(:conditions => {:visible => true})
-        #   end
-        #
-        # You can test lambdas or methods that return ActiveRecord#scoped calls:
-        #
-        #   should_have_named_scope 'recent(5)', :limit => 5
-        #   should_have_named_scope 'recent(1)', :limit => 1
-        #
-        # Passes for
-        #   named_scope :recent, lambda {|c| {:limit => c}}
-        #
-        # Or for
-        #
-        #   def self.recent(c)
-        #     scoped(:limit => c)
-        #   end
-        #
-        def should_have_named_scope(scope_call, *args)
-          klass = model_class
-          scope_opts = args.extract_options!
-          scope_call = scope_call.to_s
-
-          context scope_call do
-            setup do
-              @scope = eval("#{klass}.#{scope_call}")
-            end
-
-            should "return a scope object" do
-              assert_equal ::ActiveRecord::NamedScope::Scope, @scope.class
-            end
-
-            unless scope_opts.empty?
-              should "scope itself to #{scope_opts.inspect}" do
-                assert_equal scope_opts, @scope.proxy_options
-              end
-            end
-          end
+      # Deprecated. See should_validate_uniqueness_of
+      def should_require_acceptance_of(*attributes)
+        warn "[DEPRECATION] should_require_acceptance_of is deprecated. " <<
+             "Use should_validate_acceptance_of instead."
+        should_validate_acceptance_of(*attributes)
+      end
+
+      # Ensures that the model has a method named scope_name that returns a NamedScope object with the
+      # proxy options set to the options you supply.  scope_name can be either a symbol, or a method
+      # call which will be evaled against the model.  The eval'd method call has access to all the same
+      # instance variables that a should statement would.
+      #
+      # Options: Any of the options that the named scope would pass on to find.
+      #
+      # Example:
+      #
+      #   should_have_named_scope :visible, :conditions => {:visible => true}
+      #
+      # Passes for
+      #
+      #   named_scope :visible, :conditions => {:visible => true}
+      #
+      # Or for
+      #
+      #   def self.visible
+      #     scoped(:conditions => {:visible => true})
+      #   end
+      #
+      # You can test lambdas or methods that return ActiveRecord#scoped calls:
+      #
+      #   should_have_named_scope 'recent(5)', :limit => 5
+      #   should_have_named_scope 'recent(1)', :limit => 1
+      #
+      # Passes for
+      #   named_scope :recent, lambda {|c| {:limit => c}}
+      #
+      # Or for
+      #
+      #   def self.recent(c)
+      #     scoped(:limit => c)
+      #   end
+      #
+      def should_have_named_scope(scope_call, find_options = nil)
+        klass = model_class
+        matcher = have_named_scope(scope_call).finding(find_options)
+        should matcher.description do
+          assert_accepts matcher.in_context(self), klass.new
         end
       end
     end