rspec-sidekiq 3.0.3 → 4.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dd244416f99c35639675efb4b3473dd9741d512c
-  data.tar.gz: 6fa5eb3e029086fe4d316a6a9896b7acddb834de
+SHA256:
+  metadata.gz: a4f0ece401056914cf478dc4657d19aad569156ebf40ee29ee85c36fc430cfc3
+  data.tar.gz: 858c2c49ae54497a5201eab4cb3d9179fbe21a1684b11663719dfd17dd198cb2
 SHA512:
-  metadata.gz: fe360471b5c79f74e4af320881d97d0d26ec0cf837a8309e8b898221d71c63bce2d2a750d32b9427dfb931dc4a83837e4c2e3e6b1ddd6a5ed17050205f7e4aa3
-  data.tar.gz: 1d0913303fbdd4c72aea0248e815d4842a5c8fe9d0a338c6cad7cf0dbd59fc7145899718d51185444c72023772605e30099326c8481345927f083c9db91df7e6
+  metadata.gz: 831dfa10d07623e001f2253072b6d8e5311a0d887661421ba3eb914fce8f5020b73e5c7bda02264ebf4be6b6f23c2b02f8082a149d7ff5836895525ae61d697c
+  data.tar.gz: fda99d4e3bd9b43fb55ed60e96f77fd0ca54156bc6dcc42df3f1d2fb9323fff9fc63f5495a595766e937d0214fff10736ef18b9b468fccf4b97b91b2aae5e296

data/CHANGES.md

@@ -1,3 +1,46 @@
+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,9 @@
-**Welcome @wpolicarpo and @packrat386 as new maintainers for `rspec-sidekiq`!**
+**Welcome @wspurgin as new maintainer for `rspec-sidekiq`!**
 
-# RSpec for 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]
 
-[![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,33 +34,159 @@ end
 ```
 
 ## Matchers
-* [be_delayed](#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)
 * [be_unique](#be_unique)
-* [have_enqueued_sidekiq_job](#have_enqueued_sidekiq_job)
+* [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
+
+# 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('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"))
+```
+
+#### 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
+```
+
+#### 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
+)
+```
+
+#### 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
@@ -87,7 +199,7 @@ 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*
+*Describes if a job should retry when there is a failure in its execution*
 ```ruby
 sidekiq_options retry: 5
 # test with...
@@ -102,13 +214,13 @@ 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*
+*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
@@ -119,7 +231,7 @@ it { is_expected.to save_backtrace false }
 ```
 
 ### be_unique
-*Describes when a job should be unique within it's queue*
+*Describes when a job should be unique within its queue*
 ```ruby
 sidekiq_options unique: true
 # test with...
@@ -136,33 +248,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 +295,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 +340,15 @@ FooClass.within_sidekiq_retries_exhausted_block {
 ```
 
 ## Testing
-```bundle exec rspec spec```
+```
+bundle exec rspec spec
+```
 
 ## Maintainers
-* @wpolicarpo
+* @wspurgin
+
+### Alumni
+
 * @packrat386
 * @philostler
 
@@ -214,20 +357,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

@@ -9,7 +9,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 +64,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 +89,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,13 +1,24 @@
+require "rubygems"
+
 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
       end
+
+      def sidekiq_gte_7?
+        Gem::Version.new(::Sidekiq::VERSION) >= Gem::Version.new("7.0.0")
+      end
     end
   end
 end