rspec-rails 2.14.2 → 3.9.1

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

@@ -0,0 +1,317 @@
+require "active_job/base"
+require "active_job/arguments"
+
+module RSpec
+  module Rails
+    module Matchers
+      # Namespace for various implementations of ActiveJob features
+      #
+      # @api private
+      module ActiveJob
+        # rubocop: disable Style/ClassLength
+        # @private
+        class Base < RSpec::Rails::Matchers::BaseMatcher
+          def initialize
+            @args = []
+            @queue = nil
+            @at = nil
+            @block = Proc.new {}
+            set_expected_number(:exactly, 1)
+          end
+
+          def with(*args, &block)
+            @args = args
+            @block = block if block.present?
+            self
+          end
+
+          def on_queue(queue)
+            @queue = queue
+            self
+          end
+
+          def at(date)
+            @at = date
+            self
+          end
+
+          def exactly(count)
+            set_expected_number(:exactly, count)
+            self
+          end
+
+          def at_least(count)
+            set_expected_number(:at_least, count)
+            self
+          end
+
+          def at_most(count)
+            set_expected_number(:at_most, count)
+            self
+          end
+
+          def times
+            self
+          end
+
+          def once
+            exactly(:once)
+          end
+
+          def twice
+            exactly(:twice)
+          end
+
+          def thrice
+            exactly(:thrice)
+          end
+
+          def failure_message
+            "expected to enqueue #{base_message}".tap do |msg|
+              if @unmatching_jobs.any?
+                msg << "\nQueued jobs:"
+                @unmatching_jobs.each do |job|
+                  msg << "\n  #{base_job_message(job)}"
+                end
+              end
+            end
+          end
+
+          def failure_message_when_negated
+            "expected not to enqueue #{base_message}"
+          end
+
+          def message_expectation_modifier
+            case @expectation_type
+            when :exactly then "exactly"
+            when :at_most then "at most"
+            when :at_least then "at least"
+            end
+          end
+
+          def supports_block_expectations?
+            true
+          end
+
+        private
+
+          def check(jobs)
+            @matching_jobs, @unmatching_jobs = jobs.partition do |job|
+              if arguments_match?(job) && other_attributes_match?(job)
+                args = deserialize_arguments(job)
+                @block.call(*args)
+                true
+              else
+                false
+              end
+            end
+            @matching_jobs_count = @matching_jobs.size
+
+            case @expectation_type
+            when :exactly then @expected_number == @matching_jobs_count
+            when :at_most then @expected_number >= @matching_jobs_count
+            when :at_least then @expected_number <= @matching_jobs_count
+            end
+          end
+
+          def base_message
+            "#{message_expectation_modifier} #{@expected_number} jobs,".tap do |msg|
+              msg << " with #{@args}," if @args.any?
+              msg << " on queue #{@queue}," if @queue
+              msg << " at #{@at.inspect}," if @at
+              msg << " but enqueued #{@matching_jobs_count}"
+            end
+          end
+
+          def base_job_message(job)
+            msg_parts = []
+            msg_parts << "with #{deserialize_arguments(job)}" if job[:args].any?
+            msg_parts << "on queue #{job[:queue]}" if job[:queue]
+            msg_parts << "at #{Time.at(job[:at])}" if job[:at]
+
+            "#{job[:job].name} job".tap do |msg|
+              msg << " #{msg_parts.join(', ')}" if msg_parts.any?
+            end
+          end
+
+          def arguments_match?(job)
+            if @args.any?
+              deserialized_args = deserialize_arguments(job)
+              RSpec::Mocks::ArgumentListMatcher.new(*@args).args_match?(*deserialized_args)
+            else
+              true
+            end
+          end
+
+          def other_attributes_match?(job)
+            serialized_attributes.all? { |key, value| value == job[key] }
+          end
+
+          def serialized_attributes
+            {}.tap do |attributes|
+              attributes[:at]    = serialized_at if @at
+              attributes[:queue] = @queue if @queue
+              attributes[:job]   = @job if @job
+            end
+          end
+
+          def serialized_at
+            @at == :no_wait ? nil : @at.to_f
+          end
+
+          def set_expected_number(relativity, count)
+            @expectation_type = relativity
+            @expected_number = case count
+                               when :once then 1
+                               when :twice then 2
+                               when :thrice then 3
+                               else Integer(count)
+                               end
+          end
+
+          def deserialize_arguments(job)
+            ::ActiveJob::Arguments.deserialize(job[:args])
+          rescue ::ActiveJob::DeserializationError
+            job[:args]
+          end
+
+          def queue_adapter
+            ::ActiveJob::Base.queue_adapter
+          end
+        end
+        # rubocop: enable Style/ClassLength
+
+        # @private
+        class HaveEnqueuedJob < Base
+          def initialize(job)
+            super()
+            @job = job
+          end
+
+          def matches?(proc)
+            raise ArgumentError, "have_enqueued_job and enqueue_job only support block expectations" unless Proc === proc
+
+            original_enqueued_jobs_count = queue_adapter.enqueued_jobs.count
+            proc.call
+            in_block_jobs = queue_adapter.enqueued_jobs.drop(original_enqueued_jobs_count)
+
+            check(in_block_jobs)
+          end
+
+          def does_not_match?(proc)
+            set_expected_number(:at_least, 1)
+
+            !matches?(proc)
+          end
+        end
+
+        # @private
+        class HaveBeenEnqueued < Base
+          def matches?(job)
+            @job = job
+            check(queue_adapter.enqueued_jobs)
+          end
+
+          def does_not_match?(proc)
+            set_expected_number(:at_least, 1)
+
+            !matches?(proc)
+          end
+        end
+      end
+
+      # @api public
+      # Passes if a job has been enqueued inside block. May chain at_least, at_most or exactly to specify a number of times.
+      #
+      # @example
+      #     expect {
+      #       HeavyLiftingJob.perform_later
+      #     }.to have_enqueued_job
+      #
+      #     # Using alias
+      #     expect {
+      #       HeavyLiftingJob.perform_later
+      #     }.to enqueue_job
+      #
+      #     expect {
+      #       HelloJob.perform_later
+      #       HeavyLiftingJob.perform_later
+      #     }.to have_enqueued_job(HelloJob).exactly(:once)
+      #
+      #     expect {
+      #       3.times { HelloJob.perform_later }
+      #     }.to have_enqueued_job(HelloJob).at_least(2).times
+      #
+      #     expect {
+      #       HelloJob.perform_later
+      #     }.to have_enqueued_job(HelloJob).at_most(:twice)
+      #
+      #     expect {
+      #       HelloJob.perform_later
+      #       HeavyLiftingJob.perform_later
+      #     }.to have_enqueued_job(HelloJob).and have_enqueued_job(HeavyLiftingJob)
+      #
+      #     expect {
+      #       HelloJob.set(wait_until: Date.tomorrow.noon, queue: "low").perform_later(42)
+      #     }.to have_enqueued_job.with(42).on_queue("low").at(Date.tomorrow.noon)
+      #
+      #     expect {
+      #       HelloJob.set(queue: "low").perform_later(42)
+      #     }.to have_enqueued_job.with(42).on_queue("low").at(:no_wait)
+      #
+      #     expect {
+      #       HelloJob.perform_later('rspec_rails', 'rails', 42)
+      #     }.to have_enqueued_job.with { |from, to, times|
+      #       # Perform more complex argument matching using dynamic arguments
+      #       expect(from).to include "_#{to}"
+      #     }
+      def have_enqueued_job(job = nil)
+        check_active_job_adapter
+        ActiveJob::HaveEnqueuedJob.new(job)
+      end
+      alias_method :enqueue_job, :have_enqueued_job
+
+      # @api public
+      # Passes if a job has been enqueued. May chain at_least, at_most or exactly to specify a number of times.
+      #
+      # @example
+      #     before { ActiveJob::Base.queue_adapter.enqueued_jobs.clear }
+      #
+      #     HeavyLiftingJob.perform_later
+      #     expect(HeavyLiftingJob).to have_been_enqueued
+      #
+      #     HelloJob.perform_later
+      #     HeavyLiftingJob.perform_later
+      #     expect(HeavyLiftingJob).to have_been_enqueued.exactly(:once)
+      #
+      #     3.times { HelloJob.perform_later }
+      #     expect(HelloJob).to have_been_enqueued.at_least(2).times
+      #
+      #     HelloJob.perform_later
+      #     expect(HelloJob).to enqueue_job(HelloJob).at_most(:twice)
+      #
+      #     HelloJob.perform_later
+      #     HeavyLiftingJob.perform_later
+      #     expect(HelloJob).to have_been_enqueued
+      #     expect(HeavyLiftingJob).to have_been_enqueued
+      #
+      #     HelloJob.set(wait_until: Date.tomorrow.noon, queue: "low").perform_later(42)
+      #     expect(HelloJob).to have_been_enqueued.with(42).on_queue("low").at(Date.tomorrow.noon)
+      #
+      #     HelloJob.set(queue: "low").perform_later(42)
+      #     expect(HelloJob).to have_been_enqueued.with(42).on_queue("low").at(:no_wait)
+      def have_been_enqueued
+        check_active_job_adapter
+        ActiveJob::HaveBeenEnqueued.new
+      end
+
+    private
+
+      # @private
+      def check_active_job_adapter
+        return if ::ActiveJob::QueueAdapters::TestAdapter === ::ActiveJob::Base.queue_adapter
+        raise StandardError, "To use ActiveJob matchers set `ActiveJob::Base.queue_adapter = :test`"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,184 @@
+module RSpec
+  module Rails
+    module Matchers
+      # @ api private
+      class BaseMatcher
+        include RSpec::Matchers::Composable
+
+        # @api private
+        # Used to detect when no arg is passed to `initialize`.
+        # `nil` cannot be used because it's a valid value to pass.
+        UNDEFINED = Object.new.freeze
+
+        # @private
+        attr_reader :actual, :expected, :rescued_exception
+
+        # @private
+        attr_writer :matcher_name
+
+        def initialize(expected = UNDEFINED)
+          @expected = expected unless UNDEFINED.equal?(expected)
+        end
+
+        # @api private
+        # Indicates if the match is successful. Delegates to `match`, which
+        # should be defined on a subclass. Takes care of consistently
+        # initializing the `actual` attribute.
+        def matches?(actual)
+          @actual = actual
+          match(expected, actual)
+        end
+
+        # @api private
+        # Used to wrap a block of code that will indicate failure by
+        # raising one of the named exceptions.
+        #
+        # This is used by rspec-rails for some of its matchers that
+        # wrap rails' assertions.
+        def match_unless_raises(*exceptions)
+          exceptions.unshift Exception if exceptions.empty?
+          begin
+            yield
+            true
+          rescue *exceptions => @rescued_exception
+            false
+          end
+        end
+
+        # @api private
+        # Generates a description using {RSpec::Matchers::EnglishPhrasing}.
+        # @return [String]
+        def description
+          desc = RSpec::Matchers::EnglishPhrasing.split_words(self.class.matcher_name)
+          desc << RSpec::Matchers::EnglishPhrasing.list(@expected) if defined?(@expected)
+          desc
+        end
+
+        # @api private
+        # Matchers are not diffable by default. Override this to make your
+        # subclass diffable.
+        def diffable?
+          false
+        end
+
+        # @api private
+        # Most matchers are value matchers (i.e. meant to work with `expect(value)`)
+        # rather than block matchers (i.e. meant to work with `expect { }`), so
+        # this defaults to false. Block matchers must override this to return true.
+        def supports_block_expectations?
+          false
+        end
+
+        # @api private
+        def expects_call_stack_jump?
+          false
+        end
+
+        # @private
+        def expected_formatted
+          RSpec::Support::ObjectFormatter.format(@expected)
+        end
+
+        # @private
+        def actual_formatted
+          RSpec::Support::ObjectFormatter.format(@actual)
+        end
+
+        # @private
+        def self.matcher_name
+          @matcher_name ||= underscore(name.split('::').last)
+        end
+
+        # @private
+        def matcher_name
+          if defined?(@matcher_name)
+            @matcher_name
+          else
+            self.class.matcher_name
+          end
+        end
+
+        # @private
+        # Borrowed from ActiveSupport.
+        def self.underscore(camel_cased_word)
+          word = camel_cased_word.to_s.dup
+          word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+          word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+          word.tr!('-', '_')
+          word.downcase!
+          word
+        end
+        private_class_method :underscore
+
+      private
+
+        def assert_ivars(*expected_ivars)
+          return unless (expected_ivars - present_ivars).any?
+          ivar_list = RSpec::Matchers::EnglishPhrasing.list(expected_ivars)
+          raise "#{self.class.name} needs to supply#{ivar_list}"
+        end
+
+        if RUBY_VERSION.to_f < 1.9
+          # :nocov:
+          def present_ivars
+            instance_variables.map(&:to_sym)
+          end
+          # :nocov:
+        else
+          alias present_ivars instance_variables
+        end
+
+        # @private
+        module HashFormatting
+          # `{ :a => 5, :b => 2 }.inspect` produces:
+          #
+          #     {:a=>5, :b=>2}
+          #
+          # ...but it looks much better as:
+          #
+          #     {:a => 5, :b => 2}
+          #
+          # This is idempotent and safe to run on a string multiple times.
+          def improve_hash_formatting(inspect_string)
+            inspect_string.gsub(/(\S)=>(\S)/, '\1 => \2')
+          end
+          module_function :improve_hash_formatting
+        end
+
+        include HashFormatting
+
+        # @api private
+        # Provides default implementations of failure messages, based on the `description`.
+        module DefaultFailureMessages
+          # @api private
+          # Provides a good generic failure message. Based on `description`.
+          # When subclassing, if you are not satisfied with this failure message
+          # you often only need to override `description`.
+          # @return [String]
+          def failure_message
+            "expected #{description_of @actual} to #{description}".dup
+          end
+
+          # @api private
+          # Provides a good generic negative failure message. Based on `description`.
+          # When subclassing, if you are not satisfied with this failure message
+          # you often only need to override `description`.
+          # @return [String]
+          def failure_message_when_negated
+            "expected #{description_of @actual} not to #{description}".dup
+          end
+
+          # @private
+          def self.has_default_failure_messages?(matcher)
+            matcher.method(:failure_message).owner == self &&
+              matcher.method(:failure_message_when_negated).owner == self
+          rescue NameError
+            false
+          end
+        end
+
+        include DefaultFailureMessages
+      end
+    end
+  end
+end

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