sidekiq-unique-jobs 4.0.0 → 4.0.7

data/spec/lib/sidekiq_unique_jobs/lock/until_and_while_executing_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+RSpec.describe SidekiqUniqueJobs::Lock::UntilAndWhileExecuting do
+  let(:item) do
+    {
+      'jid' => 'maaaahjid',
+      'queue' => 'dupsallowed',
+      'class' => 'UntilAndWhileExecuting',
+      'unique' => 'until_executed',
+      'args' => [1]
+    }
+  end
+  let(:callback) { -> {} }
+  subject { described_class.new(item) }
+  describe '#execute' do
+    before { subject.lock(:client) }
+    let(:runtime_lock) { SidekiqUniqueJobs::Lock::WhileExecuting.new(item, nil) }
+
+    it 'unlocks the unique key before yielding' do
+      expect(SidekiqUniqueJobs::Lock::WhileExecuting)
+        .to receive(:new).with(item, nil)
+        .and_return(runtime_lock)
+
+      expect(callback).to receive(:call)
+
+      subject.execute(callback) do
+        Sidekiq.redis do |c|
+          expect(c.keys('uniquejobs:*').size).to eq(1)
+        end
+
+        10.times { Sidekiq::Client.push(item) }
+
+        Sidekiq.redis do |c|
+          expect(c.keys('uniquejobs:*').size).to eq(2)
+        end
+      end
+    end
+  end
+end

data/spec/lib/sidekiq_unique_jobs/lock/until_executed_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+RSpec.describe SidekiqUniqueJobs::Lock::UntilExecuted do
+  describe '#execute' do
+    subject { described_class.new(item) }
+    let(:item) do
+      { 'jid' => 'maaaahjid', 'class' => 'UntilExecutedJob', 'unique' => 'until_executed' }
+    end
+    let(:empty_callback) { -> {} }
+
+    def execute
+      subject.execute(empty_callback)
+    end
+
+    context 'when yield fails with Sidekiq::Shutdown' do
+      before do
+        allow(subject).to receive(:after_yield_yield) { fail Sidekiq::Shutdown }
+      end
+
+      it 'raises Sidekiq::Shutdown' do
+        allow(subject).to receive(:unlock).and_return(true)
+        expect(subject).not_to receive(:unlock)
+        expect(empty_callback).not_to receive(:call)
+        expect { subject.execute(empty_callback) }.to raise_error(Sidekiq::Shutdown)
+      end
+    end
+
+    context 'when yield fails with other errors' do
+      before do
+        allow(subject).to receive(:after_yield_yield) { fail 'Hell' }
+      end
+
+      it 'raises Sidekiq::Shutdown' do
+        expect(subject).to receive(:unlock).and_return(true)
+        expect(empty_callback).to receive(:call)
+        expect { subject.execute(empty_callback) }.to raise_error('Hell')
+      end
+    end
+  end
+end

data/spec/lib/sidekiq_unique_jobs/lock/while_executing_spec.rb

@@ -1,9 +1,20 @@
 require 'spec_helper'
 
 RSpec.describe SidekiqUniqueJobs::Lock::WhileExecuting do
+  let(:item) do
+    {
+      'jid' => 'maaaahjid',
+      'queue' => 'dupsallowed',
+      'class' => 'UntilAndWhileExecuting',
+      'unique' => 'until_executed',
+      'unique_digest' => 'test_mutex_key',
+      'args' => [1]
+    }
+  end
+
   it 'allows only one mutex object to have the lock at a time' do
     mutexes = (1..10).map do
-      described_class.new('test_mutex_key')
+      described_class.new(item)
     end
 
     x = 0
@@ -21,10 +32,10 @@ RSpec.describe SidekiqUniqueJobs::Lock::WhileExecuting do
   end
 
   it 'handles auto cleanup correctly' do
-    m = described_class.new('test_mutex_key')
+    m = described_class.new(item)
 
     SidekiqUniqueJobs.connection do |conn|
-      conn.set 'test_mutex_key', Time.now.to_i - 1, nx: true
+      conn.set 'test_mutex_key:run', Time.now.to_i - 1, nx: true
     end
 
     start = Time.now.to_i
@@ -37,7 +48,7 @@ RSpec.describe SidekiqUniqueJobs::Lock::WhileExecuting do
   end
 
   it 'maintains mutex semantics' do
-    m = described_class.new('test_mutex_key')
+    m = described_class.new(item)
 
     expect do
       m.synchronize do

data/spec/lib/sidekiq_unique_jobs/options_with_fallback_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+RSpec.describe SidekiqUniqueJobs::OptionsWithFallback do
+  include described_class
+  subject { self }
+
+  let(:options) { {} }
+  let(:item) { {} }
+
+  describe '#unique_lock' do
+    context 'when options have `unique: true`' do
+      let(:options) { { 'unique' => true } }
+
+      it 'warns when unique is set to true' do
+        expect(subject)
+          .to receive(:warn)
+          .with(
+            'unique: true is no longer valid. Please set it to the type of lock required like: ' \
+            '`unique: :until_executed`')
+
+        subject.unique_lock
+      end
+    end
+  end
+end

data/spec/lib/sidekiq_unique_jobs/scripts_spec.rb

@@ -1,6 +1,5 @@
 require 'spec_helper'
 RSpec.describe SidekiqUniqueJobs::Scripts do
-  include ActiveSupport::Testing::TimeHelpers
   MD5_DIGEST ||= 'unique'.freeze
   UNIQUE_KEY ||= 'uniquejobs:unique'.freeze
   JID ||= 'fuckit'.freeze
@@ -36,7 +35,7 @@ RSpec.describe SidekiqUniqueJobs::Scripts do
       context 'when job is unique' do
         specify { expect(lock_for).to eq(1) }
         specify do
-          expect(lock_for(0.5.seconds)).to eq(1)
+          expect(lock_for(0.5)).to eq(1)
           expect(Redis)
             .to have_key(UNIQUE_KEY)
             .for_seconds(1)
@@ -54,7 +53,7 @@ RSpec.describe SidekiqUniqueJobs::Scripts do
 
     describe '.release_lock' do
       context 'when job is locked by another jid' do
-        before  { expect(lock_for(10.seconds, 'anotherjid')).to eq(1) }
+        before  { expect(lock_for(10, 'anotherjid')).to eq(1) }
         specify { expect(unlock).to eq(0) }
         after { unlock(UNIQUE_KEY, ANOTHER_JID) }
       end
@@ -65,7 +64,7 @@ RSpec.describe SidekiqUniqueJobs::Scripts do
 
       context 'when job is locked by the same jid' do
         specify do
-          expect(lock_for(10.seconds)).to eq(1)
+          expect(lock_for(10)).to eq(1)
           expect(unlock).to eq(1)
         end
       end

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

@@ -5,95 +5,78 @@ require 'sidekiq/worker'
 require 'sidekiq_unique_jobs/server/middleware'
 
 RSpec.describe SidekiqUniqueJobs::Server::Middleware do
-  QUEUE ||= 'unlock_ordering'
+  QUEUE ||= 'working'
 
   def digest_for(item)
     SidekiqUniqueJobs::UniqueArgs.digest(item)
   end
 
+  before do
+    Sidekiq.redis = REDIS
+    Sidekiq.redis(&:flushdb)
+  end
+
   describe '#call' do
-    describe 'unlock order' do
-      before do
-        Sidekiq.redis = REDIS
-        Sidekiq.redis(&:flushdb)
+    context 'when unique is disabled' do
+      it 'does not use locking' do
+        allow(subject).to receive(:unique_enabled?).and_return(false)
+        expect(subject).not_to receive(:lock)
+        args = [WhileExecutingJob, { 'class' => 'WhileExecutingJob' }, 'working', nil]
+        subject.call(*args) {}
       end
+    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
+    context 'when unique is enabled' do
+      it 'executes the lock' do
+        allow(subject).to receive(:unique_enabled?).and_return(true)
+        lock = instance_spy(SidekiqUniqueJobs::Lock::WhileExecuting)
+        expect(lock).to receive(:send).with(:execute, instance_of(Proc)).and_yield
+        expect(subject).to receive(:lock).and_return(lock)
 
-          subject.call(AfterYieldWorker.new, item, QUEUE) do
-            Sidekiq.redis do |c|
-              expect(c.get(digest_for(item))).to eq('NOT_DELETED')
-            end
-          end
-        end
+        args = [WhileExecutingJob, { 'class' => 'WhileExecutingJob' }, 'working', nil]
+        subject.call(*args) {}
       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
+    describe '#unlock' do
+      it 'does not unlock mutexes it does not own' do
+        jid = UntilExecutedJob.perform_async
+        item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
+        Sidekiq.redis do |c|
+          c.set(digest_for(item), 'NOT_DELETED')
         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
+        subject.call(UntilExecutedJob.new, item, QUEUE) do
+          Sidekiq.redis do |c|
+            expect(c.get(digest_for(item))).to eq('NOT_DELETED')
           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)
+    describe ':before_yield' do
+      it 'removes the lock before yielding to the worker' do
+        jid = UntilExecutingJob.perform_async
+        item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
+        worker = UntilExecutingJob.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
 
-      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
+    describe ':after_yield' do
+      it 'removes the lock after yielding to the worker' do
+        jid = UntilExecutedJob.perform_async
+        item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
 
-        expect(worker).to receive(:after_unlock)
-        subject.call(worker, @item, 'unlock_ordering') { true }
+        subject.call('UntilExecutedJob', item, QUEUE) do
+          Sidekiq.redis do |c|
+            expect(c.get(digest_for(item))).to eq jid
+          end
+        end
       end
     end
   end

data/spec/lib/sidekiq_unique_jobs/sidekiq_testing_enabled_spec.rb

@@ -2,8 +2,6 @@ require 'spec_helper'
 require 'sidekiq/worker'
 require 'sidekiq-unique-jobs'
 require 'sidekiq/scheduled'
-require 'active_support/core_ext/time'
-require 'active_support/testing/time_helpers'
 
 RSpec.describe 'When Sidekiq::Testing is enabled' do
   describe 'when set to :fake!', sidekiq: :fake do
@@ -15,117 +13,117 @@ RSpec.describe 'When Sidekiq::Testing is enabled' do
     context 'with unique worker' do
       it 'does not push duplicate messages' do
         param = 'work'
-        expect(UniqueWorker.jobs.size).to eq(0)
-        expect(UniqueWorker.perform_async(param)).to_not be_nil
-        expect(UniqueWorker.jobs.size).to eq(1)
-        expect(UniqueWorker).to have_enqueued_job(param)
-        expect(UniqueWorker.perform_async(param)).to be_nil
-        expect(UniqueWorker.jobs.size).to eq(1)
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        expect(UntilExecutedJob.perform_async(param)).to_not be_nil
+        expect(UntilExecutedJob.jobs.size).to eq(1)
+        expect(UntilExecutedJob).to have_enqueued_job(param)
+        expect(UntilExecutedJob.perform_async(param)).to be_nil
+        expect(UntilExecutedJob.jobs.size).to eq(1)
       end
 
       it 'unlocks jobs after draining a worker' do
         param = 'work'
         param2 = 'more work'
-        expect(UniqueWorker.jobs.size).to eq(0)
-        UniqueWorker.perform_async(param)
-        UniqueWorker.perform_async(param2)
-        expect(UniqueWorker.jobs.size).to eq(2)
-        UniqueWorker.drain
-        expect(UniqueWorker.jobs.size).to eq(0)
-        UniqueWorker.perform_async(param)
-        UniqueWorker.perform_async(param2)
-        expect(UniqueWorker.jobs.size).to eq(2)
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        UntilExecutedJob.perform_async(param)
+        UntilExecutedJob.perform_async(param2)
+        expect(UntilExecutedJob.jobs.size).to eq(2)
+        UntilExecutedJob.drain
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        UntilExecutedJob.perform_async(param)
+        UntilExecutedJob.perform_async(param2)
+        expect(UntilExecutedJob.jobs.size).to eq(2)
       end
 
       it 'unlocks a single job when calling perform_one' do
         param = 'work'
         param2 = 'more work'
-        expect(UniqueWorker.jobs.size).to eq(0)
-        UniqueWorker.perform_async(param)
-        UniqueWorker.perform_async(param2)
-        expect(UniqueWorker.jobs.size).to eq(2)
-        UniqueWorker.perform_one
-        expect(UniqueWorker.jobs.size).to eq(1)
-        UniqueWorker.perform_async(param2)
-        expect(UniqueWorker.jobs.size).to eq(1)
-        UniqueWorker.perform_async(param)
-        expect(UniqueWorker.jobs.size).to eq(2)
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        UntilExecutedJob.perform_async(param)
+        UntilExecutedJob.perform_async(param2)
+        expect(UntilExecutedJob.jobs.size).to eq(2)
+        UntilExecutedJob.perform_one
+        expect(UntilExecutedJob.jobs.size).to eq(1)
+        UntilExecutedJob.perform_async(param2)
+        expect(UntilExecutedJob.jobs.size).to eq(1)
+        UntilExecutedJob.perform_async(param)
+        expect(UntilExecutedJob.jobs.size).to eq(2)
       end
 
       it 'unlocks jobs cleared from a single worker' do
         param = 'work'
         param2 = 'more work'
-        expect(UniqueWorker.jobs.size).to eq(0)
-        expect(AnotherUniqueWorker.jobs.size).to eq(0)
-        UniqueWorker.perform_async(param)
-        UniqueWorker.perform_async(param2)
-        AnotherUniqueWorker.perform_async(param)
-        expect(UniqueWorker.jobs.size).to eq(2)
-        expect(AnotherUniqueWorker.jobs.size).to eq(1)
-        UniqueWorker.clear
-        expect(UniqueWorker.jobs.size).to eq(0)
-        expect(AnotherUniqueWorker.jobs.size).to eq(1)
-        UniqueWorker.perform_async(param)
-        UniqueWorker.perform_async(param2)
-        AnotherUniqueWorker.perform_async(param)
-        expect(UniqueWorker.jobs.size).to eq(2)
-        expect(AnotherUniqueWorker.jobs.size).to eq(1)
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        expect(AnotherUniqueJob.jobs.size).to eq(0)
+        UntilExecutedJob.perform_async(param)
+        UntilExecutedJob.perform_async(param2)
+        AnotherUniqueJob.perform_async(param)
+        expect(UntilExecutedJob.jobs.size).to eq(2)
+        expect(AnotherUniqueJob.jobs.size).to eq(1)
+        UntilExecutedJob.clear
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        expect(AnotherUniqueJob.jobs.size).to eq(1)
+        UntilExecutedJob.perform_async(param)
+        UntilExecutedJob.perform_async(param2)
+        AnotherUniqueJob.perform_async(param)
+        expect(UntilExecutedJob.jobs.size).to eq(2)
+        expect(AnotherUniqueJob.jobs.size).to eq(1)
       end
 
       it 'handles clearing an empty worker queue' do
         param = 'work'
-        UniqueWorker.perform_async(param)
-        UniqueWorker.clear
-        expect(UniqueWorker.jobs.size).to eq(0)
-        expect { UniqueWorker.clear }.not_to raise_error
+        UntilExecutedJob.perform_async(param)
+        UntilExecutedJob.clear
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        expect { UntilExecutedJob.clear }.not_to raise_error
       end
 
       it 'unlocks jobs when all workers are cleared' do
         param = 'work'
-        expect(UniqueWorker.jobs.size).to eq(0)
-        expect(AnotherUniqueWorker.jobs.size).to eq(0)
-        UniqueWorker.perform_async(param)
-        AnotherUniqueWorker.perform_async(param)
-        expect(UniqueWorker.jobs.size).to eq(1)
-        expect(AnotherUniqueWorker.jobs.size).to eq(1)
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        expect(AnotherUniqueJob.jobs.size).to eq(0)
+        UntilExecutedJob.perform_async(param)
+        AnotherUniqueJob.perform_async(param)
+        expect(UntilExecutedJob.jobs.size).to eq(1)
+        expect(AnotherUniqueJob.jobs.size).to eq(1)
         Sidekiq::Worker.clear_all
-        expect(UniqueWorker.jobs.size).to eq(0)
-        expect(AnotherUniqueWorker.jobs.size).to eq(0)
-        UniqueWorker.perform_async(param)
-        AnotherUniqueWorker.perform_async(param)
-        expect(UniqueWorker.jobs.size).to eq(1)
-        expect(AnotherUniqueWorker.jobs.size).to eq(1)
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        expect(AnotherUniqueJob.jobs.size).to eq(0)
+        UntilExecutedJob.perform_async(param)
+        AnotherUniqueJob.perform_async(param)
+        expect(UntilExecutedJob.jobs.size).to eq(1)
+        expect(AnotherUniqueJob.jobs.size).to eq(1)
       end
 
       it 'handles clearing all workers when there are no jobs' do
         param = 'work'
-        UniqueWorker.perform_async(param)
-        AnotherUniqueWorker.perform_async(param)
+        UntilExecutedJob.perform_async(param)
+        AnotherUniqueJob.perform_async(param)
         Sidekiq::Worker.clear_all
-        expect(UniqueWorker.jobs.size).to eq(0)
-        expect(AnotherUniqueWorker.jobs.size).to eq(0)
+        expect(UntilExecutedJob.jobs.size).to eq(0)
+        expect(AnotherUniqueJob.jobs.size).to eq(0)
         expect { Sidekiq::Worker.jobs.size }.not_to raise_error
       end
 
       it 'adds the unique_digest to the message' do
         param = 'hash'
-        item = { 'class' => 'UniqueWorker', 'queue' => 'working', 'args' => [param] }
+        item = { 'class' => 'UntilExecutedJob', '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.last['unique_digest']).to eq(hash)
+        expect(UntilExecutedJob.perform_async(param)).to_not be_nil
+        expect(UntilExecutedJob.jobs.size).to eq(1)
+        expect(UntilExecutedJob.jobs.last['unique_digest']).to eq(hash)
       end
     end
 
     context 'with non-unique worker' do
       it 'pushes duplicates messages' do
         param = 'work'
-        expect(MyWorker.jobs.size).to eq(0)
-        MyWorker.perform_async(param)
-        expect(MyWorker.jobs.size).to eq(1)
-        expect(MyWorker).to have_enqueued_job(param)
-        MyWorker.perform_async(param)
-        expect(MyWorker.jobs.size).to eq(2)
+        expect(MyJob.jobs.size).to eq(0)
+        MyJob.perform_async(param)
+        expect(MyJob.jobs.size).to eq(1)
+        expect(MyJob).to have_enqueued_job(param)
+        MyJob.perform_async(param)
+        expect(MyJob.jobs.size).to eq(2)
       end
     end
   end
@@ -140,18 +138,16 @@ RSpec.describe 'When Sidekiq::Testing is enabled' do
     it 'if the unique is kept forever it does not allows to run the job again' do
       expect(TestClass).to receive(:run).with('args').once
 
-      InlineUnlockOrderWorker.perform_async('args')
-      InlineUnlockOrderWorker.perform_async('args')
+      UntilGlobalTimeoutJob.perform_async('args')
+      UntilGlobalTimeoutJob.perform_async('args')
     end
 
     describe 'when a job is set to run once in 10 minutes' do
-      include ActiveSupport::Testing::TimeHelpers
-
       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)
+            UntilTimeoutJob.perform_async(1)
           end
         end
       end
@@ -160,12 +156,12 @@ RSpec.describe 'When Sidekiq::Testing is enabled' 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)
+            UntilTimeoutJob.perform_async(9)
           end
 
           expect(TestClass).to receive(:run).with(2).once
           2.times do
-            InlineExpirationWorker.perform_async(2)
+            UntilTimeoutJob.perform_async(2)
           end
         end
       end