rspec-sidekiq 4.2.0 → 5.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 545725855a34595908bcd584dfcee30045ad1519fbd8295bf5fbf6aed7fdd254
-  data.tar.gz: 26905978185b4e101e0f3d40b2318c0c47143d92a4a762286e5951be92942824
+  metadata.gz: 56ce84afbf67491fa24da1f527bced61c54afa3d62dbb50e6a09a89e8c0bc16c
+  data.tar.gz: 5b4a368bbb098d580713009fb9381d66326c37eced31c91eaf85b43158a85db5
 SHA512:
-  metadata.gz: 2f9c854985b82b12fdcd32fa0a3ec68185e1ad22ebc554f3f1e7a4b0d29d1c399706e31eef4155de6805fe61628c670a91634386eb05cf9de6762693369f3276
-  data.tar.gz: a0033e0cd3b6a6e03f5042dd04931393e87806adca9f7e78cd3bf034c2018cf89da309826e78e7a067e5a5950e86ff3aef79a2e55bb6ede116a37392000123fa
+  metadata.gz: 4ec18b3d6ceff7390807d7358259b44f236ca6d81b1b9175c069b6c4912041b914082042a5396c7cf1eb0b602a5448d9aacd9e23b3cee211ad7222c3ec3719af
+  data.tar.gz: 4f0232e7b482f7c565a5cca98be9b7143e51adbe6015329f9d052e393fd857fe97e2449fb53f9e3d209ff6319c54e23e9e2919e7003a44bfc00834692039eed0

data/CHANGES.md

@@ -1,10 +1,20 @@
 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)
+* Add warning about `have_enqueued_sidekiq_job` with no arguments (default will change in next major release) (#216, #217)
 
 4.1.0
 ---

data/README.md

@@ -1,5 +1,3 @@
-**Welcome @wspurgin as new maintainer 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]
 
@@ -34,14 +32,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 +68,28 @@ 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)
@@ -83,13 +105,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 +129,26 @@ 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)
+```
+
+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`*
@@ -166,30 +209,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,8 +218,12 @@ 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*
+
+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...
@@ -213,7 +237,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,16 +254,35 @@ it { is_expected.to_not save_backtrace } # or
 it { is_expected.to save_backtrace false }
 ```
 
-### be_unique
+### ```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
@@ -248,7 +291,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/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

data/lib/rspec/sidekiq/configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rubygems"
 require "set"
 
@@ -22,6 +24,10 @@ module RSpec
         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

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers
@@ -26,7 +28,7 @@ module RSpec
               # send to custom evaluator
               at_evaluator(value)
             else
-              job.context.has_key?(key) && job.context[key] == value
+              job.context.has_key?(key) && RSpec::Support::FuzzyMatcher.values_match?(value, job.context[key])
             end
           end
         end
@@ -58,7 +60,11 @@ module RSpec
         private
 
         def active_job?
-          job["class"] == "ActiveJob::QueueAdapters::SidekiqAdapter::JobWrapper"
+          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
@@ -118,8 +124,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[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)
@@ -164,11 +181,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 +214,79 @@ 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 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
-          "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,27 +298,48 @@ 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:"
-                base << "\n    -#{formatted(job.args)}"
+                base = ["  -JID:#{job.jid} with arguments:"]
+                base << "    -#{formatted(job.args)}"
                 if expected_options.any?
-                  base << "\n   with context: #{formatted(job.context)}"
+                  base << "   with context: #{formatted(job.context)}"
                 end
 
-                base
+                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 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/be_delayed.rb

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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers
@@ -27,24 +29,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?
@@ -85,6 +74,9 @@ module RSpec
       #   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

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     module Matchers
@@ -7,18 +9,8 @@ module RSpec
 
       # @api private
       class HaveEnqueuedSidekiqJob < Base
-        DEPRECATION = [
-          "[WARNING] `have_enqueued_sidekiq_job()` without arguments default behavior will change in next major release.",
-          "Use `have_enqueued_sidekiq_job(no_args)` to maintain legacy behavior.",
-          "More available here: https://github.com/wspurgin/rspec-sidekiq/wiki/have_enqueued_sidekiq_job-without-argument-default-behavior"
-        ].join(" ").freeze
-
         def initialize(expected_arguments)
           super()
-
-          if expected_arguments == [] && RSpec::Sidekiq.configuration.warn_for?(:have_enqueued_sidekiq_job_default)
-            Kernel.warn(DEPRECATION, uplevel: 3)
-          end
           @expected_arguments = normalize_arguments(expected_arguments)
         end
 
@@ -26,7 +18,16 @@ module RSpec
           @klass = job_class
 
           @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/save_backtrace.rb

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

data/lib/rspec/sidekiq/matchers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rspec/core"
 require "rspec/matchers"
 require "rspec/mocks/argument_list_matcher"

data/lib/rspec/sidekiq/sidekiq.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RSpec
   module Sidekiq
     class << self

data/lib/rspec/sidekiq/version.rb

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

data/lib/rspec-sidekiq.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'forwardable'
 
 require 'sidekiq'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rspec-sidekiq
 version: !ruby/object:Gem::Version
-  version: 4.2.0
+  version: 5.1.0
 platform: ruby
 authors:
 - Aidan Coyle
@@ -10,7 +10,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-16 00:00:00.000000000 Z
+date: 2025-03-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec-core
@@ -63,7 +63,7 @@ dependencies:
         version: '5'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -73,7 +73,7 @@ dependencies:
         version: '5'
     - - "<"
       - !ruby/object:Gem::Version
-        version: '8'
+        version: '9'
 - !ruby/object:Gem::Dependency
   name: pry
   requirement: !ruby/object:Gem::Requirement
@@ -228,6 +228,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: railties
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simple testing of Sidekiq jobs via a collection of matchers and helpers
 email:
 executables: []
@@ -257,7 +271,8 @@ files:
 homepage: http://github.com/wspurgin/rspec-sidekiq
 licenses:
 - MIT
-metadata: {}
+metadata:
+  changelog_uri: https://github.com/wspurgin/rspec-sidekiq/blob/main/CHANGES.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -273,7 +288,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.5.22
 signing_key:
 specification_version: 4
 summary: RSpec for Sidekiq