Add support for lock_ttl to be a Proc/class method (#879)

* Add support for lock_ttl to be a Proc/class method

Add the ability to set the lock_ttl to a callable object, such as a Proc
or class method. Gives the ability for callers to set the lock_ttl
based on the job arguments or other runtime information.

* fixing lint and code complexity

Author: brayden-onesignal

lib/sidekiq_unique_jobs/lock_ttl.rb

@@ -66,12 +66,34 @@ def scheduled_at
     # @return [Integer] the number of seconds to live
     #
     def calculate
-      ttl = item[LOCK_TTL]
-      ttl ||= job_options[LOCK_TTL]
-      ttl ||= item[LOCK_EXPIRATION] # TODO: Deprecate at some point
-      ttl ||= job_options[LOCK_EXPIRATION] # TODO: Deprecate at some point
-      ttl ||= SidekiqUniqueJobs.config.lock_ttl
-      ttl && (ttl.to_i + time_until_scheduled)
+      ttl = fetch_ttl
+      return unless ttl
+
+      timing = calculate_timing(ttl)
+      return unless timing
+
+      timing.to_i + time_until_scheduled
+    end
+
+    private
+
+    def fetch_ttl
+      item[LOCK_TTL] ||
+        job_options[LOCK_TTL] ||
+        item[LOCK_EXPIRATION] || # TODO: Deprecate at some point
+        job_options[LOCK_EXPIRATION] || # TODO: Deprecate at some point
+        SidekiqUniqueJobs.config.lock_ttl
+    end
+
+    def calculate_timing(ttl)
+      case ttl
+      when String, Numeric
+        ttl
+      when Proc
+        ttl.call(item[ARGS])
+      when Symbol
+        job_class.send(ttl, item[ARGS])
+      end
     end
   end
 end

spec/sidekiq_unique_jobs/lock_ttl_spec.rb

@@ -1,9 +1,17 @@
 # frozen_string_literal: true
 
 RSpec.describe SidekiqUniqueJobs::LockTTL do
-  let(:calculator)      { described_class.new("class" => job_class_name, "at" => schedule_time) }
+  let(:item)            { { "class" => job_class_name, "at" => schedule_time } }
+  let(:calculator)      { described_class.new(item) }
   let(:job_class_name)  { "MyUniqueJob" }
   let(:schedule_time)   { nil }
+  let(:job_options) do
+    { lock: :until_executed, lock_ttl: 7_200, queue: :customqueue, retry: 10 }
+  end
+
+  before do
+    allow(MyUniqueJob).to receive(:get_sidekiq_options).and_return(job_options)
+  end
 
   describe "public api" do
     subject { calculator }
@@ -34,6 +42,66 @@
     end
   end
 
+  describe "#calculate" do
+    subject(:calculate) { calculator.calculate }
+
+    context "when no lock_ttl is set" do
+      let(:item) { { "class" => job_class_name, "lock_ttl" => nil } }
+      let(:job_options) { { lock: "until_expired", "lock_ttl" => nil } }
+
+      it "returns the default lock_ttl" do
+        expect(calculate).to eq(SidekiqUniqueJobs.config.lock_ttl)
+      end
+
+      it "returns nil" do
+        SidekiqUniqueJobs.config.lock_ttl = nil
+        expect(calculate).to be_nil
+      end
+    end
+
+    context "when item lock_ttl is numeric" do
+      let(:item) { { "class" => job_class_name, "lock_ttl" => 10 } }
+
+      it do
+        expect(calculate).to eq(10)
+      end
+    end
+
+    context "when item lock_ttl is a string" do
+      let(:item) { { "class" => job_class_name, "lock_ttl" => "10" } }
+
+      it do
+        expect(calculate).to eq(10)
+      end
+    end
+
+    context "when item lock_ttl is a proc" do
+      let(:item) { { "class" => job_class_name, "lock_ttl" => ->(_args) { 20 } } }
+
+      it do
+        expect(calculate).to eq(20)
+      end
+    end
+
+    context "when item lock_ttl is a function symbol" do
+      let(:job_class_name) { "MyOtherUniqueJob" }
+      let(:item)           { { "class" => job_class_name, "lock_ttl" => :ttl_fn } }
+
+      it do
+        stub_const(
+          job_class_name,
+          Class.new do
+            def self.ttl_fn(_args)
+              99
+            end
+          end,
+        )
+
+        expect(calculate).to eq(99)
+      end
+    end
+  end
+
   describe "#job_class" do
     subject(:job_class) { calculator.job_class }