shoulda-matchers 1.0.0 → 1.1.0

data/lib/shoulda/matchers/action_mailer.rb

@@ -1,4 +1,4 @@
-require 'shoulda/matchers/action_mailer/have_sent_email'
+require 'shoulda/matchers/action_mailer/have_sent_email_matcher'
 
 module Shoulda
   module Matchers

data/lib/shoulda/matchers/action_mailer/{have_sent_email.rb → have_sent_email_matcher.rb}

@@ -11,6 +11,7 @@ module Shoulda # :nodoc:
       #   it { should have_sent_email.with_part('text/html', /HTML spam/) }
       #   it { should have_sent_email.with_subject(/spam/).
       #                               from('do-not-reply@example.com').
+      #                               reply_to('reply-to-me@example.com').
       #                               with_body(/spam/).
       #                               to('myself@me.com') }
       #
@@ -43,6 +44,12 @@ module Shoulda # :nodoc:
           self
         end
 
+        def reply_to(reply_to = nil, &block)
+          @reply_to = reply_to
+          @reply_to_block = block
+          self
+        end
+
         def with_body(body = nil, &block)
           @body = body
           @body_block = block
@@ -94,21 +101,9 @@ module Shoulda # :nodoc:
 
         def matches?(subject)
           normalize_blocks
-          ::ActionMailer::Base.deliveries.each do |mail|
-            @subject_failed = !regexp_or_string_match(mail.subject, @email_subject) if @email_subject
-            @parts_failed = !parts_match(mail, @parts) if @parts
-            @body_failed = !body_match(mail, @body) if @body
-            @sender_failed = !regexp_or_string_match_in_array(mail.from, @sender) if @sender
-            @recipient_failed = !regexp_or_string_match_in_array(mail.to, @recipient) if @recipient
-            @cc_failed = !regexp_or_string_match_in_array(mail.cc, @cc) if @cc
-            @cc_recipients_failed = !match_array_in_array(mail.cc, @cc_recipients) if @cc_recipients
-            @bcc_failed = !regexp_or_string_match_in_array(mail.bcc, @bcc) if @bcc
-            @bcc_recipients_failed = !match_array_in_array(mail.bcc, @bcc_recipients) if @bcc_recipients
-            @multipart_failed = (mail.multipart? != @multipart) if defined?(@multipart)
-            return true unless anything_failed?
+          ::ActionMailer::Base.deliveries.all? do |mail|
+            mail_matches?(mail)
           end
-
-          false
         end
 
         def failure_message
@@ -123,10 +118,13 @@ module Shoulda # :nodoc:
           description  = "send an email"
           description << " with a subject of #{@email_subject.inspect}" if @email_subject
           description << " containing #{@body.inspect}" if @body
-          @parts.each do |_, body, content_type|
-            description << " having a #{content_type} part containing #{body.inspect}"
-          end if @parts
+          if @parts
+            @parts.each do |_, body, content_type|
+              description << " having a #{content_type} part containing #{body.inspect}"
+            end
+          end
           description << " from #{@sender.inspect}" if @sender
+          description << " reply to #{@reply_to.inspect}" if @reply_to
           description << " to #{@recipient.inspect}" if @recipient
           description << " cc #{@cc.inspect}" if @cc
           description << " with cc #{@cc_recipients.inspect}" if @cc_recipients
@@ -145,6 +143,7 @@ module Shoulda # :nodoc:
             expectation << " with a #{content_type} part containing #{body}"
           end if @parts && @parts_failed
           expectation << " from #{@sender.inspect}" if @sender_failed
+          expectation << " reply to #{@reply_to.inspect}" if @reply_to_failed
           expectation << " to #{@recipient.inspect}" if @recipient_failed
           expectation << " cc #{@cc.inspect}" if @cc_failed
           expectation << " with cc #{@cc_recipients.inspect}" if @cc_recipients_failed
@@ -160,15 +159,32 @@ module Shoulda # :nodoc:
           end.join("\n")
         end
 
+        def mail_matches?(mail)
+          @subject_failed = !regexp_or_string_match(mail.subject, @email_subject) if @email_subject
+          @parts_failed = !parts_match(mail, @parts) if @parts
+          @body_failed = !body_match(mail, @body) if @body
+          @sender_failed = !regexp_or_string_match_in_array(mail.from, @sender) if @sender
+          @reply_to_failed = !regexp_or_string_match_in_array(mail.reply_to, @reply_to) if @reply_to
+          @recipient_failed = !regexp_or_string_match_in_array(mail.to, @recipient) if @recipient
+          @cc_failed = !regexp_or_string_match_in_array(mail.cc, @cc) if @cc
+          @cc_recipients_failed = !match_array_in_array(mail.cc, @cc_recipients) if @cc_recipients
+          @bcc_failed = !regexp_or_string_match_in_array(mail.bcc, @bcc) if @bcc
+          @bcc_recipients_failed = !match_array_in_array(mail.bcc, @bcc_recipients) if @bcc_recipients
+          @multipart_failed = (mail.multipart? != @multipart) if defined?(@multipart)
+
+          ! anything_failed?
+        end
+
         def anything_failed?
-          @subject_failed || @body_failed || @sender_failed || @recipient_failed ||
-            @cc_failed || @cc_recipients_failed || @bcc_failed || @bcc_recipients_failed ||
-            @parts_failed || @multipart_failed
+          @subject_failed || @body_failed || @sender_failed || @reply_to_failed ||
+            @recipient_failed || @cc_failed || @cc_recipients_failed || @bcc_failed ||
+            @bcc_recipients_failed || @parts_failed || @multipart_failed
         end
 
         def normalize_blocks
           @email_subject = @context.instance_eval(&@email_subject_block) if @email_subject_block
           @sender = @context.instance_eval(&@sender_block) if @sender_block
+          @reply_to = @context.instance_eval(&@reply_to_block) if @reply_to_block
           @body = @context.instance_eval(&@body_block) if @body_block
           @recipient = @context.instance_eval(&@recipient_block) if @recipient_block
           @cc = @context.instance_eval(&@cc_block) if @cc_block
@@ -205,7 +221,7 @@ module Shoulda # :nodoc:
           target_array.sort!
           match_array.sort!
 
-          target_array.each_cons(match_array.size).include? match_array
+          target_array.each_cons(match_array.size).include?(match_array)
         end
 
         def body_match(mail, a_regexp_or_string)

data/lib/shoulda/matchers/active_model.rb

@@ -8,6 +8,7 @@ require 'shoulda/matchers/active_model/validate_presence_of_matcher'
 require 'shoulda/matchers/active_model/validate_format_of_matcher'
 require 'shoulda/matchers/active_model/validate_uniqueness_of_matcher'
 require 'shoulda/matchers/active_model/validate_acceptance_of_matcher'
+require 'shoulda/matchers/active_model/validate_confirmation_of_matcher'
 require 'shoulda/matchers/active_model/validate_numericality_of_matcher'
 require 'shoulda/matchers/active_model/allow_mass_assignment_of_matcher'
 

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

@@ -9,20 +9,23 @@ module Shoulda # :nodoc:
       #
       # In Rails 3.1 you can check role as well:
       #
-      #   it { should allow_mass_assigment_of(:first_name).as(:admin) }
+      #   it { should allow_mass_assignment_of(:first_name).as(:admin) }
       #
       def allow_mass_assignment_of(value)
         AllowMassAssignmentOfMatcher.new(value)
       end
 
       class AllowMassAssignmentOfMatcher # :nodoc:
+        attr_reader :failure_message, :negative_failure_message
 
         def initialize(attribute)
           @attribute = attribute.to_s
         end
 
         def as(role)
-          raise "You can specify role only in Rails 3.1 or greater" unless rails_3_1?
+          unless at_least_rails_3_1?
+            raise "You can specify role only in Rails 3.1 or greater" 
+          end
           @role = role
           self
         end
@@ -45,18 +48,14 @@ module Shoulda # :nodoc:
             true
           else
             if whitelisting?
-              @failure_message =
-                "Expected #{@attribute} to be accessible"
+              @failure_message = "Expected #{@attribute} to be accessible"
             else
-              @failure_message =
-                "Did not expect #{@attribute} to be protected"
+              @failure_message = "Did not expect #{@attribute} to be protected"
             end
             false
           end
         end
 
-        attr_reader :failure_message, :negative_failure_message
-
         def description
           "allow mass assignment of #{@attribute}"
         end
@@ -80,7 +79,7 @@ module Shoulda # :nodoc:
         end
 
         def authorizer
-          if rails_3_1?
+          if at_least_rails_3_1?
             @subject.class.active_authorizer[@role]
           else
             @subject.class.active_authorizer
@@ -91,7 +90,7 @@ module Shoulda # :nodoc:
           @subject.class.name
         end
 
-        def rails_3_1?
+        def at_least_rails_3_1?
           ::ActiveModel::VERSION::MAJOR == 3 && ::ActiveModel::VERSION::MINOR >= 1
         end
       end

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

@@ -2,7 +2,10 @@ module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
 
-      # Ensures that the attribute can be set to the given value.
+      # Ensures that the attribute can be set to the given value or values. If
+      # multiple values are given the match succeeds only if all given values
+      # are allowed. Otherwise, the matcher fails at the first bad value in the
+      # argument list (the remaining arguments are not processed then).
       #
       # Options:
       # * <tt>with_message</tt> - value the test expects to find in
@@ -13,15 +16,19 @@ module Shoulda # :nodoc:
       #   it { should_not allow_value('bad').for(:isbn) }
       #   it { should allow_value("isbn 1 2345 6789 0").for(:isbn) }
       #
-      def allow_value(value)
-        AllowValueMatcher.new(value)
+      def allow_value(*values)
+        if values.empty?
+          raise ArgumentError, "need at least one argument"
+        else
+          AllowValueMatcher.new(*values)
+        end
       end
 
       class AllowValueMatcher # :nodoc:
         include Helpers
 
-        def initialize(value)
-          @value = value
+        def initialize(*values)
+          @values_to_match = values
         end
 
         def for(attribute)
@@ -30,17 +37,17 @@ module Shoulda # :nodoc:
         end
 
         def with_message(message)
-          @expected_message = message if message
+          @expected_message = message
           self
         end
 
         def matches?(instance)
           @instance = instance
-          if Symbol === @expected_message
-            @expected_message = default_error_message(@expected_message)
+          @values_to_match.none? do |value|
+            @value = value
+            @instance.send("#{@attribute}=", @value)
+            errors_match?
           end
-          @instance.send("#{@attribute}=", @value)
-          !errors_match?
         end
 
         def failure_message
@@ -52,48 +59,47 @@ module Shoulda # :nodoc:
         end
 
         def description
-          "allow #{@attribute} to be set to #{@value.inspect}"
+          "allow #{@attribute} to be set to #{allowed_values}"
         end
 
         private
 
         def errors_match?
-          @instance.valid?
-          @errors = errors_for_attribute(@instance, @attribute)
-          @errors = [@errors] unless @errors.is_a?(Array)
-          @expected_message ? (errors_match_regexp? || errors_match_string?) : (@errors.compact.any?)
+          if @instance.valid?
+            false
+          else
+            if expected_message
+              errors_match_regexp? || errors_match_string?
+            else
+              errors_for_attribute.compact.any?
+            end
+          end
         end
 
-        def errors_for_attribute(instance, attribute)
-          if instance.errors.respond_to?(:[])
-            instance.errors[attribute]
+        def errors_for_attribute
+          if @instance.errors.respond_to?(:[])
+            errors = @instance.errors[@attribute]
           else
-            instance.errors.on(attribute)
+            errors = @instance.errors.on(@attribute)
           end
+          Array.wrap(errors)
         end
 
         def errors_match_regexp?
-          if Regexp === @expected_message
-            @matched_error = @errors.detect { |e| e =~ @expected_message }
-            !@matched_error.nil?
-          else
-            false
+          if Regexp === expected_message
+            @matched_error = errors_for_attribute.detect { |e| e =~ expected_message }
           end
         end
 
         def errors_match_string?
-          if @errors.include?(@expected_message)
-            @matched_error = @expected_message
-            true
-          else
-            false
+          if errors_for_attribute.include?(expected_message)
+            @matched_error = expected_message
           end
         end
 
         def expectation
-          "errors " <<
-          (@expected_message ? "to include #{@expected_message.inspect} " : "") <<
-          "when #{@attribute} is set to #{@value.inspect}"
+          includes_expected_message = expected_message ? "to include #{expected_message.inspect}" : ''
+          ["errors", includes_expected_message, "when #{@attribute} is set to #{@value.inspect}"].join(' ')
         end
 
         def error_description
@@ -103,8 +109,29 @@ module Shoulda # :nodoc:
             "errors: #{pretty_error_messages(@instance)}"
           end
         end
-      end
 
+        def allowed_values
+          if @values_to_match.length > 1
+            "any of [#{@values_to_match.map(&:inspect).join(', ')}]"
+          else
+            @values_to_match.first.inspect
+          end
+        end
+
+        def expected_message
+          if @expected_message
+            if Symbol === @expected_message
+              default_error_message(@expected_message, :model_name => model_name, :attribute => @attribute)
+            else
+              @expected_message
+            end
+          end
+        end
+
+        def model_name
+          @instance.class.to_s.underscore
+        end
+      end
     end
   end
 end

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

@@ -135,7 +135,6 @@ module Shoulda # :nodoc:
           'x' * length
         end
       end
-
     end
   end
 end

data/lib/shoulda/matchers/active_model/helpers.rb

@@ -3,9 +3,9 @@ module Shoulda # :nodoc:
     module ActiveModel # :nodoc:
       module Helpers
         def pretty_error_messages(obj) # :nodoc:
-          obj.errors.map do |a, m|
-            msg = "#{a} #{m}"
-            msg << " (#{obj.send(a).inspect})" unless a.to_sym == :base
+          obj.errors.map do |attribute, model|
+            msg = "#{attribute} #{model}"
+            msg << " (#{obj.send(attribute).inspect})" unless attribute.to_sym == :base
           end
         end
 
@@ -16,12 +16,16 @@ module Shoulda # :nodoc:
         #   default_error_message(:blank)
         #   default_error_message(:too_short, :count => 5)
         #   default_error_message(:too_long, :count => 60)
-        def default_error_message(key, values = {})
-          if Object.const_defined?(:I18n) # Rails >= 2.2           
-            I18n.translate(:"activerecord.errors.messages.#{key}", {:default => :"errors.messages.#{key}"}.merge(values))
-          else # Rails <= 2.1.x
-            ::ActiveRecord::Errors.default_error_messages[key] % values[:count]
-          end
+        #   default_error_message(:blank, :model_name => 'user', :attribute => 'name')
+        def default_error_message(key, options = {})
+          model_name = options.delete(:model_name)
+          attribute = options.delete(:attribute)
+          default_translation = [ :"activerecord.errors.models.#{model_name}.#{key}",
+                                  :"activerecord.errors.messages.#{key}",
+                                  :"errors.attributes.#{attribute}.#{key}",
+                                  :"errors.messages.#{key}" ]
+          I18n.translate(:"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{key}",
+            { :default => default_translation }.merge(options))
         end
       end
     end

data/lib/shoulda/matchers/active_model/validate_confirmation_of_matcher.rb

@@ -0,0 +1,63 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+      # Ensures that the model's attribute matches confirmation
+      #
+      # Example:
+      #   it { should validate_confirmation_of(:password) }
+      #
+      def validate_confirmation_of(attr)
+        ValidateConfirmationOfMatcher.new(attr)
+      end
+
+      class ValidateConfirmationOfMatcher < ValidationMatcher # :nodoc:
+        include Helpers
+
+        def initialize(attribute)
+          @attribute = attribute
+          @confirmation = "#{attribute}_confirmation"
+        end
+
+        def with_message(message)
+          @message = message if message
+          self
+        end
+
+        def description
+          "require #{@base_attribute} to match #{@attribute}"
+        end
+
+        def matches?(subject)
+          super(subject)
+          @message ||= :confirmation
+
+          disallows_different_value &&
+            allows_same_value &&
+            allows_missing_confirmation
+        end
+
+        private
+
+        def disallows_different_value
+          set_confirmation("some value")
+          matches = disallows_value_of("different value", @message)
+        end
+
+        def allows_same_value
+          set_confirmation("same value")
+          allows_value_of("same value", @message)
+        end
+
+        def allows_missing_confirmation
+          set_confirmation(nil)
+          allows_value_of("any value", @message)
+        end
+
+        def set_confirmation(val)
+          setter = :"#{@confirmation}="
+          @subject.send(setter, val) if @subject.respond_to?(setter)
+        end
+      end
+    end
+  end
+end