shoulda-matchers 1.0.0.beta1

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

@@ -0,0 +1,98 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActionController # :nodoc:
+
+      # Ensures that a session key was set to the expected value.
+      #
+      # Example:
+      #
+      #   it { should set_session(:message) }
+      #   it { should set_session(:user_id).to(@user.id) }
+      #   it { should_not set_session(:user_id) }
+      def set_session(key)
+        SetSessionMatcher.new(key)
+      end
+
+      class SetSessionMatcher # :nodoc:
+
+        def initialize(key)
+          @key = key.to_s
+        end
+
+        def to(value = nil, &block)
+          @value = value
+          @value_block = block
+          self
+        end
+
+        def matches?(controller)
+          @controller = controller
+          @value = @context.instance_eval(&@value_block) if @value_block
+          (assigned_value? && assigned_correct_value?) || cleared_value?
+        end
+
+        def failure_message
+          "Expected #{expectation}, but #{result}"
+        end
+
+        def negative_failure_message
+          "Didn't expect #{expectation}, but #{result}"
+        end
+
+        def description
+          description = "set session variable #{@key.inspect}"
+          description << " to #{@value.inspect}" if defined?(@value)
+          description
+        end
+
+        def in_context(context)
+          @context = context
+          self
+        end
+
+        private
+
+        def assigned_value?
+          !assigned_value.nil?
+        end
+
+        def cleared_value?
+          defined?(@value) && @value.nil? && assigned_value.nil?
+        end
+
+        def assigned_correct_value?
+          return true if @value.nil?
+          assigned_value == @value
+        end
+
+        def assigned_value
+          session[@key]
+        end
+
+        def session
+          if @controller.request.respond_to?(:session)
+            @controller.request.session.to_hash
+          else
+            @controller.response.session.data
+          end
+        end
+
+        def expectation
+          expectation = "session variable #{@key} to be set"
+          expectation << " to #{@value.inspect}" if @value
+          expectation
+        end
+
+        def result
+          if session.empty?
+            "no session variables were set"
+          else
+            "the session was #{session.inspect}"
+          end
+        end
+
+      end
+
+    end
+  end
+end

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.values.any? {|value| value == @value }
+        end
+
+        def regexp_value_matches?
+          return true unless Regexp === @value
+          flash.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,115 @@
+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_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 to(recipient)
+          @recipient = recipient
+          self
+        end
+
+        def matches?(subject)
+          ::ActionMailer::Base.deliveries.each do |mail|
+            @subject_failed = !regexp_or_string_match(mail.subject, @email_subject) if @email_subject
+            @body_failed = !regexp_or_string_match(mail.body, @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
+            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
+          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
+          expectation << " from #{@sender.inspect}" if @sender_failed
+          expectation << " to #{@recipient.inspect}" if @recipient_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 || @sender_failed || @recipient_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
+      end
+    end
+  end
+
+end

data/lib/shoulda/matchers/active_record.rb

@@ -0,0 +1,42 @@
+require 'shoulda/matchers/active_record/helpers'
+require 'shoulda/matchers/active_record/validation_matcher'
+require 'shoulda/matchers/active_record/allow_value_matcher'
+require 'shoulda/matchers/active_record/ensure_length_of_matcher'
+require 'shoulda/matchers/active_record/ensure_inclusion_of_matcher'
+require 'shoulda/matchers/active_record/validate_presence_of_matcher'
+require 'shoulda/matchers/active_record/validate_format_of_matcher'
+require 'shoulda/matchers/active_record/validate_uniqueness_of_matcher'
+require 'shoulda/matchers/active_record/validate_acceptance_of_matcher'
+require 'shoulda/matchers/active_record/validate_numericality_of_matcher'
+require 'shoulda/matchers/active_record/association_matcher'
+require 'shoulda/matchers/active_record/have_db_column_matcher'
+require 'shoulda/matchers/active_record/have_db_index_matcher'
+require 'shoulda/matchers/active_record/have_readonly_attribute_matcher'
+require 'shoulda/matchers/active_record/allow_mass_assignment_of_matcher'
+
+
+module Shoulda
+  module Matchers
+    # = Matchers for your active record models
+    #
+    # These matchers will test most of the validations and associations for your
+    # ActiveRecord models.
+    #
+    #   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) }
+    #     it { should have_one(:profile) }
+    #     it { should have_many(:dogs) }
+    #     it { should have_many(:messes).through(:dogs) }
+    #     it { should belong_to(:lover) }
+    #   end
+    #
+    module ActiveRecord
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Shoulda # :nodoc:
+  module Matchers
+    module ActiveRecord # :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