sidekiq-unique-jobs 3.0.2 → 3.0.5

data/lib/{sidekiq-unique-jobs → sidekiq_unique_jobs}/middleware/server/unique_jobs.rb

@@ -1,4 +1,5 @@
 require 'digest'
+require 'sidekiq_unique_jobs/connectors'
 
 module SidekiqUniqueJobs
   module Middleware
@@ -6,10 +7,10 @@ module SidekiqUniqueJobs
       class UniqueJobs
         attr_reader :unlock_order, :redis_pool
 
-        def call(worker, item, queue, redis_pool = nil)
+        def call(worker, item, _queue, redis_pool = nil)
           @redis_pool = redis_pool
 
-          set_unlock_order(worker.class)
+          decide_unlock_order(worker.class)
           lock_key = payload_hash(item)
           unlocked = before_yield? ? unlock(lock_key).inspect : 0
 
@@ -20,12 +21,12 @@ module SidekiqUniqueJobs
           end
         end
 
-        def set_unlock_order(klass)
+        def decide_unlock_order(klass)
           @unlock_order = if unlock_order_configured?(klass)
-            klass.get_sidekiq_options['unique_unlock_order']
-          else
-            default_unlock_order
-          end
+                            klass.get_sidekiq_options['unique_unlock_order']
+                          else
+                            default_unlock_order
+                          end
         end
 
         def unlock_order_configured?(klass)
@@ -34,7 +35,7 @@ module SidekiqUniqueJobs
         end
 
         def default_unlock_order
-          SidekiqUniqueJobs::Config.default_unlock_order
+          SidekiqUniqueJobs.config.default_unlock_order
         end
 
         def before_yield?
@@ -52,16 +53,16 @@ module SidekiqUniqueJobs
         end
 
         def unlock(payload_hash)
-          if redis_pool
-            redis_pool.with { |conn| conn.del(payload_hash) }
-          else
-            Sidekiq.redis { |conn| conn.del(payload_hash) }
-          end
+          conn.del(payload_hash)
         end
 
         def logger
           Sidekiq.logger
         end
+
+        def conn
+          SidekiqUniqueJobs::Connectors.conn(redis_pool)
+        end
       end
     end
   end

data/lib/sidekiq_unique_jobs/payload_helper.rb

@@ -0,0 +1,42 @@
+module SidekiqUniqueJobs
+  class PayloadHelper
+    def self.config
+      SidekiqUniqueJobs.config
+    end
+
+    def self.get_payload(klass, queue, *args)
+      unique_on_all_queues = false
+      if config.unique_args_enabled
+        worker_class = klass.constantize
+        args = yield_unique_args(worker_class, *args)
+        unique_on_all_queues =
+          worker_class.get_sidekiq_options['unique_on_all_queues']
+      end
+      md5_arguments = { class: klass, args: args }
+      md5_arguments[:queue] = queue unless unique_on_all_queues
+      "#{config.unique_prefix}:" \
+        "#{Digest::MD5.hexdigest(Sidekiq.dump_json(md5_arguments))}"
+    end
+
+    def self.yield_unique_args(worker_class, args)
+      unique_args = worker_class.get_sidekiq_options['unique_args']
+      filtered_args(worker_class, unique_args, args)
+    rescue NameError
+      # fallback to not filtering args when class can't be instantiated
+      args
+    end
+
+    def self.filtered_args(worker_class, unique_args, args)
+      case unique_args
+      when Proc
+        unique_args.call(args)
+      when Symbol
+        if worker_class.respond_to?(unique_args)
+          worker_class.send(unique_args, *args)
+        end
+      else
+        args
+      end
+    end
+  end
+end

data/lib/{sidekiq-unique-jobs → sidekiq_unique_jobs}/testing.rb

@@ -1,6 +1,6 @@
 require 'mock_redis'
 module SidekiqUniqueJobs
   def self.redis_mock
-     @redis_mock ||= MockRedis.new
+    @redis_mock ||= MockRedis.new
   end
-end
+end

data/lib/{sidekiq-unique-jobs → sidekiq_unique_jobs}/version.rb

@@ -1,3 +1,3 @@
 module SidekiqUniqueJobs
-  VERSION = "3.0.2"
+  VERSION = '3.0.5'
 end

data/sidekiq-unique-jobs.gemspec

@@ -1,24 +1,25 @@
 # -*- encoding: utf-8 -*-
-require File.expand_path('../lib/sidekiq-unique-jobs/version', __FILE__)
+require File.expand_path('../lib/sidekiq_unique_jobs/version', __FILE__)
 
 Gem::Specification.new do |gem|
-  gem.authors       = ["Mikael Henriksson"]
-  gem.email         = ["mikael@zoolutions.se"]
-  gem.description   = gem.summary = "The unique jobs that were removed from sidekiq"
-  gem.homepage      = "https://github.com/mhenrixon/sidekiq-unique-jobs"
-  gem.license       = "LGPL-3.0"
+  gem.authors       = ['Mikael Henriksson']
+  gem.email         = ['mikael@zoolutions.se']
+  gem.description   = gem.summary = 'The unique jobs that were removed from sidekiq'
+  gem.homepage      = 'https://github.com/mhenrixon/sidekiq-unique-jobs'
+  gem.license       = 'LGPL-3.0'
 
   # gem.executables   = ['']
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- test/*`.split("\n")
-  gem.name          = "sidekiq-unique-jobs"
-  gem.require_paths = ["lib"]
+  gem.name          = 'sidekiq-unique-jobs'
+  gem.require_paths = ['lib']
   gem.version       = SidekiqUniqueJobs::VERSION
-  gem.add_dependency             'sidekiq', '>= 2.6'
-  gem.add_dependency             'mock_redis'
-  gem.add_development_dependency 'rspec', '~> 3.0.0.beta'
+  gem.add_dependency 'sidekiq', '>= 2.6'
+  gem.add_development_dependency 'mock_redis'
+  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'
 end

data/spec/lib/client_spec.rb

@@ -1,98 +1,98 @@
 require 'spec_helper'
 require 'celluloid'
 require 'sidekiq/worker'
-require "sidekiq-unique-jobs"
+require 'sidekiq_unique_jobs'
 require 'sidekiq/scheduled'
-require 'sidekiq-unique-jobs/middleware/server/unique_jobs'
+require 'sidekiq_unique_jobs/middleware/server/unique_jobs'
 
-describe "Client" do
+describe 'Client' do
   describe 'with real redis' do
     before do
       Sidekiq.redis = REDIS
-      Sidekiq.redis {|c| c.flushdb }
-      QueueWorker.sidekiq_options :unique => nil, :unique_job_expiration => nil
+      Sidekiq.redis(&:flushdb)
+      QueueWorker.sidekiq_options unique: nil, unique_job_expiration: nil
     end
 
     class QueueWorker
       include Sidekiq::Worker
-      sidekiq_options :queue => 'customqueue'
-      def perform(x)
+      sidekiq_options queue: 'customqueue'
+      def perform(_x)
       end
     end
 
     class PlainClass
-      def run(x)
+      def run(_x)
       end
     end
 
     it 'does not push duplicate messages when configured for unique only' do
-      QueueWorker.sidekiq_options :unique => true
+      QueueWorker.sidekiq_options unique: true
       10.times { Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue',  'args' => [1, 2]) }
-      result = Sidekiq.redis {|c| c.llen("queue:customqueue") }
+      result = Sidekiq.redis { |c| c.llen('queue:customqueue') }
       expect(result).to eq 1
     end
 
     it 'does push duplicate messages to different queues' do
-      QueueWorker.sidekiq_options :unique => true
+      QueueWorker.sidekiq_options unique: true
       Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue',  'args' => [1, 2])
       Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue2',  'args' => [1, 2])
-      q1_length = Sidekiq.redis {|c| c.llen("queue:customqueue") }
-      q2_length = Sidekiq.redis {|c| c.llen("queue:customqueue2") }
+      q1_length = Sidekiq.redis { |c| c.llen('queue:customqueue') }
+      q2_length = Sidekiq.redis { |c| c.llen('queue:customqueue2') }
       expect(q1_length).to eq 1
       expect(q2_length).to eq 1
     end
 
     it 'does not queue duplicates when when calling delay' do
       10.times { PlainClass.delay(unique: true, queue: 'customqueue').run(1) }
-      result = Sidekiq.redis {|c| c.llen("queue:customqueue") }
+      result = Sidekiq.redis { |c| c.llen('queue:customqueue') }
       expect(result).to eq 1
     end
 
     it 'does not schedule duplicates when calling perform_in' do
-      QueueWorker.sidekiq_options :unique => true
+      QueueWorker.sidekiq_options unique: true
       10.times { QueueWorker.perform_in(60, [1, 2]) }
-      result = Sidekiq.redis { |c| c.zcount("schedule", -1, Time.now.to_f + 2 * 60) }
+      result = Sidekiq.redis { |c| c.zcount('schedule', -1, Time.now.to_f + 2 * 60) }
       expect(result).to eq 1
     end
 
     it 'enqueues previously scheduled job' do
-      QueueWorker.sidekiq_options :unique => true
+      QueueWorker.sidekiq_options unique: true
       QueueWorker.perform_in(60 * 60, 1, 2)
 
       # time passes and the job is pulled off the schedule:
       Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue', 'args' => [1, 2])
 
-      result = Sidekiq.redis {|c| c.llen("queue:customqueue") }
+      result = Sidekiq.redis { |c| c.llen('queue:customqueue') }
       expect(result).to eq 1
     end
 
     it 'sets an expiration when provided by sidekiq options' do
       one_hour_expiration = 60 * 60
-      QueueWorker.sidekiq_options :unique => true, :unique_job_expiration => one_hour_expiration
+      QueueWorker.sidekiq_options unique: true, unique_job_expiration: one_hour_expiration
       Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue',  'args' => [1, 2])
 
-      payload_hash = SidekiqUniqueJobs::PayloadHelper.get_payload("QueueWorker", "customqueue", [1, 2])
-      actual_expires_at = Sidekiq.redis {|c| c.ttl(payload_hash) }
+      payload_hash = SidekiqUniqueJobs::PayloadHelper.get_payload('QueueWorker', 'customqueue', [1, 2])
+      actual_expires_at = Sidekiq.redis { |c| c.ttl(payload_hash) }
 
-      result = Sidekiq.redis {|c| c.llen("queue:customqueue") }
+      Sidekiq.redis { |c| c.llen('queue:customqueue') }
       expect(actual_expires_at).to be_within(2).of(one_hour_expiration)
     end
 
     it 'does push duplicate messages when not configured for unique only' do
-      QueueWorker.sidekiq_options :unique => false
+      QueueWorker.sidekiq_options unique: false
       10.times { Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue',  'args' => [1, 2]) }
-      expect(Sidekiq.redis {|c| c.llen("queue:customqueue") }).to eq 10
+      expect(Sidekiq.redis { |c| c.llen('queue:customqueue') }).to eq 10
 
-      result = Sidekiq.redis {|c| c.llen("queue:customqueue") }
+      result = Sidekiq.redis { |c| c.llen('queue:customqueue') }
       expect(result).to eq 10
     end
 
     describe 'when unique_args is defined' do
-      before { SidekiqUniqueJobs::Config.unique_args_enabled = true }
-      after  { SidekiqUniqueJobs::Config.unique_args_enabled = false }
+      before { SidekiqUniqueJobs.config.unique_args_enabled = true }
+      after  { SidekiqUniqueJobs.config.unique_args_enabled = false }
 
       class QueueWorkerWithFilterMethod < QueueWorker
-        sidekiq_options :unique => true, :unique_args => :args_filter
+        sidekiq_options unique: true, unique_args: :args_filter
 
         def self.args_filter(*args)
           args.first
@@ -100,19 +100,27 @@ describe "Client" do
       end
 
       class QueueWorkerWithFilterProc < QueueWorker
-        # slightly contrived example of munging args to the worker and removing a random bit.
-        sidekiq_options :unique => true, :unique_args => lambda { |args| a = args.last.dup; a.delete(:random); [ args.first, a ] }
+        # slightly contrived example of munging args to the
+        # worker and removing a random bit.
+        sidekiq_options unique: true, unique_args: (lambda do |args|
+          a = args.last.dup
+          a.delete(:random)
+          [args.first, a]
+        end)
       end
 
       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
 
-
-        for i in (0..10).to_a
-          Sidekiq::Client.push('class' => QueueWorkerWithFilterMethod, 'queue' => 'customqueue', 'args' => [1, i])
+        (0..10).each do |i|
+          Sidekiq::Client.push(
+            'class' => QueueWorkerWithFilterMethod,
+            'queue' => 'customqueue',
+            'args' => [1, i]
+          )
         end
-        result = Sidekiq.redis {|c| c.llen("queue:customqueue") }
+        result = Sidekiq.redis { |c| c.llen('queue:customqueue') }
         expect(result).to eq 1
       end
 
@@ -120,20 +128,24 @@ describe "Client" do
         expect(QueueWorkerWithFilterProc.get_sidekiq_options['unique_args']).to be_a(Proc)
 
         10.times do
-          Sidekiq::Client.push('class' => QueueWorkerWithFilterProc, 'queue' => 'customqueue', 'args' => [ 1, {:random => rand(), :name => "foobar"} ])
+          Sidekiq::Client.push(
+            'class' => QueueWorkerWithFilterProc,
+            'queue' => 'customqueue',
+            'args' => [1, { random: rand, name: 'foobar' }]
+          )
         end
-        result = Sidekiq.redis {|c| c.llen("queue:customqueue") }
+        result = Sidekiq.redis { |c| c.llen('queue:customqueue') }
         expect(result).to eq 1
       end
 
       describe 'when unique_on_all_queues is set' do
-        before { QueueWorker.sidekiq_options :unique => true, :unique_on_all_queues => true }
-        before { QueueWorker.sidekiq_options :unique => true }
+        before { QueueWorker.sidekiq_options unique: true, unique_on_all_queues: true }
+        before { QueueWorker.sidekiq_options unique: true }
         it 'does not push duplicate messages on different queues' do
           Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue',  'args' => [1, 2])
           Sidekiq::Client.push('class' => QueueWorker, 'queue' => 'customqueue2',  'args' => [1, 2])
-          q1_length = Sidekiq.redis {|c| c.llen("queue:customqueue") }
-          q2_length = Sidekiq.redis {|c| c.llen("queue:customqueue2") }
+          q1_length = Sidekiq.redis { |c| c.llen('queue:customqueue') }
+          q2_length = Sidekiq.redis { |c| c.llen('queue:customqueue2') }
           expect(q1_length).to eq 1
           expect(q2_length).to eq 0
         end
@@ -145,16 +157,16 @@ describe "Client" do
     # jobs are set around the same time as the scheduled job itself feel free to improve.
     it 'expires the payload_hash when a scheduled job is scheduled at' do
       require 'active_support/all'
-      QueueWorker.sidekiq_options :unique => true
+      QueueWorker.sidekiq_options unique: true
 
       at = 15.minutes.from_now
-      expected_expires_at = (Time.at(at) - Time.now.utc) + SidekiqUniqueJobs::Config.default_expiration
+      expected_expires_at = (Time.at(at) - Time.now.utc) + SidekiqUniqueJobs.config.default_expiration
 
       QueueWorker.perform_in(at, 'mike')
-      payload_hash = SidekiqUniqueJobs::PayloadHelper.get_payload("QueueWorker", "customqueue", ['mike'])
+      payload_hash = SidekiqUniqueJobs::PayloadHelper.get_payload('QueueWorker', 'customqueue', ['mike'])
 
       # deconstruct this into a time format we can use to get a decent delta for
-      actual_expires_at = Sidekiq.redis {|c| c.ttl(payload_hash) }
+      actual_expires_at = Sidekiq.redis { |c| c.ttl(payload_hash) }
 
       expect(actual_expires_at).to be_within(2).of(expected_expires_at)
     end

data/spec/lib/middleware/server/unique_jobs_spec.rb

@@ -6,48 +6,48 @@ module SidekiqUniqueJobs
       describe UniqueJobs do
         describe '#unlock_order_configured?' do
           context "when class isn't a Sidekiq::Worker" do
-            it "returns false" do
+            it 'returns false' do
               expect(subject.unlock_order_configured?(Class))
                 .to eq(false)
             end
           end
 
-          context "when get_sidekiq_options[:unique_unlock_order] is nil" do
-            it "returns false" do
+          context 'when get_sidekiq_options[:unique_unlock_order] is nil' do
+            it 'returns false' do
               expect(subject.unlock_order_configured?(MyWorker))
                 .to eq(false)
             end
           end
 
-          it "returns true when unique_unlock_order has been set" do
+          it 'returns true when unique_unlock_order has been set' do
             UniqueWorker.sidekiq_options unique_unlock_order: :before_yield
             expect(subject.unlock_order_configured?(UniqueWorker))
               .to eq(true)
           end
         end
 
-        describe '#set_unlock_order' do
-          context "when worker has specified unique_unlock_order" do
-            it "changes unlock_order to the configured value" do
+        describe '#decide_unlock_order' do
+          context 'when worker has specified unique_unlock_order' do
+            it 'changes unlock_order to the configured value' do
               UniqueWorker.sidekiq_options unique_unlock_order: :before_yield
               expect do
-                subject.set_unlock_order(UniqueWorker)
+                subject.decide_unlock_order(UniqueWorker)
               end.to change { subject.unlock_order }.to :before_yield
             end
           end
 
           context "when worker hasn't specified unique_unlock_order" do
-            it "falls back to configured default_unlock_order" do
-              SidekiqUniqueJobs::Config.default_unlock_order = :before_yield
+            it 'falls back to configured default_unlock_order' do
+              SidekiqUniqueJobs.config.default_unlock_order = :before_yield
               expect do
-                subject.set_unlock_order(UniqueWorker)
+                subject.decide_unlock_order(UniqueWorker)
               end.to change { subject.unlock_order }.to :before_yield
             end
           end
         end
 
         describe '#before_yield?' do
-          it "returns unlock_order == :before_yield" do
+          it 'returns unlock_order == :before_yield' do
             allow(subject).to receive(:unlock_order).and_return(:after_yield)
             expect(subject.before_yield?).to eq(false)
 
@@ -57,7 +57,7 @@ module SidekiqUniqueJobs
         end
 
         describe '#after_yield?' do
-          it "returns unlock_order == :before_yield" do
+          it 'returns unlock_order == :before_yield' do
             allow(subject).to receive(:unlock_order).and_return(:before_yield)
             expect(subject.after_yield?).to eq(false)
 
@@ -68,14 +68,14 @@ module SidekiqUniqueJobs
 
         describe '#default_unlock_order' do
           it 'returns the default value from config' do
-            SidekiqUniqueJobs::Config.default_unlock_order = :before_yield
+            SidekiqUniqueJobs.config.default_unlock_order = :before_yield
             expect(subject.default_unlock_order).to eq(:before_yield)
 
-            SidekiqUniqueJobs::Config.default_unlock_order = :after_yield
+            SidekiqUniqueJobs.config.default_unlock_order = :after_yield
             expect(subject.default_unlock_order).to eq(:after_yield)
           end
         end
       end
     end
   end
-end
+end