Add a requested job

Close #121

See readme for more information

CHANGELOG.md

@@ -3,6 +3,7 @@
 - Remove `unique_lock` and use `unique: ` to set this like in `unique: :until_timeout`
 - Warn when using `unique: true` and suggest to change it to what we need with a fallback.
 - Create constants for hash keys to avoid having to fix spelling or for renaming keys only having to be done in one place and avoid having to type .freeze everywhere.
+- Move all explicit logic out from the server middle ware and make it just call execute on the instance of the lock class (prepare for allowing custom locking classes to be used).
 
 ## v4.0.2
 

README.md

@@ -68,6 +68,20 @@ sidekiq_options unique: :until_timeout
 
 The job won't be unlocked until the timeout/expiry runs out.
 
+### Unique Until And While Executing
+
+```ruby
+sidekiq_options unique: :until_and_while_executing
+```
+
+This lock is exactly what you would expect. It is considered unique in a way until executing begins and it is locked while executing so what differs from `UntilExecuted`? 
+
+The difference is that this job has two types of uniqueness:
+1. It is unique until execution
+2. It is unique while executing
+
+That means it locks for any job with the same arguments to be persisted into redis and just like you would expect it will only ever allow one job of the same unique arguments to run at any given time but as soon as the runtime lock has been aquired the schedule/async lock is released.
+
 ### Uniqueness Scope
 
 - Queue specific locks

lib/sidekiq_unique_jobs/lock.rb

@@ -2,6 +2,7 @@
 require 'sidekiq_unique_jobs/lock/until_executing'
 require 'sidekiq_unique_jobs/lock/while_executing'
 require 'sidekiq_unique_jobs/lock/until_timeout'
+require 'sidekiq_unique_jobs/lock/until_and_while_executing'
 
 module SidekiqUniqueJobs
   module Lock

lib/sidekiq_unique_jobs/lock/until_and_while_executing.rb

@@ -0,0 +1,13 @@
+module SidekiqUniqueJobs
+  module Lock
+    class UntilAndWhileExecuting < UntilExecuting
+      def execute(callback)
+        lock = WhileExecuting.new(item, redis_pool)
+        lock.synchronize do
+          callback.call if unlock(:server)
+          yield
+        end
+      end
+    end
+  end
+end

lib/sidekiq_unique_jobs/options_with_fallback.rb

@@ -1,9 +1,7 @@
 module SidekiqUniqueJobs
   module OptionsWithFallback
     def self.included(base)
-      base.class_exec do
-        class_attribute :lock_cache
-      end
+      base.class_attribute :lock_cache unless base.respond_to?(:lock_cache)
       base.lock_cache ||= {}
     end
 

spec/jobs/until_and_while_executing_job.rb

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

spec/jobs/until_executing_worker.rb → spec/jobs/until_executing_job.rb

@@ -1,4 +1,4 @@
-class UntilExecutingWorker
+class UntilExecutingJob
   include Sidekiq::Worker
 
   sidekiq_options queue: :working

spec/lib/sidekiq_unique_jobs/lock/until_and_while_executing_spec.rb

@@ -0,0 +1,36 @@
+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

spec/lib/sidekiq_unique_jobs/server/middleware_spec.rb

@@ -36,9 +36,9 @@ def digest_for(item)
 
       describe ':before_yield' do
         it 'removes the lock before yielding to the worker' do
-          jid = UntilExecutingWorker.perform_async
+          jid = UntilExecutingJob.perform_async
           item = Sidekiq::Queue.new(QUEUE).find_job(jid).item
-          worker = UntilExecutingWorker.new
+          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