shoulda 2.10.1 → 2.10.2

data/CONTRIBUTION_GUIDELINES.rdoc

@@ -1,12 +1,10 @@
-We're using GitHub[http://github.com/thoughtbot/shoulda/tree/master] and Lighthouse[http://thoughtbot.lighthouseapp.com/projects/5807], and we've been getting any combination of github pull requests, Lighthouse tickets, patches, emails, etc.  We need to normalize this workflow to make sure we don't miss any fixes. 
+We're using GitHub[http://github.com/thoughtbot/shoulda/tree/master], and we've been getting any combination of github pull requests, tickets, patches, emails, etc.  We need to normalize this workflow to make sure we don't miss any fixes. 
 
 * Make sure you're accessing the source from the {official repository}[http://github.com/thoughtbot/shoulda/tree/master].
-* We prefer git branches over patches, but we can take either. 
+* We prefer git branches over patches, but we can take either.
 * If you're using git, please make a branch for each separate contribution.  We can cherry pick your commits, but pulling from a branch is easier. 
 * If you're submitting patches, please cut each fix or feature into a separate patch.
-* There should be a Lighthouse[http://thoughtbot.lighthouseapp.com/projects/5807] ticket for any submission.  If you've found a bug and want to fix it, open a new ticket at the same time. 
-* We've got github/lighthouse integration going, so you can update tickets when you commit.  {This blog post}[http://hoth.entp.com/2008/4/11/github-and-lighthouse-sitting-in-a-tree] explains the commit options pretty well.
-* Please <b>don't send pull requests</b>  Just update the lighthouse ticket with the url for your fix (or attach the patch) when it's ready.  The github pull requests pretty much get dropped on the floor until someone with commit rights notices them in the mailbox. 
+* There should be an issue[http://github.com/thoughtbot/shoulda/issues] for any submission.  If you've found a bug and want to fix it, open a new ticket at the same time. 
+* Please <b>don't send pull requests</b>  Just update the issue with the url for your fix (or attach the patch) when it's ready.  The github pull requests pretty much get dropped on the floor until someone with commit rights notices them in the mailbox. 
 * Contributions without tests won't be accepted.  The file <tt>/test/README</tt> explains the testing system pretty thoroughly. 
 
-

data/README.rdoc

@@ -75,22 +75,24 @@ Makes TDD so much easier.
 === Controller Tests (Shoulda::Controller::Macros)
 
 Macros to test the most common controller patterns...
+  
+  class PostsControllerTest < ActionController::TestCase
+    context "on GET to :show for first record" do
+      setup do
+        get :show, :id => 1
+      end
 
-  context "on GET to :show for first record" do
-    setup do
-      get :show, :id => 1
-    end
-
-    should_assign_to :user
-    should_respond_with :success
-    should_render_template :show
-    should_not_set_the_flash
+      should_assign_to :user
+      should_respond_with :success
+      should_render_template :show
+      should_not_set_the_flash
 
-    should "do something else really cool" do
-      assert_equal 1, assigns(:user).id
+      should "do something else really cool" do
+        assert_equal 1, assigns(:user).id
+      end
     end
   end
-
+  
 === Helpful Assertions (Shoulda::Assertions)
 
 More to come here, but have fun with what's there.

data/lib/shoulda.rb

@@ -1,5 +1,5 @@
 module Shoulda
-  VERSION = "2.10.1"
+  VERSION = "2.10.2"
 end
 
 if defined? Spec

data/lib/shoulda/action_controller.rb

@@ -1,5 +1,4 @@
 require 'shoulda'
-require 'shoulda/action_controller/helpers'
 require 'shoulda/action_controller/matchers'
 require 'shoulda/action_controller/macros'
 
@@ -7,7 +6,6 @@ module Test # :nodoc: all
   module Unit
     class TestCase
       include Shoulda::ActionController::Matchers
-      include Shoulda::ActionController::Helpers
       extend Shoulda::ActionController::Macros
     end
   end

data/lib/shoulda/action_controller/macros.rb

@@ -24,31 +24,35 @@ module Shoulda # :nodoc:
     module Macros
       include Matchers
 
-      # Macro that creates a test asserting that the flash contains the given value.
-      # val can be a String, a Regex, or nil (indicating that the flash should not be set)
+      # Macro that creates a test asserting that the flash contains the given
+      # value. Expects a +String+ or +Regexp+.
+      #
+      # If the argument is +nil+, it will assert that the flash is not set.
+      # This behavior is deprecated.
       #
       # Example:
       #
       #   should_set_the_flash_to "Thank you for placing this order."
       #   should_set_the_flash_to /created/i
-      #   should_set_the_flash_to nil
       def should_set_the_flash_to(val)
-        matcher = set_the_flash.to(val)
         if val
+          matcher = set_the_flash.to(val)
           should matcher.description do
             assert_accepts matcher, @controller
           end
         else
-          should "not #{matcher.description}" do
-            assert_rejects matcher, @controller
-          end
+          warn "[DEPRECATION] should_set_the_flash_to nil is deprecated. " <<
+               "Use should_not_set_the_flash instead."
+          should_not_set_the_flash
         end
       end
 
-      # Macro that creates a test asserting that the flash is empty.  Same as
-      # @should_set_the_flash_to nil@
+      # Macro that creates a test asserting that the flash is empty.
       def should_not_set_the_flash
-        should_set_the_flash_to nil
+        matcher = set_the_flash
+        should "not #{matcher.description}" do
+          assert_rejects matcher, @controller
+        end
       end
 
       # Macro that creates a test asserting that filter_parameter_logging
@@ -71,8 +75,9 @@ module Shoulda # :nodoc:
       #
       # Options:
       # * <tt>:class</tt> - The expected class of the instance variable being checked.
-      # * <tt>:equals</tt> - A string which is evaluated and compared for equality with
-      # the instance variable being checked.
+      #
+      # If a block is passed, the assigned variable is expected to be equal to
+      # the return value of that block.
       #
       # Example:
       #
@@ -80,25 +85,11 @@ module Shoulda # :nodoc:
       #   should_assign_to :user, :class => User
       #   should_assign_to(:user) { @user }
       def should_assign_to(*names, &block)
-        opts = names.extract_options!
-        if opts[:equals]
-          warn "[DEPRECATION] should_assign_to :var, :equals => 'val' " <<
-               "is deprecated. Use should_assign_to(:var) { 'val' } instead."
-        end
+        klass = get_options!(names, :class)
         names.each do |name|
-          matcher = assign_to(name).with_kind_of(opts[:class])
-          test_name = matcher.description
-          test_name << " which is equal to #{opts[:equals]}" if opts[:equals]
-          should test_name do
-            if opts[:equals]
-              instantiate_variables_from_assigns do
-                expected_value = eval(opts[:equals],
-                                      self.send(:binding),
-                                      __FILE__,
-                                      __LINE__)
-                matcher = matcher.with(expected_value)
-              end
-            elsif block
+          matcher = assign_to(name).with_kind_of(klass)
+          should matcher.description do
+            if block
               expected_value = instance_eval(&block)
               matcher = matcher.with(expected_value)
             end
@@ -141,49 +132,29 @@ module Shoulda # :nodoc:
       #   should_respond_with_content_type :rss
       #   should_respond_with_content_type /rss/
       def should_respond_with_content_type(content_type)
-        should "respond with content type of #{content_type}" do
-          matcher = respond_with_content_type(content_type)
+        matcher = respond_with_content_type(content_type)
+        should matcher.description do
           assert_accepts matcher, @controller
         end
       end
 
-      # Macro that creates a test asserting that a value returned from the session is correct.
-      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
-      # set by the controller are available to the evaled string.
+      # Macro that creates a test asserting that a value returned from the
+      # session is correct. Expects the session key as a parameter, and a block
+      # that returns the expected value.
+      #
       # Example:
       #
-      #   should_set_session(:user_id) { '@user.id' }
+      #   should_set_session(:user_id) { @user.id }
       #   should_set_session(:message) { "Free stuff" }
-      def should_set_session(key, expected = nil, &block)
+      def should_set_session(key, &block)
         matcher = set_session(key)
-        if expected
-          warn "[DEPRECATION] should_set_session :key, 'val' is deprecated. " <<
-               "Use should_set_session(:key) { 'val' } instead."
-        end
         should matcher.description do
-          if expected
-            instantiate_variables_from_assigns do
-              expected_value = eval(expected, 
-                                    self.send(:binding),
-                                    __FILE__,
-                                    __LINE__)
-              matcher = matcher.to(expected_value)
-            end
-          else
-            expected_value = instance_eval(&block)
-            matcher = matcher.to(expected_value)
-          end
+          expected_value = instance_eval(&block)
+          matcher = matcher.to(expected_value)
           assert_accepts matcher, @controller
         end
       end
 
-      # Deprecated. See should_set_session
-      def should_return_from_session(key, expected)
-        warn "[DEPRECATION] should_require_attributes is deprecated. " <<
-             "Use should_set_session instead."
-        should_set_session(key, expected)
-      end
-
       # Macro that creates a test asserting that the controller rendered the given template.
       # Example:
       #
@@ -217,26 +188,18 @@ module Shoulda # :nodoc:
         should_render_with_layout nil
       end
 
-      # Macro that creates a test asserting that the controller returned a redirect to the given path.
-      # The given string is evaled to produce the resulting redirect path.  All of the instance variables
-      # set by the controller are available to the evaled string.
+      # Macro that creates a test asserting that the controller returned a
+      # redirect to the given path. The passed description will be used when
+      # generating a test name. Expects a block that returns the expected path
+      # for the redirect.
+      #
       # Example:
       #
       #   should_redirect_to("the user's profile") { user_url(@user) }
       def should_redirect_to(description, &block)
-        unless block
-          warn "[DEPRECATION] should_redirect_to without a block is " <<
-               "deprecated. Use should_redirect_to('somewhere') { } instead."
-        end
         should "redirect to #{description}" do
-          if block
-            url = instance_eval(&block)
-          else
-            instantiate_variables_from_assigns do
-              url = eval(description, self.send(:binding), __FILE__, __LINE__)
-            end
-          end
-          assert_redirected_to url
+          expected_url = instance_eval(&block)
+          assert_redirected_to expected_url
         end
       end
 

data/lib/shoulda/action_controller/matchers/respond_with_content_type_matcher.rb

@@ -30,6 +30,10 @@ module Shoulda # :nodoc:
             content_type
           end
         end
+
+        def description
+          "respond with content type of #{@content_type}"
+        end
         
         def matches?(controller)
           @controller = controller

data/lib/shoulda/action_controller/matchers/set_session_matcher.rb

@@ -46,7 +46,7 @@ module Shoulda # :nodoc:
         private
 
         def assigned_value?
-          !assigned_value.blank?
+          !assigned_value.nil?
         end
 
         def cleared_value?

data/lib/shoulda/action_view/macros.rb

@@ -11,7 +11,6 @@ module Shoulda # :nodoc:
     #       get :new
     #     end
     #
-    #     should_render_a_form
     #     should_render_page_with_metadata :title => /index/
     #
     #     should "do something else really cool" do
@@ -23,12 +22,17 @@ module Shoulda # :nodoc:
     module Macros
 
       # Macro that creates a test asserting that the rendered view contains a <form> element.
+      #
+      # Deprecated.
       def should_render_a_form
+        warn "[DEPRECATION] should_render_a_form is deprecated."
         should "display a form" do
           assert_select "form", true, "The template doesn't contain a <form> element"
         end
       end
 
+      # Deprecated.
+      #
       # Macro that creates a test asserting that the rendered view contains the selected metatags.
       # Values can be string or Regexps.
       # Example:
@@ -40,6 +44,7 @@ module Shoulda # :nodoc:
       # Example:
       #   should_render_page_with_metadata :title => /index/
       def should_render_page_with_metadata(options)
+        warn "[DEPRECATION] should_render_page_with_metadata is deprecated."
         options.each do |key, value|
           should "have metatag #{key}" do
             if key.to_sym == :title

data/lib/shoulda/active_record/assertions.rb

@@ -30,8 +30,8 @@ module Shoulda # :nodoc:
       #
       #   assert_good_value(User, :email, "user@example.com")
       #
-      #   @product = Product.new(:tangible => false)
-      #   assert_good_value(Product, :price, "0")
+      #   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).
@@ -54,8 +54,8 @@ module Shoulda # :nodoc:
       #
       #   assert_bad_value(User, :email, "invalid")
       #
-      #   @product = Product.new(:tangible => true)
-      #   assert_bad_value(Product, :price, "0")
+      #   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)

data/lib/shoulda/active_record/helpers.rb

@@ -8,19 +8,6 @@ module Shoulda # :nodoc:
         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.

data/lib/shoulda/active_record/macros.rb

@@ -25,10 +25,6 @@ module Shoulda # :nodoc:
 
       # 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>
@@ -38,23 +34,15 @@ module Shoulda # :nodoc:
       #
       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))
+            assert_accepts(matcher, subject)
           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
       #
@@ -78,37 +66,27 @@ module Shoulda # :nodoc:
         scope = [*scope].compact
         case_sensitive = true if case_sensitive.nil?
 
-        klass = model_class
-
         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))
+            assert_accepts(matcher, subject)
           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
+            assert_accepts matcher, subject
           end
         end
       end
@@ -119,90 +97,67 @@ module Shoulda # :nodoc:
       #
       def should_not_allow_mass_assignment_of(*attributes)
         get_options!(attributes)
-        klass = model_class
 
         attributes.each do |attribute|
           matcher = allow_mass_assignment_of(attribute)
           should "not #{matcher.description}" do
-            assert_rejects matcher, klass.new
+            assert_rejects matcher, subject
           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
       #
       def should_have_readonly_attributes(*attributes)
         get_options!(attributes)
-        klass = model_class
 
         attributes.each do |attribute|
           matcher = have_readonly_attribute(attribute)
           should matcher.description do
-            assert_accepts matcher, klass.new
+            assert_accepts matcher, subject
           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>
+      #   Regexp or string. If omitted, the test will pass if there is ANY error in
+      #   <tt>errors.on(:attribute)</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)
+            assert_rejects matcher, subject
           end
         end
       end
 
       # 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)
+            assert_accepts matcher, subject
           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>
@@ -216,8 +171,6 @@ module Shoulda # :nodoc:
         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).
@@ -225,16 +178,12 @@ module Shoulda # :nodoc:
           with_long_message(long_message)
 
         should matcher.description do
-          assert_accepts matcher, get_instance_of(klass)
+          assert_accepts matcher, subject
         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>
@@ -244,23 +193,18 @@ module Shoulda # :nodoc:
       #
       def should_ensure_length_at_least(attribute, min_length, opts = {})
         short_message = get_options!([opts], :short_message)
-        klass = model_class
 
         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)
+          assert_accepts matcher, subject
         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>
@@ -270,22 +214,17 @@ module Shoulda # :nodoc:
       #
       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)
+          assert_accepts matcher, subject
         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>
@@ -300,23 +239,18 @@ module Shoulda # :nodoc:
                                                           :message,
                                                           :low_message,
                                                           :high_message)
-        klass = model_class
         matcher = ensure_inclusion_of(attribute).
           in_range(range).
           with_message(message).
           with_low_message(low_message).
           with_high_message(high_message)
         should matcher.description do
-          assert_accepts matcher, get_instance_of(klass)
+          assert_accepts matcher, subject
         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>
@@ -326,23 +260,15 @@ module Shoulda # :nodoc:
       #
       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)
+            assert_accepts matcher, subject
           end
         end
       end
 
-      # Deprecated. See should_validate_numericality_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.
@@ -358,11 +284,10 @@ module Shoulda # :nodoc:
       #
       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)
+            assert_accepts(matcher, subject)
           end
         end
       end
@@ -378,12 +303,11 @@ module Shoulda # :nodoc:
       #   should_have_one :god # unless hindu
       #
       def should_have_one(*associations)
-        dependent = get_options!(associations, :dependent)
-        klass = model_class
+        dependent, through = get_options!(associations, :dependent, :through)
         associations.each do |association|
-          matcher = have_one(association).dependent(dependent)
+          matcher = have_one(association).dependent(dependent).through(through)
           should matcher.description do
-            assert_accepts(matcher, klass.new)
+            assert_accepts(matcher, subject)
           end
         end
       end
@@ -395,12 +319,11 @@ module Shoulda # :nodoc:
       #
       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)
+            assert_accepts(matcher, subject)
           end
         end
       end
@@ -411,11 +334,10 @@ module Shoulda # :nodoc:
       #
       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)
+            assert_accepts(matcher, subject)
           end
         end
       end
@@ -426,7 +348,7 @@ module Shoulda # :nodoc:
       #
       def should_have_class_methods(*methods)
         get_options!(methods)
-        klass = model_class
+        klass = described_type
         methods.each do |method|
           should "respond to class method ##{method}" do
             assert_respond_to klass, method, "#{klass.name} does not have class method #{method}"
@@ -440,7 +362,7 @@ module Shoulda # :nodoc:
       #
       def should_have_instance_methods(*methods)
         get_options!(methods)
-        klass = model_class
+        klass = described_type
         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}"
@@ -449,7 +371,7 @@ 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.
+      # Also aliased to should_have_db_column for readability.
       # Takes the same options available in migrations: 
       # :type, :precision, :limit, :default, :null, and :scale
       #
@@ -465,7 +387,6 @@ module Shoulda # :nodoc:
         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).
@@ -473,7 +394,7 @@ module Shoulda # :nodoc:
                                    :default   => default,   :null     => null,
                                    :scale     => scale,     :sql_type => sql_type)
           should matcher.description do
-            assert_accepts(matcher, klass.new)
+            assert_accepts(matcher, subject)
           end
         end
       end
@@ -481,7 +402,7 @@ module Shoulda # :nodoc:
       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
+      # Also aliased to should_have_db_index for readability
       #
       # Options:
       # * <tt>:unique</tt> - whether or not the index has a unique
@@ -492,30 +413,39 @@ module Shoulda # :nodoc:
       #
       # Examples:
       #
-      #   should_have_indices :email, :name, [:commentable_type, :commentable_id]
-      #   should_have_index :age
-      #   should_have_index :ssn, :unique => true
+      #   should_have_db_indices :email, :name, [:commentable_type, :commentable_id]
+      #   should_have_db_index :age
+      #   should_have_db_index :ssn, :unique => true
       #
-      def should_have_indices(*columns)
+      def should_have_db_indices(*columns)
         unique = get_options!(columns, :unique)
-        klass  = model_class
         
         columns.each do |column|
-          matcher = have_index(column).unique(unique)
+          matcher = have_db_index(column).unique(unique)
           should matcher.description do
-            assert_accepts(matcher, klass.new)
+            assert_accepts(matcher, subject)
           end
         end
       end
 
-      alias_method :should_have_index, :should_have_indices
+      alias_method :should_have_db_index, :should_have_db_indices
+
+      # Deprecated. See should_have_db_index
+      def should_have_index(*args)
+        warn "[DEPRECATION] should_have_index is deprecated. " <<
+             "Use should_have_db_index instead."
+        should_have_db_index(*args)
+      end
+
+      # Deprecated. See should_have_db_indices
+      def should_have_indices(*args)
+        warn "[DEPRECATION] should_have_indices is deprecated. " <<
+             "Use should_have_db_indices instead."
+        should_have_db_indices(*args)
+      end
 
       # 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>
@@ -525,23 +455,17 @@ module Shoulda # :nodoc:
       #
       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)
+            assert_accepts matcher, subject
           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
-
+      # Deprecated.
+      #
       # 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
@@ -578,10 +502,9 @@ module Shoulda # :nodoc:
       #   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
+          assert_accepts matcher.in_context(self), subject
         end
       end
     end