rspec-sidekiq 3.0.3 → 5.1.0

data/lib/rspec/sidekiq/helpers.rb

@@ -1,2 +1,4 @@
+# frozen_string_literal: true
+
 require 'rspec/core'
 require 'rspec/sidekiq/helpers/within_sidekiq_retries_exhausted_block'

data/lib/rspec/sidekiq/matchers/base.rb

@@ -0,0 +1,368 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Sidekiq
+    module Matchers
+      # @api private
+      class JobOptionParser
+        attr_reader :job
+
+        def initialize(job)
+          @job = job
+        end
+
+        def matches?(options)
+          with_context(**options)
+        end
+
+        private
+
+        def at_evaluator(value)
+          return value.nil? if job["at"].to_s.empty?
+          value == Time.at(job["at"]).to_i
+        end
+
+        def with_context(**expected_context)
+          expected_context.all? do |key, value|
+            if key == "at"
+              # send to custom evaluator
+              at_evaluator(value)
+            else
+              job.context.has_key?(key) && RSpec::Support::FuzzyMatcher.values_match?(value, job.context[key])
+            end
+          end
+        end
+      end
+
+      # @api private
+      class JobArguments
+        include RSpec::Mocks::ArgumentMatchers
+
+        def initialize(job)
+          self.job = job
+        end
+        attr_accessor :job
+
+        def matches?(expected_args)
+          matcher = RSpec::Mocks::ArgumentListMatcher.new(*expected_args)
+
+          matcher.args_match?(*unwrapped_arguments)
+        end
+
+        def unwrapped_arguments
+          args = job["args"]
+
+          return deserialized_active_job_args if active_job?
+
+          args
+        end
+
+        private
+
+        def active_job?
+          if RSpec::Sidekiq.configuration.sidekiq_gte_8?
+            job["class"] == "Sidekiq::ActiveJob::Wrapper"
+          else
+            job["class"] == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+          end
+        end
+
+        def deserialized_active_job_args
+          active_job_args = ActiveJob::Arguments.deserialize(active_job_original_args)
+
+          # ActiveJob 7 (aj7) changed deserialization structure, adding passed arguments
+          # in an aj-specific hash under the :args key
+          aj7_args_hash = active_job_args.detect { |arg| arg.respond_to?(:key) && arg.key?(:args) }
+
+          return active_job_args if aj7_args_hash.nil?
+
+          active_job_args.delete(aj7_args_hash)
+          active_job_args.concat(aj7_args_hash[:args])
+        end
+
+        def active_job_original_args
+          active_job_args = job["args"].detect { |arg| arg.is_a?(Hash) && arg.key?("arguments") }
+          active_job_args ||= {}
+          active_job_args["arguments"] || []
+        end
+      end
+
+      class EnqueuedJob
+        extend Forwardable
+        attr_reader :job
+        delegate :[] => :@job
+
+        def initialize(job)
+          @job = job
+        end
+
+        def jid
+          job["jid"]
+        end
+
+        def args
+          @args ||= JobArguments.new(job).unwrapped_arguments
+        end
+
+        def context
+          @context ||= job.except("args")
+        end
+
+        def ==(other)
+          super(other) unless other.is_a?(EnqueuedJob)
+
+          jid == other.jid
+        end
+        alias_method :eql?, :==
+      end
+
+      class EnqueuedJobs
+        include Enumerable
+        attr_reader :jobs
+
+        def initialize(klass)
+          @jobs = unwrap_jobs(klass.jobs).map { |job| EnqueuedJob.new(job) }
+        end
+
+        def includes?(arguments, options, count)
+          matching = jobs.filter { |job| matches?(job, arguments, options) }
+
+          case count[0]
+          when :exactly
+            matching.size == count[1]
+          when :at_least
+            matching.size >= count[1]
+          when :at_most
+            matching.size <= count[1]
+          else
+            matching.size > 0
+          end
+        end
+
+        def each(&block)
+          jobs.each(&block)
+        end
+
+        def minus!(other)
+          self unless other.is_a?(EnqueuedJobs)
+
+          @jobs -= other.jobs
+
+          self
+        end
+
+        private
+
+        def matches?(job, arguments, options)
+          arguments_matches?(job, arguments) &&
+            options_matches?(job, options)
+        end
+
+        def arguments_matches?(job, arguments)
+          job_arguments = JobArguments.new(job)
+
+          job_arguments.matches?(arguments)
+        end
+
+        def options_matches?(job, options)
+          parser = JobOptionParser.new(job)
+
+          parser.matches?(options)
+        end
+
+        def unwrap_jobs(jobs)
+          return jobs if jobs.is_a?(Array)
+          jobs.values.flatten
+        end
+      end
+
+      # @api private
+      class Base
+        include RSpec::Mocks::ArgumentMatchers
+        include RSpec::Matchers::Composable
+
+        attr_reader :expected_arguments, :expected_options, :klass, :actual_jobs, :expected_count
+
+        def initialize
+          @expected_arguments = [any_args]
+          @expected_options = {}
+          set_expected_count :positive, 1
+        end
+
+        def with(*expected_arguments)
+          @expected_arguments = normalize_arguments(expected_arguments)
+          self
+        end
+
+        def at(timestamp)
+          @expected_options["at"] = timestamp.to_time.to_i
+          self
+        end
+
+        def in(interval)
+          @expected_options["at"] = (Time.now.to_f + interval.to_f).to_i
+          self
+        end
+
+        def immediately
+          @expected_options["at"] = nil
+          self
+        end
+
+        def on(queue)
+          @expected_options["queue"] = queue
+          self
+        end
+
+        def once
+          set_expected_count :exactly, 1
+          self
+        end
+
+        def twice
+          set_expected_count :exactly, 2
+          self
+        end
+
+        def thrice
+          set_expected_count :exactly, 3
+          self
+        end
+
+        def exactly(n)
+          set_expected_count :exactly, n
+          self
+        end
+
+        def at_least(n)
+          set_expected_count :at_least, n
+          self
+        end
+
+        def at_most(n)
+          set_expected_count :at_most, n
+          self
+        end
+
+        def times
+          self
+        end
+        alias :time :times
+
+        def with_context(**kwargs)
+          raise ArgumentError, "Must specify keyword arguments to with_context" if kwargs.empty?
+
+          # gather keys and compare against currently set expected_options
+          # Someone could have accidentally used with_context and other
+          # chainables with different expectations. Better to explicitly
+          # inform loudly of clashes than let them overwrite silently
+          normalized = normalize_arguments(kwargs)
+          already_set = normalized.keys & @expected_options.keys
+          if already_set.any?
+            prettied = already_set.map { |key| "'#{key}'" }
+            raise ArgumentError, "There are already expectations against #{prettied.join(",")}. Did you already call other context chainables like `on` or `at`?"
+          end
+
+          # We're good, no accidental overwrites of expectations
+          @expected_options.merge!(normalized)
+
+          self
+        end
+
+        def set_expected_count(relativity, n)
+          n =
+            case n
+            when Integer then n
+            when :once   then 1
+            when :twice  then 2
+            when :thrice then 3
+            else raise ArgumentError, "Unsupported #{n} in '#{relativity} #{n}'. Use either an Integer, :once, :twice, or :thrice."
+            end
+          @expected_count = [relativity, n]
+        end
+
+        def description
+          "#{common_message} with arguments #{expected_arguments}"
+        end
+
+        def failure_message
+          message = ["expected to #{common_message}"]
+          if expected_arguments
+            message << "  with arguments:"
+            message << "    -#{formatted(expected_arguments)}"
+          end
+
+          if expected_options.any?
+            message << "  with context:"
+            message << "    -#{formatted(expected_options)}"
+          end
+
+          if actual_jobs.any?
+            message << "but enqueued only jobs"
+            if expected_arguments
+              job_messages = actual_jobs.map do |job|
+                base = ["  -JID:#{job.jid} with arguments:"]
+                base << "    -#{formatted(job.args)}"
+                if expected_options.any?
+                  base << "   with context: #{formatted(job.context)}"
+                end
+
+                base.join("\n")
+              end
+
+              message << job_messages.join("\n")
+            end
+          else
+            message << "but enqueued 0 jobs"
+          end
+
+          message.join("\n")
+        end
+
+        def common_message
+          "#{prefix_message} #{count_message} #{klass} #{expected_count.last == 1 ? "job" : "jobs"}"
+        end
+
+        def prefix_message
+          raise NotImplementedError
+        end
+
+        def count_message
+          case expected_count[0]
+          when :positive
+            "a"
+          when :exactly
+            expected_count[1]
+          else
+            "#{expected_count[0].to_s.gsub('_', ' ')} #{expected_count[1]}"
+          end
+        end
+
+        def failure_message_when_negated
+          message = ["expected not to #{common_message} but enqueued #{actual_jobs.count}"]
+          message << "  arguments: #{expected_arguments}" if expected_arguments.any?
+          message << "  options: #{expected_options}" if expected_options.any?
+          message.join("\n")
+        end
+
+        def formatted(thing)
+          RSpec::Support::ObjectFormatter.format(thing)
+        end
+
+        def normalize_arguments(args)
+          if args.is_a?(Array)
+            args.map{ |x| normalize_arguments(x) }
+          elsif args.is_a?(Hash)
+            args.each_with_object({}) do |(key, value), hash|
+              hash[key.to_s] = normalize_arguments(value)
+            end
+          elsif args.is_a?(Symbol)
+            args.to_s
+          else
+            args
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq/matchers/be_delayed.rb

@@ -1,12 +1,20 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers
+      include RSpec::Mocks::ArgumentMatchers
+
       def be_delayed(*expected_arguments)
         BeDelayed.new(*expected_arguments)
       end
 
       class BeDelayed
         def initialize(*expected_arguments)
+          raise <<~MSG if RSpec::Sidekiq.configuration.sidekiq_gte_7?
+            Use of the be_delayed matcher with Sidekiq 7+ is not possible. Try refactoring to a Sidekiq Job with `perform_at` or `perform_in` and the `have_enqueued_sidekiq_job` matcher
+          MSG
+
           @expected_arguments = expected_arguments
         end
 
@@ -34,7 +42,7 @@ module RSpec
           find_job @expected_method, @expected_arguments do |job|
             if @expected_interval
               created_enqueued_at = job['enqueued_at'] || job['created_at']
-              return job['at'].to_i == created_enqueued_at.to_i + @expected_interval
+              return job['at'].to_i == Time.at(created_enqueued_at.to_f + @expected_interval.to_f).to_i
             elsif @expected_time
               return job['at'].to_i == @expected_time.to_i
             else
@@ -58,8 +66,16 @@ module RSpec
 
         def find_job(method, arguments, &block)
           job = (::Sidekiq::Extensions::DelayedClass.jobs + ::Sidekiq::Extensions::DelayedModel.jobs + ::Sidekiq::Extensions::DelayedMailer.jobs).find do |job|
-            yaml = YAML.load(job['args'].first)
-            @expected_method_receiver == yaml[0] && @expected_method.name == yaml[1] && (@expected_arguments <=> yaml[2]) == 0
+            arg = job['args'].first
+            yaml = begin
+              YAML.load(arg, aliases: true) # Psych 4 required syntax
+            rescue ArgumentError
+              YAML.load(arg) # Pysch < 4 syntax
+            end
+
+            @expected_method_receiver == yaml[0] &&
+              method.name == yaml[1] &&
+              (arguments.empty? || RSpec::Mocks::ArgumentListMatcher.new(*arguments).args_match?(*yaml[2]))
           end
 
           yield job if block && job

data/lib/rspec/sidekiq/matchers/be_expired_in.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers

data/lib/rspec/sidekiq/matchers/be_processed_in.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers

data/lib/rspec/sidekiq/matchers/be_retryable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers

data/lib/rspec/sidekiq/matchers/be_unique.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers
@@ -25,6 +27,9 @@ module RSpec
             if !interval_matches? && @expected_interval
               "expected #{@klass} to be unique for #{@expected_interval} seconds, "\
               "but its interval was #{actual_interval} seconds"
+            elsif !expiration_matches?
+              "expected #{@klass} to be unique until #{@expected_expiration}, "\
+              "but its unique_until was #{actual_expiration || 'not specified'}"
             else
               "expected #{@klass} to be unique in the queue"
             end
@@ -33,7 +38,7 @@ module RSpec
           def matches?(job)
             @klass = job.is_a?(Class) ? job : job.class
             @actual = @klass.get_sidekiq_options[unique_key]
-            !!(value_matches? && interval_matches?)
+            !!(value_matches? && interval_matches? && expiration_matches?)
           end
 
           def for(interval)
@@ -41,6 +46,11 @@ module RSpec
             self
           end
 
+          def until(expiration)
+            @expected_expiration = expiration
+            self
+          end
+
           def interval_specified?
             @expected_interval
           end
@@ -49,6 +59,10 @@ module RSpec
             !interval_specified? || actual_interval == @expected_interval
           end
 
+          def expiration_matches?
+            @expected_expiration.nil? || actual_expiration ==  @expected_expiration
+          end
+
           def failure_message_when_negated
             "expected #{@klass} to not be unique in the queue"
           end
@@ -59,6 +73,10 @@ module RSpec
             @klass.get_sidekiq_options['unique_job_expiration']
           end
 
+          def actual_expiration
+            fail 'until is not supported for SidekiqUniqueJobs'
+          end
+
           def value_matches?
             [true, :all].include?(@actual)
           end
@@ -73,6 +91,10 @@ module RSpec
             @actual
           end
 
+          def actual_expiration
+            @klass.get_sidekiq_options['unique_until']
+          end
+
           def value_matches?
             @actual && @actual > 0
           end

data/lib/rspec/sidekiq/matchers/enqueue_sidekiq_job.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Sidekiq
+    module Matchers
+      # @api private
+      class EnqueueSidekiqJob < Base
+        attr_reader :original_jobs # Plus that from Base
+
+        def initialize(job_class)
+          super()
+          default = if RSpec::Sidekiq.configuration.sidekiq_gte_7?
+            ::Sidekiq::Job
+          else
+            ::Sidekiq::Worker
+          end
+
+          @klass = job_class || default
+        end
+
+        def matches?(proc)
+          raise ArgumentError, "Only block syntax supported for enqueue_sidekiq_job" unless Proc === proc
+
+          @original_jobs = EnqueuedJobs.new(@klass)
+          proc.call
+          @actual_jobs = EnqueuedJobs.new(@klass).minus!(original_jobs)
+
+          if @actual_jobs.none?
+            return false
+          end
+
+          @actual_jobs.includes?(expected_arguments, expected_options, expected_count)
+        end
+
+        def prefix_message
+          "enqueue"
+        end
+
+        def supports_block_expectations?
+          true
+        end
+      end
+
+      # @api public
+      #
+      # Passes if a Job is enqueued as the result of a block. Chainable `with`
+      # for arguments, `on` for queue, `at` for queued for a specific time, and
+      # `in` for a specific interval delay to being queued, `immediately` for
+      # queued without delay.
+      #
+      # @example
+      #
+      #   expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job
+      #
+      #   # A specific job class
+      #   expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job(AwesomeJob)
+      #
+      #   # with specific arguments
+      #   expect { AwesomeJob.perform_async "Awesome!" }.to enqueue_sidekiq_job.with("Awesome!")
+      #
+      #   # On a specific queue
+      #   expect { AwesomeJob.set(queue: "high").perform_async }.to enqueue_sidekiq_job.on("high")
+      #
+      #   # At a specific datetime
+      #   specific_time = 1.hour.from_now
+      #   expect { AwesomeJob.perform_at(specific_time) }.to enqueue_sidekiq_job.at(specific_time)
+      #
+      #   # In a specific interval (be mindful of freezing or managing time here)
+      #   freeze_time do
+      #     expect { AwesomeJob.perform_in(1.hour) }.to enqueue_sidekiq_job.in(1.hour)
+      #   end
+      #
+      #   # Without any delay
+      #   expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.immediately
+      #   expect { AwesomeJob.perform_at(1.hour.ago) }.to enqueue_sidekiq_job.immediately
+      #
+      #   # With specific context
+      #   expect { AwesomeJob.set(trace_id: "something").perform_async }.to enqueue_sidekiq_job.with_context(trace_id: anything)
+      #
+      #   ## Composable
+      #
+      #   expect do
+      #     AwesomeJob.perform_async
+      #     OtherJob.perform_async
+      #   end.to enqueue_sidekiq_job(AwesomeJob).and enqueue_sidekiq_job(OtherJob)
+      def enqueue_sidekiq_job(job_class = nil)
+        EnqueueSidekiqJob.new(job_class)
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq/matchers/have_enqueued_sidekiq_job.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RSpec
+  module Sidekiq
+    module Matchers
+      def have_enqueued_sidekiq_job(*expected_arguments)
+        HaveEnqueuedSidekiqJob.new expected_arguments
+      end
+
+      # @api private
+      class HaveEnqueuedSidekiqJob < Base
+        def initialize(expected_arguments)
+          super()
+          @expected_arguments = normalize_arguments(expected_arguments)
+        end
+
+        def matches?(job_class)
+          @klass = job_class
+
+          @actual_jobs = EnqueuedJobs.new(klass)
+
+          actual_jobs.includes?(
+            expected_arguments == [] ? any_args : expected_arguments,
+            expected_options,
+            expected_count
+          )
+        end
+
+        def prefix_message
+          "have enqueued"
+        end
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq/matchers/save_backtrace.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers

data/lib/rspec/sidekiq/matchers.rb

@@ -1,11 +1,19 @@
-require 'rspec/core'
-require 'rspec/sidekiq/matchers/be_delayed'
-require 'rspec/sidekiq/matchers/be_expired_in'
-require 'rspec/sidekiq/matchers/be_processed_in'
-require 'rspec/sidekiq/matchers/be_retryable'
-require 'rspec/sidekiq/matchers/be_unique'
-require 'rspec/sidekiq/matchers/have_enqueued_job'
-require 'rspec/sidekiq/matchers/save_backtrace'
+# frozen_string_literal: true
+
+require "rspec/core"
+require "rspec/matchers"
+require "rspec/mocks/argument_list_matcher"
+require "rspec/mocks/argument_matchers"
+
+require "rspec/sidekiq/matchers/base"
+require "rspec/sidekiq/matchers/be_delayed"
+require "rspec/sidekiq/matchers/be_expired_in"
+require "rspec/sidekiq/matchers/be_processed_in"
+require "rspec/sidekiq/matchers/be_retryable"
+require "rspec/sidekiq/matchers/be_unique"
+require "rspec/sidekiq/matchers/have_enqueued_sidekiq_job"
+require "rspec/sidekiq/matchers/save_backtrace"
+require "rspec/sidekiq/matchers/enqueue_sidekiq_job"
 
 RSpec.configure do |config|
   config.include RSpec::Sidekiq::Matchers

data/lib/rspec/sidekiq/sidekiq.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     class << self
@@ -14,7 +16,7 @@ end
 
 RSpec.configure do |config|
   config.before(:suite) do
-    message = '[rspec-sidekiq] WARNING! Sidekiq will *NOT* process jobs in this environment. See https://github.com/philostler/rspec-sidekiq/wiki/FAQ-&-Troubleshooting'
+    message = '[rspec-sidekiq] WARNING! Sidekiq will *NOT* process jobs in this environment. See https://github.com/wspurgin/rspec-sidekiq/wiki/FAQ-&-Troubleshooting'
     message = "\e[33m#{message}\e[0m" if RSpec::Sidekiq.configuration.enable_terminal_colours
     puts message if RSpec::Sidekiq.configuration.warn_when_jobs_not_processed_by_sidekiq
   end

data/lib/rspec/sidekiq/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
-    VERSION = '3.0.3'
+    VERSION = "5.1.0"
   end
 end