ratnikov-shoulda 2.0.6.3 → 2.9.0

data/lib/shoulda/active_record/macros.rb

@@ -1,32 +1,15 @@
 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]
-        end
-      end
-    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_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_protect_attributes :password
+    #     should_not_allow_mass_assignment_of :password
     #
     #     should_have_one :profile
     #     should_have_many :dogs
@@ -37,7 +20,8 @@ module Shoulda # :nodoc:
     # For all of these helpers, the last parameter may be a hash of options.
     #
     module Macros
-      include MacroHelpers
+      include Helpers
+      include Matchers
 
       # <b>DEPRECATED:</b> Use <tt>fixtures :all</tt> instead
       #
@@ -58,24 +42,26 @@ module Shoulda # :nodoc:
       #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.blank')</tt>
       #
       # Example:
-      #   should_require_attributes :name, :phone_number
+      #   should_validate_presence_of :name, :phone_number
       #
-      def should_require_attributes(*attributes)
+      def should_validate_presence_of(*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
-            reflection = klass.reflect_on_association(attribute)
-            if reflection && [:has_many, :has_and_belongs_to_many].include?(reflection.macro)
-              assert_bad_value(klass, attribute, [], message)
-            else
-              assert_bad_value(klass, attribute, nil, message)
-            end
+          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
 
       # Ensures that the model cannot be saved if one of the attributes listed is not unique.
       # Requires an existing record
@@ -89,75 +75,75 @@ module Shoulda # :nodoc:
       #   exact match. Ignored by non-text attributes. Default = <tt>true</tt>
       #
       # 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]
-      #   should_require_unique_attributes :email, :case_sensitive => false
+      #   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
       #
-      def should_require_unique_attributes(*attributes)
+      def should_validate_uniqueness_of(*attributes)
         message, scope, case_sensitive = get_options!(attributes, :message, :scoped_to, :case_sensitive)
         scope = [*scope].compact
-        message ||= default_error_message(:taken)
         case_sensitive = true if case_sensitive.nil?
 
         klass = model_class
+
         attributes.each do |attribute|
-          attribute = attribute.to_sym
-          should "require#{' case insensitive' unless case_sensitive} 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)
-            existing_value.swapcase! if existing_value.respond_to?(:swapcase!) unless case_sensitive
-
-            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
+          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
+
+      # 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 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
+
+        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 on mass update.
       #
-      #   should_protect_attributes :password, :admin_flag
+      #   should_not_allow_mass_assignment_of :password, :admin_flag
       #
-      def should_protect_attributes(*attributes)
+      def should_not_allow_mass_assignment_of(*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")
+          matcher = allow_mass_assignment_of(attribute)
+          should "not #{matcher.description}" do
+            assert_rejects matcher, klass.new
           end
         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
+
       # Ensures that the attribute cannot be changed once the record has been created.
       #
       #   should_have_readonly_attributes :password, :admin_flag
@@ -167,14 +153,9 @@ module Shoulda # :nodoc:
         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}.")
+          matcher = have_readonly_attribute(attribute)
+          should matcher.description do
+            assert_accepts matcher, klass.new
           end
         end
       end
@@ -194,11 +175,11 @@ module Shoulda # :nodoc:
       #
       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)
+        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
@@ -215,9 +196,11 @@ module Shoulda # :nodoc:
       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)
+        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
@@ -238,39 +221,19 @@ module Shoulda # :nodoc:
       #   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)
-
+        short_message, long_message = get_options!([opts], 
+                                                   :short_message,
+                                                   :long_message)
         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
+        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 "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
-
-        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
+        should matcher.description do
+          assert_accepts matcher, get_instance_of(klass)
         end
       end
 
@@ -289,19 +252,14 @@ module Shoulda # :nodoc:
       #
       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)
+        matcher = ensure_length_of(attribute).
+          is_at_least(min_length).
+          with_short_message(short_message)
+
+        should matcher.description do
+          assert_accepts matcher, get_instance_of(klass)
         end
       end
 
@@ -320,23 +278,13 @@ module Shoulda # :nodoc:
       #
       def should_ensure_length_is(attribute, length, opts = {})
         message = get_options!([opts], :message)
-        message ||= default_error_message(:wrong_length, :count => length)
+        klass   = model_class
+        matcher = ensure_length_of(attribute).
+          is_equal_to(length).
+          with_message(message)
 
-        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)
-        end
-
-        should "allow #{attribute} to be #{length} chars long" do
-          valid_value = "x" * (length)
-          assert_good_value(klass, attribute, valid_value, message)
+        should matcher.description do
+          assert_accepts matcher, get_instance_of(klass)
         end
       end
 
@@ -356,32 +304,15 @@ module Shoulda # :nodoc:
       #   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)
+        message = get_options!([opts], :message)
+        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
-
-        should "allow #{attribute} to be #{min}" do
-          v = min
-          assert_good_value(klass, attribute, v, low_message)
-        end
-
-        should "not allow #{attribute} to be more than #{max}" do
-          v = max + 1
-          assert_bad_value(klass, attribute, v, high_message)
-        end
-
-        should "allow #{attribute} to be #{max}" do
-          v = max
-          assert_good_value(klass, attribute, v, high_message)
+        matcher = ensure_inclusion_of(attribute).
+          in_range(range).
+          with_message(message)
+        should matcher.description do
+          assert_accepts matcher, get_instance_of(klass)
         end
       end
 
@@ -396,20 +327,27 @@ module Shoulda # :nodoc:
       #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.not_a_number')</tt>
       #
       # Example:
-      #   should_only_allow_numeric_values_for :age
+      #   should_validate_numericality_of :age
       #
-      def should_only_allow_numeric_values_for(*attributes)
+      def should_validate_numericality_of(*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)
+          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
+
       # Ensures that the has_many relationship exists.  Will also test that the
       # associated table has the required columns.  Works with polymorphic
       # associations.
@@ -427,42 +365,9 @@ module Shoulda # :nodoc:
         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
+          matcher = have_many(association).through(through).dependent(dependent)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
       end
@@ -481,33 +386,9 @@ module Shoulda # :nodoc:
         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
+          matcher = have_one(association).dependent(dependent)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
       end
@@ -522,12 +403,9 @@ module Shoulda # :nodoc:
         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"
+          matcher = have_and_belong_to_many(association)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
       end
@@ -540,22 +418,9 @@ module Shoulda # :nodoc:
         dependent = get_options!(associations, :dependent)
         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
-
-            if dependent
-              assert_equal dependent.to_s,
-                           reflection.options[:dependent].to_s,
-                           "#{association} should have #{dependent} dependency"
-            end
+          matcher = belong_to(association).dependent(dependent)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
       end
@@ -589,41 +454,36 @@ module Shoulda # :nodoc:
       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 = get_options!(columns, :type)
+        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|
-          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
-        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}"
+          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
@@ -643,19 +503,12 @@ module Shoulda # :nodoc:
       #
       def should_have_indices(*columns)
         unique = get_options!(columns, :unique)
-        table = model_class.table_name
-        indices = ::ActiveRecord::Base.connection.indexes(table)
-        index_types = { true => "unique", false => "non-unique" }
-        index_type = index_types[unique] || "an"
-
+        klass  = model_class
+        
         columns.each do |column|
-          should "have #{index_type} index on #{table} for #{column.inspect}" do
-            columns = [column].flatten.map(&:to_s)
-            index = indices.detect {|ind| ind.columns == columns }
-            assert index, "#{table} does not have an index for #{column.inspect}"
-            if [true, false].include?(unique)
-              assert_equal unique, index.unique, "Expected #{index_type} index but was #{index_types[index.unique]}."
-            end
+          matcher = have_index(column).unique(unique)
+          should matcher.description do
+            assert_accepts(matcher, klass.new)
           end
         end
       end
@@ -673,20 +526,27 @@ module Shoulda # :nodoc:
       #   Regexp or string.  Default = <tt>I18n.translate('activerecord.errors.messages.accepted')</tt>
       #
       # Example:
-      #   should_require_acceptance_of :eula
+      #   should_validate_acceptance_of :eula
       #
-      def should_require_acceptance_of(*attributes)
+      def should_validate_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)
+          matcher = validate_acceptance_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_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
@@ -722,25 +582,11 @@ module Shoulda # :nodoc:
       #     scoped(:limit => c)
       #   end
       #
-      def should_have_named_scope(scope_call, *args)
+      def should_have_named_scope(scope_call, find_options = nil)
         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
+        matcher = have_named_scope(scope_call).finding(find_options)
+        should matcher.description do
+          assert_accepts matcher.in_context(self), klass.new
         end
       end
     end