sidekiq-unique-jobs 3.0.14 → 4.0.0

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

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'sidekiq/api'
+require 'sidekiq/cli'
+require 'sidekiq/worker'
+require 'sidekiq_unique_jobs/server/middleware'
+
+RSpec.describe SidekiqUniqueJobs::Server::Middleware do
+  QUEUE ||= 'unlock_ordering'
+
+  def digest_for(item)
+    SidekiqUniqueJobs::UniqueArgs.digest(item)
+  end
+
+  describe '#call' do
+    describe 'unlock order' do
+      before do
+        Sidekiq.redis = REDIS
+        Sidekiq.redis(&:flushdb)
+      end
+
+      describe '#unlock' do
+        it 'does not unlock mutexes it does not own' do
+          jid = AfterYieldWorker.perform_async
+          item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
+          Sidekiq.redis do |c|
+            c.set(digest_for(item), 'NOT_DELETED')
+          end
+
+          subject.call(AfterYieldWorker.new, item, QUEUE) do
+            Sidekiq.redis do |c|
+              expect(c.get(digest_for(item))).to eq('NOT_DELETED')
+            end
+          end
+        end
+      end
+
+      describe ':before_yield' do
+        it 'removes the lock before yielding to the worker' do
+          jid = BeforeYieldWorker.perform_async
+          item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
+          worker = BeforeYieldWorker.new
+          subject.call(worker, item, QUEUE) do
+            Sidekiq.redis do |c|
+              expect(c.ttl(digest_for(item))).to eq(-2) # key does not exist
+            end
+          end
+        end
+      end
+
+      describe ':after_yield' do
+        it 'removes the lock after yielding to the worker' do
+          jid = AfterYieldWorker.perform_async
+          item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
+
+          subject.call('AfterYieldWorker', item, QUEUE) do
+            Sidekiq.redis do |c|
+              expect(c.get(digest_for(item))).to eq jid
+            end
+          end
+        end
+      end
+    end
+
+    context 'unlock' do
+      let(:worker) { AfterYieldWorker.new }
+
+      before do
+        jid  = AfterYieldWorker.perform_async
+        @item = Sidekiq::Queue.new('unlock_ordering').find_job(jid).item
+      end
+
+      it 'unlocks after yield when call succeeds' do
+        expect(subject).to receive(:unlock)
+        subject.call(worker, @item, 'unlock_ordering') { true }
+      end
+
+      it 'unlocks after yield when call errors' do
+        expect(subject).to receive(:unlock)
+        allow(subject).to receive(:after_yield_yield) { fail 'WAT!' }
+        expect { subject.call(worker, @item, 'unlock_ordering') }
+          .to raise_error
+      end
+
+      it 'should not unlock after yield on shutdown, but still raise error' do
+        expect(subject).not_to receive(:unlock)
+        allow(subject).to receive(:after_yield_yield) { fail Sidekiq::Shutdown }
+        expect { subject.call(worker, @item, 'unlock_ordering') }
+          .to raise_error(Sidekiq::Shutdown)
+      end
+
+      it 'calls after_unlock_hook if defined' do
+        allow(subject).to receive(:unlock).and_call_original
+        allow(subject).to receive(:after_unlock_hook).and_call_original
+
+        expect(worker).to receive(:after_unlock)
+        subject.call(worker, @item, 'unlock_ordering') { true }
+      end
+    end
+  end
+end

data/spec/lib/{sidekiq_testing_enabled_spec.rb → sidekiq_unique_jobs/sidekiq_testing_enabled_spec.rb}

@@ -2,12 +2,10 @@ require 'spec_helper'
 require 'sidekiq/worker'
 require 'sidekiq-unique-jobs'
 require 'sidekiq/scheduled'
-require 'sidekiq_unique_jobs/middleware/server/unique_jobs'
 require 'active_support/core_ext/time'
 require 'active_support/testing/time_helpers'
-require 'rspec-sidekiq'
 
-describe 'When Sidekiq::Testing is enabled' do
+RSpec.describe 'When Sidekiq::Testing is enabled' do
   describe 'when set to :fake!', sidekiq: :fake do
     before do
       Sidekiq.redis = REDIS
@@ -109,12 +107,13 @@ describe 'When Sidekiq::Testing is enabled' do
         expect { Sidekiq::Worker.jobs.size }.not_to raise_error
       end
 
-      it 'adds the unique_hash to the message' do
+      it 'adds the unique_digest to the message' do
         param = 'hash'
-        hash = SidekiqUniqueJobs::PayloadHelper.get_payload(UniqueWorker, :working, [param])
+        item = { 'class' => 'UniqueWorker', 'queue' => 'working', 'args' => [param] }
+        hash = SidekiqUniqueJobs::UniqueArgs.digest(item)
         expect(UniqueWorker.perform_async(param)).to_not be_nil
         expect(UniqueWorker.jobs.size).to eq(1)
-        expect(UniqueWorker.jobs.first['unique_hash']).to eq(hash)
+        expect(UniqueWorker.jobs.last['unique_digest']).to eq(hash)
       end
     end
 
@@ -132,81 +131,43 @@ describe 'When Sidekiq::Testing is enabled' do
   end
 
   describe 'when set to :inline!', sidekiq: :inline do
-    class InlineWorker
-      include Sidekiq::Worker
-      sidekiq_options unique: true
-
-      def perform(x)
-        TestClass.run(x)
-      end
-    end
-
-    class InlineUnlockOrderWorker
-      include Sidekiq::Worker
-      sidekiq_options unique: true, unique_unlock_order: :never
-
-      def perform(x)
-        TestClass.run(x)
-      end
-    end
-
-    class InlineUnlockOrderWorker
-      include Sidekiq::Worker
-      sidekiq_options unique: true, unique_unlock_order: :never
-
-      def perform(x)
-        TestClass.run(x)
-      end
-    end
-
-    class InlineExpirationWorker
-      include Sidekiq::Worker
-      sidekiq_options unique: true, unique_unlock_order: :never,
-                      unique_job_expiration: 10 * 60
-      def perform(x)
-        TestClass.run(x)
-      end
-    end
-
-    class TestClass
-      def self.run(_x)
-      end
-    end
-
     it 'once the job is completed allows to run another one' do
-      expect(TestClass).to receive(:run).exactly(2).times
-
+      expect(TestClass).to receive(:run).with('test').twice
       InlineWorker.perform_async('test')
       InlineWorker.perform_async('test')
     end
 
     it 'if the unique is kept forever it does not allows to run the job again' do
-      expect(TestClass).to receive(:run).once
+      expect(TestClass).to receive(:run).with('args').once
 
-      InlineUnlockOrderWorker.perform_async('test')
-      InlineUnlockOrderWorker.perform_async('test')
+      InlineUnlockOrderWorker.perform_async('args')
+      InlineUnlockOrderWorker.perform_async('args')
     end
 
     describe 'when a job is set to run once in 10 minutes' do
       include ActiveSupport::Testing::TimeHelpers
-      it 'only allows 1 call per 10 minutes' do
-        allow(TestClass).to receive(:run).with(1).and_return(true)
-        allow(TestClass).to receive(:run).with(2).and_return(true)
-
-        InlineExpirationWorker.perform_async(1)
-        expect(TestClass).to have_received(:run).with(1).once
-        100.times do
-          InlineExpirationWorker.perform_async(1)
-        end
-        expect(TestClass).to have_received(:run).with(1).once
-        InlineExpirationWorker.perform_async(2)
-        expect(TestClass).to have_received(:run).with(1).once
-        expect(TestClass).to have_received(:run).with(2).once
-        travel_to(Time.now + (11 * 60)) do
-          InlineExpirationWorker.perform_async(1)
+
+      context 'when spammed' do
+        it 'only allows 1 call per 10 minutes' do
+          expect(TestClass).to receive(:run).with(1).once
+          100.times do
+            InlineExpirationWorker.perform_async(1)
+          end
         end
+      end
 
-        expect(TestClass).to have_received(:run).with(1).twice
+      context 'with different arguments' do
+        it 'only allows 1 call per 10 minutes' do
+          expect(TestClass).to receive(:run).with(9).once
+          2.times do
+            InlineExpirationWorker.perform_async(9)
+          end
+
+          expect(TestClass).to receive(:run).with(2).once
+          2.times do
+            InlineExpirationWorker.perform_async(2)
+          end
+        end
       end
     end
   end

data/spec/lib/sidekiq_unique_jobs/sidekiq_unique_ext_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'sidekiq/api'
+require 'sidekiq/worker'
+require 'sidekiq_unique_jobs/server/middleware'
+require 'sidekiq_unique_jobs/client/middleware'
+require 'sidekiq_unique_jobs/sidekiq_unique_ext'
+
+RSpec.describe 'Sidekiq::Api' do
+  before do
+    Sidekiq.redis = REDIS
+    Sidekiq.redis(&:flushdb)
+  end
+
+  let(:item) do
+    { 'class' => JustAWorker,
+      'queue' => 'testqueue',
+      'args'  => [foo: 'bar'] }
+  end
+
+  def unique_key
+    SidekiqUniqueJobs::UniqueArgs.digest(
+      'class' => JustAWorker,
+      'queue' => 'testqueue',
+      'args'  => [foo: 'bar'],
+      'at'    => Time.now.tomorrow.to_i)
+  end
+
+  def schedule_job
+    JustAWorker.perform_in(60 * 60 * 3, foo: 'bar')
+  end
+
+  def perform_async
+    JustAWorker.perform_async(foo: 'bar')
+  end
+
+  describe Sidekiq::SortedEntry::UniqueExtension, sidekiq_ver: '>= 3.1' do
+    it 'deletes uniqueness lock on delete' do
+      expect(schedule_job).to be_truthy
+
+      Sidekiq::ScheduledSet.new.each(&:delete)
+      Sidekiq.redis do |c|
+        expect(c.exists(unique_key)).to be_falsy
+      end
+
+      expect(schedule_job).to be_truthy
+    end
+  end
+
+  describe Sidekiq::Job::UniqueExtension do
+    it 'deletes uniqueness lock on delete' do
+      jid = perform_async
+      Sidekiq::Queue.new('testqueue').find_job(jid).delete
+      Sidekiq.redis do |c|
+        expect(c.exists(unique_key)).to be_falsy
+      end
+      expect(true).to be_truthy
+    end
+  end
+
+  describe Sidekiq::Queue::UniqueExtension do
+    it 'deletes uniqueness locks on clear' do
+      perform_async
+      Sidekiq::Queue.new('testqueue').clear
+      Sidekiq.redis do |c|
+        expect(c.exists(unique_key)).to be_falsy
+      end
+    end
+  end
+
+  describe Sidekiq::JobSet::UniqueExtension, sidekiq_ver: '>= 3' do
+    it 'deletes uniqueness locks on clear' do
+      schedule_job
+      Sidekiq::JobSet.new('schedule').clear
+      Sidekiq.redis do |c|
+        expect(c.exists(unique_key)).to be_falsy
+      end
+    end
+  end
+end

data/spec/lib/sidekiq_unique_jobs/sidekiq_unique_jobs_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+RSpec.describe SidekiqUniqueJobs do
+  describe '.configure_middleware' do
+    it 'configures both client and server middleware' do
+      expect(described_class).to receive(:configure_server_middleware)
+      expect(described_class).to receive(:configure_client_middleware)
+
+      described_class.configure_middleware
+    end
+  end
+
+  describe '.configure_server_middleware' do
+    let(:server_config) { class_double(Sidekiq) }
+    let(:server_middleware) { double(Sidekiq::Middleware::Chain) }
+
+    it 'adds server middleware when required' do
+      expect(Sidekiq).to receive(:configure_server).and_yield(server_config)
+      expect(server_config).to receive(:server_middleware).and_yield(server_middleware)
+      expect(server_middleware).to receive(:add).with(SidekiqUniqueJobs::Server::Middleware)
+      described_class.configure_server_middleware
+    end
+  end
+
+  describe '.configure_client_middleware' do
+    let(:client_config) { class_double(Sidekiq) }
+    let(:client_middleware) { double(Sidekiq::Middleware::Chain) }
+
+    it 'adds client middleware when required' do
+      expect(Sidekiq).to receive(:configure_client).and_yield(client_config)
+      expect(client_config).to receive(:client_middleware).and_yield(client_middleware)
+      expect(client_middleware).to receive(:add).with(SidekiqUniqueJobs::Client::Middleware)
+
+      described_class.configure_client_middleware
+    end
+  end
+end

data/spec/lib/sidekiq_unique_jobs/unique_args_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+RSpec.describe SidekiqUniqueJobs::UniqueArgs do
+  let(:item) { { 'class' => 'UniqueWorker', 'queue' => 'myqueue', 'args' => [[1, 2]] } }
+  subject { described_class.new(item) }
+
+  describe '#unique_args_enabled_in_worker?' do
+    with_sidekiq_options_for(UniqueWorker, unique_args: :unique_args) do
+      its(:unique_args_enabled_in_worker?) { is_expected.to eq(:unique_args) }
+    end
+
+    with_sidekiq_options_for(UniqueWorker, unique_args: false) do
+      its(:unique_args_enabled_in_worker?) { is_expected.to eq(false) }
+    end
+
+    # For when a worker doesn't exist in the current context
+    with_sidekiq_options_for('NotAWorker') do
+      its(:unique_args_enabled_in_worker?) { is_expected.to eq(nil) }
+    end
+  end
+
+  describe '#unique_args_enabled?' do
+    with_global_config(unique_args_enabled: true) do
+      with_sidekiq_options_for(UniqueWorker, unique_args: :unique_args) do
+        its(:unique_args_enabled?) { is_expected.to eq(:unique_args) }
+      end
+
+      with_sidekiq_options_for(UniqueWorker, unique_args: false) do
+        its(:unique_args_enabled?) { is_expected.to eq(true) }
+      end
+    end
+
+    with_global_config(unique_args_enabled: false) do
+      with_sidekiq_options_for(UniqueWorker, unique_args: :unique_args) do
+        its(:unique_args_enabled?) { is_expected.to eq(:unique_args) }
+      end
+
+      with_sidekiq_options_for(UniqueWorker, unique_args: false) do
+        its(:unique_args_enabled?) { is_expected.to eq(false) }
+      end
+
+      its(:unique_args_enabled?) { is_expected.to eq(false) }
+    end
+  end
+
+  describe '#unique_on_all_queues?' do
+    with_global_config(unique_args_enabled: true) do
+      its(:unique_on_all_queues?) { is_expected.to eq(nil) }
+
+      with_sidekiq_options_for(UniqueWorker, unique_args: :unique_args, unique_on_all_queues: true) do
+        its(:unique_on_all_queues?) { is_expected.to eq(true) }
+      end
+
+      with_sidekiq_options_for(UniqueWorker, unique_args: :unique_args, unique_on_all_queues: false) do
+        its(:unique_on_all_queues?) { is_expected.to eq(false) }
+      end
+
+      # For when a worker doesn't exist in the current context
+      with_sidekiq_options_for('NotAWorker', unique_args: :unique_args, unique_on_all_queues: true) do
+        its(:unique_args_enabled_in_worker?) { is_expected.to eq(nil) }
+      end
+    end
+
+    with_global_config(unique_args_enabled: false) do
+      its(:unique_on_all_queues?) { is_expected.to eq(nil) }
+
+      with_sidekiq_options_for(UniqueWorker, unique_args: :unique_args, unique_on_all_queues: false) do
+        its(:unique_on_all_queues?) { is_expected.to eq(false) }
+      end
+
+      with_sidekiq_options_for(UniqueWorker, unique_args: :unique_args, unique_on_all_queues: true) do
+        its(:unique_on_all_queues?) { is_expected.to eq(true) }
+      end
+
+      # For when a worker doesn't exist in the current context
+      with_sidekiq_options_for('NotAWorker', unique_args: :unique_args, unique_on_all_queues: true) do
+        its(:unique_args_enabled_in_worker?) { is_expected.to eq(nil) }
+      end
+    end
+  end
+
+  describe '#filter_by_proc' do
+    let(:proc) { ->(args) { args[1]['test'] } }
+    before do
+      allow(subject).to receive(:unique_args_method).and_return(proc)
+    end
+
+    it 'returns the value of the provided ' do
+      expect(subject.filter_by_proc([1, 'test' => 'it'])).to eq('it')
+    end
+  end
+
+  describe '#filter_by_symbol' do
+    let(:item) do
+      { 'class' => 'UniqueJobWithFilterMethod',
+        'queue' => 'myqueue',
+        'args' => [[1, 2]] }
+    end
+    subject { described_class.new(item) }
+
+    it 'returns the value of the provided class method' do
+      expect(subject.filter_by_symbol(['name', 2, 'whatever' => nil, 'type' => 'test']))
+        .to eq(%w(name test))
+    end
+  end
+end