activejob-unique 0.5.0 → 0.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 061e508b94c278bf8ccd34aa73f19461625922aec84783d6337968342ef7a8db
-  data.tar.gz: 135d045c623b181d2bb86bd2234b72f25c84f7c4549829e4d40d0908fd4dd838
+  metadata.gz: 3d3d98846579f10faf49bb988ff0a81d4d314698d973d9456a39f034aed7a2c5
+  data.tar.gz: 6b8ab6c42aaf7b66fc5bbdd3eefbff5a08f7432be9d3d9e33b196c490a1c9c06
 SHA512:
-  metadata.gz: 14b1956520105caeef38dcb7e5c4b5f51dbc197d575f3f839d6d9d5a7ca2502cda85ebeacf56b7dff206589566bc1680fa20707d7437a74c95509706e4ce253b
-  data.tar.gz: a821c7491fd5f0768863d0ed475ea72f81ee318ce19ac5999765c6bde3f156bda1e78baeda5390e0fb0dc73d14f9453b20bc10365f9a5c0352f4452a2dcf9b1e
+  metadata.gz: 87c694b5db932ec8eb855a22e0318a4b71d522489310a6347340024e77ce0c27a56697054e7ff2d0a12c3f65041f43de36de4ffb3c9e337bb760ae6a8947e0c9
+  data.tar.gz: 3fcc445bc7487fa1a1e97efa56779d66ee37354f1f2c39758f6964d1f63afc8ccad5361caf92fd63ef643dbb66afab63bcd08ad3fdeda52c26ec5ba39b38f716

data/CHANGELOG.md

@@ -3,13 +3,34 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
-## [Unreleased](https://github.com/nordinvestments/activejob-uniqueness/compare/v0.5.0...HEAD)
+## [Unreleased](https://github.com/nordinvestments/activejob-uniqueness/compare/v0.5.1...HEAD)
+
+## [0.5.1](https://github.com/nordinvestments/activejob-uniqueness/compare/v0.5.0...v0.5.1) - 2026-08-25
+
+### Fixed
+- [#11](https://github.com/nordinvestments/activejob-uniqueness/pull/11) `TestLockManager` now stubs the full public API of `LockManager` so `test_mode!` no longer raises `NoMethodError` for methods like `locked?`, `unlock`, `lock!`, `valid_lock?` or the TTL lookups ([#7](https://github.com/nordinvestments/activejob-uniqueness/issues/7))
+- Release the correct lock when Sidekiq deletes a job with custom lock key arguments
+- Allow Sidekiq to delete jobs whose ActiveJob class no longer exists
+- Preserve uniqueness locks when Sidekiq moves jobs between sets and queues
+- [#10](https://github.com/nordinvestments/activejob-uniqueness/pull/10) Release the lock for jobs that override `#lock_key` when deleted via the Sidekiq API, instead of a class + arguments wildcard that never matches a custom key
+- [#10](https://github.com/nordinvestments/activejob-uniqueness/pull/10) Only release enqueue locks during Sidekiq queue/set cleanup: the runtime lock of an `:until_and_while_executing` job and the `:while_executing` guard (which is not an enqueue lock) are left untouched, so removing a queued duplicate can no longer free the guard of an instance that is currently executing
+
+### Changed
+- Added `gemfiles/activejob_8.0.x.gemfile` to the CI matrix, so ActiveJob 8.0 (allowed by the gemspec) is now exercised
 
 ## [0.5.0](https://github.com/nordinvestments/activejob-uniqueness/compare/v0.4.0...v0.5.0) - 2026-01-12
 
+### Added
+- [#4](https://github.com/nordinvestments/activejob-uniqueness/pull/4) Support for Rails 8.1 (ActiveJob `>= 7.1, < 8.2`) and Sidekiq 8
+- CI coverage for ActiveJob 8.1 and Sidekiq 8 (`gemfiles/activejob_8.1.x.gemfile`, `gemfiles/sidekiq_8.x.gemfile`)
+
 ### Changed
 - Fork published as `activejob-unique` gem by [@nordinvestments](https://github.com/nordinvestments)
 - Updated gem metadata to point to fork repository
+- Replaced the deprecated `ActiveSupport::Configurable` in `ActiveJob::Uniqueness::Configuration`
+  with `class_attribute`, required for ActiveSupport 8.1 compatibility
+- Minimum supported Ruby raised to 3.1
+- ActiveJob 8.1 and Sidekiq 8 require Ruby >= 3.2, encoded as `exclude:` entries in the CI matrix
 
 ---
 

data/README.md

@@ -11,9 +11,12 @@
 | Dependency | Version |
 |------------|---------|
 | Ruby | >= 3.1 |
-| Rails (ActiveJob) | >= 7.1, < 7.3 |
+| Rails (ActiveJob) | >= 7.1, < 8.2 |
+| Sidekiq (optional) | 6.x - 8.x (CI-tested) |
 | Redis | >= 2.8 |
 
+> **Note:** ActiveJob 8.1 and Sidekiq 8 require Ruby >= 3.2.
+
 > **Note:** This fork targets modern Ruby and Rails versions. For older Ruby (2.5-3.0) or Rails (4.2-7.0) support, use the [original gem](https://github.com/veeqo/activejob-uniqueness).
 
 ## Overview

data/lib/active_job/uniqueness/sidekiq_patch.rb

@@ -13,18 +13,54 @@ module ActiveJob
     def self.unlock_sidekiq_job!(job_data)
       return unless SIDEKIQ_JOB_WRAPPERS.include?(job_data['class'])
 
-      job = ActiveJob::Base.deserialize(job_data.fetch('args').first)
+      job = deserialize_sidekiq_job(job_data)
 
-      return unless job.class.lock_strategy_class
+      return unless job&.class&.lock_strategy_class
+      return unless locks_on_enqueue?(job)
 
-      begin
-        job.send(:deserialize_arguments_if_needed)
-      rescue ActiveJob::DeserializationError
-        # Most probably, GlobalID fails to locate AR record (record is deleted)
-      else
-        ActiveJob::Uniqueness.unlock!(job_class_name: job.class.name, arguments: job.arguments)
-      end
+      lock_key = enqueue_lock_key(job)
+      return unless lock_key
+
+      ActiveJob::Uniqueness.lock_manager.delete_lock(lock_key)
+    end
+
+    # Only strategies that lock on enqueue store an enqueue lock under #lock_key.
+    # :while_executing does not lock on enqueue: its #lock_key holds the *runtime*
+    # guard of a currently-executing instance, so cleaning up a queued duplicate
+    # must not touch it. Strategies advertise this via #locks_on_enqueue?, which
+    # custom strategies can override.
+    def self.locks_on_enqueue?(job)
+      job.class.lock_strategy_class.locks_on_enqueue?
+    end
+    private_class_method :locks_on_enqueue?
+
+    def self.deserialize_sidekiq_job(job_data)
+      serialized_job = job_data.fetch('args').first
+
+      # ActiveJob only wraps a missing job class in UnknownJobClassError as of version 8.1
+      return unless serialized_job.fetch('job_class').safe_constantize
+
+      ActiveJob::Base.deserialize(serialized_job)
+    end
+    private_class_method :deserialize_sidekiq_job
+
+    # Returns the enqueue lock key to release, or nil when it cannot be rebuilt.
+    #
+    # The key is rebuilt from the job's own #lock_key, so custom overrides are
+    # honored (a class + arguments wildcard never matched them). ActiveJob does
+    # not deserialize arguments until asked, so we trigger it explicitly: if a
+    # referenced record no longer exists (e.g. a deleted GlobalID) it raises
+    # DeserializationError and we skip the unlock, letting the lock expire by its
+    # TTL. Rebuilding a key from an incomplete argument list and deleting it could
+    # free another job's live lock, so skipping is the safe choice. Any other
+    # error is a genuine bug (e.g. in a custom #lock_key) and is left to surface.
+    def self.enqueue_lock_key(job)
+      job.send(:deserialize_arguments_if_needed)
+      job.lock_key
+    rescue ActiveJob::DeserializationError
+      nil
     end
+    private_class_method :enqueue_lock_key
 
     module SidekiqPatch
       module SortedEntry
@@ -32,15 +68,6 @@ module ActiveJob
           ActiveJob::Uniqueness.unlock_sidekiq_job!(item) if super
           item
         end
-
-        private
-
-        def remove_job
-          super do |message|
-            ActiveJob::Uniqueness.unlock_sidekiq_job!(Sidekiq.load_json(message))
-            yield message
-          end
-        end
       end
 
       module ScheduledSet

data/lib/active_job/uniqueness/strategies/base.rb

@@ -13,6 +13,18 @@ module ActiveJob
 
         attr_reader :lock_key, :lock_ttl, :on_conflict, :on_redis_connection_error, :job
 
+        # Whether the strategy acquires its #lock_key at enqueue time.
+        #
+        # Sidekiq queue/set cleanup only releases enqueue locks, so a strategy
+        # whose #lock_key is instead a runtime guard (e.g. :while_executing) must
+        # report false to avoid freeing the guard of a currently executing
+        # instance. Built-in enqueue-locking strategies signal this by including
+        # LockingOnEnqueue; a custom strategy that locks on enqueue by other means
+        # can override this method to return true.
+        def self.locks_on_enqueue?
+          include?(LockingOnEnqueue)
+        end
+
         def initialize(job:)
           @lock_key = job.lock_key
           @lock_ttl = (job.lock_options[:lock_ttl] || config.lock_ttl).to_i * 1000 # ms

data/lib/active_job/uniqueness/test_lock_manager.rb

@@ -2,15 +2,52 @@
 
 module ActiveJob
   module Uniqueness
-    # Mocks ActiveJob::Uniqueness::LockManager methods.
+    # Mocks the full public API of ActiveJob::Uniqueness::LockManager so that
+    # enabling ActiveJob::Uniqueness.test_mode! never raises NoMethodError for a
+    # method the real manager (a Redlock::Client subclass) responds to.
+    #
+    # Return values are consistent with "no lock is ever actually held": locking
+    # always succeeds, nothing is ever locked, and TTL lookups are nil.
+    #
     # See ActiveJob::Uniqueness.test_mode!
     class TestLockManager
       def lock(*_args)
+        block_given? ? yield(true) : true
+      end
+
+      def lock!(*args, &block)
+        return lock(*args, &block) if block
+
+        true
+      end
+
+      def unlock(*_args)
+        nil
+      end
+
+      def locked?(*_args)
+        false
+      end
+
+      def valid_lock?(*_args)
+        false
+      end
+
+      def get_remaining_ttl_for_lock(*_args)
+        nil
+      end
+
+      def get_remaining_ttl_for_resource(*_args)
+        nil
+      end
+
+      def delete_lock(*_args)
         true
       end
 
-      alias delete_lock lock
-      alias delete_locks lock
+      def delete_locks(*_args)
+        true
+      end
     end
   end
 end

data/lib/active_job/uniqueness/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveJob
   module Uniqueness
-    VERSION = '0.5.0'
+    VERSION = '0.5.1'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activejob-unique
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: ruby
 authors:
 - Rustam Sharshenov