rspec-rails 2.14.2 → 4.1.2

data/lib/rspec/rails/matchers/be_a_new.rb

@@ -1,76 +1,83 @@
-module RSpec::Rails::Matchers
-  class BeANew < RSpec::Matchers::BuiltIn::BaseMatcher
+module RSpec
+  module Rails
+    module Matchers
+      # @api private
+      #
+      # Matcher class for `be_a_new`. Should not be instantiated directly.
+      #
+      # @see RSpec::Rails::Matchers#be_a_new
+      class BeANew < RSpec::Rails::Matchers::BaseMatcher
+        # @private
+        def initialize(expected)
+          @expected = expected
+        end
 
-    def initialize(expected)
-      @expected = expected
-    end
+        # @private
+        def matches?(actual)
+          @actual = actual
+          actual.is_a?(expected) && actual.new_record? && attributes_match?(actual)
+        end
 
-    # @api private
-    def matches?(actual)
-      @actual = actual
-      actual.is_a?(expected) && actual.new_record? && attributes_match?(actual)
-    end
+        # @api public
+        # @see RSpec::Rails::Matchers#be_a_new
+        def with(expected_attributes)
+          attributes.merge!(expected_attributes)
+          self
+        end
 
-    # Use this to specify the specific attributes to match on the new record.
-    #
-    # @example
-    #
-    #     it "assigns a new Thing with the submitted attributes" do
-    #       post :create, :thing => { :name => "Illegal Value" }
-    #       assigns(:thing).should be_a_new(Thing).with(:name => nil)
-    #     end
-    def with(expected_attributes)
-      attributes.merge!(expected_attributes)
-      self
-    end
+        # @private
+        def failure_message
+          [].tap do |message|
+            unless actual.is_a?(expected) && actual.new_record?
+              message << "expected #{actual.inspect} to be a new #{expected.inspect}"
+            end
+            unless attributes_match?(actual)
+              describe_unmatched_attributes = surface_descriptions_in(unmatched_attributes)
+              if unmatched_attributes.size > 1
+                message << "attributes #{describe_unmatched_attributes.inspect} were not set on #{actual.inspect}"
+              else
+                message << "attribute #{describe_unmatched_attributes.inspect} was not set on #{actual.inspect}"
+              end
+            end
+          end.join(' and ')
+        end
 
-    # @api private
-    def failure_message_for_should
-      [].tap do |message|
-        unless actual.is_a?(expected) && actual.new_record?
-          message << "expected #{actual.inspect} to be a new #{expected.inspect}"
+      private
+
+        def attributes
+          @attributes ||= {}
         end
-        unless attributes_match?(actual)
-          if unmatched_attributes.size > 1
-            message << "attributes #{unmatched_attributes.inspect} were not set on #{actual.inspect}"
-          else
-            message << "attribute #{unmatched_attributes.inspect} was not set on #{actual.inspect}"
+
+        def attributes_match?(actual)
+          attributes.stringify_keys.all? do |key, value|
+            values_match?(value, actual.attributes[key])
           end
         end
-      end.join(' and ')
-    end
-
-    private
 
-    def attributes
-      @attributes ||= {}
-    end
-
-    def attributes_match?(actual)
-      attributes.stringify_keys.all? do |key, value|
-        actual.attributes[key].eql?(value)
+        def unmatched_attributes
+          attributes.stringify_keys.reject do |key, value|
+            values_match?(value, actual.attributes[key])
+          end
+        end
       end
-    end
 
-    def unmatched_attributes
-      attributes.stringify_keys.reject do |key, value|
-        actual.attributes[key].eql?(value)
+      # @api public
+      # Passes if actual is an instance of `model_class` and returns `true` for
+      # `new_record?`. Typically used to specify instance variables assigned to
+      # views by controller actions
+      #
+      # Use the `with` method to specify the specific attributes to match on the
+      # new record.
+      #
+      # @example
+      #     get :new
+      #     assigns(:thing).should be_a_new(Thing)
+      #
+      #     post :create, :thing => { :name => "Illegal Value" }
+      #     assigns(:thing).should be_a_new(Thing).with(:name => nil)
+      def be_a_new(model_class)
+        BeANew.new(model_class)
       end
     end
   end
-
-  # Passes if actual is an instance of `model_class` and returns `false` for
-  # `persisted?`. Typically used to specify instance variables assigned to
-  # views by controller actions
-  #
-  # @example
-  #
-  #     get :new
-  #     assigns(:thing).should be_a_new(Thing)
-  #
-  #     post :create, :thing => { :name => "Illegal Value" }
-  #     assigns(:thing).should be_a_new(Thing).with(:name => nil)
-  def be_a_new(model_class)
-    BeANew.new(model_class)
-  end
 end

data/lib/rspec/rails/matchers/be_new_record.rb

@@ -1,27 +1,30 @@
-module RSpec::Rails::Matchers
-  class BeANewRecord < RSpec::Matchers::BuiltIn::BaseMatcher
+module RSpec
+  module Rails
+    module Matchers
+      # @private
+      class BeANewRecord < RSpec::Rails::Matchers::BaseMatcher
+        def matches?(actual)
+          actual.new_record?
+        end
 
-    # @api private
-    def matches?(actual)
-      !actual.persisted?
-    end
+        def failure_message
+          "expected #{actual.inspect} to be a new record, but was persisted"
+        end
 
-    def failure_message_for_should
-      "expected #{actual.inspect} to be a new record, but was persisted"
-    end
+        def failure_message_when_negated
+          "expected #{actual.inspect} to be persisted, but was a new record"
+        end
+      end
 
-    def failure_message_for_should_not
-      "expected #{actual.inspect} to be persisted, but was a new record"
+      # @api public
+      # Passes if actual returns `true` for `new_record?`.
+      #
+      # @example
+      #     get :new
+      #     expect(assigns(:thing)).to be_new_record
+      def be_new_record
+        BeANewRecord.new
+      end
     end
   end
-
-  # Passes if actual returns `false` for `persisted?`.
-  #
-  # @example
-  #
-  #     get :new
-  #     assigns(:thing).should be_new_record
-  def be_new_record
-    BeANewRecord.new
-  end
 end

data/lib/rspec/rails/matchers/be_valid.rb

@@ -1,40 +1,49 @@
-module RSpec::Rails::Matchers
-  class BeValid < RSpec::Matchers::BuiltIn::Be
-    def initialize(*args)
-      @args = args
-    end
+module RSpec
+  module Rails
+    module Matchers
+      # @private
+      class BeValid < RSpec::Matchers::BuiltIn::Be
+        def initialize(*args)
+          @args = args
+        end
 
-    # @api private
-    def matches?(actual)
-      @actual = actual
-      actual.valid?(*@args)
-    end
+        def matches?(actual)
+          @actual = actual
+          actual.valid?(*@args)
+        end
 
-    # @api private
-    def failure_message_for_should
-      message = "expected #{actual.inspect} to be valid"
-      if actual.respond_to?(:errors)
-        message << ", but got errors: #{actual.errors.full_messages.join(', ')}"
-      end
+        def failure_message
+          message = "expected #{actual.inspect} to be valid"
 
-      message
-    end
+          if actual.respond_to?(:errors) && actual.method(:errors).arity < 1
+            errors = if actual.errors.respond_to?(:full_messages)
+                       actual.errors.full_messages
+                     else
+                       actual.errors
+                     end
 
-    # @api private
-    def failure_message_for_should_not
-      "expected #{actual.inspect} not to be valid"
-    end
-  end
+            message << ", but got errors: #{errors.map(&:to_s).join(', ')}"
+          end
 
-  # Passes if the given model instance's `valid?` method is true, meaning all
-  # of the `ActiveModel::Validations` passed and no errors exist. If a message
-  # is not given, a default message is shown listing each error.
-  #
-  # @example
-  #
-  #     thing = Thing.new
-  #     thing.should be_valid
-  def be_valid(*args)
-    BeValid.new(*args)
+          message
+        end
+
+        def failure_message_when_negated
+          "expected #{actual.inspect} not to be valid"
+        end
+      end
+
+      # @api public
+      # Passes if the given model instance's `valid?` method is true, meaning
+      # all of the `ActiveModel::Validations` passed and no errors exist. If a
+      # message is not given, a default message is shown listing each error.
+      #
+      # @example
+      #     thing = Thing.new
+      #     expect(thing).to be_valid
+      def be_valid(*args)
+        BeValid.new(*args)
+      end
+    end
   end
 end

data/lib/rspec/rails/matchers/have_enqueued_mail.rb

@@ -0,0 +1,198 @@
+# We require the minimum amount of rspec-mocks possible to avoid
+# conflicts with other mocking frameworks.
+# See: https://github.com/rspec/rspec-rails/issues/2252
+require "rspec/mocks/argument_matchers"
+require "rspec/rails/matchers/active_job"
+
+module RSpec
+  module Rails
+    module Matchers
+      # Matcher class for `have_enqueued_mail`. Should not be instantiated directly.
+      #
+      # @private
+      # @see RSpec::Rails::Matchers#have_enqueued_mail
+      class HaveEnqueuedMail < ActiveJob::HaveEnqueuedJob
+        MAILER_JOB_METHOD = 'deliver_now'.freeze
+
+        include RSpec::Mocks::ArgumentMatchers
+
+        def initialize(mailer_class, method_name)
+          super(nil)
+          @mailer_class = mailer_class
+          @method_name = method_name
+          @mail_args = []
+        end
+
+        def description
+          "enqueues #{mailer_class_name}.#{@method_name}"
+        end
+
+        def with(*args, &block)
+          @mail_args = args
+          block.nil? ? super : super(&yield_mail_args(block))
+        end
+
+        def matches?(block)
+          raise ArgumentError, 'have_enqueued_mail and enqueue_mail only work with block arguments' unless block.respond_to?(:call)
+
+          check_active_job_adapter
+          super
+        end
+
+        def failure_message
+          "expected to enqueue #{base_message}".tap do |msg|
+            msg << "\n#{unmatching_mail_jobs_message}" if unmatching_mail_jobs.any?
+          end
+        end
+
+        def failure_message_when_negated
+          "expected not to enqueue #{base_message}"
+        end
+
+        private
+
+        def base_message
+          [mailer_class_name, @method_name].compact.join('.').tap do |msg|
+            msg << " #{expected_count_message}"
+            msg << " with #{@mail_args}," if @mail_args.any?
+            msg << " on queue #{@queue}," if @queue
+            msg << " at #{@at.inspect}," if @at
+            msg << " but enqueued #{@matching_jobs.size}"
+          end
+        end
+
+        def expected_count_message
+          "#{message_expectation_modifier} #{@expected_number} #{@expected_number == 1 ? 'time' : 'times'}"
+        end
+
+        def mailer_class_name
+          @mailer_class ? @mailer_class.name : 'ActionMailer::Base'
+        end
+
+        def job_match?(job)
+          legacy_mail?(job) || parameterized_mail?(job) || unified_mail?(job)
+        end
+
+        def arguments_match?(job)
+          @args =
+            if @mail_args.any?
+              base_mailer_args + @mail_args
+            elsif @mailer_class && @method_name
+              base_mailer_args + [any_args]
+            elsif @mailer_class
+              [mailer_class_name, any_args]
+            else
+              []
+            end
+
+          super(job)
+        end
+
+        def base_mailer_args
+          [mailer_class_name, @method_name.to_s, MAILER_JOB_METHOD]
+        end
+
+        def yield_mail_args(block)
+          proc { |*job_args| block.call(*(job_args - base_mailer_args)) }
+        end
+
+        def check_active_job_adapter
+          return if ::ActiveJob::QueueAdapters::TestAdapter === ::ActiveJob::Base.queue_adapter
+
+          raise StandardError, "To use HaveEnqueuedMail matcher set `ActiveJob::Base.queue_adapter = :test`"
+        end
+
+        def unmatching_mail_jobs
+          @unmatching_jobs.select do |job|
+            job_match?(job)
+          end
+        end
+
+        def unmatching_mail_jobs_message
+          msg = "Queued deliveries:"
+
+          unmatching_mail_jobs.each do |job|
+            msg << "\n  #{mail_job_message(job)}"
+          end
+
+          msg
+        end
+
+        def mail_job_message(job)
+          mailer_method = job[:args][0..1].join('.')
+
+          mailer_args = job[:args][3..-1]
+          msg_parts = []
+          msg_parts << "with #{mailer_args}" if mailer_args.any?
+          msg_parts << "on queue #{job[:queue]}" if job[:queue] && job[:queue] != 'mailers'
+          msg_parts << "at #{Time.at(job[:at])}" if job[:at]
+
+          "#{mailer_method} #{msg_parts.join(', ')}".strip
+        end
+
+        def legacy_mail?(job)
+          job[:job] <= ActionMailer::DeliveryJob
+        end
+
+        def parameterized_mail?(job)
+          RSpec::Rails::FeatureCheck.has_action_mailer_parameterized? && job[:job] <= ActionMailer::Parameterized::DeliveryJob
+        end
+
+        def unified_mail?(job)
+          RSpec::Rails::FeatureCheck.has_action_mailer_unified_delivery? && job[:job] <= ActionMailer::MailDeliveryJob
+        end
+      end
+      # @api public
+      # Passes if an email has been enqueued inside block.
+      # May chain with to specify expected arguments.
+      # May chain at_least, at_most or exactly to specify a number of times.
+      # May chain at to specify a send time.
+      # May chain on_queue to specify a queue.
+      #
+      # @example
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer, :welcome)
+      #
+      #     # Using alias
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to enqueue_mail(MyMailer, :welcome)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer, :welcome).with(user)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer, :welcome).at_least(:once)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later
+      #     }.to have_enqueued_mail(MyMailer, :welcome).at_most(:twice)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later(wait_until: Date.tomorrow.noon)
+      #     }.to have_enqueued_mail(MyMailer, :welcome).at(Date.tomorrow.noon)
+      #
+      #     expect {
+      #       MyMailer.welcome(user).deliver_later(queue: :urgent_mail)
+      #     }.to have_enqueued_mail(MyMailer, :welcome).on_queue(:urgent_mail)
+      def have_enqueued_mail(mailer_class = nil, mail_method_name = nil)
+        HaveEnqueuedMail.new(mailer_class, mail_method_name)
+      end
+      alias_method :have_enqueued_email, :have_enqueued_mail
+      alias_method :enqueue_mail, :have_enqueued_mail
+      alias_method :enqueue_email, :have_enqueued_mail
+    end
+  end
+end