shoulda 2.10.3 → 2.11.0

data/lib/shoulda/active_record/matchers.rb

@@ -13,7 +13,6 @@ require 'shoulda/active_record/matchers/have_db_column_matcher'
 require 'shoulda/active_record/matchers/have_db_index_matcher'
 require 'shoulda/active_record/matchers/have_readonly_attribute_matcher'
 require 'shoulda/active_record/matchers/allow_mass_assignment_of_matcher'
-require 'shoulda/active_record/matchers/have_named_scope_matcher'
 
 
 module Shoulda # :nodoc:

data/lib/shoulda/active_record/matchers/allow_mass_assignment_of_matcher.rb

@@ -24,7 +24,7 @@ module Shoulda # :nodoc:
               @failure_message = "#{@attribute} was made accessible"
             else
               if protected_attributes.empty?
-                @failure_message = "no attributes were protected"
+                @negative_failure_message = "no attributes were protected"
               else
                 @failure_message = "#{class_name} is protecting " <<
                   "#{protected_attributes.to_a.to_sentence}, " <<

data/lib/shoulda/active_record/matchers/allow_value_matcher.rb

@@ -59,9 +59,17 @@ module Shoulda # :nodoc:
 
         def errors_match?
           @instance.valid?
-          @errors = @instance.errors.on(@attribute)
+          @errors = errors_for_attribute(@instance, @attribute)
           @errors = [@errors] unless @errors.is_a?(Array)
-          @expected_message ? (errors_match_regexp? || errors_match_string?) : (@errors != [nil])
+          @expected_message ? (errors_match_regexp? || errors_match_string?) : (@errors.compact.any?)
+        end
+
+        def errors_for_attribute(instance, attribute)
+          if instance.errors.respond_to?(:[])
+            instance.errors[attribute]
+          else
+            instance.errors.on(attribute)
+          end
         end
 
         def errors_match_regexp?

data/lib/shoulda/assertions.rb

@@ -46,6 +46,10 @@ module Shoulda # :nodoc:
 
     # Asserts that the given matcher returns true when +target+ is passed to #matches?
     def assert_accepts(matcher, target, options = {})
+      if matcher.respond_to?(:in_context)
+        matcher.in_context(self)
+      end
+
       if matcher.matches?(target)
         assert_block { true }
         if options[:message]
@@ -58,6 +62,10 @@ module Shoulda # :nodoc:
 
     # Asserts that the given matcher returns false when +target+ is passed to #matches?
     def assert_rejects(matcher, target, options = {})
+      if matcher.respond_to?(:in_context)
+        matcher.in_context(self)
+      end
+
       unless matcher.matches?(target)
         assert_block { true }
         if options[:message]

data/lib/shoulda/context.rb

@@ -21,9 +21,10 @@ module Shoulda
   module ClassMethods
     # == Should statements
     #
-    # Should statements are just syntactic sugar over normal Test::Unit test methods.  A should block
-    # contains all the normal code and assertions you're used to seeing, with the added benefit that
-    # they can be wrapped inside context blocks (see below).
+    # Should statements are just syntactic sugar over normal Test::Unit test
+    # methods.  A should block contains all the normal code and assertions
+    # you're used to seeing, with the added benefit that they can be wrapped
+    # inside context blocks (see below).
     #
     # === Example:
     #
@@ -56,14 +57,43 @@ module Shoulda
     #      assert true
     #    end
     #  end
+    #
+    # Should statements can also wrap matchers, making virtually any matcher
+    # usable in a macro style. The matcher's description is used to generate a
+    # test name and failure message, and the test will pass if the matcher
+    # matches the subject.
+    #
+    # === Example:
+    #
+    #   should validate_presence_of(:first_name).with_message(/gotta be there/)
+    #
+
+    def should(name_or_matcher, options = {}, &blk)
+      if Shoulda.current_context
+        Shoulda.current_context.should(name_or_matcher, options, &blk)
+      else
+        context_name = self.name.gsub(/Test/, "")
+        context = Shoulda::Context.new(context_name, self) do
+          should(name_or_matcher, options, &blk)
+        end
+        context.build
+      end
+    end
 
-    def should(name, options = {}, &blk)
+    # Allows negative tests using matchers. The matcher's description is used
+    # to generate a test name and negative failure message, and the test will
+    # pass unless the matcher matches the subject.
+    #
+    # === Example:
+    #
+    #   should_not set_the_flash
+    def should_not(matcher)
       if Shoulda.current_context
-        block_given? ? Shoulda.current_context.should(name, options, &blk) : Shoulda.current_context.should_eventually(name)
+        Shoulda.current_context.should_not(matcher)
       else
         context_name = self.name.gsub(/Test/, "")
         context = Shoulda::Context.new(context_name, self) do
-          block_given? ? should(name, options, &blk) : should_eventually(name)
+          should_not(matcher)
         end
         context.build
       end
@@ -214,19 +244,6 @@ module Shoulda
     #     end
     #   end
     #
-    # If an instance variable exists named after the described class, that
-    # instance variable will be used as the subject. This behavior is
-    # deprecated, and will be removed in a future version of Shoulda. The
-    # recommended approach for using a different subject is to use the subject
-    # class method.
-    #
-    #   class UserTest
-    #     should "be the existing user" do
-    #       @user = User.new
-    #       assert_equal @user, subject # passes
-    #     end
-    #   end
-    #
     # The subject is used by all macros that require an instance of the class
     # being tested.
     def subject
@@ -239,17 +256,7 @@ module Shoulda
 
     def get_instance_of(object_or_klass) # :nodoc:
       if object_or_klass.is_a?(Class)
-        klass = object_or_klass
-        ivar = "@#{instance_variable_name_for(klass)}"
-        if instance = instance_variable_get(ivar)
-          warn "[WARNING] Using #{ivar} as the subject. Future versions " <<
-               "of Shoulda will require an explicit subject using the " <<
-               "subject class method. Add this after your setup to avoid " <<
-               "this warning: subject { #{ivar} }"
-          instance
-        else
-          klass.new
-        end
+        object_or_klass.new
       else
         object_or_klass
       end
@@ -311,14 +318,27 @@ module Shoulda
       self.teardown_blocks << blk
     end
 
-    def should(name, options = {}, &blk)
-      if block_given?
+    def should(name_or_matcher, options = {}, &blk)
+      if name_or_matcher.respond_to?(:description) && name_or_matcher.respond_to?(:matches?)
+        name = name_or_matcher.description
+        blk = lambda { assert_accepts name_or_matcher, subject }
+      else
+        name = name_or_matcher
+      end
+
+      if blk
         self.shoulds << { :name => name, :before => options[:before], :block => blk }
       else
        self.should_eventuallys << { :name => name }
      end
     end
 
+    def should_not(matcher)
+      name = matcher.description
+      blk = lambda { assert_rejects matcher, subject }
+      self.shoulds << { :name => "not #{name}", :block => blk }
+    end
+
     def should_eventually(name, &blk)
       self.should_eventuallys << { :name => name, :block => blk }
     end

data/lib/shoulda/macros.rb

@@ -2,6 +2,8 @@ require 'shoulda/private_helpers'
 
 module Shoulda # :nodoc:
   module Macros
+    # Deprecated.
+    #
     # Macro that creates a test asserting a change between the return value
     # of a block that is run before and after the current setup block
     # is run. This is similar to Active Support's <tt>assert_difference</tt>
@@ -35,23 +37,17 @@ module Shoulda # :nodoc:
     #   # Assert the value changed to "new:"
     #   should_change("the post title", :to => "new") { @post.title }
     def should_change(description, options = {}, &block)
+      ::ActiveSupport::Deprecation.warn
       by, from, to = get_options!([options], :by, :from, :to)
       stmt = "change #{description}"
       stmt << " from #{from.inspect}" if from
       stmt << " to #{to.inspect}" if to
       stmt << " by #{by.inspect}" if by
 
-      if block_given?
-        code = block
-      else
-        warn "[DEPRECATION] should_change(expression, options) is deprecated. " <<
-             "Use should_change(description, options) { code } instead."
-        code = lambda { eval(description) }
-      end
-      before = lambda { @_before_should_change = code.bind(self).call }
+      before = lambda { @_before_should_change = block.bind(self).call }
       should stmt, :before => before do
         old_value = @_before_should_change
-        new_value = code.bind(self).call
+        new_value = block.bind(self).call
         assert_operator from, :===, old_value, "#{description} did not originally match #{from.inspect}" if from
         assert_not_equal old_value, new_value, "#{description} did not change" unless by == 0
         assert_operator to, :===, new_value, "#{description} was not changed to match #{to.inspect}" if to
@@ -59,6 +55,8 @@ module Shoulda # :nodoc:
       end
     end
 
+    # Deprecated.
+    #
     # Macro that creates a test asserting no change between the return value
     # of a block that is run before and after the current setup block
     # is run. This is the logical opposite of should_change.
@@ -72,20 +70,16 @@ module Shoulda # :nodoc:
     #     should_not_change("the number of posts") { Post.count }
     #   end
     def should_not_change(description, &block)
-      if block_given?
-        code = block
-      else
-        warn "[DEPRECATION] should_not_change(expression) is deprecated. " <<
-             "Use should_not_change(description) { code } instead."
-        code = lambda { eval(description) }
-      end
-      before = lambda { @_before_should_not_change = code.bind(self).call }
+      ::ActiveSupport::Deprecation.warn
+      before = lambda { @_before_should_not_change = block.bind(self).call }
       should "not change #{description}", :before => before do
-        new_value = code.bind(self).call
+        new_value = block.bind(self).call
         assert_equal @_before_should_not_change, new_value, "#{description} changed"
       end
     end
 
+    # Deprecated.
+    #
     # Macro that creates a test asserting that a record of the given class was
     # created.
     #
@@ -96,9 +90,12 @@ module Shoulda # :nodoc:
     #     should_create :post
     #   end
     def should_create(class_name)
+      ::ActiveSupport::Deprecation.warn
       should_change_record_count_of(class_name, 1, 'create')
     end
 
+    # Deprecated.
+    #
     # Macro that creates a test asserting that a record of the given class was
     # destroyed.
     #
@@ -109,6 +106,7 @@ module Shoulda # :nodoc:
     #     should_destroy :post
     #   end
     def should_destroy(class_name)
+      ::ActiveSupport::Deprecation.warn
       should_change_record_count_of(class_name, -1, 'destroy')
     end
 

data/lib/shoulda/rails.rb

@@ -4,10 +4,5 @@ require 'shoulda'
 
 require 'shoulda/active_record'     if defined? ActiveRecord::Base
 require 'shoulda/action_controller' if defined? ActionController::Base
-require 'shoulda/action_view'       if defined? ActionView::Base
 require 'shoulda/action_mailer'     if defined? ActionMailer::Base
 
-if defined?(RAILS_ROOT)
-  # load in the 3rd party macros from vendorized plugins and gems
-  Shoulda.autoload_macros RAILS_ROOT, File.join("vendor", "{plugins,gems}", "*")
-end

data/lib/shoulda/rspec.rb

@@ -1,5 +1,6 @@
 require 'shoulda/active_record/matchers'
 require 'shoulda/action_controller/matchers'
+require 'shoulda/action_mailer/matchers'
 require 'active_support/test_case'
 
 # :enddoc:
@@ -7,5 +8,6 @@ module ActiveSupport
   class TestCase
     include Shoulda::ActiveRecord::Matchers
     include Shoulda::ActionController::Matchers
+    include Shoulda::ActionMailer::Matchers
   end
 end

data/lib/shoulda/version.rb

@@ -0,0 +1,4 @@
+module Shoulda
+  VERSION = "2.11.0"
+end
+

data/rails/init.rb

@@ -3,5 +3,6 @@ if RAILS_ENV == 'test'
     require 'shoulda/rspec'
   else
     require 'shoulda/rails' 
+    Shoulda.autoload_macros RAILS_ROOT, File.join("vendor", "{plugins,gems}", "*")
   end
 end

data/test/fail_macros.rb

@@ -27,13 +27,29 @@ module Shoulda
 
   class Context
     # alias_method_chain hack to allow the should_fail macro to work
-    def should_with_failure_scenario(name, options = {}, &block)
+    def should_with_failure_scenario(*args, &block)
+      should_without_failure_scenario(*args, &block)
+      wrap_last_should_with_failure_expectation
+    end
+    alias_method_chain :should, :failure_scenario
+
+    # alias_method_chain hack to allow the should_fail macro to work
+    def should_not_with_failure_scenario(*args, &block)
+      should_not_without_failure_scenario(*args, &block)
+      wrap_last_should_with_failure_expectation
+    end
+    alias_method_chain :should_not, :failure_scenario
+
+    def wrap_last_should_with_failure_expectation
       if Shoulda.expected_exceptions
         expected_exceptions = Shoulda.expected_exceptions
-        failure_block = lambda { assert_raise(*expected_exceptions, &block.bind(self)) }
+        should = self.shoulds.last
+        assertion_block = should[:block]
+        failure_block = lambda do
+          assert_raise(*expected_exceptions, &assertion_block.bind(self))
+        end
+        should[:block] = failure_block
       end
-      should_without_failure_scenario(name, options, &(failure_block || block))
     end
-    alias_method_chain :should, :failure_scenario
   end
 end

data/test/functional/posts_controller_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require 'test_helper'
 require 'posts_controller'
 
 # Re-raise errors caught by the controller.
@@ -54,8 +54,6 @@ class PostsControllerTest < ActionController::TestCase
       end
       should_assign_to :posts
       should_not_assign_to :foo, :bar
-      should_render_page_with_metadata :description => /Posts/, :title => /index/
-      should_render_page_with_metadata :keywords => "posts"
     end
 
     context "viewing posts for a user with rss format" do
@@ -65,8 +63,12 @@ class PostsControllerTest < ActionController::TestCase
       end
       should_respond_with :success
       should_respond_with_content_type 'application/rss+xml'
-      should_respond_with_content_type :rss
-      should_respond_with_content_type /rss/
+      context "with a symbol" do
+        should_respond_with_content_type :rss
+      end
+      context "with a regexp" do
+        should_respond_with_content_type /rss/
+      end
       should_set_session(:mischief) { nil }
       should_set_session(:special) { '$2 off your next purchase' }
       should_set_session(:special_user_id) { @user.id }
@@ -85,7 +87,6 @@ class PostsControllerTest < ActionController::TestCase
         should_render_with_layout :wide
       end
       should_assign_to :false_flag
-      should_set_the_flash_to nil
       should_fail do
         should_set_the_flash_to /.*/
       end
@@ -95,7 +96,6 @@ class PostsControllerTest < ActionController::TestCase
       setup { get :new, :user_id => users(:first) }
       should_render_without_layout
       should_not_set_the_flash
-      should_render_a_form
     end
 
     context "on POST to #create" do

data/test/functional/users_controller_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/../test_helper'
+require 'test_helper'
 require 'users_controller'
 
 # Re-raise errors caught by the controller.

data/test/matchers/action_mailer/have_sent_email_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class HaveSentEmailTest < ActiveSupport::TestCase # :nodoc:
+  context "an email" do
+    setup do
+      define_mailer :mailer, [:the_email] do
+        def the_email
+          if defined?(AbstractController::Rendering)
+            mail :from    => "do-not-reply@example.com",
+                 :to      => "myself@me.com",
+                 :subject => "This is spam",
+                 :body    => "Every email is spam."
+          else
+            from       "do-not-reply@example.com"
+            recipients "myself@me.com"
+            subject    "This is spam"
+            body       "Every email is spam."
+          end
+        end
+      end
+      if defined?(AbstractController::Rendering)
+        ::ActionMailer::Base.deliveries << Mailer.the_email
+      else
+        ::ActionMailer::Base.deliveries << Mailer.create_the_email
+      end
+    end
+
+    should "accept based on the subject" do
+      assert_accepts have_sent_email.with_subject(/is spam$/), nil
+      assert_rejects have_sent_email.with_subject(/totally safe/), nil
+    end
+
+    should "accept based on the sender" do
+      assert_accepts have_sent_email.from('do-not-reply@example.com'), nil
+      assert_rejects have_sent_email.from('you@example.com'), nil
+    end
+
+    should "accept based on the body" do
+      assert_accepts have_sent_email.with_body(/is spam\./), nil
+      assert_rejects have_sent_email.with_body(/totally safe/), nil
+    end
+
+    should "accept baed on the recipienct" do
+      assert_accepts have_sent_email.to('myself@me.com'), nil
+      assert_rejects have_sent_email.to('you@example.com'), nil
+    end
+
+    should "chain" do
+      assert_accepts have_sent_email.with_subject(/spam/).from('do-not-reply@example.com').with_body(/spam/).to('myself@me.com'), nil
+      assert_rejects have_sent_email.with_subject(/ham/).from('you@example.com').with_body(/ham/).to('them@example.com'), nil
+    end
+  end
+end