yetanothernguyen-shoulda-matchers 1.0.0.beta3

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

@@ -0,0 +1,94 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActionController # :nodoc:
+
+      # Ensures that the flash contains the given value. Can be a String, a
+      # Regexp, or nil (indicating that the flash should not be set).
+      #
+      # Example:
+      #
+      #   it { should set_the_flash }
+      #   it { should set_the_flash.to("Thank you for placing this order.") }
+      #   it { should set_the_flash.to(/created/i) }
+      #   it { should set_the_flash.to(/logged in/i).now }
+      #   it { should_not set_the_flash }
+      def set_the_flash
+        SetTheFlashMatcher.new
+      end
+
+      class SetTheFlashMatcher # :nodoc:
+
+        def to(value)
+          @value = value
+          self
+        end
+
+        def now
+          @now = true
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          sets_the_flash? && string_value_matches? && regexp_value_matches?
+        end
+
+        attr_reader :failure_message, :negative_failure_message
+
+        def description
+          description = "set the flash"
+          description << " to #{@value.inspect}" unless @value.nil?
+          description
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        private
+
+        def sets_the_flash?
+          !flash.blank?
+        end
+
+        def string_value_matches?
+          return true unless String === @value
+          flash.to_hash.values.any? {|value| value == @value }
+        end
+
+        def regexp_value_matches?
+          return true unless Regexp === @value
+          flash.to_hash.values.any? {|value| value =~ @value }
+        end
+
+        def flash
+          return @flash if @flash
+          @flash = @controller.flash.dup
+          @flash.sweep unless @now
+          @flash
+        end
+
+        def expectation
+          expectation = "the flash#{".now" if @now} to be set"
+          expectation << " to #{@value.inspect}" unless @value.nil?
+          expectation << ", but #{flash_description}"
+          expectation
+        end
+
+        def flash_description
+          if flash.blank?
+            "no flash was set"
+          else
+            "was #{flash.inspect}"
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/shoulda/matchers/action_mailer.rb

@@ -0,0 +1,22 @@
+require 'shoulda/matchers/action_mailer/have_sent_email'
+
+module Shoulda
+  module Matchers
+    # = Matchers for your mailers
+    #
+    # This matcher will test that email is sent properly
+    #
+    #   describe User do
+    #     it { should have_sent_email.with_subject(/is spam$/) }
+    #     it { should have_sent_email.from('do-not-reply@example.com') }
+    #     it { should have_sent_email.with_body(/is spam\./) }
+    #     it { should have_sent_email.to('myself@me.com') }
+    #     it { should have_sent_email.with_subject(/spam/).
+    #                                 from('do-not-reply@example.com').
+    #                                 with_body(/spam/).
+    #                                 to('myself@me.com') }
+    #   end
+    module ActionMailer
+    end
+  end
+end

data/lib/shoulda/matchers/action_mailer/have_sent_email.rb

@@ -0,0 +1,166 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActionMailer # :nodoc:
+
+      # The right email is sent.
+      #
+      #   it { should have_sent_email.with_subject(/is spam$/) }
+      #   it { should have_sent_email.from('do-not-reply@example.com') }
+      #   it { should have_sent_email.with_body(/is spam\./) }
+      #   it { should have_sent_email.to('myself@me.com') }
+      #   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').
+      #                               with_body(/spam/).
+      #                               to('myself@me.com') }
+      def have_sent_email
+        HaveSentEmailMatcher.new
+      end
+
+      class HaveSentEmailMatcher # :nodoc:
+
+        def initialize
+        end
+
+        def with_subject(email_subject)
+          @email_subject = email_subject
+          self
+        end
+
+        def from(sender)
+          @sender = sender
+          self
+        end
+
+        def with_body(body)
+          @body = body
+          self
+        end
+
+        def with_part(content_type, body)
+          @parts ||= []
+          @parts << [/#{Regexp.escape(content_type)}/, body, content_type]
+          self
+        end
+
+        def to(recipient)
+          @recipient = recipient
+          self
+        end
+
+        def multipart(flag = true)
+          @multipart = !!flag
+          self
+        end
+
+        def matches?(subject)
+          ::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
+            @multipart_failed = mail.multipart? != @multipart if defined?(@multipart)
+            return true unless anything_failed?
+          end
+
+          false
+        end
+
+        def failure_message
+          "Expected #{expectation}"
+        end
+
+        def negative_failure_message
+          "Did not expect #{expectation}"
+        end
+
+        def description
+          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
+          description << " from #{@sender.inspect}" if @sender
+          description << " to #{@recipient.inspect}" if @recipient
+          description
+        end
+
+        private
+
+        def expectation
+          expectation = "sent email"
+          expectation << " with subject #{@email_subject.inspect}" if @subject_failed
+          expectation << " with body #{@body.inspect}" if @body_failed
+          @parts.each do |_, body, content_type|
+            expectation << " with a #{content_type} part containing #{body}"
+          end if @parts && @parts_failed
+          expectation << " from #{@sender.inspect}" if @sender_failed
+          expectation << " to #{@recipient.inspect}" if @recipient_failed
+          expectation << " #{'not ' if !@multipart}being multipart" if @multipart_failed
+          expectation << "\nDeliveries:\n#{inspect_deliveries}"
+        end
+
+        def inspect_deliveries
+          ::ActionMailer::Base.deliveries.map do |delivery|
+            "#{delivery.subject.inspect} to #{delivery.to.inspect}"
+          end.join("\n")
+        end
+
+        def anything_failed?
+          @subject_failed || @body_failed || @parts_failed || @sender_failed ||
+              @recipient_failed || @multipart_failed
+        end
+
+        def regexp_or_string_match(a_string, a_regexp_or_string)
+          case a_regexp_or_string
+          when Regexp
+            a_string =~ a_regexp_or_string
+          when String
+            a_string == a_regexp_or_string
+          end
+        end
+
+        def regexp_or_string_match_in_array(an_array, a_regexp_or_string)
+          case a_regexp_or_string
+          when Regexp
+            an_array.any? { |string| string =~ a_regexp_or_string }
+          when String
+            an_array.include?(a_regexp_or_string)
+          end
+        end
+
+        def body_match(mail, a_regexp_or_string)
+          # Mail objects instantiated by ActionMailer3 return a blank
+          # body if the e-mail is multipart. TMail concatenates the
+          # String representation of each part instead.
+          if mail.body.blank? && mail.multipart?
+            part_match(mail, /^text\//, a_regexp_or_string)
+          else
+            regexp_or_string_match(mail.body, a_regexp_or_string)
+          end
+        end
+
+        def parts_match(mail, parts)
+          return false if mail.parts.empty?
+
+          parts.all? do |content_type, match, _|
+            part_match(mail, content_type, match)
+          end
+        end
+
+        def part_match(mail, content_type, a_regexp_or_string)
+          matching = mail.parts.select {|p| p.content_type =~ content_type}
+          return false if matching.empty?
+
+          matching.all? do |part|
+            regexp_or_string_match(part.body, a_regexp_or_string)
+          end
+        end
+
+      end
+    end
+  end
+
+end

data/lib/shoulda/matchers/active_model.rb

@@ -0,0 +1,33 @@
+require 'shoulda/matchers/active_model/helpers'
+require 'shoulda/matchers/active_model/validation_matcher'
+require 'shoulda/matchers/active_model/allow_value_matcher'
+require 'shoulda/matchers/active_model/ensure_length_of_matcher'
+require 'shoulda/matchers/active_model/ensure_inclusion_of_matcher'
+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_numericality_of_matcher'
+require 'shoulda/matchers/active_model/allow_mass_assignment_of_matcher'
+
+
+module Shoulda
+  module Matchers
+    # = Matchers for your active record models
+    #
+    # These matchers will test most of the validations of ActiveModel::Validations.
+    #
+    #   describe User do
+    #     it { should validate_presence_of(:name) }
+    #     it { should validate_presence_of(:phone_number) }
+    #     %w(abcd 1234).each do |value|
+    #       it { should_not allow_value(value).for(:phone_number) }
+    #     end
+    #     it { should allow_value("(123) 456-7890").for(:phone_number) }
+    #     it { should_not allow_mass_assignment_of(:password) }
+    #   end
+    #
+    module ActiveModel
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # Ensures that the attribute can be set on mass update.
+      #
+      #   it { should_not allow_mass_assignment_of(:password) }
+      #   it { should allow_mass_assignment_of(:first_name) }
+      #
+      def allow_mass_assignment_of(value)
+        AllowMassAssignmentOfMatcher.new(value)
+      end
+
+      class AllowMassAssignmentOfMatcher # :nodoc:
+
+        def initialize(attribute)
+          @attribute = attribute.to_s
+        end
+
+        def matches?(subject)
+          @subject = subject
+          if attr_mass_assignable?
+            if whitelisting?
+              @negative_failure_message = "#{@attribute} was made accessible"
+            else
+              if protected_attributes.empty?
+                @negative_failure_message = "no attributes were protected"
+              else
+                @negative_failure_message = "#{class_name} is protecting " <<
+                  "#{protected_attributes.to_a.to_sentence}, " <<
+                  "but not #{@attribute}."
+              end
+            end
+            true
+          else
+            if whitelisting?
+              @failure_message =
+                "Expected #{@attribute} to be accessible"
+            else
+              @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
+
+        private
+
+        def protected_attributes
+          @protected_attributes ||= (@subject.class.protected_attributes || [])
+        end
+
+        def accessible_attributes
+          @accessible_attributes ||= (@subject.class.accessible_attributes || [])
+        end
+
+        def whitelisting?
+          !accessible_attributes.empty?
+        end
+
+        def attr_mass_assignable?
+          if whitelisting?
+            accessible_attributes.include?(@attribute)
+          else
+            !protected_attributes.include?(@attribute)
+          end
+        end
+
+        def class_name
+          @subject.class.name
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,110 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveModel # :nodoc:
+
+      # Ensures that the attribute can be set to the given value.
+      #
+      # Options:
+      # * <tt>with_message</tt> - value the test expects to find in
+      #   <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) }
+      #   it { should allow_value("isbn 1 2345 6789 0").for(:isbn) }
+      #
+      def allow_value(value)
+        AllowValueMatcher.new(value)
+      end
+
+      class AllowValueMatcher # :nodoc:
+        include Helpers
+
+        def initialize(value)
+          @value = value
+        end
+
+        def for(attribute)
+          @attribute = attribute
+          self
+        end
+
+        def with_message(message)
+          @expected_message = message if message
+          self
+        end
+
+        def matches?(instance)
+          @instance = instance
+          if Symbol === @expected_message
+            @expected_message = default_error_message(@expected_message)
+          end
+          @instance.send("#{@attribute}=", @value)
+          !errors_match?
+        end
+
+        def failure_message
+          "Did not expect #{expectation}, got error: #{@matched_error}"
+        end
+
+        def negative_failure_message
+          "Expected #{expectation}, got #{error_description}"
+        end
+
+        def description
+          "allow #{@attribute} to be set to #{@value.inspect}"
+        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?)
+        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?
+          if Regexp === @expected_message
+            @matched_error = @errors.detect { |e| e =~ @expected_message }
+            !@matched_error.nil?
+          else
+            false
+          end
+        end
+
+        def errors_match_string?
+          if @errors.include?(@expected_message)
+            @matched_error = @expected_message
+            true
+          else
+            false
+          end
+        end
+
+        def expectation
+          "errors " <<
+          (@expected_message ? "to include #{@expected_message.inspect} " : "") <<
+          "when #{@attribute} is set to #{@value.inspect}"
+        end
+
+        def error_description
+          if @instance.errors.empty?
+            "no errors"
+          else
+            "errors: #{pretty_error_messages(@instance)}"
+          end
+        end
+      end
+
+    end
+  end
+end