sidekiq-unique-jobs 4.0.0 → 4.0.7

data/lib/sidekiq_unique_jobs/testing/sidekiq_overrides.rb

@@ -34,11 +34,15 @@ module Sidekiq
         end
         jobs.clear
       end
+
+      def execute_job(worker, args)
+        worker.perform(*args)
+      end unless respond_to?(:execute_job)
     end
 
     module Overrides
       def self.included(base)
-        base.extend Sidekiq::Worker::Overrides::ClassMethods
+        base.extend Testing
         base.class_eval do
           class << self
             alias_method :clear_all_orig, :clear_all
@@ -47,7 +51,7 @@ module Sidekiq
         end
       end
 
-      module ClassMethods
+      module Testing
         def clear_all_ext
           Sidekiq.redis do |c|
             unique_keys = c.keys("#{SidekiqUniqueJobs.config.unique_prefix}:*")

data/lib/sidekiq_unique_jobs/timeout_calculator.rb

@@ -0,0 +1,42 @@
+module SidekiqUniqueJobs
+  class TimeoutCalculator
+    def self.for_item(item)
+      new(item)
+    end
+
+    def initialize(item)
+      @item = item
+    end
+
+    def seconds
+      time_until_scheduled + unique_expiration
+    end
+
+    def time_until_scheduled
+      scheduled = item[AT_KEY]
+      return 0 unless scheduled
+      (Time.at(scheduled) - Time.now.utc).to_i
+    end
+
+    def unique_expiration
+      @unique_expiration ||=
+        (
+          worker_class_unique_expiration ||
+          SidekiqUniqueJobs.config.default_expiration
+        ).to_i
+    end
+
+    def worker_class_unique_expiration
+      return unless worker_class.respond_to?(:get_sidekiq_options)
+      worker_class.get_sidekiq_options[UNIQUE_TIMEOUT_KEY]
+    end
+
+    def worker_class
+      @worker_class ||= SidekiqUniqueJobs.worker_class_constantize(item[CLASS_KEY])
+    end
+
+    private
+
+    attr_reader :item
+  end
+end

data/lib/sidekiq_unique_jobs/unique_args.rb

@@ -1,26 +1,28 @@
+require 'digest'
 require 'sidekiq_unique_jobs/normalizer'
 
 module SidekiqUniqueJobs
   # This class exists to be testable and the entire api should be considered private
   # rubocop:disable ClassLength
   class UniqueArgs
+    CLASS_NAME = 'SidekiqUniqueJobs::UniqueArgs'.freeze
     extend Forwardable
     include Normalizer
 
     def_delegators :SidekiqUniqueJobs, :config, :worker_class_constantize
-    def_delegators :'Sidekiq.logger', :logger, :debug, :warn, :error, :fatal
+    def_delegators :Sidekiq, :logger
 
     def self.digest(item)
       new(item).unique_digest
     end
 
     def initialize(job)
-      Sidekiq::Logging.with_context(self.class.name) do
+      Sidekiq::Logging.with_context(CLASS_NAME) do
         @item = job
-        @worker_class ||= worker_class_constantize(@item['class'.freeze])
-        @item['unique_prefix'.freeze] ||= unique_prefix
-        @item['unique_args'.freeze] ||= unique_args(@item['args'.freeze])
-        @item['unique_digest'.freeze] ||= unique_digest
+        @worker_class ||= worker_class_constantize(@item[CLASS_KEY])
+        @item[UNIQUE_PREFIX_KEY] ||= unique_prefix
+        @item[UNIQUE_ARGS_KEY] ||= unique_args(@item[ARGS_KEY])
+        @item[UNIQUE_DIGEST_KEY] ||= unique_digest
       end
     end
 
@@ -28,22 +30,24 @@ module SidekiqUniqueJobs
       @unique_digest ||= begin
         digest = Digest::MD5.hexdigest(Sidekiq.dump_json(digestable_hash))
         digest = "#{unique_prefix}:#{digest}"
-        debug { "#{__method__} : #{digestable_hash} into #{digest}" }
+        logger.debug { "#{__method__} : #{digestable_hash} into #{digest}" }
         digest
       end
     end
 
     def unique_prefix
       return config.unique_prefix unless sidekiq_worker_class?
-      @worker_class.get_sidekiq_options['unique_prefix'.freeze] || config.unique_prefix
+      @worker_class.get_sidekiq_options[UNIQUE_PREFIX_KEY] || config.unique_prefix
     end
 
     def digestable_hash
-      hash = @item.slice('class', 'queue', 'unique_args')
+      hash = @item.slice(CLASS_KEY, QUEUE_KEY, UNIQUE_ARGS_KEY)
 
       if unique_on_all_queues?
-        debug { "uniqueness specified across all queues (deleting queue: #{@item['queue']} from hash)" }
-        hash.delete('queue')
+        logger.debug do
+          "uniqueness specified across all queues (deleting queue: #{@item[QUEUE_KEY]} from hash)"
+        end
+        hash.delete(QUEUE_KEY)
       end
       hash
     end
@@ -52,7 +56,7 @@ module SidekiqUniqueJobs
       if unique_args_enabled?
         filtered_args(args)
       else
-        debug { "#{__method__} : unique arguments disabled" }
+        logger.debug { "#{__method__} : unique arguments disabled" }
         args
       end
     rescue NameError
@@ -62,26 +66,19 @@ module SidekiqUniqueJobs
 
     def unique_on_all_queues?
       return unless sidekiq_worker_class?
-      return unless unique_args_enabled?
-      @worker_class.get_sidekiq_options['unique_on_all_queues'.freeze]
+      @item[UNIQUE_ON_ALL_QUEUES_KEY] || @worker_class.get_sidekiq_options[UNIQUE_ON_ALL_QUEUES_KEY]
     end
 
     def unique_args_enabled?
-      unique_args_enabled_in_worker? ||
-        config.unique_args_enabled
-    end
-
-    def unique_args_enabled_in_worker?
       return unless sidekiq_worker_class?
-      @worker_class.get_sidekiq_options['unique_args_enabled'.freeze] ||
-        @worker_class.get_sidekiq_options['unique_args'.freeze]
+      unique_args_method # && !unique_args_method.is_a?(Boolean)
     end
 
     def sidekiq_worker_class?
       if @worker_class.respond_to?(:get_sidekiq_options)
         true
       else
-        debug { "#{@worker_class} does not respond to :get_sidekiq_options" }
+        logger.debug { "#{@worker_class} does not respond to :get_sidekiq_options" }
         nil
       end
     end
@@ -91,7 +88,7 @@ module SidekiqUniqueJobs
     def filtered_args(args)
       return args if args.empty?
       json_args = Normalizer.jsonify(args)
-      debug { "#filtered_args #{args} => #{json_args}" }
+      logger.debug { "#filtered_args #{args} => #{json_args}" }
 
       case unique_args_method
       when Proc
@@ -99,20 +96,24 @@ module SidekiqUniqueJobs
       when Symbol
         filter_by_symbol(json_args)
       else
-        debug { 'arguments not filtered (the combined arguments count towards uniqueness)' }
+        logger.debug { 'arguments not filtered (the combined arguments count towards uniqueness)' }
         json_args
       end
     end
 
     def filter_by_proc(args)
+      if unique_args_method.nil?
+        warn { "#{__method__} : Proc was nil, returning args as is #{args} -> #{filter_args}" }
+        return args
+      end
       filter_args = unique_args_method.call(args)
-      debug { "#{__method__} : #{args} -> #{filter_args}" }
+      logger.debug { "#{__method__} : #{args} -> #{filter_args}" }
       filter_args
     end
 
     def filter_by_symbol(args)
       unless @worker_class.respond_to?(unique_args_method)
-        warn do
+        logger.warn do
           "#{__method__} : #{unique_args_method}) not defined in #{@worker_class} " \
                "returning #{args} unchanged"
         end
@@ -120,13 +121,14 @@ module SidekiqUniqueJobs
       end
 
       filter_args = @worker_class.send(unique_args_method, args)
-      debug { "#{__method__} : #{unique_args_method}(#{args}) => #{filter_args}" }
+      logger.debug { "#{__method__} : #{unique_args_method}(#{args}) => #{filter_args}" }
       filter_args
     end
 
     def unique_args_method
-      @unique_args_method ||=
-        @worker_class.get_sidekiq_options['unique_args'.freeze] if sidekiq_worker_class?
+      @unique_args_method ||= @worker_class.get_sidekiq_options[UNIQUE_ARGS_KEY] if sidekiq_worker_class?
+      @unique_args_method ||= :unique_args if @worker_class.respond_to?(:unique_args)
+      @unique_args_method ||= Sidekiq.default_worker_options.stringify_keys[UNIQUE_ARGS_KEY]
     end
   end
 end

data/lib/sidekiq_unique_jobs/version.rb

@@ -1,3 +1,3 @@
 module SidekiqUniqueJobs
-  VERSION = '4.0.0'
+  VERSION = '4.0.7'
 end

data/redis/synchronize.lua

@@ -7,7 +7,7 @@ end
 
 local stored_time = redis.pcall('get', unique_key)
 if stored_time and stored_time < time then
-  if redis.call('set', unique_key, time + 60, 'nx', 'ex') then
+  if redis.pcall('set', unique_key, time + 60, 'xx', 'ex', 60) then
     return 1
   end
 end

data/sidekiq-unique-jobs.gemspec

@@ -19,7 +19,6 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency 'rspec', '~> 3.1.0'
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec-sidekiq'
-  gem.add_development_dependency 'activesupport', '>= 3'
   gem.add_development_dependency 'rubocop'
-  gem.add_development_dependency 'simplecov'
+  gem.add_development_dependency 'timecop'
 end

data/spec/{workers/unique_worker.rb → jobs/another_unique_job.rb}

@@ -1,7 +1,7 @@
-class UniqueWorker
+class AnotherUniqueJob
   include Sidekiq::Worker
-  sidekiq_options queue: :working, retry: 1, backtrace: 10
-  sidekiq_options unique: true, unique_lock: :until_executed
+  sidekiq_options queue: :working, retry: 1, backtrace: 10,
+                  unique: :until_executed
 
   sidekiq_retries_exhausted do |msg|
     Sidekiq.logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"

data/spec/{workers/queue_worker.rb → jobs/custom_queue_job.rb}

@@ -1,4 +1,4 @@
-class QueueWorker
+class CustomQueueJob
   include Sidekiq::Worker
   sidekiq_options queue: :customqueue
   def perform(_)

data/spec/jobs/custom_queue_job_with_filter_method.rb

@@ -0,0 +1,7 @@
+class CustomQueueJobWithFilterMethod < CustomQueueJob
+  sidekiq_options unique: :until_executed, unique_args: :args_filter
+
+  def self.args_filter(*args)
+    args.first
+  end
+end

data/spec/{workers/queue_worker_with_filter_proc.rb → jobs/custom_queue_job_with_filter_proc.rb}

@@ -1,8 +1,7 @@
-class QueueWorkerWithFilterProc < QueueWorker
+class CustomQueueJobWithFilterProc < CustomQueueJob
   # slightly contrived example of munging args to the
   # worker and removing a random bit.
-  sidekiq_options unique: true,
-                  unique_lock: :until_timeout,
+  sidekiq_options unique: :until_timeout,
                   unique_args: (lambda do |*args|
                     options = args.extract_options!
                     options.delete(:random)

data/spec/jobs/expiring_job.rb

@@ -0,0 +1,4 @@
+class ExpiringJob
+  include Sidekiq::Worker
+  sidekiq_options unique: :until_executed, unique_expiration: 10 * 60
+end

data/spec/{workers → jobs}/inline_worker.rb

@@ -1,6 +1,6 @@
 class InlineWorker
   include Sidekiq::Worker
-  sidekiq_options unique: true
+  sidekiq_options unique: :while_executing
 
   def perform(x)
     TestClass.run(x)

data/spec/jobs/just_a_worker.rb

@@ -0,0 +1,8 @@
+class JustAWorker
+  include Sidekiq::Worker
+
+  sidekiq_options unique: :until_executed, queue: 'testqueue'
+
+  def perform
+  end
+end

data/spec/jobs/main_job.rb

@@ -0,0 +1,8 @@
+class MainJob
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue, unique: :until_executed,
+                  log_duplicate_payload: true
+
+  def perform(_)
+  end
+end

data/spec/{workers/my_worker.rb → jobs/my_job.rb}

@@ -1,7 +1,6 @@
-class MyWorker
+class MyJob
   include Sidekiq::Worker
-  sidekiq_options queue: :working, retry: 1, backtrace: 10
-  sidekiq_options unique: false
+  sidekiq_options queue: :working, retry: 1, backtrace: 10, unique: false
 
   sidekiq_retries_exhausted do |msg|
     Sidekiq.logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"

data/spec/jobs/my_unique_job.rb

@@ -0,0 +1,7 @@
+class MyUniqueJob
+  include Sidekiq::Worker
+  sidekiq_options queue: :customqueue, retry: true, unique: :until_executed,
+                  unique_expiration: 7_200, retry_count: 10
+  def perform(_)
+  end
+end

data/spec/{workers → jobs}/unique_job_with_filter_method.rb

@@ -1,7 +1,7 @@
 class UniqueJobWithFilterMethod
   include Sidekiq::Worker
-  sidekiq_options queue: :customqueue, retry: 1, backtrace: 10
-  sidekiq_options unique: true, unique_args: :filtered_args
+  sidekiq_options queue: :customqueue, retry: 1, backtrace: 10,
+                  unique: :while_executing, unique_args: :filtered_args
 
   sidekiq_retries_exhausted do |msg|
     Sidekiq.logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"

data/spec/{workers/unique_on_all_queues_worker.rb → jobs/unique_on_all_queues_job.rb}

@@ -1,7 +1,7 @@
-class UniqueOnAllQueuesWorker
+class UniqueOnAllQueuesJob
   include Sidekiq::Worker
-  sidekiq_options queue: :working, retry: 1, backtrace: 10
-  sidekiq_options unique: true, unique_on_all_queues: true, unique_lock: :until_executed
+  sidekiq_options queue: :working, retry: 1, backtrace: 10,
+                  unique: :until_executed, unique_on_all_queues: true
 
   sidekiq_retries_exhausted do |msg|
     Sidekiq.logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"

data/spec/jobs/until_and_while_executing_job.rb

@@ -0,0 +1,8 @@
+class UntilAndWhileExecuting
+  include Sidekiq::Worker
+
+  sidekiq_options queue: :working, unique: :until_and_while_executing
+
+  def perform
+  end
+end

data/spec/{workers/another_unique_worker.rb → jobs/until_executed_job.rb}

@@ -1,7 +1,7 @@
-class AnotherUniqueWorker
+class UntilExecutedJob
   include Sidekiq::Worker
   sidekiq_options queue: :working, retry: 1, backtrace: 10
-  sidekiq_options unique: true, unique_lock: :until_executed
+  sidekiq_options unique: :until_executed
 
   sidekiq_retries_exhausted do |msg|
     Sidekiq.logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"
@@ -10,4 +10,8 @@ class AnotherUniqueWorker
   def perform(*)
     # NO-OP
   end
+
+  def after_unlock
+    fail 'HELL'
+  end
 end

data/spec/jobs/until_executing_job.rb

@@ -0,0 +1,8 @@
+class UntilExecutingJob
+  include Sidekiq::Worker
+
+  sidekiq_options queue: :working, unique: :until_executing
+
+  def perform
+  end
+end

data/spec/jobs/until_global_timeout_job.rb

@@ -0,0 +1,8 @@
+class UntilGlobalTimeoutJob
+  include Sidekiq::Worker
+  sidekiq_options unique: :until_timeout
+
+  def perform(x)
+    TestClass.run(x)
+  end
+end

data/spec/{workers/inline_expiration_worker.rb → jobs/until_timeout_job.rb}

@@ -1,6 +1,6 @@
-class InlineExpirationWorker
+class UntilTimeoutJob
   include Sidekiq::Worker
-  sidekiq_options unique: true, unique_lock: :until_timeout,
+  sidekiq_options unique: :until_timeout,
                   unique_expiration: 10 * 60
   def perform(x)
     TestClass.run(x)

data/spec/{workers/after_unlock_worker.rb → jobs/while_executing_job.rb}

@@ -1,7 +1,6 @@
-class AfterUnlockWorker
+class WhileExecutingJob
   include Sidekiq::Worker
-  sidekiq_options queue: :working, retry: 1, backtrace: 10
-  sidekiq_options unique: true, unique_lock: :until_executed
+  sidekiq_options queue: :working, retry: 1, backtrace: 10, unique: :while_executing
 
   sidekiq_retries_exhausted do |msg|
     Sidekiq.logger.warn "Failed #{msg['class']} with #{msg['args']}: #{msg['error_message']}"

data/spec/lib/sidekiq_unique_jobs/client/middleware_spec.rb

@@ -1,5 +1,4 @@
 require 'spec_helper'
-require 'celluloid/current'
 require 'sidekiq/worker'
 require 'sidekiq-unique-jobs'
 require 'sidekiq/scheduled'
@@ -13,36 +12,50 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
     before do
       Sidekiq.redis = REDIS
       Sidekiq.redis(&:flushdb)
-      QueueWorker.sidekiq_options unique: nil, unique_expiration: nil
     end
 
     describe 'when a job is already scheduled' do
-      context '#new_unique_for' do
-        it 'rejects new scheduled jobs with the same argument' do
-          MyUniqueWorker.perform_in(3600, 1)
-          expect(MyUniqueWorker.perform_in(3600, 1)).to eq(nil)
+      it 'rejects new scheduled jobs with the same argument' do
+        MyUniqueJob.perform_in(3600, 1)
+        expect(MyUniqueJob.perform_in(3600, 1)).to eq(nil)
+      end
+
+      it 'will run a job in real time with the same arguments' do
+        WhileExecutingJob.perform_in(3600, 1)
+        expect(WhileExecutingJob.perform_async(1)).not_to eq(nil)
+      end
+
+      it 'schedules new jobs when arguments differ' do
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].each do |x|
+          MainJob.perform_in(x, x)
         end
 
-        it 'will run a job in real time with the same arguments' do
-          WhileExecutingWorker.perform_in(3600, 1)
-          expect(WhileExecutingWorker.perform_async(1)).not_to eq(nil)
+        Sidekiq.redis do |c|
+          count = c.zcount('schedule', -1, Time.now.to_f + 2 * 60)
+          expect(count).to eq(20)
         end
+      end
 
-        it 'schedules new jobs when arguments differ' do
-          [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].each do |x|
-            MainJob.perform_in(x.seconds.from_now, x)
+      it 'schedules allows jobs to be scheduled ' do
+        class ShitClass
+          def do_it(_arg)
+            # whatever
           end
+        end
 
-          Sidekiq.redis do |c|
-            count = c.zcount('schedule', -1, Time.now.to_f + 2 * 60)
-            expect(count).to eq(20)
-          end
+        [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].each do |x|
+          ShitClass.delay_for(x, unique: :while_executing).do_it(1)
+        end
+
+        Sidekiq.redis do |c|
+          count = c.zcount('schedule', -1, Time.now.to_f + 2 * 60)
+          expect(count).to eq(20)
         end
       end
     end
 
     it 'does not push duplicate messages when configured for unique only' do
-      item = { 'class' => MyUniqueWorker, 'queue' => 'customqueue', 'args' => [1, 2] }
+      item = { 'class' => MyUniqueJob, 'queue' => 'customqueue', 'args' => [1, 2] }
       10.times { Sidekiq::Client.push(item) }
       Sidekiq.redis do |c|
         expect(c.llen('queue:customqueue')).to eq(1)
@@ -50,8 +63,8 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
     end
 
     it 'does push duplicate messages to different queues' do
-      Sidekiq::Client.push('class' => MyUniqueWorker, 'queue' => 'customqueue', 'args' => [1, 2])
-      Sidekiq::Client.push('class' => MyUniqueWorker, 'queue' => 'customqueue2', 'args' => [1, 2])
+      Sidekiq::Client.push('class' => MyUniqueJob, 'queue' => 'customqueue', 'args' => [1, 2])
+      Sidekiq::Client.push('class' => MyUniqueJob, 'queue' => 'customqueue2', 'args' => [1, 2])
       Sidekiq.redis do |c|
         expect(c.llen('queue:customqueue')).to eq 1
         expect(c.llen('queue:customqueue2')).to eq 1
@@ -59,14 +72,14 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
     end
 
     it 'does not queue duplicates when when calling delay' do
-      10.times { PlainClass.delay(unique_lock: :until_executed, unique: true, queue: 'customqueue').run(1) }
+      10.times { PlainClass.delay(unique: :until_executed, queue: 'customqueue').run(1) }
       Sidekiq.redis do |c|
         expect(c.llen('queue:customqueue')).to eq(1)
       end
     end
 
     it 'does not schedule duplicates when calling perform_in' do
-      10.times { MyUniqueWorker.perform_in(60, [1, 2]) }
+      10.times { MyUniqueJob.perform_in(60, [1, 2]) }
       Sidekiq.redis do |c|
         expect(c.zcount('schedule', -1, Time.now.to_f + 2 * 60))
           .to eq(1)
@@ -74,8 +87,8 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
     end
 
     it 'enqueues previously scheduled job' do
-      jid = WhileExecutingWorker.perform_in(60 * 60, 1, 2)
-      item = { 'class' => WhileExecutingWorker, 'queue' => 'customqueue', 'args' => [1, 2], 'jid' => jid }
+      jid = WhileExecutingJob.perform_in(60 * 60, 1, 2)
+      item = { 'class' => WhileExecutingJob, 'queue' => 'customqueue', 'args' => [1, 2], 'jid' => jid }
 
       # time passes and the job is pulled off the schedule:
       Sidekiq::Client.push(item)
@@ -86,18 +99,20 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
     end
 
     it 'sets an expiration when provided by sidekiq options' do
-      item = { 'class' => ExpiringWorker, 'queue' => 'customqueue', 'args' => [1, 2] }
+      item = { 'class' => ExpiringJob, 'queue' => 'customqueue', 'args' => [1, 2] }
       Sidekiq::Client.push(item)
 
       Sidekiq.redis do |c|
         expect(c.llen('queue:customqueue')).to eq(1)
         expect(c.ttl(digest_for(item)))
-          .to eq(ExpiringWorker.get_sidekiq_options['unique_expiration'])
+          .to eq(ExpiringJob.get_sidekiq_options['unique_expiration'])
       end
     end
 
     it 'does push duplicate messages when not configured for unique only' do
-      10.times { Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue', 'args' => [1, 2]) }
+      10.times do
+        Sidekiq::Client.push('class' => CustomQueueJob, 'queue' => 'customqueue', 'args' => [1, 2])
+      end
 
       Sidekiq.redis do |c|
         expect(c.llen('queue:customqueue')).to eq(10)
@@ -105,16 +120,13 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
     end
 
     describe 'when unique_args is defined' do
-      before(:all) { SidekiqUniqueJobs.config.unique_args_enabled = true }
-      after(:all)  { SidekiqUniqueJobs.config.unique_args_enabled = false }
-
       it 'does not push duplicate messages based on args filter method' do
-        expect(QueueWorkerWithFilterMethod).to respond_to(:args_filter)
-        expect(QueueWorkerWithFilterMethod.get_sidekiq_options['unique_args']).to eq :args_filter
+        expect(CustomQueueJobWithFilterMethod).to respond_to(:args_filter)
+        expect(CustomQueueJobWithFilterMethod.get_sidekiq_options['unique_args']).to eq :args_filter
 
         (0..10).each do |i|
           Sidekiq::Client.push(
-            'class' => QueueWorkerWithFilterMethod,
+            'class' => CustomQueueJobWithFilterMethod,
             'queue' => 'customqueue',
             'args' => [1, i]
           )
@@ -126,11 +138,11 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
       end
 
       it 'does not push duplicate messages based on args filter proc' do
-        expect(QueueWorkerWithFilterProc.get_sidekiq_options['unique_args']).to be_a(Proc)
+        expect(CustomQueueJobWithFilterProc.get_sidekiq_options['unique_args']).to be_a(Proc)
 
         100.times do
           Sidekiq::Client.push(
-            'class' => QueueWorkerWithFilterProc,
+            'class' => CustomQueueJobWithFilterProc,
             'queue' => 'customqueue',
             'args' => [1, { random: rand, name: 'foobar' }]
           )
@@ -143,7 +155,7 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
 
       describe 'when unique_on_all_queues is set' do
         it 'does not push duplicate messages on different queues' do
-          item = { 'class' => UniqueOnAllQueuesWorker, 'args' => [1, 2] }
+          item = { 'class' => UniqueOnAllQueuesJob, 'args' => [1, 2] }
           Sidekiq::Client.push(item.merge('queue' => 'customqueue'))
           Sidekiq::Client.push(item.merge('queue' => 'customqueue2'))
           Sidekiq.redis do |c|
@@ -158,9 +170,9 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
     # jobs are set around the same time as the scheduled job itself feel free to improve.
     it 'expires the digest when a scheduled job is scheduled at' do
       expected_expires_at =
-        (Time.at(15.minutes.from_now) - Time.now.utc) + SidekiqUniqueJobs.config.default_expiration
-      jid = MyUniqueWorker.perform_in(expected_expires_at, 'mike')
-      item = { 'class' => MyUniqueWorker,
+        (Time.at(Time.now.to_i + 15 * 60) - Time.now.utc) + SidekiqUniqueJobs.config.default_expiration
+      jid = MyUniqueJob.perform_in(expected_expires_at, 'mike')
+      item = { 'class' => MyUniqueJob,
                'queue' => 'customqueue',
                'args' => ['mike'],
                'at' => expected_expires_at }
@@ -172,24 +184,28 @@ RSpec.describe SidekiqUniqueJobs::Client::Middleware do
 
     it 'logs duplicate payload when config turned on' do
       expect(Sidekiq.logger).to receive(:warn).with(/^payload is not unique/)
-      UniqueWorker.sidekiq_options log_duplicate_payload: true
-      2.times { Sidekiq::Client.push('class' => UniqueWorker, 'queue' => 'customqueue', 'args' => [1, 2]) }
+      UntilExecutedJob.sidekiq_options log_duplicate_payload: true
+      2.times do
+        Sidekiq::Client.push('class' => UntilExecutedJob, 'queue' => 'customqueue', 'args' => [1, 2])
+      end
       Sidekiq.redis do |c|
         expect(c.llen('queue:customqueue')).to eq 1
       end
-      UniqueWorker.sidekiq_options log_duplicate_payload: true
+      UntilExecutedJob.sidekiq_options log_duplicate_payload: true
     end
 
     it 'does not log duplicate payload when config turned off' do
       expect(Sidekiq.logger).to_not receive(:warn).with(/^payload is not unique/)
 
-      UniqueWorker.sidekiq_options log_duplicate_payload: false
+      UntilExecutedJob.sidekiq_options log_duplicate_payload: false
 
-      2.times { Sidekiq::Client.push('class' => UniqueWorker, 'queue' => 'customqueue', 'args' => [1, 2]) }
+      2.times do
+        Sidekiq::Client.push('class' => UntilExecutedJob, 'queue' => 'customqueue', 'args' => [1, 2])
+      end
       Sidekiq.redis do |c|
         expect(c.llen('queue:customqueue')).to eq 1
       end
-      UniqueWorker.sidekiq_options log_duplicate_payload: true
+      UntilExecutedJob.sidekiq_options log_duplicate_payload: true
     end
   end
 end