rspec-sidekiq 2.2.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4e76f040dc9a72982978b86c4085e90a4efeab6f
-  data.tar.gz: 4f3531dc67714ce9f1aae2858b2e12c4baf80f2e
+SHA256:
+  metadata.gz: 9521e2acad8dae8dc1c47afeb1a3f4f1052f44d2d512ae29866548f5cefdbb61
+  data.tar.gz: 4ce5c1b0a18cec884a1b023ae113f3e692afcc471c9e2dd067c762d6051a77d5
 SHA512:
-  metadata.gz: 02c75664a4f650debe93f2a6a61d51ce5c8341c16388824f500d0d5afe75b7ab044a6606a2c3fab25649ea424f9da683da05e8ab71dd69893f54a9dc7cea5345
-  data.tar.gz: 7528d4c9f3cda76979b3118dee4069fdb86792e566e91bfd475703d2f107e5555ed1a850a0ff0e4b79b874f37b74261f2250bc28e148324555d22b31bdf4dbfd
+  metadata.gz: e3501020bc4f14f5294b1cb67483c3018f608111e4c50ec74c193927e0dadf41ad7532e5c2a695f7d107cd435094eb59751ab23743f6b97a316059f8cc77ba7f
+  data.tar.gz: 79003f53fa67a71b288a2de8d35bdc65aeb123e5dedf929e8012cff2e999aadaa5f3830d9d4dc33889ff4a270adbf9b1045a81e0b7372882b577e8d9553e8e9c

data/CHANGES.md

@@ -1,3 +1,37 @@
+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)
+
+3.0.2
+---
+* README updates (nilsding #110, packrat386 #122)
+* Ruby 2.4 support (packrat386 #119)
+* Fixes for Sidekiq 5 deprecations (packrat #130 with help from trev)
+
+3.0.1
+---
+* Remove implicit runtime dependency on ActiveSupport [aprescott#109]
+
+3.0.0
+---
+* Use default arguments for NullStatus initialization [briansharon#111]
+* Fix at and in chainable methods [wpolicarpo#109]
+* Rely on all of RSpec in development [packrat386#101]
+* Pass exception to within_sidekiq_retries_exhausted_block [packrat386#100]
+* Add support for testing scheduled jobs [wpolicarpo#81]
+* only depend on rspec-core [urkle#96]
+* Add support for Sidekiq Enterprise [Geesu#82]
+* Fix clash with rspec-rails [pavel-jurasek-bcgdv-com#95]
+
 2.2.0
 ---
 * Fix typo in README file [bradhaydon#87]

data/README.md

@@ -1,3 +1,5 @@
+**Welcome @packrat386 as new maintainer for `rspec-sidekiq`!**
+
 # RSpec for Sidekiq
 
 [![RubyGems][gem_version_badge]][ruby_gems]
@@ -50,7 +52,7 @@ end
 * [be_processed_in](#be_processed_in)
 * [be_retryable](#be_retryable)
 * [be_unique](#be_unique)
-* [have_enqueued_job](#have_enqueued_job)
+* [have_enqueued_sidekiq_job](#have_enqueued_sidekiq_job)
 
 ### be_delayed
 *Describes a method that should be invoked asynchronously (See [Sidekiq Delayed Extensions][sidekiq_wiki_delayed_extensions])*
@@ -85,7 +87,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...
@@ -100,7 +102,7 @@ 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...
@@ -117,13 +119,14 @@ 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...
 expect(AwesomeJob).to be_unique
 it { is_expected.to be_unique }
 ```
+
 ### be_expired_in
 *Describes when a job should expire*
 ```ruby
@@ -133,14 +136,36 @@ it { is_expected.to be_expired_in 1.hour }
 it { is_expected.to_not be_expired_in 2.hours }
 ```
 
-### have_enqueued_job
+### have_enqueued_sidekiq_job
 *Describes that there should be an enqueued job with the specified arguments*
+
+**Note:** When using rspec-rails >= 3.4, use `have_enqueued_sidekiq_job` instead to
+prevent a name clash with rspec-rails' ActiveJob matcher.
+
 ```ruby
 AwesomeJob.perform_async 'Awesome', true
 # test with...
+expect(AwesomeJob).to have_enqueued_sidekiq_job('Awesome', true)
+
+# Code written with older versions of the gem may use the deprecated
+# have_enqueued_job matcher.
 expect(AwesomeJob).to have_enqueued_job('Awesome', true)
 ```
 
+#### Testing scheduled jobs
+*Use chainable matchers `#at` and `#in`*
+```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)
+```
+
 ## Example matcher usage
 ```ruby
 require 'spec_helper'
@@ -154,7 +179,7 @@ describe AwesomeJob do
   it 'enqueues another awesome job' do
     subject.perform
 
-    expect(AnotherAwesomeJob).to have_enqueued_job('Awesome', true)
+    expect(AnotherAwesomeJob).to have_enqueued_sidekiq_job('Awesome', true)
   end
 end
 ```
@@ -180,6 +205,10 @@ FooClass.within_sidekiq_retries_exhausted_block {
 ## Testing
 ```bundle exec rspec spec```
 
+## Maintainers
+* @packrat386
+* @philostler
+
 ## Contribute
 Please do! If there's a feature missing that you'd love to see then get in on the action!
 

data/lib/rspec/sidekiq/batch.rb

@@ -10,6 +10,7 @@ if defined? Sidekiq::Batch
       end
 
       class NullBatch < NullObject
+        attr_accessor :description
         attr_reader :bid
 
         def initialize(bid = nil)
@@ -33,7 +34,7 @@ if defined? Sidekiq::Batch
       class NullStatus < NullObject
         attr_reader :bid
 
-        def initialize(bid, callbacks)
+        def initialize(bid = SecureRandom.hex(8), callbacks = [])
           @bid = bid
           @callbacks = callbacks
         end
@@ -45,9 +46,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
@@ -59,6 +68,7 @@ if defined? Sidekiq::Batch
     end
   end
 
+  # :nocov:
   RSpec.configure do |config|
     config.before(:each) do |example|
       next if example.metadata[:stub_batches] == false
@@ -76,4 +86,5 @@ if defined? Sidekiq::Batch
   def mocked_with_mocha?
     Sidekiq::Batch.respond_to? :stubs
   end
+  # :nocov:
 end

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

@@ -1,12 +1,12 @@
 module Sidekiq
   module Worker
     module ClassMethods
-      def within_sidekiq_retries_exhausted_block(user_msg = {}, &block)
+      def within_sidekiq_retries_exhausted_block(user_msg = {}, exception = default_retries_exhausted_exception, &block)
         block.call
-        sidekiq_retries_exhausted_block.call default_retries_exhausted_args.merge(user_msg)
+        sidekiq_retries_exhausted_block.call(default_retries_exhausted_message.merge(user_msg), exception)
       end
 
-      def default_retries_exhausted_args
+      def default_retries_exhausted_message
         {
           'queue' => get_sidekiq_options[:worker],
           'class' => name,
@@ -14,6 +14,10 @@ module Sidekiq
           'error_message' => 'An error occured'
         }
       end
+
+      def default_retries_exhausted_exception
+        StandardError.new('An error occured')
+      end
     end
   end
 end

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

@@ -11,7 +11,7 @@ module RSpec
         end
 
         def description
-          if @expected_retry.is_a?(Fixnum)
+          if @expected_retry.is_a?(Numeric)
             "retry #{@expected_retry} times"    # retry: 5
           elsif @expected_retry
             'retry the default number of times' # retry: true

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

@@ -6,22 +6,80 @@ module RSpec
       end
 
       class BeUnique
-        def description
-          'be unique in the queue'
+        def self.new
+          if defined?(::Sidekiq::Enterprise)
+            SidekiqEnterprise.new
+          elsif defined?(::SidekiqUniqueJobs)
+            SidekiqUniqueJobs.new
+          else
+            fail "No support found for Sidekiq unique jobs"
+          end
         end
 
-        def failure_message
-          "expected #{@klass} to be unique in the queue"
+        class Base
+          def description
+            'be unique in the queue'
+          end
+
+          def failure_message
+            if !interval_matches? && @expected_interval
+              "expected #{@klass} to be unique for #{@expected_interval} seconds, "\
+              "but its interval was #{actual_interval} seconds"
+            else
+              "expected #{@klass} to be unique in the queue"
+            end
+          end
+
+          def matches?(job)
+            @klass = job.is_a?(Class) ? job : job.class
+            @actual = @klass.get_sidekiq_options[unique_key]
+            !!(value_matches? && interval_matches?)
+          end
+
+          def for(interval)
+            @expected_interval = interval
+            self
+          end
+
+          def interval_specified?
+            @expected_interval
+          end
+
+          def interval_matches?
+            !interval_specified? || actual_interval == @expected_interval
+          end
+
+          def failure_message_when_negated
+            "expected #{@klass} to not be unique in the queue"
+          end
         end
 
-        def matches?(job)
-          @klass = job.is_a?(Class) ? job : job.class
-          @actual = @klass.get_sidekiq_options['unique']
-          [true, :all].include?(@actual)
+        class SidekiqUniqueJobs < Base
+          def actual_interval
+            @klass.get_sidekiq_options['unique_job_expiration']
+          end
+
+          def value_matches?
+            [true, :all].include?(@actual)
+          end
+
+          def unique_key
+            'unique'
+          end
         end
 
-        def failure_message_when_negated
-          "expected #{@klass} to not be unique in the queue"
+        class SidekiqEnterprise < Base
+          def actual_interval
+            @actual
+          end
+
+          def value_matches?
+            @actual && @actual > 0
+          end
+
+          def unique_key
+            'unique_for'
+          end
         end
       end
     end

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

@@ -1,15 +1,114 @@
 module RSpec
   module Sidekiq
     module Matchers
-      def have_enqueued_job(*expected_arguments)
+      def have_enqueued_sidekiq_job(*expected_arguments)
         HaveEnqueuedJob.new expected_arguments
       end
 
+      def have_enqueued_job(*expected_arguments)
+        warn "[DEPRECATION] `have_enqueued_job` is deprecated.  Please use `have_enqueued_sidekiq_job` instead."
+        have_enqueued_sidekiq_job(*expected_arguments)
+      end
+
+      class JobOptionParser
+        attr_reader :job
+
+        def initialize(job)
+          @job = job
+        end
+
+        def matches?(option, value)
+          raise ArgumentError, "Option `#{option}` is not defined." unless %w(in at).include?(option.to_s)
+          send("#{option}_evaluator", value)
+        end
+
+        private
+
+        def at_evaluator(value)
+          return false if job['at'].to_s.empty?
+          value.to_time.to_i == Time.at(job['at']).to_i
+        end
+
+        def in_evaluator(value)
+          return false if job['at'].to_s.empty?
+          (Time.now + value).to_i == Time.at(job['at']).to_i
+        end
+      end
+
+      class JobMatcher
+        attr_reader :jobs
+
+        def initialize(klass)
+          @jobs = unwrap_jobs(klass.jobs)
+        end
+
+        def present?(arguments, options)
+          !!find_job(arguments, options)
+        end
+
+        private
+
+        def matches?(job, arguments, options)
+          arguments_matches?(job, arguments) &&
+            options_matches?(job, options)
+        end
+
+        def arguments_matches?(job, arguments)
+          arguments_got = job_arguments(job)
+          contain_exactly?(arguments, arguments_got)
+        end
+
+        def options_matches?(job, options)
+          options.all? do |option, value|
+            parser = JobOptionParser.new(job)
+            parser.matches?(option, value)
+          end
+        end
+
+        def find_job(arguments, options)
+          jobs.find { |job| matches?(job, arguments, options) }
+        end
+
+        def job_arguments(job)
+          args = job['args']
+          return args[0]['arguments'] if args.is_a?(Array) && args[0].is_a?(Hash) && args[0].has_key?('arguments')
+          args
+        end
+
+        def unwrap_jobs(jobs)
+          return jobs if jobs.is_a?(Array)
+          jobs.values.flatten
+        end
+
+        def contain_exactly?(expected, got)
+          exactly = RSpec::Matchers::BuiltIn::ContainExactly.new(expected)
+          exactly.matches?(got)
+        end
+      end
+
       class HaveEnqueuedJob
-        attr_reader :klass, :expected_arguments, :actual
+        attr_reader :klass, :expected_arguments, :actual_arguments, :expected_options, :actual_options
 
         def initialize(expected_arguments)
           @expected_arguments = normalize_arguments(expected_arguments)
+          @expected_options = {}
+        end
+
+        def matches?(klass)
+          @klass = klass
+          @actual_arguments = unwrapped_job_arguments(klass.jobs)
+          @actual_options = unwrapped_job_options(klass.jobs)
+          JobMatcher.new(klass).present?(expected_arguments, expected_options)
+        end
+
+        def at(timestamp)
+          @expected_options['at'] = timestamp
+          self
+        end
+
+        def in(interval)
+          @expected_options['in'] = interval
+          self
         end
 
         def description
@@ -17,30 +116,39 @@ module RSpec
         end
 
         def failure_message
-          "expected to have an enqueued #{klass} job with arguments #{expected_arguments}\n\n" \
-          "found: #{actual}"
-        end
-
-        def matches?(klass)
-          @klass = klass
-          @actual = unwrapped_job_arguments(klass.jobs)
-          @actual.any? { |arguments| contain_exactly?(arguments) }
+          message = ["expected to have an enqueued #{klass} job"]
+          message << "  arguments: #{expected_arguments}" if expected_arguments
+          message << "  options: #{expected_options}" if expected_options.any?
+          message << "found"
+          message << "  arguments: #{actual_arguments}" if expected_arguments
+          message << "  options: #{actual_options}" if expected_options.any?
+          message.join("\n")
         end
 
         def failure_message_when_negated
-          "expected to not have an enqueued #{klass} job with arguments #{expected_arguments}"
+          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
 
         private
 
+        def unwrapped_job_options(jobs)
+          jobs = jobs.values if jobs.is_a?(Hash)
+          jobs.flatten.map do |job|
+            { 'at' => job['at'] }
+          end
+        end
+
         def unwrapped_job_arguments(jobs)
           if jobs.is_a? Hash
             jobs.values.flatten.map do |job|
-              map_arguments(job).flatten
+              map_arguments(job)
             end
           else
             map_arguments(jobs)
-          end
+          end.map { |job| job.flatten }
         end
 
         def map_arguments(job)
@@ -56,11 +164,6 @@ module RSpec
           hash['arguments'] || hash['args'] if hash.is_a? Hash
         end
 
-        def contain_exactly?(arguments)
-          exactly = RSpec::Matchers::BuiltIn::ContainExactly.new(expected_arguments)
-          exactly.matches?(arguments)
-        end
-
         def normalize_arguments(args)
           if args.is_a?(Array)
             args.map{ |x| normalize_arguments(x) }
@@ -68,6 +171,8 @@ module RSpec
             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

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

@@ -11,7 +11,7 @@ module RSpec
         end
 
         def description
-          if @expected_backtrace.is_a?(Fixnum)
+          if @expected_backtrace.is_a?(Numeric)
             "save #{@expected_backtrace} lines of error backtrace" # backtrace: 5
           elsif @expected_backtrace
             'save error backtrace' # backtrace: true

data/lib/rspec/sidekiq/version.rb

@@ -1,5 +1,5 @@
 module RSpec
   module Sidekiq
-    VERSION = '2.2.0'
+    VERSION = '3.1.0'
   end
 end

data/rspec-sidekiq.gemspec

@@ -11,13 +11,17 @@ Gem::Specification.new do |s|
   s.description = 'Simple testing of Sidekiq jobs via a collection of matchers and helpers'
   s.license     = 'MIT'
 
-  s.add_dependency 'rspec', '~> 3.0', '>= 3.0.0'
+  s.add_dependency 'rspec-core', '~> 3.0', '>= 3.0.0'
   s.add_dependency 'sidekiq', '>= 2.4.0'
 
-  s.add_development_dependency 'coveralls', '~> 0.8', '>= 0.8.0'
-  s.add_development_dependency 'fuubar', '~> 2.0', '>= 2.0.0'
-  s.add_development_dependency 'activejob', '~> 4.2', '>= 4.0.0'
-  s.add_development_dependency 'actionmailer', '~> 4.2', '>= 4.0.0'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'coveralls'
+  s.add_development_dependency 'fuubar'
+  s.add_development_dependency 'activejob'
+  s.add_development_dependency 'actionmailer'
+  s.add_development_dependency 'activerecord'
+  s.add_development_dependency 'activemodel'
+  s.add_development_dependency 'activesupport'
 
 
   s.files = Dir['.gitattributes'] +

data/spec/rspec/sidekiq/batch_spec.rb

@@ -10,31 +10,74 @@ RSpec.describe 'Batch' do
 
   load File.expand_path(File.join(File.dirname(__FILE__), '../../../lib/rspec/sidekiq/batch.rb'))
 
+  describe 'NullObject' do
+    describe '#method_missing' do
+      it 'returns itself' do
+        batch = Sidekiq::Batch.new
+        expect(batch.non_existent_method).to eq(batch)
+      end
+    end
+  end
+
+  describe 'NullBatch' do
+  end
+
   describe 'NullStatus' do
+    let(:batch) {  Sidekiq::Batch.new }
+
+    subject { batch.status }
+
     describe '#total' do
       it 'returns 0 when no jobs' do
-        null_status = Sidekiq::Batch.new.status
-        expect(null_status.total).to eq(0)
+        expect(subject.total).to eq(0)
       end
 
       it 'returns 1 when 1 job' do
-        batch = Sidekiq::Batch.new
-
         batch.jobs do
           TestWorker.perform_async('5')
         end
 
-        null_status = batch.status
+        expect(subject.total).to eq(1)
+      end
+    end
 
-        expect(null_status.total).to eq(1)
+    describe '#failures' do
+      it 'returns 0' do
+        expect(subject.failures).to eq(0)
       end
     end
 
     describe '#bid' do
       it 'returns a bid' do
-        null_status = Sidekiq::Batch.new
-        expect(null_status.bid).to_not be_nil
+        expect(subject.bid).to_not be_nil
+      end
+    end
+
+    describe '#join' do
+      class MyCallback
+        def on_event(status, options); end
+      end
+
+      class OtherCallback
+        def foo(status, options); end
+      end
+
+      before(:each) do
+        batch.on(:event, MyCallback, my_arg: 42)
+        batch.on(:event, 'OtherCallback#foo', my_arg: 23)
+      end
+
+      it 'executes callbacks' do
+        expect_any_instance_of(MyCallback).to receive(:on_event).with(subject, { my_arg: 42 })
+        expect_any_instance_of(OtherCallback).to receive(:foo).with(subject, { my_arg: 23 })
+        subject.join
+      end
+    end
+
+    describe '#initialize' do
+      it 'uses default argument values when none are provided' do
+        expect { Sidekiq::Batch::Status.new }.to_not raise_error
       end
     end
   end
-end
+end

data/spec/rspec/sidekiq/helpers/retries_exhausted_spec.rb

@@ -2,9 +2,10 @@ require 'spec_helper'
 
 RSpec.describe 'Retries Exhausted block' do
   class FooClass < TestWorkerAlternative
-    sidekiq_retries_exhausted do |msg|
+    sidekiq_retries_exhausted do |msg, exception|
       bar('hello')
       foo(msg)
+      baz(exception)
     end
 
     def self.bar(input)
@@ -12,17 +13,28 @@ RSpec.describe 'Retries Exhausted block' do
 
     def self.foo(msg)
     end
+
+    def self.baz(exception)
+    end
   end
 
   it 'executes whatever is within the block' do
     FooClass.within_sidekiq_retries_exhausted_block { expect(FooClass).to receive(:bar).with('hello') }
   end
 
-  it 'passes arguments to the block' do
+  it 'passes message and exception to the block' do
     args = { 'args' => ['a', 'b']}
-    FooClass.within_sidekiq_retries_exhausted_block(args) do
-      expect(FooClass).to receive(:foo).with(FooClass.default_retries_exhausted_args.merge(args))
+    exception = StandardError.new('something went wrong')
+    FooClass.within_sidekiq_retries_exhausted_block(args, exception) do
+      expect(FooClass).to receive(:foo).with(FooClass.default_retries_exhausted_message.merge(args))
+      expect(FooClass).to receive(:baz).with(exception)
     end
   end
 
+  it 'sets a default value for the message and exception' do
+    FooClass.within_sidekiq_retries_exhausted_block do
+      expect(FooClass).to receive(:foo).with(FooClass.default_retries_exhausted_message)
+      expect(FooClass).to receive(:baz).with(FooClass.default_retries_exhausted_exception)
+    end
+  end
 end

data/spec/rspec/sidekiq/matchers/be_unique_spec.rb

@@ -2,6 +2,9 @@ require 'spec_helper'
 
 RSpec.describe RSpec::Sidekiq::Matchers::BeUnique do
   shared_context 'a unique worker' do
+    before do
+      stub_const(module_constant, true)
+    end
     before(:each) { subject.matches? @worker }
 
     describe 'expected usage' do
@@ -14,7 +17,6 @@ RSpec.describe RSpec::Sidekiq::Matchers::BeUnique do
           expect(subject.failure_message).to eq "expected #{@worker} to be unique in the queue"
         end
       end
-
     end
 
     describe '#matches?' do
@@ -36,27 +38,78 @@ RSpec.describe RSpec::Sidekiq::Matchers::BeUnique do
         end
       end
     end
+
+    describe '#description' do
+      it 'returns description' do
+        expect(subject.description).to eq 'be unique in the queue'
+      end
+    end
   end
 
-  context 'a scheduled worker' do
-    before { @worker =  create_worker unique: :all }
+  context 'a sidekiq-enterprise scheduled worker' do
+    let(:interval) { 3.hours }
+    let(:module_constant) { "Sidekiq::Enterprise" }
+    before { @worker = create_worker unique_for: interval }
     include_context 'a unique worker'
   end
 
-  context 'a regular worker' do
-    before { @worker =  create_worker unique: true }
+  context 'a sidekiq-unique-jobs scheduled worker' do
+    let(:module_constant) { "SidekiqUniqueJobs" }
+    before { @worker = create_worker unique: :all }
+    include_context 'a unique worker'
+  end
+
+  context 'a sidekiq-unique-jobs regular worker' do
+    let(:module_constant) { "SidekiqUniqueJobs" }
+    before { @worker = create_worker unique: true }
     include_context 'a unique worker'
   end
 
   describe '#be_unique' do
+    before do
+      stub_const("SidekiqUniqueJobs", true)
+    end
+
     it 'returns instance' do
-      expect(be_unique).to be_a RSpec::Sidekiq::Matchers::BeUnique
+      expect(be_unique).to be_kind_of RSpec::Sidekiq::Matchers::BeUnique::Base
     end
   end
 
   describe '#failure_message_when_negated' do
+    before do
+      stub_const("SidekiqUniqueJobs", true)
+    end
+
     it 'returns message' do
       expect(subject.failure_message_when_negated).to eq "expected #{@worker} to not be unique in the queue"
     end
   end
+
+  describe '#unique_key' do
+    context "with Sidekiq Enterprise" do
+      before do
+        stub_const("Sidekiq::Enterprise", true)
+      end
+
+      it "returns the correct key" do
+        expect(subject.unique_key).to eq('unique_for')
+      end
+    end
+
+    context "with sidekiq-unique-jobs" do
+      before do
+        stub_const("SidekiqUniqueJobs", true)
+      end
+
+      it "returns the correct key" do
+        expect(subject.unique_key).to eq('unique')
+      end
+    end
+
+    context "without a uniquing solution" do
+      it "raises an exception" do
+        expect{subject.unique_key}.to raise_error RuntimeError, 'No support found for Sidekiq unique jobs'
+      end
+    end
+  end
 end

data/spec/rspec/sidekiq/matchers/have_enqueued_job_spec.rb

@@ -1,54 +1,92 @@
 require 'spec_helper'
 
 RSpec.describe RSpec::Sidekiq::Matchers::HaveEnqueuedJob do
+  let(:tomorrow) { DateTime.now + 1 }
+  let(:interval) { 3.minutes }
   let(:argument_subject) { RSpec::Sidekiq::Matchers::HaveEnqueuedJob.new worker_args }
-  let(:matcher_subject) { RSpec::Sidekiq::Matchers::HaveEnqueuedJob.new [be_a(String), be_a(Fixnum), true, be_a(Hash)] }
+  let(:matcher_subject) { RSpec::Sidekiq::Matchers::HaveEnqueuedJob.new [be_a(String), be_a(Integer), true, be_a(Hash)] }
   let(:worker) { create_worker }
-  let(:worker_args) { ['string', 1, true, {key: 'value', nested: [{hash: true}]}] }
+  let(:worker_args) { ['string', 1, true, { key: 'value', bar: :foo, nested: [{hash: true}] }] }
   let(:active_job) { create_active_job :mailers }
   let(:resource) { TestResource.new }
 
   before(:each) do
+    GlobalID.app = 'rspec-sidekiq'
     worker.perform_async *worker_args
     active_job.perform_later 'someResource'
     active_job.perform_later(resource)
     TestActionMailer.testmail.deliver_later
     TestActionMailer.testmail(resource).deliver_later
-    argument_subject.matches? worker
   end
 
   describe 'expected usage' do
-    it 'matches' do
-      expect(worker).to have_enqueued_job *worker_args
-    end
+    context 'Sidekiq' do
+      it 'matches' do
+        expect(worker).to have_enqueued_sidekiq_job *worker_args
+      end
 
-    it 'matches on the global Worker queue' do
-      expect(Sidekiq::Worker).to have_enqueued_job *worker_args
-    end
+      it 'matches on the global Worker queue' do
+        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job *worker_args
+      end
+
+      context 'perform_in' do
+        let(:worker_args_in) { worker_args + ['in'] }
 
-    it 'matches on an enqueued ActiveJob' do
-      expect(Sidekiq::Worker).to have_enqueued_job 'someResource'
+        before(:each) do
+          worker.perform_in 3.minutes, *worker_args_in
+        end
+
+        it 'matches on an scheduled job with #perform_in' do
+          expect(worker).to have_enqueued_sidekiq_job(*worker_args_in).in(interval)
+        end
+      end
+
+      context 'perform_at' do
+        let(:worker_args_at) { worker_args + ['at'] }
+
+        before(:each) do
+          worker.perform_at tomorrow, *worker_args_at
+        end
+
+        it 'matches on an scheduled job with #perform_at' do
+          expect(worker).to have_enqueued_sidekiq_job(*worker_args_at).at(tomorrow)
+        end
+      end
     end
 
-    it 'matches on an enqueued ActiveJob by global_id' do
-      expect(Sidekiq::Worker).to have_enqueued_job("_aj_globalid" => resource.to_global_id.uri.to_s)
+    context 'ActiveJob' do
+      it 'matches on an enqueued ActiveJob' do
+        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job 'someResource'
+      end
+
+      it 'matches on an enqueued ActiveJob by global_id' do
+        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job('_aj_globalid' => resource.to_global_id.uri.to_s)
+      end
     end
 
-    it 'matches on ActionMailer Job' do
-      expect(Sidekiq::Worker).to have_enqueued_job(
-        "TestActionMailer",
-        "testmail",
-        "deliver_now"
-      )
+    context 'ActionMailer' do
+      it 'matches on ActionMailer Job' do
+        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job(
+          'TestActionMailer',
+          'testmail',
+          'deliver_now'
+        )
+      end
+
+      it 'matches on ActionMailer with a resource Job' do
+        expect(Sidekiq::Worker).to have_enqueued_sidekiq_job(
+          'TestActionMailer',
+          'testmail',
+          'deliver_now',
+          { '_aj_globalid' => resource.to_global_id.uri.to_s }
+        )
+      end
     end
+  end
 
-    it 'matches on ActionMailer with a resource Job' do
-      expect(Sidekiq::Worker).to have_enqueued_job(
-        "TestActionMailer",
-        "testmail",
-        "deliver_now",
-        { "_aj_globalid" => resource.to_global_id.uri.to_s }
-      )
+  describe '#have_enqueued_sidekiq_job' do
+    it 'returns instance' do
+      expect(have_enqueued_sidekiq_job).to be_a RSpec::Sidekiq::Matchers::HaveEnqueuedJob
     end
   end
 
@@ -56,17 +94,42 @@ RSpec.describe RSpec::Sidekiq::Matchers::HaveEnqueuedJob do
     it 'returns instance' do
       expect(have_enqueued_job).to be_a RSpec::Sidekiq::Matchers::HaveEnqueuedJob
     end
+
+    it 'provides deprecation warning' do
+      expect { have_enqueued_job }.to output(/[DEPRECATION]/).to_stderr
+    end
+
+    it 'matches the same way have_enqueued_sidekiq_job does' do
+      expect(worker).to have_enqueued_job *worker_args
+    end
   end
 
   describe '#description' do
     it 'returns description' do
-      expect(argument_subject.description).to eq "have an enqueued #{worker} job with arguments [\"string\", 1, true, {\"key\"=>\"value\", \"nested\"=>[{\"hash\"=>true}]}]"
+      argument_subject.matches? worker
+      expect(argument_subject.description).to eq %{have an enqueued #{worker} job with arguments [\"string\", 1, true, {\"key\"=>\"value\", \"bar\"=>\"foo\", \"nested\"=>[{\"hash\"=>true}]}]}
     end
   end
 
   describe '#failure_message' do
     it 'returns message' do
-      expect(argument_subject.failure_message).to eq "expected to have an enqueued #{worker} job with arguments [\"string\", 1, true, {\"key\"=>\"value\", \"nested\"=>[{\"hash\"=>true}]}]\n\nfound: [[\"string\", 1, true, {\"key\"=>\"value\", \"nested\"=>[{\"hash\"=>true}]}]]"
+      argument_subject.matches? worker
+      expect(argument_subject.failure_message).to eq <<-eos.gsub(/^ {6}/, '').strip
+      expected to have an enqueued #{worker} job
+        arguments: [\"string\", 1, true, {\"key\"=>\"value\", \"bar\"=>\"foo\", \"nested\"=>[{\"hash\"=>true}]}]
+      found
+        arguments: [[\"string\", 1, true, {\"key\"=>\"value\", \"bar\"=>\"foo\", \"nested\"=>[{\"hash\"=>true}]}]]
+      eos
+    end
+  end
+
+  describe '#failure_message_when_negated' do
+    it 'returns message' do
+      argument_subject.matches? worker
+      expect(argument_subject.failure_message_when_negated).to eq <<-eos.gsub(/^ {6}/, '').strip
+      expected not to have an enqueued #{worker} job
+        arguments: [\"string\", 1, true, {\"key\"=>\"value\", \"bar\"=>\"foo\", \"nested\"=>[{\"hash\"=>true}]}]
+      eos
     end
   end
 
@@ -74,15 +137,55 @@ RSpec.describe RSpec::Sidekiq::Matchers::HaveEnqueuedJob do
     context 'when condition matches' do
       context 'when expected are arguments' do
         it 'returns true' do
+          worker.perform_async *worker_args
           expect(argument_subject.matches? worker).to be true
         end
       end
 
       context 'when expected are matchers' do
         it 'returns true' do
+          worker.perform_async *worker_args
           expect(matcher_subject.matches? worker).to be true
         end
       end
+
+      context 'when job is scheduled' do
+        context 'with #perform_at' do
+          before(:each) do
+            worker.perform_at(tomorrow, *worker_args)
+          end
+
+          context 'and timestamp matches' do
+            it 'returns true' do
+              expect(matcher_subject.at(tomorrow).matches? worker).to be true
+            end
+          end
+
+          context 'and timestamp does not match' do
+            it 'returns false' do
+              expect(matcher_subject.at(tomorrow + 1).matches? worker).to be false
+            end
+          end
+        end
+
+        context 'with #perform_in' do
+          before(:each) do
+            worker.perform_in(interval, *worker_args)
+          end
+
+          context 'and interval matches' do
+            it 'returns true' do
+              expect(matcher_subject.in(interval).matches? worker).to be true
+            end
+          end
+
+          context 'and interval does not match' do
+            it 'returns false' do
+              expect(matcher_subject.in(interval + 1.minute).matches? worker).to be false
+            end
+          end
+        end
+      end
     end
 
     context 'when condition does not match' do
@@ -99,12 +202,28 @@ RSpec.describe RSpec::Sidekiq::Matchers::HaveEnqueuedJob do
           expect(matcher_subject.matches? worker).to be false
         end
       end
-    end
-  end
 
-  describe '#failure_message_when_negated' do
-    it 'returns message' do
-      expect(argument_subject.failure_message_when_negated).to eq "expected to not have an enqueued #{worker} job with arguments [\"string\", 1, true, {\"key\"=>\"value\", \"nested\"=>[{\"hash\"=>true}]}]"
+      context 'when job is scheduled' do
+        context 'with #perform_at' do
+          before(:each) do
+            allow(matcher_subject).to receive(:options).and_return(at: tomorrow + 1)
+          end
+
+          it 'returns false' do
+            expect(matcher_subject.at(tomorrow).matches? worker).to be false
+          end
+        end
+
+        context 'with #perform_in' do
+          before(:each) do
+            allow(matcher_subject).to receive(:options).and_return(in: interval + 1)
+          end
+
+          it 'returns false' do
+            expect(matcher_subject.in(interval).matches? worker).to be false
+          end
+        end
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -9,10 +9,9 @@ require 'action_mailer'
 
 require_relative 'support/init'
 
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  Coveralls::SimpleCov::Formatter,
-  SimpleCov::Formatter::HTMLFormatter
-]
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+  [Coveralls::SimpleCov::Formatter, SimpleCov::Formatter::HTMLFormatter]
+)
 SimpleCov.start
 
 RSpec.configure do |config|
@@ -22,3 +21,9 @@ RSpec.configure do |config|
 end
 
 ActiveJob::Base.queue_adapter = :sidekiq
+
+if Gem::Dependency.new('sidekiq', '>= 5.0.0').matching_specs.any?
+  require 'active_record'
+  ActiveSupport.run_load_hooks(:active_record, ActiveRecord::Base)
+  Sidekiq::Extensions.enable_delay!
+end

data/spec/support/test_resource.rb

@@ -1,16 +1,10 @@
 class TestResource
   include GlobalID::Identification
 
-  attr_reader :global_id
-
-  def initialize
-    @global_id = GlobalID.create(self, { app: 'rspec-sidekiq' })
-  end
-
   def self.find(id)
   end
 
   def id
-    rand(36**10).to_s 36
+    @id ||= rand(36**10).to_s 36
   end
 end

metadata

@@ -1,35 +1,35 @@
 --- !ruby/object:Gem::Specification
 name: rspec-sidekiq
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Phil Ostler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-22 00:00:00.000000000 Z
+date: 2020-06-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rspec-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
     - - ">="
       - !ruby/object:Gem::Version
         version: 3.0.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
@@ -45,85 +45,117 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 2.4.0
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.8'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.8'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.8.0
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: fuubar
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.0'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.2'
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: actionmailer
   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: '4.2'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.0.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  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'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  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: 4.0.0
+        version: '0'
 description: Simple testing of Sidekiq jobs via a collection of matchers and helpers
 email: github@philostler.com
 executables: []
@@ -164,7 +196,6 @@ files:
 - spec/rspec/sidekiq/matchers/have_enqueued_job_spec.rb
 - spec/rspec/sidekiq/matchers/save_backtrace_spec.rb
 - spec/rspec/sidekiq/sidekiq_spec.rb
-- spec/rspec/sidekiq/version_spec.rb
 - spec/spec_helper.rb
 - spec/support/factories.rb
 - spec/support/init.rb
@@ -192,8 +223,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: RSpec for Sidekiq

data/spec/rspec/sidekiq/version_spec.rb

@@ -1,5 +0,0 @@
-require 'spec_helper'
-
-RSpec.describe RSpec::Sidekiq::VERSION do
-  it { is_expected.to eq('2.2.0') }
-end