shoulda 2.10.1 → 2.10.2

data/lib/shoulda/active_record/matchers.rb

@@ -4,12 +4,13 @@ require 'shoulda/active_record/matchers/allow_value_matcher'
 require 'shoulda/active_record/matchers/ensure_length_of_matcher'
 require 'shoulda/active_record/matchers/ensure_inclusion_of_matcher'
 require 'shoulda/active_record/matchers/validate_presence_of_matcher'
+require 'shoulda/active_record/matchers/validate_format_of_matcher'
 require 'shoulda/active_record/matchers/validate_uniqueness_of_matcher'
 require 'shoulda/active_record/matchers/validate_acceptance_of_matcher'
 require 'shoulda/active_record/matchers/validate_numericality_of_matcher'
 require 'shoulda/active_record/matchers/association_matcher'
 require 'shoulda/active_record/matchers/have_db_column_matcher'
-require 'shoulda/active_record/matchers/have_index_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'

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

@@ -47,7 +47,7 @@ module Shoulda # :nodoc:
         attr_reader :failure_message, :negative_failure_message
 
         def description
-          "protect #{@attribute} from mass updates"
+          "allow mass assignment of #{@attribute}"
         end
 
         private

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

@@ -6,8 +6,8 @@ module Shoulda # :nodoc:
       #
       # Options:
       # * <tt>with_message</tt> - value the test expects to find in
-      #   <tt>errors.on(:attribute)</tt>. Regexp or string. Defaults to the
-      #   translation for :invalid.
+      #   <tt>errors.on(:attribute)</tt>. Regexp or string. If omitted,
+      #   the test looks for any errors in <tt>errors.on(:attribute)</tt>.
       #
       # Example:
       #   it { should_not allow_value('bad').for(:isbn) }
@@ -36,7 +36,6 @@ module Shoulda # :nodoc:
 
         def matches?(instance)
           @instance = instance
-          @expected_message ||= :invalid
           if Symbol === @expected_message
             @expected_message = default_error_message(@expected_message)
           end
@@ -62,7 +61,7 @@ module Shoulda # :nodoc:
           @instance.valid?
           @errors = @instance.errors.on(@attribute)
           @errors = [@errors] unless @errors.is_a?(Array)
-          errors_match_regexp? || errors_match_string?
+          @expected_message ? (errors_match_regexp? || errors_match_string?) : (@errors != [nil])
         end
 
         def errors_match_regexp?
@@ -84,7 +83,8 @@ module Shoulda # :nodoc:
         end
 
         def expectation
-          "errors to include #{@expected_message.inspect} " <<
+          "errors " <<
+          (@expected_message ? "to include #{@expected_message.inspect} " : "") <<
           "when #{@attribute} is set to #{@value.inspect}"
         end
 

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

@@ -133,7 +133,7 @@ module Shoulda # :nodoc:
 
         def through_association_exists?
           if through_reflection.nil?
-            "#{model_class.name} does not have any relationship to #{@through}"
+            @missing = "#{model_class.name} does not have any relationship to #{@through}"
             false
           else
             true
@@ -142,10 +142,10 @@ module Shoulda # :nodoc:
 
         def through_association_correct?
           if @through == reflection.options[:through]
-            "Expected #{model_class.name} to have #{@name} through #{@through}, " <<
-              " but got it through #{reflection.options[:through]}"
             true
           else
+            @missing = "Expected #{model_class.name} to have #{@name} through #{@through}, " <<
+              "but got it through #{reflection.options[:through]}"
             false
           end
         end

data/lib/shoulda/active_record/matchers/{have_index_matcher.rb → have_db_index_matcher.rb}

@@ -14,15 +14,15 @@ module Shoulda # :nodoc:
       #
       # Examples:
       #
-      #   it { should have_index(:age) }
-      #   it { should have_index([:commentable_type, :commentable_id]) }
-      #   it { should have_index(:ssn).unique(true) }
+      #   it { should have_db_index(:age) }
+      #   it { should have_db_index([:commentable_type, :commentable_id]) }
+      #   it { should have_db_index(:ssn).unique(true) }
       #
-      def have_index(columns)
-        HaveIndexMatcher.new(:have_index, columns)
+      def have_db_index(columns)
+        HaveDbIndexMatcher.new(:have_index, columns)
       end
 
-      class HaveIndexMatcher # :nodoc:
+      class HaveDbIndexMatcher # :nodoc:
         def initialize(macro, columns)
           @macro = macro
           @columns = normalize_columns_to_array(columns)
@@ -47,7 +47,7 @@ module Shoulda # :nodoc:
         end
 
         def description
-          "have a #{index_type} index on columns #{@columns}"
+          "have a #{index_type} index on columns #{@columns.join(' and ')}"
         end
 
         protected
@@ -88,7 +88,14 @@ module Shoulda # :nodoc:
         end
         
         def index_type
-          @unique ? "unique" : "non-unique"
+          case @unique
+          when nil
+            ''
+          when false
+            'non-unique'
+          else
+            'unique'
+          end
         end
         
         def normalize_columns_to_array(columns)

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

@@ -2,6 +2,8 @@ module Shoulda # :nodoc:
   module ActiveRecord # :nodoc:
     module Matchers
 
+      # Deprecated.
+      #
       # Ensures that the model has a method named scope_call that returns a
       # NamedScope object with the proxy options set to the options you supply.
       # scope_call can be either a symbol, or a Ruby expression in a String
@@ -43,6 +45,7 @@ module Shoulda # :nodoc:
       #   end
       #
       def have_named_scope(scope_call)
+        warn "[DEPRECATION] should_have_named_scope is deprecated."
         HaveNamedScopeMatcher.new(scope_call).in_context(self)
       end
 

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

@@ -0,0 +1,67 @@
+module Shoulda # :nodoc:
+  module ActiveRecord # :nodoc:
+    module Matchers
+
+      # Ensures that the model is not valid if the given attribute is not
+      # formatted correctly.
+      #
+      # Options:
+      # * <tt>with_message</tt> - value the test expects to find in
+      #   <tt>errors.on(:attribute)</tt>. <tt>Regexp</tt> or <tt>String</tt>.
+      #   Defaults to the translation for <tt>:blank</tt>.
+      # * <tt>with(string to test against)</tt>
+      # * <tt>not_with(string to test against)</tt>
+      #
+      # Examples:
+      #   it { should validate_format_of(:name).
+      #                 with('12345').
+      #                 with_message(/is not optional/) }
+      #   it { should validate_format_of(:name).
+      #                 not_with('12D45').
+      #                 with_message(/is not optional/) }
+      #
+      def validate_format_of(attr)
+        ValidateFormatOfMatcher.new(attr)
+      end
+
+      class ValidateFormatOfMatcher < ValidationMatcher # :nodoc:
+        
+        def initialize(attribute)
+          super
+        end
+
+        def with_message(message)
+          @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
+          @value_to_fail = value
+          self
+        end
+
+
+        def matches?(subject)
+          super(subject)
+          @expected_message ||= :blank
+          return disallows_value_of(@value_to_fail, @expected_message) if @value_to_fail
+          allows_value_of(@value_to_pass, @expected_message) if @value_to_pass
+        end
+
+        def description
+          "#{@attribute} have a valid format"
+        end
+
+      end
+
+    end
+  end
+end

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

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

data/lib/shoulda/assertions.rb

@@ -45,15 +45,27 @@ module Shoulda # :nodoc:
     end
 
     # Asserts that the given matcher returns true when +target+ is passed to #matches?
-    def assert_accepts(matcher, target)
-      success = matcher.matches?(target)
-      assert_block(matcher.failure_message) { success }
+    def assert_accepts(matcher, target, options = {})
+      if matcher.matches?(target)
+        assert_block { true }
+        if options[:message]
+          assert_match options[:message], matcher.negative_failure_message
+        end
+      else
+        assert_block(matcher.failure_message) { false }
+      end
     end
 
     # Asserts that the given matcher returns false when +target+ is passed to #matches?
-    def assert_rejects(matcher, target)
-      success = !matcher.matches?(target)
-      assert_block(matcher.negative_failure_message) { success }
+    def assert_rejects(matcher, target, options = {})
+      unless matcher.matches?(target)
+        assert_block { true }
+        if options[:message]
+          assert_match options[:message], matcher.failure_message
+        end
+      else
+        assert_block(matcher.negative_failure_message) { false }
+      end
     end
   end
 end

data/lib/shoulda/context.rb

@@ -59,7 +59,7 @@ module Shoulda
 
     def should(name, options = {}, &blk)
       if Shoulda.current_context
-        block_given? ? Shoulda.current_context.should(name, options, &blk) : Should.current_context.should_eventually(name)
+        block_given? ? Shoulda.current_context.should(name, options, &blk) : Shoulda.current_context.should_eventually(name)
       else
         context_name = self.name.gsub(/Test/, "")
         context = Shoulda::Context.new(context_name, self) do
@@ -170,6 +170,98 @@ module Shoulda
         context.build
       end
     end
+
+    # Returns the class being tested, as determined by the test class name.
+    #
+    #   class UserTest; described_type; end
+    #   # => User
+    def described_type
+      self.name.gsub(/Test$/, '').constantize
+    end
+
+    # Sets the return value of the subject instance method:
+    #
+    #   class UserTest < Test::Unit::TestCase
+    #     subject { User.first }
+    #
+    #     # uses the existing user
+    #     should_validate_uniqueness_of :email
+    #   end
+    def subject(&block)
+      @subject_block = block
+    end
+
+    def subject_block # :nodoc:
+      @subject_block
+    end
+  end
+
+  module InstanceMethods
+    # Returns an instance of the class under test.
+    #
+    #   class UserTest
+    #     should "be a user" do
+    #       assert_kind_of User, subject # passes
+    #     end
+    #   end
+    #
+    # The subject can be explicitly set using the subject class method:
+    #
+    #   class UserTest
+    #     subject { User.first }
+    #     should "be an existing user" do
+    #       assert !subject.new_record? # uses the first user
+    #     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
+    end
+
+    def subject_block # :nodoc:
+      (@shoulda_context && @shoulda_context.subject_block) || self.class.subject_block
+    end
+
+    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
+      else
+        object_or_klass
+      end
+    end
+
+    def instance_variable_name_for(klass) # :nodoc:
+      klass.to_s.split('::').last.underscore
+    end
   end
 
   class Context # :nodoc:
@@ -181,6 +273,7 @@ module Shoulda
     attr_accessor :teardown_blocks    # blocks given via teardown methods
     attr_accessor :shoulds            # array of hashes representing the should statements
     attr_accessor :should_eventuallys # array of hashes representing the should eventually statements
+    attr_accessor :subject_block
 
     def initialize(name, parent, &blk)
       Shoulda.add_context(self)
@@ -224,6 +317,10 @@ module Shoulda
       self.should_eventuallys << { :name => name, :block => blk }
     end
 
+    def subject(&block)
+      self.subject_block = block
+    end
+
     def full_name
       parent_name = parent.full_name if am_subcontext?
       return [parent_name, name].join(" ").strip
@@ -246,6 +343,7 @@ module Shoulda
 
       context = self
       test_unit_class.send(:define_method, test_name) do
+        @shoulda_context = context
         begin
           context.run_parent_setup_blocks(self)
           should[:before].bind(self).call if should[:before]

data/lib/shoulda/macros.rb

@@ -3,70 +3,130 @@ require 'shoulda/private_helpers'
 module Shoulda # :nodoc:
   module Macros
     # Macro that creates a test asserting a change between the return value
-    # of an expression that is run before and after the current setup block
+    # 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>
     # assertion, but supports more than just numeric values.  See also
     # should_not_change.
     #
+    # The passed description will be used when generating the test name and failure messages.
+    #
     # Example:
     #
     #   context "Creating a post" do
     #     setup { Post.create }
-    #     should_change "Post.count", :by => 1
+    #     should_change("the number of posts", :by => 1) { Post.count }
     #   end
     #
     # As shown in this example, the <tt>:by</tt> option expects a numeric
     # difference between the before and after values of the expression.  You
     # may also specify <tt>:from</tt> and <tt>:to</tt> options:
     #
-    #   should_change "Post.count", :from => 0, :to => 1
-    #   should_change "@post.title", :from => "old", :to => "new"
+    #   should_change("the number of posts", :from => 0, :to => 1) { Post.count }
+    #   should_change("the post title", :from => "old", :to => "new") { @post.title }
     #
     # Combinations of <tt>:by</tt>, <tt>:from</tt>, and <tt>:to</tt> are allowed:
     #
-    #   should_change "@post.title"                # => assert the value changed in some way
-    #   should_change "@post.title", :from => "old" # => assert the value changed to anything other than "old"
-    #   should_change "@post.title", :to   => "new" # => assert the value changed from anything other than "new"
-    def should_change(expression, options = {})
+    #   # Assert the value changed in some way:
+    #   should_change("the post title") { @post.title }
+    #
+    #   # Assert the value changed to anything other than "old:"
+    #   should_change("the post title", :from => "old") { @post.title }
+    #
+    #   # Assert the value changed to "new:"
+    #   should_change("the post title", :to => "new") { @post.title }
+    def should_change(description, options = {}, &block)
       by, from, to = get_options!([options], :by, :from, :to)
-      stmt = "change #{expression.inspect}"
+      stmt = "change #{description}"
       stmt << " from #{from.inspect}" if from
       stmt << " to #{to.inspect}" if to
       stmt << " by #{by.inspect}" if by
 
-      expression_eval = lambda { eval(expression) }
-      before = lambda { @_before_should_change = expression_eval.bind(self).call }
+      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 }
       should stmt, :before => before do
         old_value = @_before_should_change
-        new_value = expression_eval.bind(self).call
-        assert_operator from, :===, old_value, "#{expression.inspect} did not originally match #{from.inspect}" if from
-        assert_not_equal old_value, new_value, "#{expression.inspect} did not change" unless by == 0
-        assert_operator to, :===, new_value, "#{expression.inspect} was not changed to match #{to.inspect}" if to
+        new_value = code.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
         assert_equal old_value + by, new_value if by
       end
     end
 
     # Macro that creates a test asserting no change between the return value
-    # of an expression that is run before and after the current setup block
+    # of a block that is run before and after the current setup block
     # is run. This is the logical opposite of should_change.
     #
+    # The passed description will be used when generating the test name and failure message.
+    #
     # Example:
     #
     #   context "Updating a post" do
     #     setup { @post.update_attributes(:title => "new") }
-    #     should_not_change "Post.count"
+    #     should_not_change("the number of posts") { Post.count }
     #   end
-    def should_not_change(expression)
-      expression_eval = lambda { eval(expression) }
-      before = lambda { @_before_should_not_change = expression_eval.bind(self).call }
-      should "not change #{expression.inspect}", :before => before do
-        new_value = expression_eval.bind(self).call
-        assert_equal @_before_should_not_change, new_value, "#{expression.inspect} changed"
+    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 }
+      should "not change #{description}", :before => before do
+        new_value = code.bind(self).call
+        assert_equal @_before_should_not_change, new_value, "#{description} changed"
       end
     end
 
+    # Macro that creates a test asserting that a record of the given class was
+    # created.
+    #
+    # Example:
+    #
+    #   context "creating a post" do
+    #     setup { Post.create(post_attributes) }
+    #     should_create :post
+    #   end
+    def should_create(class_name)
+      should_change_record_count_of(class_name, 1, 'create')
+    end
+
+    # Macro that creates a test asserting that a record of the given class was
+    # destroyed.
+    #
+    # Example:
+    #
+    #   context "destroying a post" do
+    #     setup { Post.first.destroy }
+    #     should_destroy :post
+    #   end
+    def should_destroy(class_name)
+      should_change_record_count_of(class_name, -1, 'destroy')
+    end
+
     private
 
+    def should_change_record_count_of(class_name, amount, action) # :nodoc:
+      klass = class_name.to_s.camelize.constantize
+      before = lambda do
+        @_before_change_record_count = klass.count
+      end
+      human_name = class_name.to_s.humanize.downcase
+      should "#{action} a #{human_name}", :before => before do
+        assert_equal @_before_change_record_count + amount,
+                     klass.count,
+                     "Expected to #{action} a #{human_name}"
+      end
+    end
+
     include Shoulda::Private
   end
 end