rspec-sidekiq 4.1.0 → 5.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4f0ece401056914cf478dc4657d19aad569156ebf40ee29ee85c36fc430cfc3
-  data.tar.gz: 858c2c49ae54497a5201eab4cb3d9179fbe21a1684b11663719dfd17dd198cb2
+  metadata.gz: e2bbe8c4c2097c67abf526af45ba5a3652fa83e898ccb82732f3639b83cc7d33
+  data.tar.gz: ec606df39e62123fd43d595c412f9dd70edc5c93389395b6d6e58f53deccf32a
 SHA512:
-  metadata.gz: 831dfa10d07623e001f2253072b6d8e5311a0d887661421ba3eb914fce8f5020b73e5c7bda02264ebf4be6b6f23c2b02f8082a149d7ff5836895525ae61d697c
-  data.tar.gz: fda99d4e3bd9b43fb55ed60e96f77fd0ca54156bc6dcc42df3f1d2fb9323fff9fc63f5495a595766e937d0214fff10736ef18b9b468fccf4b97b91b2aae5e296
+  metadata.gz: 7a601baf7161f039f0fb8b78a8ea3bed432b418431eae0b2e149365922f88d7f7c543450433175c4c16ba974ab91b8050ba1dc927619bbc2162a229f34de94ad
+  data.tar.gz: 2964a340caee3c386a99eb8a69a79552782ff2e9cfcdacd9140d50232939138f95297b313620ec658f1e21fa044d946e3f030d8a8a212b3b1af2e1c89a175c6a

data/CHANGES.md

@@ -1,3 +1,15 @@
+Unreleased
+---
+
+5.0.0
+---
+* [BREAKING] Make `have_enqueued_sidekiq_job()` match jobs with any arguments (same as `enqueue_sidekiq_job()` or `have_enqueued_sidekiq_job(any_args)`) (#215)
+* Add support for expected number of jobs to both `enqueue_sidekiq_job` and `have_enqueued_sidekiq_job` (#219)
+
+4.2.0
+---
+* Add warning about `have_enqueued_sidekiq_job` with no arguments (default will change in next major release) (#216, #217)
+
 4.1.0
 ---
 * Add Composable support to `enqueue_sidekiq_job` and

data/README.md

@@ -34,14 +34,16 @@ end
 ```
 
 ## Matchers
-* [enqueue_sidekiq_job](#enqueue_sidekiq_job)
-* [have_enqueued_sidekiq_job](#have_enqueued_sidekiq_job)
-* [be_processed_in](#be_processed_in)
-* [be_retryable](#be_retryable)
-* [be_unique](#be_unique)
-* [be_delayed (_deprecated_)](#be_delayed)
+* [```enqueue_sidekiq_job```](#enqueue_sidekiq_job)
+* [```have_enqueued_sidekiq_job```](#have_enqueued_sidekiq_job)
+* [```be_processed_in```](#be_processed_in)
+* [```be_retryable```](#be_retryable)
+* [```save_backtrace```](#save_backtrace)
+* [```be_unique```](#be_unique)
+* [```be_expired_in```](#be_expired_in)
+* [```be_delayed``` (_deprecated_)](#be_delayed)
 
-### enqueue_sidekiq_job
+### ```enqueue_sidekiq_job```
 
 *Describes that the block should enqueue a job*. Optionally specify the
 specific job class, arguments, timing, and other context
@@ -68,6 +70,17 @@ freeze_time do
   expect { AwesomeJob.perform_in(1.hour) }.to enqueue_sidekiq_job.in(1.hour)
 end
 
+# A specific number of times
+
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.once
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.exactly(1).time
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.exactly(:once)
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_least(1).time
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_least(:once)
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_most(2).times
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_most(:twice)
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job.at_most(:thrice)
+
 # Combine and chain them as desired
 expect { AwesomeJob.perform_at(specific_time, "Awesome!") }.to(
   enqueue_sidekiq_job(AwesomeJob)
@@ -83,13 +96,14 @@ expect do
 end.to enqueue_sidekiq_job(AwesomeJob).and enqueue_sidekiq_job(OtherJob)
 ```
 
-### have_enqueued_sidekiq_job
+### ```have_enqueued_sidekiq_job```
 
-Describes that there should be an enqueued job with the **specified arguments**
+Describes that there should be an enqueued job (with the specified arguments):
 
 ```ruby
 AwesomeJob.perform_async 'Awesome', true
 # test with...
+expect(AwesomeJob).to have_enqueued_sidekiq_job
 expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true)
 ```
 
@@ -106,6 +120,19 @@ expect(AwesomeJob).to have_enqueued_sidekiq_job(hash_excluding("bad_stuff" => an
 expect(AwesomeJob).to have_enqueued_sidekiq_job(any_args).and have_enqueued_sidekiq_job(hash_including("something" => "Awesome"))
 ```
 
+You can specify the number of jobs enqueued:
+
+```ruby
+expect(AwesomeJob).to have_enqueued_sidekiq_job.once
+expect(AwesomeJob).to have_enqueued_sidekiq_job.exactly(1).time
+expect(AwesomeJob).to have_enqueued_sidekiq_job.exactly(:once)
+expect(AwesomeJob).to have_enqueued_sidekiq_job.at_least(1).time
+expect(AwesomeJob).to have_enqueued_sidekiq_job.at_least(:once)
+expect(AwesomeJob).to have_enqueued_sidekiq_job.at_most(2).times
+expect(AwesomeJob).to have_enqueued_sidekiq_job.at_most(:twice)
+expect(AwesomeJob).to have_enqueued_sidekiq_job.at_most(:thrice)
+```
+
 #### Testing scheduled jobs
 
 *Use chainable matchers `#at`, `#in` and `#immediately`*
@@ -166,30 +193,7 @@ expect(Sidekiq::Worker).to have_enqueued_sidekiq_job(
 )
 ```
 
-#### Testing a job is _not_ enqueued
-
-The negative case for `have_enqueued_sidekiq_job` is provided, but it's
-important to remember that `have_enqueued_sidekiq_job` is an expectation that a
-job is enqueued _with specific arguments_. In other words, passing no arguments
-to `have_enqueued_sidekiq_job` is implicitly telling the matcher to look for
-jobs _without_ arguments.
-
-In short, unless you tell the matcher that _no_ jobs with _any_ arguments should be enqueued, you'll get the wrong result:
-
-```ruby
-# example this is a test that we'd expect to fail
-AwesomeJob.perform_async "Actually not awesome"
-
-### BAD - saying there shouldn't be a job enqueued _without_ args
-expect(AwesomeJob).not_to have_enqueued_sidekiq_job
-# => passes! 😱 Our job was enqueued _with_ args so no job exists without args.
-
-### Good
-expect(AwesomeJob).not_to have_enqueued_sidekiq_job(any_args)
-# => fails
-```
-
-### be_processed_in
+### ```be_processed_in```
 *Describes the queue that a job should be processed in*
 ```ruby
 sidekiq_options queue: :download
@@ -198,7 +202,7 @@ expect(AwesomeJob).to be_processed_in :download # or
 it { is_expected.to be_processed_in :download }
 ```
 
-### be_retryable
+### ```be_retryable```
 *Describes if a job should retry when there is a failure in its execution*
 ```ruby
 sidekiq_options retry: 5
@@ -213,7 +217,7 @@ expect(AwesomeJob).to be_retryable false # or
 it { is_expected.to be_retryable false }
 ```
 
-### save_backtrace
+### ```save_backtrace```
 *Describes if a job should save the error backtrace when there is a failure in its execution*
 ```ruby
 sidekiq_options backtrace: 5
@@ -230,7 +234,7 @@ it { is_expected.to_not save_backtrace } # or
 it { is_expected.to save_backtrace false }
 ```
 
-### be_unique
+### ```be_unique```
 *Describes when a job should be unique within its queue*
 ```ruby
 sidekiq_options unique: true
@@ -239,7 +243,7 @@ expect(AwesomeJob).to be_unique
 it { is_expected.to be_unique }
 ```
 
-### be_expired_in
+### ```be_expired_in```
 *Describes when a job should expire*
 ```ruby
 sidekiq_options expires_in: 1.hour
@@ -248,7 +252,7 @@ it { is_expected.to be_expired_in 1.hour }
 it { is_expected.to_not be_expired_in 2.hours }
 ```
 
-### be_delayed
+### ```be_delayed```
 
 **This matcher is deprecated**. Use of it with Sidekiq 7+ will raise an error.
 Sidekiq 7 [dropped Delayed

data/lib/rspec/sidekiq/configuration.rb

@@ -1,4 +1,5 @@
 require "rubygems"
+require "set"
 
 module RSpec
   module Sidekiq
@@ -14,11 +15,20 @@ module RSpec
         # Functional settings defaults
         @clear_all_enqueued_jobs = true
         @warn_when_jobs_not_processed_by_sidekiq = true
+        @silence_warnings = Set.new
       end
 
       def sidekiq_gte_7?
         Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new("7.0.0")
       end
+
+      def silence_warning(symbol)
+        @silence_warnings << symbol
+      end
+
+      def warn_for?(symbol)
+        !@silence_warnings.include?(symbol)
+      end
     end
   end
 end

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

@@ -118,8 +118,19 @@ module RSpec
           @jobs = unwrap_jobs(klass.jobs).map { |job| EnqueuedJob.new(job) }
         end
 
-        def includes?(arguments, options)
-          !!jobs.find { |job| matches?(job, arguments, options) }
+        def includes?(arguments, options, count)
+          matching = jobs.filter { |job| matches?(job, arguments, options) }
+
+          case count
+          in [:exactly, n]
+            matching.size == n
+          in [:at_least, n]
+            matching.size >= n
+          in [:at_most, n]
+            matching.size <= n
+          else
+            matching.size > 0
+          end
         end
 
         def each(&block)
@@ -164,11 +175,12 @@ module RSpec
         include RSpec::Mocks::ArgumentMatchers
         include RSpec::Matchers::Composable
 
-        attr_reader :expected_arguments, :expected_options, :klass, :actual_jobs
+        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)
@@ -196,12 +208,59 @@ module RSpec
           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 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
-          "have an enqueued #{klass} job with arguments #{expected_arguments}"
+          "#{common_message} with arguments #{expected_arguments}"
         end
 
         def failure_message
-          message = ["expected to have an enqueued #{klass} job"]
+          message = ["expected to #{common_message}"]
           if expected_arguments
             message << "  with arguments:"
             message << "    -#{formatted(expected_arguments)}"
@@ -213,7 +272,7 @@ module RSpec
           end
 
           if actual_jobs.any?
-            message << "but have enqueued only jobs"
+            message << "but enqueued only jobs"
             if expected_arguments
               job_messages = actual_jobs.map do |job|
                 base = "  -JID:#{job.jid} with arguments:"
@@ -227,13 +286,34 @@ module RSpec
 
               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
+          in [:positive, _]
+            "a"
+          in [:exactly, n]
+            n
+          in [relativity, n]
+            "#{relativity.to_s.gsub('_', ' ')} #{n}"
+          end
+        end
+
         def failure_message_when_negated
-          message = ["expected not to have an enqueued #{klass} job"]
+          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")

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

@@ -27,24 +27,11 @@ module RSpec
             return false
           end
 
-          @actual_jobs.includes?(expected_arguments, expected_options)
+          @actual_jobs.includes?(expected_arguments, expected_options, expected_count)
         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")
+        def prefix_message
+          "enqueue"
         end
 
         def supports_block_expectations?

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

@@ -17,7 +17,15 @@ module RSpec
 
           @actual_jobs = EnqueuedJobs.new(klass)
 
-          actual_jobs.includes?(expected_arguments, expected_options)
+          actual_jobs.includes?(
+            expected_arguments == [] ? any_args : expected_arguments,
+            expected_options,
+            expected_count
+          )
+        end
+
+        def prefix_message
+          "have enqueued"
         end
       end
     end

data/lib/rspec/sidekiq/matchers.rb

@@ -1,4 +1,5 @@
 require "rspec/core"
+require "rspec/matchers"
 require "rspec/mocks/argument_list_matcher"
 require "rspec/mocks/argument_matchers"
 

data/lib/rspec/sidekiq/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module Sidekiq
-    VERSION = "4.1.0"
+    VERSION = "5.0.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-sidekiq
 version: !ruby/object:Gem::Version
-  version: 4.1.0
+  version: 5.0.0
 platform: ruby
 authors:
 - Aidan Coyle
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-10-27 00:00:00.000000000 Z
+date: 2024-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core