rspec-sidekiq 3.0.3 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dd244416f99c35639675efb4b3473dd9741d512c
-  data.tar.gz: 6fa5eb3e029086fe4d316a6a9896b7acddb834de
+SHA256:
+  metadata.gz: 56ce84afbf67491fa24da1f527bced61c54afa3d62dbb50e6a09a89e8c0bc16c
+  data.tar.gz: 5b4a368bbb098d580713009fb9381d66326c37eced31c91eaf85b43158a85db5
 SHA512:
-  metadata.gz: fe360471b5c79f74e4af320881d97d0d26ec0cf837a8309e8b898221d71c63bce2d2a750d32b9427dfb931dc4a83837e4c2e3e6b1ddd6a5ed17050205f7e4aa3
-  data.tar.gz: 1d0913303fbdd4c72aea0248e815d4842a5c8fe9d0a338c6cad7cf0dbd59fc7145899718d51185444c72023772605e30099326c8481345927f083c9db91df7e6
+  metadata.gz: 4ec18b3d6ceff7390807d7358259b44f236ca6d81b1b9175c069b6c4912041b914082042a5396c7cf1eb0b602a5448d9aacd9e23b3cee211ad7222c3ec3719af
+  data.tar.gz: 4f0232e7b482f7c565a5cca98be9b7143e51adbe6015329f9d052e393fd857fe97e2449fb53f9e3d209ff6319c54e23e9e2919e7003a44bfc00834692039eed0

data/CHANGES.md

@@ -1,3 +1,64 @@
+Unreleased
+---
+* Add `until` matcher for Sidekiq Enterprise unique jobs (#232, #147)
+* Add `with_context` matcher for matching against job contexts (#222)
+* Support for Sidekiq 8 (#233)
+* Add `frozen_string_literal: true` (#220)
+* Fix queue always nil in default_retries_exhausted_message (#229)
+* Fix pattern matching warnings on Ruby 2.7 (#227)
+
+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
+  `have_enqueued_sidekiq_job` (#211)
+* Add `immediately` to specify that a job should be enqueued without any delay (#210)
+
+4.0.2
+---
+* Explicitly require forwardable (#204)
+
+4.0.1
+---
+* Restore the old normalizing expected args behavior with symbols (#205)
+  * fixes an unintentional breaking change in 4.0.0
+
+4.0.0
+---
+* [BREAKING] Dropped support for matching jobs on ActiveJob's private API args, (e.g. `_aj_globalid` and `_aj_ruby2_keywords`). `_aj_globalid` can be replaced with the object itself, e.g. `have_enqueued_sidekiq_job(user)`.
+* [BREAKING] Dropped support for Ruby 2.6
+* [BREAKING] Mocking Sidekiq::Batch is now _opt in_ (was opt-out) by default
+* [BREAKING] Dropped the `have_enqueued_job` matcher (deprecated since v3)
+* [BREAKING] Dropped support for Sidekiq <5
+* [BREAKING] Dropped support for Rails 5
+* Add support for Sidekiq 7 (#192)
+* Add support for builtin argument matchers from rspec mocks for
+  `have_enqueued_sidekiq_job` (#200)
+* Add `#on` to `have_enqueued_sidekiq_job` to support testing queue at enqueue time (#197)
+* Add `enqueue_sidekiq_job` for block-syntax style expectations
+* Clarified `have_enqueued_sidekiq_job` error message to make it clear that the "actual arguments" list is an array of argument-lists across all enqueued jobs. (#195)
+* Fix `in` and `at` evaluation to match Sidekiq (#194)
+* Fix `be_delayed` argument matcher (#196)
+* Fix argument matching ignoring order (#200)
+* Fix `be_delayed` time math when using `delay_for` (#198)
+
+3.1.0
+---
+* Add support for latest ruby and Rails 5 (coding-bunny #156)
+* Support `Class#method` notation in batch callback (caalberts #155)
+* Fix bug with time comparison in delayed jobs (geeosh #153 with help from col)
+* remove usage of `Integer#blank?` (lanej #152)
+* Add `NullBatch#description` (dsantosmerino #139)
+* README updates (BenMusch #142, akihikodaki #141, wpolicarpo #160)
+
 3.0.3
 ---
 * Re-splat arguments for the have_enqueued_job alias (aprescott #136)

data/LICENSE

@@ -1,5 +1,17 @@
 The MIT License (MIT)
 
+Copyright (c) 2023 Will Spurgin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Elements of this software and associated documentation files are covered by the following license:
+
+The MIT License (MIT)
+
 Copyright (c) 2014, 2015 Phil Ostler
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

data/README.md

@@ -1,23 +1,7 @@
-**Welcome @wpolicarpo and @packrat386 as new maintainers for `rspec-sidekiq`!**
+[![Gem Version](https://badge.fury.io/rb/rspec-sidekiq.svg)](https://badge.fury.io/rb/rspec-sidekiq)
+[![Github Actions CI][github_actions_badge]][github_actions]
 
-# RSpec for Sidekiq
-
-[![RubyGems][gem_version_badge]][ruby_gems]
-[![Code Climate][code_climate_badge]][code_climate]
-[![Travis CI][travis_ci_badge]][travis_ci]
-[![Coveralls][coveralls_badge]][coveralls]
-[![Gemnasium][gemnasium_badge]][gemnasium]
-
-***Simple testing of Sidekiq jobs via a collection of matchers and helpers***
-
-[RubyGems][ruby_gems] |
-[Code Climate][code_climate] |
-[GitHub][github] |
-[Travis CI][travis_ci] |
-[Coveralls][coveralls] |
-[Gemnasium][gemnasium] |
-[RubyDoc][ruby_doc] |
-[Ruby Toolbox][ruby_toolbox]
+Simple testing of Sidekiq jobs via a collection of matchers and helpers.
 
 [Jump to Matchers »](#matchers) | [Jump to Helpers »](#helpers)
 
@@ -48,36 +32,184 @@ end
 ```
 
 ## Matchers
-* [be_delayed](#be_delayed)
-* [be_processed_in](#be_processed_in)
-* [be_retryable](#be_retryable)
-* [be_unique](#be_unique)
-* [have_enqueued_sidekiq_job](#have_enqueued_sidekiq_job)
+* [```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```
+
+*Describes that the block should enqueue a job*. Optionally specify the
+specific job class, arguments, timing, and other context
 
-### be_delayed
-*Describes a method that should be invoked asynchronously (See [Sidekiq Delayed Extensions][sidekiq_wiki_delayed_extensions])*
 ```ruby
-Object.delay.is_nil? # delay
-expect(Object.method :is_nil?).to be_delayed
-Object.delay.is_a? Object # delay with argument
-expect(Object.method :is_a?).to be_delayed(Object)
+# Basic
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job
 
-Object.delay_for(1.hour).is_nil? # delay for
-expect(Object.method :is_nil?).to be_delayed.for 1.hour
-Object.delay_for(1.hour).is_a? Object # delay for with argument
-expect(Object.method :is_a?).to be_delayed(Object).for 1.hour
+# A specific job class
+expect { AwesomeJob.perform_async }.to enqueue_sidekiq_job(AwesomeJob)
 
-Object.delay_until(1.hour.from_now).is_nil? # delay until
-expect(Object.method :is_nil?).to be_delayed.until 1.hour.from_now
-Object.delay_until(1.hour.from_now).is_a? Object # delay until with argument
-expect(Object.method :is_a?).to be_delayed(Object).until 1.hour.from_now
+# with specific arguments
+expect { AwesomeJob.perform_async "Awesome!" }.to enqueue_sidekiq_job.with("Awesome!")
 
-#Rails Mailer
-MyMailer.delay.some_mail
-expect(MyMailer.instance_method :some_mail).to be_delayed
+# 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
+
+# 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)
+
+# With specific context:
+# Useful for testing anything `set` on the job, including
+# overrides to things like `retry`
+expect {
+  AwesomeJob.set(trace_id: "something").perform_async
+}.to enqueue_sidekiq_job.with_context(trace_id: anything)
+
+expect {
+  AwesomeJob.set(retry: 5).perform_async
+}.to enqueue_sidekiq_job.with_context(retry: 5)
+
+# Combine and chain them as desired
+expect { AwesomeJob.perform_at(specific_time, "Awesome!") }.to(
+  enqueue_sidekiq_job(AwesomeJob)
+  .with("Awesome!")
+  .on("default")
+  .at(specific_time)
+)
+
+# Also composable
+expect do
+  AwesomeJob.perform_async
+  OtherJob.perform_async
+end.to enqueue_sidekiq_job(AwesomeJob).and enqueue_sidekiq_job(OtherJob)
+```
+
+### ```have_enqueued_sidekiq_job```
+
+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)
+```
+
+You can use the built-in RSpec args matchers too:
+```ruby
+AwesomeJob.perform_async({"something" => "Awesome", "extra" => "stuff"})
+
+# using built-in matchers from rspec-mocks:
+expect(AwesomeJob).to have_enqueued_sidekiq_job(hash_including("something" => "Awesome"))
+expect(AwesomeJob).to have_enqueued_sidekiq_job(any_args)
+expect(AwesomeJob).to have_enqueued_sidekiq_job(hash_excluding("bad_stuff" => anything))
+
+# composable as well
+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)
+```
+
+Likewise, specify what should be in the context:
+```ruby
+AwesomeJob.set(trace_id: "something").perform_async
+
+expect(AwesomeJob).to have_enqueued_sidekiq_job.with_context(trace_id: anything)
+```
+
+#### Testing scheduled jobs
+
+*Use chainable matchers `#at`, `#in` and `#immediately`*
+
+```ruby
+time = 5.minutes.from_now
+AwesomeJob.perform_at time, 'Awesome', true
+# test with...
+expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true).at(time)
+```
+```ruby
+AwesomeJob.perform_in 5.minutes, 'Awesome', true
+# test with...
+expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true).in(5.minutes)
+```
+
+```ruby
+# Job scheduled for a date in the past are enqueued immediately.
+AwesomeJob.perform_later 5.minutes.ago, 'Awesome', true # equivalent to: AwesomeJob.perform_async 'Awesome', true
+# test with...
+expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true).immediately
 ```
 
-### be_processed_in
+#### Testing queue set for job
+
+Use the chainable `#on` matcher
+
+```ruby
+class AwesomeJob
+  include Sidekiq::Job
+
+  sidekiq_options queue: :low
+end
+
+AwesomeJob.perform_async("a little awesome")
+
+# test with..
+expect(AwesomeJob).to have_enqueued_sidekiq_job("a little awesome").on("low")
+
+# Setting the queue when enqueuing
+AwesomeJob.set(queue: "high").perform_async("Very Awesome!")
+
+expect(AwesomeJob).to have_enqueued_sidekiq_job("Very Awesome!").on("high")
+```
+
+#### Testing ActiveMailer jobs
+
+```ruby
+user = User.first
+AwesomeActionMailer.invite(user, true).deliver_later
+
+expect(Sidekiq::Worker).to have_enqueued_sidekiq_job(
+  "AwesomeActionMailer",
+  "invite",
+  "deliver_now",
+  user,
+  true
+)
+```
+
+### ```be_processed_in```
 *Describes the queue that a job should be processed in*
 ```ruby
 sidekiq_options queue: :download
@@ -86,8 +218,12 @@ expect(AwesomeJob).to be_processed_in :download # or
 it { is_expected.to be_processed_in :download }
 ```
 
-### be_retryable
-*Describes if a job should retry when there is a failure in it's execution*
+### ```be_retryable```
+*Describes if a job should retry when there is a failure in its execution*
+
+Note: this only tests against the `retry` option in the job's Sidekiq options.
+To test an enqueued job's retry, i.e. `AwesomeJob.set(retry: 5)`, use
+`with_context`
 ```ruby
 sidekiq_options retry: 5
 # test with...
@@ -101,14 +237,14 @@ expect(AwesomeJob).to be_retryable false # or
 it { is_expected.to be_retryable false }
 ```
 
-### save_backtrace
-*Describes if a job should save the error backtrace when there is a failure in it's execution*
+### ```save_backtrace```
+*Describes if a job should save the error backtrace when there is a failure in its execution*
 ```ruby
 sidekiq_options backtrace: 5
 # test with...
 expect(AwesomeJob).to save_backtrace # or
 it { is_expected.to save_backtrace }
-# ...or alternatively specifiy the number of lines that should be saved
+# ...or alternatively specify the number of lines that should be saved
 expect(AwesomeJob).to save_backtrace 5 # or
 it { is_expected.to save_backtrace 5 }
 # ...or when it should not save the backtrace
@@ -118,16 +254,35 @@ it { is_expected.to_not save_backtrace } # or
 it { is_expected.to save_backtrace false }
 ```
 
-### be_unique
-*Describes when a job should be unique within it's queue*
+### ```be_unique```
+
+:warning: This is intended to for Sidekiq Enterprise unique job implementation.
+There is _limited_ support for Sidekiq Unique Jobs, but compatibility is not
+guaranteed.
+
+*Describes when a job should be unique within its queue*
 ```ruby
-sidekiq_options unique: true
+sidekiq_options unique_for: 1.hour
 # test with...
 expect(AwesomeJob).to be_unique
 it { is_expected.to be_unique }
+
+# specify a specific interval
+sidekiq_options unique_for: 1.hour
+it { is_expected.to be_unique.for(1.hour) }
 ```
 
-### be_expired_in
+#### `until` sub-matcher
+
+:warning: This sub-matcher only works for Sidekiq Enterprise
+
+```ruby
+sidekiq_options unique_for: 1.hour, unique_until: :start
+it { is_expected.to be_unique.until(:start) }
+```
+
+
+### ```be_expired_in```
 *Describes when a job should expire*
 ```ruby
 sidekiq_options expires_in: 1.hour
@@ -136,33 +291,32 @@ it { is_expected.to be_expired_in 1.hour }
 it { is_expected.to_not be_expired_in 2.hours }
 ```
 
-### have_enqueued__sidekiq_job
-*Describes that there should be an enqueued job with the specified arguments*
+### ```be_delayed```
 
-**Note:** When using rspec-rails >= 3.4, use `have_enqueued_sidekiq_job` instead to
-prevent a name clash with rspec-rails' ActiveJob matcher.
+**This matcher is deprecated**. Use of it with Sidekiq 7+ will raise an error.
+Sidekiq 7 [dropped Delayed
+Extensions](https://github.com/sidekiq/sidekiq/issues/5076).
 
+*Describes a method that should be invoked asynchronously (See [Sidekiq Delayed Extensions][sidekiq_wiki_delayed_extensions])*
 ```ruby
-AwesomeJob.perform_async 'Awesome', true
-# test with...
-expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true)
+Object.delay.is_nil? # delay
+expect(Object.method :is_nil?).to be_delayed
+Object.delay.is_a? Object # delay with argument
+expect(Object.method :is_a?).to be_delayed(Object)
 
-# Code written with older versions of the gem may use the deprecated
-# have_enqueued_job matcher.
-expect(AwesomeJob).to have_enqueued_job('Awesome', true)
-```
+Object.delay_for(1.hour).is_nil? # delay for
+expect(Object.method :is_nil?).to be_delayed.for 1.hour
+Object.delay_for(1.hour).is_a? Object # delay for with argument
+expect(Object.method :is_a?).to be_delayed(Object).for 1.hour
 
-#### Testing scheduled jobs
-*Use chainable matchers `#at` and `#in`*
-```ruby
-Awesomejob.perform_at 5.minutes.from_now, 'Awesome', true
-# test with...
-expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true).at(5.minutes.from_now)
-```
-```ruby
-Awesomejob.perform_in 5.minutes, 'Awesome', true
-# test with...
-expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true).in(5.minutes)
+Object.delay_until(1.hour.from_now).is_nil? # delay until
+expect(Object.method :is_nil?).to be_delayed.until 1.hour.from_now
+Object.delay_until(1.hour.from_now).is_a? Object # delay until with argument
+expect(Object.method :is_a?).to be_delayed(Object).until 1.hour.from_now
+
+#Rails Mailer
+MyMailer.delay.some_mail
+expect(MyMailer.instance_method :some_mail).to be_delayed
 ```
 
 ## Example matcher usage
@@ -184,11 +338,38 @@ end
 ```
 
 ## Helpers
-* [Batches (Sidekiq Pro)](#batches)
+* [Batches (Sidekiq Pro) _experimental_](#batches)
 * [`within_sidekiq_retries_exhausted_block`](#within_sidekiq_retries_exhausted_block)
 
 ### Batches
-If you are using Sidekiq Batches ([Sidekiq Pro feature][sidekiq_wiki_batches]), rspec-sidekiq replaces the implementation (using the NullObject pattern) enabling testing without a Redis instance. Mocha and RSpec stubbing is supported here.
+
+If you are using Sidekiq Batches ([Sidekiq Pro feature][sidekiq_wiki_batches]),
+You can *opt-in* with `stub_batches` to make `rspec-sidekiq` mock the
+implementation (using a NullObject pattern). This enables testing without a
+Redis instance. Mocha and RSpec stubbing is supported here.
+
+:warning: **Caution**: Opting-in to this feature, while allowing you to test without
+having Redis, _does not_ provide the exact API that `Sidekiq::Batch` does. As
+such it can cause surprises.
+
+
+```ruby
+RSpec.describe "Using mocked batches", stub_batches: true do
+  it "uses mocked batches" do
+    batch = Sidekiq::Batch.new
+    batch.jobs do
+      SomeJob.perform_async 123
+    end
+
+    expect(SomeJob).to have_enqueued_sidekiq_job
+
+    # Caution, the NullObject pattern means that the mocked Batch implementation
+    # responds to anything... even if it's not on the true `Sidekiq::Batch` API
+    # For example, the following fails
+    expect { batch.foobar! }.to raise_error(NoMethodError)
+  end
+end
+```
 
 ### within_sidekiq_retries_exhausted_block
 ```ruby
@@ -202,10 +383,15 @@ FooClass.within_sidekiq_retries_exhausted_block {
 ```
 
 ## Testing
-```bundle exec rspec spec```
+```
+bundle exec rspec spec
+```
 
 ## Maintainers
-* @wpolicarpo
+* @wspurgin
+
+### Alumni
+
 * @packrat386
 * @philostler
 
@@ -214,20 +400,10 @@ Please do! If there's a feature missing that you'd love to see then get in on th
 
 Issues/Pull Requests/Comments all welcome...
 
-[code_climate]: https://codeclimate.com/github/philostler/rspec-sidekiq
-[code_climate_badge]: https://codeclimate.com/github/philostler/rspec-sidekiq.svg
-[coveralls]: https://coveralls.io/r/philostler/rspec-sidekiq
-[coveralls_badge]: https://img.shields.io/coveralls/philostler/rspec-sidekiq.svg?branch=develop
-[gem_version_badge]: https://badge.fury.io/rb/rspec-sidekiq.svg
-[gemnasium]: https://gemnasium.com/philostler/rspec-sidekiq
-[gemnasium_badge]: https://gemnasium.com/philostler/rspec-sidekiq.svg
-[github]: http://github.com/philostler/rspec-sidekiq
-[ruby_doc]: http://rubydoc.info/gems/rspec-sidekiq/frames
-[ruby_gems]: http://rubygems.org/gems/rspec-sidekiq
-[ruby_toolbox]: http://www.ruby-toolbox.com/projects/rspec-sidekiq
-[travis_ci]: http://travis-ci.org/philostler/rspec-sidekiq
-[travis_ci_badge]: https://travis-ci.org/philostler/rspec-sidekiq.svg?branch=develop
-
-[rspec_sidekiq_wiki_faq_&_troubleshooting]: https://github.com/philostler/rspec-sidekiq/wiki/FAQ-&-Troubleshooting
-[sidekiq_wiki_batches]: https://github.com/mperham/sidekiq/wiki/Batches
-[sidekiq_wiki_delayed_extensions]: https://github.com/mperham/sidekiq/wiki/Delayed-Extensions
+[github]: http://github.com/wspurgin/rspec-sidekiq
+[github_actions]: https://github.com/wspurgin/rspec-sidekiq/actions
+[github_actions_badge]: https://github.com/wspurgin/rspec-sidekiq/actions/workflows/main.yml/badge.svg
+
+[rspec_sidekiq_wiki_faq_&_troubleshooting]: https://github.com/wspurgin/rspec-sidekiq/wiki/FAQ-&-Troubleshooting
+[sidekiq_wiki_batches]: https://github.com/sidekiq/sidekiq/wiki/Batches
+[sidekiq_wiki_delayed_extensions]: https://github.com/sidekiq/sidekiq/wiki/Delayed-Extensions

data/lib/rspec/sidekiq/batch.rb

@@ -1,4 +1,7 @@
-require 'rspec/core'
+# frozen_string_literal: true
+
+require "rspec/core"
+require "rspec/support/fuzzy_matcher"
 
 if defined? Sidekiq::Batch
   module RSpec
@@ -9,7 +12,26 @@ if defined? Sidekiq::Batch
         end
       end
 
+      ##
+      # Sidekiq::Batch is a Sidekiq::Pro feature. However the general consensus is
+      # that, by defeault, you can't test without redis. RSpec::Sidekiq includes
+      # a "null object" pattern implementation to mock Batches. This will mock
+      # Sidekiq::Batch and prevent it from using Redis.
+      #
+      # This is _opt-in_ only feature.
+      #
+      #     RSpec.describe "Using mocked batches", stub_batches: true do
+      #       it "uses mocked batches" do
+      #         batch = Sidekiq::Batch.new
+      #         batch.jobs do
+      #           SomeJob.perform_async 123
+      #         end
+      #
+      #         expect(SomeJob).to have_enqueued_sidekiq_job
+      #       end
+      #     end
       class NullBatch < NullObject
+        attr_accessor :description
         attr_reader :bid
 
         def initialize(bid = nil)
@@ -45,9 +67,17 @@ if defined? Sidekiq::Batch
         def join
           ::Sidekiq::Worker.drain_all
 
-          @callbacks.each do |event, callback_class, options|
+          @callbacks.each do |event, callback, options|
             if event != :success || failures == 0
-              callback_class.new.send("on_#{event}", self, options)
+              case callback
+              when Class
+                callback.new.send("on_#{event}", self, options)
+              when String
+                klass, meth = callback.split('#')
+                klass.constantize.new.send(meth, self, options)
+              else
+                raise ArgumentError, 'Unsupported callback notation'
+              end
             end
           end
         end
@@ -62,7 +92,7 @@ if defined? Sidekiq::Batch
   # :nocov:
   RSpec.configure do |config|
     config.before(:each) do |example|
-      next if example.metadata[:stub_batches] == false
+      next unless example.metadata[:stub_batches] == true
 
       if mocked_with_mocha?
         Sidekiq::Batch.stubs(:new) { RSpec::Sidekiq::NullBatch.new }

data/lib/rspec/sidekiq/configuration.rb

@@ -1,12 +1,39 @@
+# frozen_string_literal: true
+
+require "rubygems"
+require "set"
+
 module RSpec
   module Sidekiq
     class Configuration
-      attr_accessor :clear_all_enqueued_jobs, :enable_terminal_colours, :warn_when_jobs_not_processed_by_sidekiq
+      attr_accessor :clear_all_enqueued_jobs,
+        :enable_terminal_colours,
+        :warn_when_jobs_not_processed_by_sidekiq
 
       def initialize
-        @clear_all_enqueued_jobs = true
+        # Display settings defaults
         @enable_terminal_colours = true
+
+        # 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 sidekiq_gte_8?
+        Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new("8.0.0")
+      end
+
+      def silence_warning(symbol)
+        @silence_warnings << symbol
+      end
+
+      def warn_for?(symbol)
+        !@silence_warnings.include?(symbol)
       end
     end
   end

data/lib/rspec/sidekiq/helpers/within_sidekiq_retries_exhausted_block.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Sidekiq
   module Worker
     module ClassMethods
@@ -8,15 +10,15 @@ module Sidekiq
 
       def default_retries_exhausted_message
         {
-          'queue' => get_sidekiq_options[:worker],
+          'queue' => get_sidekiq_options['queue'],
           'class' => name,
           'args' => [],
-          'error_message' => 'An error occured'
+          'error_message' => 'An error occurred'
         }
       end
 
       def default_retries_exhausted_exception
-        StandardError.new('An error occured')
+        StandardError.new('An error occurred')
       end
     end
   end