rspec-sidekiq 3.0.3 → 4.1.0

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

@@ -0,0 +1,262 @@
+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) && job.context[key] == value
+            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?
+          job["class"] == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+        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)
+          !!jobs.find { |job| matches?(job, arguments, options) }
+        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
+
+        def initialize
+          @expected_arguments = [any_args]
+          @expected_options = {}
+        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 description
+          "have an enqueued #{klass} job with arguments #{expected_arguments}"
+        end
+
+        def failure_message
+          message = ["expected to have an enqueued #{klass} job"]
+          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 have enqueued only jobs"
+            if expected_arguments
+              job_messages = actual_jobs.map do |job|
+                base = "  -JID:#{job.jid} with arguments:"
+                base << "\n    -#{formatted(job.args)}"
+                if expected_options.any?
+                  base << "\n   with context: #{formatted(job.context)}"
+                end
+
+                base
+              end
+
+              message << job_messages.join("\n")
+            end
+          end
+
+          message.join("\n")
+        end
+
+        def failure_message_when_negated
+          message = ["expected not to have an enqueued #{klass} job"]
+          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,18 @@
 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 +40,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 +64,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/enqueue_sidekiq_job.rb

@@ -0,0 +1,99 @@
+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)
+        end
+
+        def failure_message
+          if @actual_jobs.none?
+            "expected to enqueue a job but enqueued 0"
+          else
+            super
+          end
+        end
+
+        def failure_message_when_negated
+          messages = ["expected not to enqueue a #{@klass} job but enqueued #{actual_jobs.count}"]
+
+          messages << "  with arguments #{formatted(expected_arguments)}" if expected_arguments
+          messages << "  with context #{formatted(expected_options)}" if expected_options
+
+          messages.join("\n")
+        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
+      #
+      #   ## 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,25 @@
+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, expected_options)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/sidekiq/matchers.rb

@@ -1,11 +1,16 @@
-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'
+require "rspec/core"
+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

@@ -14,7 +14,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,5 @@
 module RSpec
   module Sidekiq
-    VERSION = '3.0.3'
+    VERSION = "4.1.0"
   end
 end

data/lib/rspec-sidekiq.rb

@@ -1,3 +1,5 @@
+require 'forwardable'
+
 require 'sidekiq'
 require 'sidekiq/testing'