shoulda-matchers 1.5.6 → 2.0.0

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

@@ -1,130 +0,0 @@
-require 'active_support/deprecation'
-
-module Shoulda # :nodoc:
-  module Matchers
-    module ActionController # :nodoc:
-      # Ensures that the controller assigned to the named instance variable.
-      #
-      # Options:
-      # * <tt>with_kind_of</tt> - The expected class of the instance variable
-      #   being checked.
-      # * <tt>with</tt> - The value that should be assigned.
-      #
-      # Example:
-      #
-      #   it { should assign_to(:user) }
-      #   it { should_not assign_to(:user) }
-      #   it { should assign_to(:user).with_kind_of(User) }
-      #   it { should assign_to(:user).with(@user) }
-      def assign_to(variable)
-        AssignToMatcher.new(variable)
-      end
-
-      class AssignToMatcher # :nodoc:
-        attr_reader :failure_message_for_should, :failure_message_for_should_not
-
-        def initialize(variable)
-          ActiveSupport::Deprecation.warn 'The assign_to matcher is deprecated and will be removed in 2.0'
-          @variable    = variable.to_s
-          @options = {}
-          @options[:check_value] = false
-        end
-
-        def with_kind_of(expected_class)
-          @options[:expected_class] = expected_class
-          self
-        end
-
-        def with(expected_value = nil, &block)
-          @options[:check_value] = true
-          @options[:expected_value] = expected_value
-          @options[:expectation_block] = block
-          self
-        end
-
-        def matches?(controller)
-          @controller = controller
-          normalize_expected_value!
-          assigned_value? &&
-            kind_of_expected_class? &&
-            equal_to_expected_value?
-        end
-
-        def description
-          description = "assign @#{@variable}"
-          if @options.key?(:expected_class)
-            description << " with a kind of #{@options[:expected_class]}"
-          end
-          description
-        end
-
-        def in_context(context)
-          @context = context
-          self
-        end
-
-        private
-
-        def assigned_value?
-          if @controller.instance_variables.map(&:to_s).include?("@#{@variable}")
-            @failure_message_for_should_not =
-              "Didn't expect action to assign a value for @#{@variable}, " <<
-              "but it was assigned to #{assigned_value.inspect}"
-            true
-          else
-            @failure_message_for_should =
-              "Expected action to assign a value for @#{@variable}"
-            false
-          end
-        end
-
-        def kind_of_expected_class?
-          if @options.key?(:expected_class)
-            if assigned_value.kind_of?(@options[:expected_class])
-              @failure_message_for_should_not =
-                "Didn't expect action to assign a kind of #{@options[:expected_class]} " <<
-                "for #{@variable}, but got one anyway"
-              true
-            else
-              @failure_message_for_should =
-                "Expected action to assign a kind of #{@options[:expected_class]} " <<
-                "for #{@variable}, but got #{assigned_value.inspect} " <<
-                "(#{assigned_value.class.name})"
-              false
-            end
-          else
-            true
-          end
-        end
-
-        def equal_to_expected_value?
-          if @options[:check_value]
-            if @options[:expected_value] == assigned_value
-              @failure_message_for_should_not =
-                "Didn't expect action to assign #{@options[:expected_value].inspect} " <<
-                "for #{@variable}, but got it anyway"
-              true
-            else
-              @failure_message_for_should =
-                "Expected action to assign #{@options[:expected_value].inspect} " <<
-                "for #{@variable}, but got #{assigned_value.inspect}"
-              false
-            end
-          else
-            true
-          end
-        end
-
-        def normalize_expected_value!
-          if @options[:expectation_block]
-            @options[:expected_value] = @context.instance_eval(&@options[:expectation_block])
-          end
-        end
-
-        def assigned_value
-          @controller.instance_variable_get("@#{@variable}")
-        end
-      end
-    end
-  end
-end

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

@@ -1,83 +0,0 @@
-require 'active_support/deprecation'
-
-module Shoulda # :nodoc:
-  module Matchers
-    module ActionController # :nodoc:
-
-      # Ensures a controller responded with expected 'response' content type.
-      #
-      # You can pass an explicit content type such as 'application/rss+xml'
-      # or its symbolic equivalent :rss
-      # or a regular expression such as /rss/
-      #
-      # Example:
-      #
-      #   it { should respond_with_content_type(:xml)  }
-      #   it { should respond_with_content_type(:csv)  }
-      #   it { should respond_with_content_type(:atom) }
-      #   it { should respond_with_content_type(:yaml) }
-      #   it { should respond_with_content_type(:text) }
-      #   it { should respond_with_content_type('application/rss+xml')  }
-      #   it { should respond_with_content_type(/json/) }
-      def respond_with_content_type(content_type)
-        RespondWithContentTypeMatcher.new(content_type)
-      end
-
-      class RespondWithContentTypeMatcher # :nodoc:
-        def initialize(content_type)
-          ActiveSupport::Deprecation.warn 'The respond_with_content_type matcher is deprecated and will be removed in 2.0'
-          @content_type = look_up_content_type(content_type)
-        end
-
-        def description
-          "respond with content type of #{@content_type}"
-        end
-
-        def matches?(controller)
-          @controller = controller
-          content_type_matches_regexp? || content_type_matches_string?
-        end
-
-        def failure_message_for_should
-          "Expected #{expectation}"
-        end
-
-        def failure_message_for_should_not
-          "Did not expect #{expectation}"
-        end
-
-        protected
-
-        def content_type_matches_regexp?
-          if @content_type.is_a?(Regexp)
-            response_content_type =~ @content_type
-          end
-        end
-
-        def content_type_matches_string?
-          response_content_type == @content_type
-        end
-
-        def response_content_type
-          @controller.response.content_type.to_s
-        end
-
-        def look_up_by_extension(extension)
-          Mime::Type.lookup_by_extension(extension.to_s).to_s
-        end
-
-        def look_up_content_type(content_type)
-          if content_type.is_a?(Symbol)
-            look_up_by_extension(content_type)
-          else
-            content_type
-          end
-        end
-
-        def expectation
-          "content type to be #{@content_type}, but was #{response_content_type}"
-        end
-      end
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-require 'bourne'
-require 'active_support/deprecation'
-begin
-  require 'strong_parameters'
-rescue LoadError
-end
-
-module Shoulda
-  module Matchers
-    module ActionController
-      def permit(*attributes)
-        attributes_and_context = attributes + [self]
-        StrongParametersMatcher.new(*attributes_and_context)
-      end
-
-      class StrongParametersMatcher
-        def initialize(*attributes_and_context)
-          ActiveSupport::Deprecation.warn 'The strong_parameters matcher is deprecated and will be removed in 2.0'
-          @attributes = attributes_and_context[0...-1]
-          @context = attributes_and_context.last
-          @permitted_params = []
-        end
-
-        def for(action, options = {})
-          @action = action
-          @verb = options[:verb] || verb_for_action
-          self
-        end
-
-        def in_context(context)
-          @context = context
-          self
-        end
-
-        def matches?(controller = nil)
-          simulate_controller_action && parameters_difference.empty?
-        end
-
-        def does_not_match?(controller = nil)
-          simulate_controller_action && parameters_difference.present?
-        end
-
-        def failure_message
-          "Expected controller to permit #{parameters_difference.to_sentence}, but it did not."
-        end
-
-        def negative_failure_message
-          "Expected controller not to permit #{parameters_difference.to_sentence}, but it did."
-        end
-
-        private
-        attr_reader :verb, :action, :attributes, :context
-        attr_accessor :permitted_params
-
-        def simulate_controller_action
-          ensure_action_and_verb_present!
-          model_attrs = stubbed_model_attributes
-
-          context.send(verb, action)
-
-          verify_permit_call(model_attrs)
-        end
-
-        def verify_permit_call(model_attrs)
-          matcher = Mocha::API::HaveReceived.new(:permit).with do |*params|
-            self.permitted_params = params
-          end
-
-          matcher.matches?(model_attrs)
-        rescue Mocha::ExpectationError
-          false
-        end
-
-        def parameters_difference
-          attributes - permitted_params
-        end
-
-        def stubbed_model_attributes
-          extend Mocha::API
-
-          model_attrs = ::ActionController::Parameters.new(arbitrary_attributes)
-          model_attrs.stubs(:permit)
-          ::ActionController::Parameters.any_instance.stubs(:[]).returns(model_attrs)
-
-          model_attrs
-        end
-
-        def ensure_action_and_verb_present!
-          if action.blank?
-            raise ActionNotDefinedError
-          end
-          if verb.blank?
-            raise VerbNotDefinedError
-          end
-        end
-
-        def arbitrary_attributes
-          {:any_key => 'any_value'}
-        end
-
-        def verb_for_action
-          verb_lookup = { :create => :post, :update => :put }
-          verb_lookup[action]
-        end
-      end
-
-      class StrongParametersMatcher::ActionNotDefinedError < StandardError
-        def message
-          'You must specify the controller action using the #for method.'
-        end
-      end
-
-      class StrongParametersMatcher::VerbNotDefinedError < StandardError
-        def message
-          'You must specify an HTTP verb when using a non-RESTful action.' +
-          ' e.g. for(:authorize, :verb => :post)'
-        end
-      end
-    end
-  end
-end

data/lib/shoulda/matchers/action_mailer.rb

@@ -1,22 +0,0 @@
-require 'shoulda/matchers/action_mailer/have_sent_email_matcher'
-
-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_matcher.rb

@@ -1,260 +0,0 @@
-require 'active_support/deprecation'
-
-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').
-      #                               reply_to('reply-to-me@example.com').
-      #                               with_body(/spam/).
-      #                               to('myself@me.com') }
-      #
-      # Use values of instance variables
-      #   it {should have_sent_email.to {@user.email} }
-      def have_sent_email
-        HaveSentEmailMatcher.new(self)
-      end
-
-      class HaveSentEmailMatcher # :nodoc:
-
-        def initialize(context)
-          ActiveSupport::Deprecation.warn 'The have_sent_email matcher is deprecated and will be removed in 2.0'
-          @context = context
-        end
-
-        def in_context(context)
-          @context = context
-          self
-        end
-
-        def with_subject(email_subject = nil, &block)
-          @email_subject = email_subject
-          @email_subject_block = block
-          self
-        end
-
-        def from(sender = nil, &block)
-          @sender = sender
-          @sender_block = block
-          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
-          self
-        end
-
-        def with_part(content_type, body = nil, &block)
-          @parts ||= []
-          @parts << [/#{Regexp.escape(content_type)}/, body, content_type]
-          @parts_blocks ||= []
-          @parts_blocks << block
-          self
-        end
-
-        def to(recipient = nil, &block)
-          @recipient = recipient
-          @recipient_block = block
-          self
-        end
-
-        def cc(recipient = nil, &block)
-          @cc = recipient
-          @cc_block = block
-          self
-        end
-
-        def with_cc(recipients = nil, &block)
-          @cc_recipients = recipients
-          @cc_recipients_block = block
-          self
-        end
-
-        def bcc(recipient = nil, &block)
-          @bcc = recipient
-          @bcc_block = block
-          self
-        end
-
-        def with_bcc(recipients = nil, &block)
-          @bcc_recipients = recipients
-          @bcc_recipients_block = block
-          self
-        end
-
-        def multipart(flag = true)
-          @multipart = !!flag
-          self
-        end
-
-        def matches?(subject)
-          normalize_blocks
-          ::ActionMailer::Base.deliveries.any? do |mail|
-            mail_matches?(mail)
-          end
-        end
-
-        def failure_message_for_should
-          "Expected #{expectation}"
-        end
-
-        def failure_message_for_should_not
-          "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
-          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
-          description << " bcc #{@bcc.inspect}" if @bcc
-          description << " with bcc #{@bcc_recipients.inspect}" if @bcc_recipients
-          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 << " 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
-          expectation << " bcc #{@bcc.inspect}" if @bcc_failed
-          expectation << " with bcc #{@bcc_recipients.inspect}" if @bcc_recipients_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 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 || @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
-          @cc_recipients = @context.instance_eval(&@cc_recipients_block) if @cc_recipients_block
-          @bcc = @context.instance_eval(&@bcc_block) if @bcc_block
-          @bcc_recipients = @context.instance_eval(&@bcc_recipients_block) if @bcc_recipients_block
-
-          if @parts
-            @parts.each_with_index do |part, i|
-              part[1] = @context.instance_eval(&@parts_blocks[i]) if @parts_blocks[i]
-            end
-          end
-        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 match_array_in_array(target_array, match_array)
-          target_array.sort!
-          match_array.sort!
-
-          target_array.each_cons(match_array.size).include?(match_array)
-        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