thoughtbot-shoulda 2.10.2 → 2.11.1

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/active_record/matchers/association_matcher.rb

@@ -20,9 +20,9 @@ module Shoulda # :nodoc:
       #   dependent option.
       #
       # Example:
-      #   it { should_have_many(:friends) }
-      #   it { should_have_many(:enemies).through(:friends) }
-      #   it { should_have_many(:enemies).dependent(:destroy) }
+      #   it { should have_many(:friends) }
+      #   it { should have_many(:enemies).through(:friends) }
+      #   it { should have_many(:enemies).dependent(:destroy) }
       #
       def have_many(name)
         AssociationMatcher.new(:has_many, name)
@@ -70,10 +70,10 @@ module Shoulda # :nodoc:
 
         def matches?(subject)
           @subject = subject
-          association_exists? && 
-            macro_correct? && 
-            foreign_key_exists? && 
-            through_association_valid? && 
+          association_exists? &&
+            macro_correct? &&
+            foreign_key_exists? &&
+            through_association_valid? &&
             dependent_correct? &&
             join_table_exists?
         end
@@ -160,7 +160,7 @@ module Shoulda # :nodoc:
         end
 
         def join_table_exists?
-          if @macro != :has_and_belongs_to_many || 
+          if @macro != :has_and_belongs_to_many ||
               ::ActiveRecord::Base.connection.tables.include?(join_table.to_s)
             true
           else

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

@@ -57,7 +57,7 @@ module Shoulda # :nodoc:
           @low_message  ||= :inclusion
           @high_message ||= :inclusion
 
-          disallows_lower_value && 
+          disallows_lower_value &&
             allows_minimum_value &&
             disallows_higher_value &&
             allows_maximum_value

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

@@ -84,7 +84,7 @@ module Shoulda # :nodoc:
         def matches?(subject)
           super(subject)
           translate_messages!
-          disallows_lower_length && 
+          disallows_lower_length &&
             allows_minimum_length &&
             ((@minimum == @maximum) ||
               (disallows_higher_length &&
@@ -106,7 +106,7 @@ module Shoulda # :nodoc:
         end
 
         def disallows_lower_length
-          @minimum == 0 || 
+          @minimum == 0 ||
             @minimum.nil? ||
             disallows_length_of(@minimum - 1, @short_message)
         end

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

@@ -24,12 +24,12 @@ module Shoulda # :nodoc:
           @macro  = macro
           @column = column
         end
-        
+
         def of_type(column_type)
           @column_type = column_type
           self
         end
-        
+
         def with_options(opts = {})
           @precision = opts[:precision]
           @limit     = opts[:limit]
@@ -41,8 +41,8 @@ module Shoulda # :nodoc:
 
         def matches?(subject)
           @subject = subject
-          column_exists? && 
-            correct_column_type? && 
+          column_exists? &&
+            correct_column_type? &&
             correct_precision? &&
             correct_limit? &&
             correct_default? &&
@@ -80,7 +80,7 @@ module Shoulda # :nodoc:
             false
           end
         end
-        
+
         def correct_column_type?
           return true if @column_type.nil?
           if matched_column.type.to_s == @column_type.to_s
@@ -91,7 +91,7 @@ module Shoulda # :nodoc:
             false
           end
         end
-        
+
         def correct_precision?
           return true if @precision.nil?
           if matched_column.precision.to_s == @precision.to_s
@@ -103,7 +103,7 @@ module Shoulda # :nodoc:
             false
           end
         end
-        
+
         def correct_limit?
           return true if @limit.nil?
           if matched_column.limit.to_s == @limit.to_s
@@ -115,7 +115,7 @@ module Shoulda # :nodoc:
             false
           end
         end
-        
+
         def correct_default?
           return true if @default.nil?
           if matched_column.default.to_s == @default.to_s
@@ -127,7 +127,7 @@ module Shoulda # :nodoc:
             false
           end
         end
-        
+
         def correct_null?
           return true if @null.nil?
           if matched_column.null.to_s == @null.to_s
@@ -139,7 +139,7 @@ module Shoulda # :nodoc:
             false
           end
         end
-                
+
         def correct_scale?
           return true if @scale.nil?
           if matched_column.scale.to_s == @scale.to_s
@@ -150,7 +150,7 @@ module Shoulda # :nodoc:
             false
           end
         end
-        
+
         def matched_column
           model_class.columns.detect { |each| each.name == @column.to_s }
         end

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

@@ -27,7 +27,7 @@ module Shoulda # :nodoc:
           @macro = macro
           @columns = normalize_columns_to_array(columns)
         end
-        
+
         def unique(unique)
           @unique = unique
           self
@@ -51,11 +51,11 @@ module Shoulda # :nodoc:
         end
 
         protected
-        
+
         def index_exists?
           ! matched_index.nil?
         end
-        
+
         def correct_unique?
           return true if @unique.nil?
           if matched_index.unique == @unique
@@ -66,7 +66,7 @@ module Shoulda # :nodoc:
             false
           end
         end
-        
+
         def matched_index
           indexes.detect { |each| each.columns == @columns }
         end
@@ -74,11 +74,11 @@ module Shoulda # :nodoc:
         def model_class
           @subject.class
         end
-        
+
         def table_name
           model_class.table_name
         end
-        
+
         def indexes
           ::ActiveRecord::Base.connection.indexes(table_name)
         end
@@ -86,7 +86,7 @@ module Shoulda # :nodoc:
         def expectation
           expected = "#{model_class.name} to #{description}"
         end
-        
+
         def index_type
           case @unique
           when nil
@@ -97,7 +97,7 @@ module Shoulda # :nodoc:
             'unique'
           end
         end
-        
+
         def normalize_columns_to_array(columns)
           if columns.class == Array
             columns.collect { |each| each.to_s }

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

@@ -25,7 +25,7 @@ module Shoulda # :nodoc:
       end
 
       class ValidateFormatOfMatcher < ValidationMatcher # :nodoc:
-        
+
         def initialize(attribute)
           super
         end
@@ -34,13 +34,12 @@ module Shoulda # :nodoc:
           @expected_message = message if message
           self
         end
-        
+
         def with(value)
           raise "You may not call both with and not_with" if @value_to_fail
           @value_to_pass = value
           self
         end
-        
 
         def not_with(value)
           raise "You may not call both with and not_with" if @value_to_pass
@@ -48,7 +47,6 @@ module Shoulda # :nodoc:
           self
         end
 
-
         def matches?(subject)
           super(subject)
           @expected_message ||= :blank

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

@@ -67,8 +67,8 @@ module Shoulda # :nodoc:
         def matches?(subject)
           @subject = subject.class.new
           @expected_message ||= :taken
-          find_existing && 
-            set_scoped_attributes && 
+          find_existing &&
+            set_scoped_attributes &&
             validate_attribute &&
             validate_after_scope_change
         end
@@ -121,7 +121,7 @@ module Shoulda # :nodoc:
               @subject.send("#{scope}=", next_value)
 
               if allows_value_of(existing_value, @expected_message)
-                @negative_failure_message << 
+                @negative_failure_message <<
                   " (with different value of #{scope})"
                 true
               else

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

@@ -18,7 +18,6 @@ module Shoulda # :nodoc:
           @subject = subject
           false
         end
-        
 
         private
 

data/lib/shoulda/assertions.rb

@@ -26,7 +26,7 @@ module Shoulda # :nodoc:
       case x
       when Regexp
         assert(collection.detect { |e| e =~ x }, msg)
-      else         
+      else
         assert(collection.include?(x), msg)
       end
     end
@@ -39,13 +39,17 @@ module Shoulda # :nodoc:
       case x
       when Regexp
         assert(!collection.detect { |e| e =~ x }, msg)
-      else         
+      else
         assert(!collection.include?(x), msg)
       end
     end
 
     # 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/autoload_macros.rb

@@ -1,40 +1,40 @@
 module Shoulda # :nodoc:
-  # Call autoload_macros when you want to load test macros automatically in a non-Rails 
+  # Call autoload_macros when you want to load test macros automatically in a non-Rails
   # project (it's done automatically for Rails projects).
   # You don't need to specify ROOT/test/shoulda_macros explicitly. Your custom macros
   # are loaded automatically when you call autoload_macros.
   #
   # The first argument is the path to you application's root directory.
-  # All following arguments are directories relative to your root, which contain 
-  # shoulda_macros subdirectories. These directories support the same kinds of globs as the 
+  # All following arguments are directories relative to your root, which contain
+  # shoulda_macros subdirectories. These directories support the same kinds of globs as the
   # Dir class.
-  # 
+  #
   # Basic usage (from a test_helper):
   # Shoulda.autoload_macros(File.dirname(__FILE__) + '/..')
-  #	will load everything in 
-  #	- your_app/test/shoulda_macros
+  # will load everything in
+  # - your_app/test/shoulda_macros
   #
-  #	To load vendored macros as well:
+  # To load vendored macros as well:
   # Shoulda.autoload_macros(APP_ROOT, 'vendor/*')
-  #	will load everything in 
-  #	- APP_ROOT/vendor/*/shoulda_macros
-  #	- APP_ROOT/test/shoulda_macros
+  # will load everything in
+  # - APP_ROOT/vendor/*/shoulda_macros
+  # - APP_ROOT/test/shoulda_macros
   #
-  #	To load macros in an app with a vendor directory laid out like Rails':
+  # To load macros in an app with a vendor directory laid out like Rails':
   # Shoulda.autoload_macros(APP_ROOT, 'vendor/{plugins,gems}/*')
   # or
   # Shoulda.autoload_macros(APP_ROOT, 'vendor/plugins/*', 'vendor/gems/*')
-  #	will load everything in 
-  #	- APP_ROOT/vendor/plugins/*/shoulda_macros
-  #	- APP_ROOT/vendor/gems/*/shoulda_macros
-  #	- APP_ROOT/test/shoulda_macros
+  # will load everything in
+  # - APP_ROOT/vendor/plugins/*/shoulda_macros
+  # - APP_ROOT/vendor/gems/*/shoulda_macros
+  # - APP_ROOT/test/shoulda_macros
   #
-  #	If you prefer to stick testing dependencies away from your production dependencies:
+  # If you prefer to stick testing dependencies away from your production dependencies:
   # Shoulda.autoload_macros(APP_ROOT, 'vendor/*', 'test/vendor/*')
-  #	will load everything in 
-  #	- APP_ROOT/vendor/*/shoulda_macros
-  #	- APP_ROOT/test/vendor/*/shoulda_macros
-  #	- APP_ROOT/test/shoulda_macros
+  # will load everything in
+  # - APP_ROOT/vendor/*/shoulda_macros
+  # - APP_ROOT/test/vendor/*/shoulda_macros
+  # - APP_ROOT/test/shoulda_macros
   def self.autoload_macros(root, *dirs)
     dirs << File.join('test')
     complete_dirs = dirs.map{|d| File.join(root, d, 'shoulda_macros')}

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
@@ -86,7 +116,7 @@ module Shoulda
     #      context "on GET" do
     #        setup { get :index }
     #
-    #        should_respond_with :success
+    #        should respond_with(:success)
     #
     #        # runs before "get :index"
     #        before_should "find all users" do
@@ -185,7 +215,7 @@ module Shoulda
     #     subject { User.first }
     #
     #     # uses the existing user
-    #     should_validate_uniqueness_of :email
+    #     should validate_uniqueness_of(:email)
     #   end
     def subject(&block)
       @subject_block = block
@@ -214,27 +244,10 @@ 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
-      if subject_block
-        instance_eval(&subject_block)
-      else
-        get_instance_of(self.class.described_type)
-      end
+      @shoulda_subject ||= construct_subject
     end
 
     def subject_block # :nodoc:
@@ -243,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
@@ -262,6 +265,16 @@ module Shoulda
     def instance_variable_name_for(klass) # :nodoc:
       klass.to_s.split('::').last.underscore
     end
+
+    private
+
+    def construct_subject
+      if subject_block
+        instance_eval(&subject_block)
+      else
+        get_instance_of(self.class.described_type)
+      end
+    end
   end
 
   class Context # :nodoc:
@@ -305,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
@@ -321,6 +347,11 @@ module Shoulda
       self.subject_block = block
     end
 
+    def subject_block
+      return @subject_block if @subject_block
+      parent.subject_block
+    end
+
     def full_name
       parent_name = parent.full_name if am_subcontext?
       return [parent_name, name].join(" ").strip