rspec-sidekiq 2.2.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4e76f040dc9a72982978b86c4085e90a4efeab6f
-  data.tar.gz: 4f3531dc67714ce9f1aae2858b2e12c4baf80f2e
+  metadata.gz: 71242ca35cdc2cccbfbae1008db364d84f58a1f1
+  data.tar.gz: 6114262aa4025c8d10b982d3a7261b36667318bb
 SHA512:
-  metadata.gz: 02c75664a4f650debe93f2a6a61d51ce5c8341c16388824f500d0d5afe75b7ab044a6606a2c3fab25649ea424f9da683da05e8ab71dd69893f54a9dc7cea5345
-  data.tar.gz: 7528d4c9f3cda76979b3118dee4069fdb86792e566e91bfd475703d2f107e5555ed1a850a0ff0e4b79b874f37b74261f2250bc28e148324555d22b31bdf4dbfd
+  metadata.gz: 861094f58471094e392603b3978e9c95d8f6ca0ca1da86ff064831d0bd42c28c4ea8fac5c779a01b030286bbab6bde0ca378b066bf8635706cd7f2e9a00583d1
+  data.tar.gz: 0f6a5cd8b3f6a5fbc436e4594d96cc25286a9631a7f93941878f87df7ccb8dc313e2ce3fa21535c1b442d5fa2849526a22c003afee4d59315b10992690d43b7e

data/CHANGES.md

@@ -1,3 +1,14 @@
+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 @wpolicarpo and @packrat386 as new maintainers for `rspec-sidekiq`!**
+
 # RSpec for Sidekiq
 
 [![RubyGems][gem_version_badge]][ruby_gems]
@@ -124,6 +126,7 @@ sidekiq_options unique: true
 expect(AwesomeJob).to be_unique
 it { is_expected.to be_unique }
 ```
+
 ### be_expired_in
 *Describes when a job should expire*
 ```ruby
@@ -141,6 +144,19 @@ AwesomeJob.perform_async 'Awesome', true
 expect(AwesomeJob).to have_enqueued_job('Awesome', true)
 ```
 
+#### 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_job('Awesome', true).at(5.minutes.from_now)
+```
+```ruby
+Awesomejob.perform_in 5.minutes, 'Awesome', true
+# test with...
+expect(AwesomeJob).to have_enqueued_job('Awesome', true).in(5.minutes)
+```
+
 ## Example matcher usage
 ```ruby
 require 'spec_helper'
@@ -180,6 +196,11 @@ FooClass.within_sidekiq_retries_exhausted_block {
 ## Testing
 ```bundle exec rspec spec```
 
+## Maintainers
+* @wpolicarpo
+* @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

@@ -33,7 +33,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
@@ -59,6 +59,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 +77,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_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

@@ -5,11 +5,110 @@ module RSpec
         HaveEnqueuedJob.new expected_arguments
       end
 
+      if Gem::Dependency.new('rspec-rails', '>= 3.4.0').matching_specs.max_by(&:version)
+        warn "[DEPRECATION] `have_enqueued_job` is deprecated.  Please use `have_enqueued_sidekiq_job` instead."
+        alias have_enqueued_sidekiq_job have_enqueued_job
+      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'].blank?
+          value.to_time.to_s == Time.at(job['at']).to_s
+        end
+
+        def in_evaluator(value)
+          return false if job['at'].blank?
+          (Time.now + value).to_s == Time.at(job['at']).to_s
+        end
+      end
+
+      class JobMatcher
+        attr_reader :jobs
+
+        def initialize(klass)
+          @jobs = unwrap_jobs(klass.jobs)
+        end
+
+        def present?(arguments, options)
+          find_job(arguments, options).present?
+        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|
+            job.slice('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/version.rb

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

data/rspec-sidekiq.gemspec

@@ -11,9 +11,10 @@ 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 'rspec', '~> 3.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'

data/spec/rspec/sidekiq/batch_spec.rb

@@ -10,31 +10,68 @@ 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
+
+      before(:each) do
+        batch.on(:event, MyCallback, my_arg: 42)
+      end
+
+      it 'executes callbacks' do
+        expect_any_instance_of(MyCallback).to receive(:on_event).with(subject, { my_arg: 42 })
+        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
+      end
+    end
+  end
 end

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

@@ -1,10 +1,12 @@
 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(: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 }
 
@@ -14,41 +16,70 @@ RSpec.describe RSpec::Sidekiq::Matchers::HaveEnqueuedJob do
     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_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_job *worker_args
+      end
 
-    it 'matches on an enqueued ActiveJob' do
-      expect(Sidekiq::Worker).to have_enqueued_job 'someResource'
-    end
+      context 'perform_in' do
+        let(:worker_args_in) { worker_args + ['in'] }
+
+        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_job(*worker_args_in).in(interval)
+        end
+      end
+
+      context 'perform_at' do
+        let(:worker_args_at) { worker_args + ['at'] }
 
-    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)
+        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_job(*worker_args_at).at(tomorrow)
+        end
+      end
     end
 
-    it 'matches on ActionMailer Job' do
-      expect(Sidekiq::Worker).to have_enqueued_job(
-        "TestActionMailer",
-        "testmail",
-        "deliver_now"
-      )
+    context 'ActiveJob' do
+      it 'matches on an enqueued ActiveJob' do
+        expect(Sidekiq::Worker).to have_enqueued_job 'someResource'
+      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)
+      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 }
-      )
+    context 'ActionMailer' do
+      it 'matches on ActionMailer Job' do
+        expect(Sidekiq::Worker).to have_enqueued_job(
+          'TestActionMailer',
+          'testmail',
+          'deliver_now'
+        )
+      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 }
+        )
+      end
     end
   end
 
@@ -60,13 +91,30 @@ RSpec.describe RSpec::Sidekiq::Matchers::HaveEnqueuedJob do
 
   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 +122,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 +187,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/rspec/sidekiq/version_spec.rb

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

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: rspec-sidekiq
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 3.0.0
 platform: ruby
 authors:
 - Phil Ostler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-12-22 00:00:00.000000000 Z
+date: 2017-04-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: rspec-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
@@ -44,6 +44,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 2.4.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
@@ -193,7 +207,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.8
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: RSpec for Sidekiq