activejob-locking 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a62c77b88570136b09f1b8d6c592e84f5e2786df
-  data.tar.gz: fb0d7bf38c6a1c1251ed95e17a032d67a2d49e63
+SHA256:
+  metadata.gz: be52bd8f794ad9f15a6a66dfda55233ee68348f1a67a84985586215a8ad257a2
+  data.tar.gz: 24b93c41cff4548b2aa6fd128cc67ec62ea1da329f1f2dae4fa0bac2418e23b3
 SHA512:
-  metadata.gz: 7bf13cd8b5c355a51fe756280c5cdea838f1217e776e1f7c7d875111fca54ff1c6c9c7755723c52f43d31b4f8aa3beeec7b2f43d43b6fe7921c8368a7560b928
-  data.tar.gz: c3cf54eec859296f2751eb00d2cba54d27fae322bba9204af540ccb4a369915ec962802cd6b8fdaa23191fccdca02b7bce50f1c7e689e82f630a98a29fffc897
+  metadata.gz: 9755a392e33e9bba7ce7ac809d2b6ff82029fe62ed17cfdc90d6cde3a0b389e6d95588aac6d0d957fbd91c1ea8f067038d16e68ae39ea6c6d5c567213c6407fb
+  data.tar.gz: 547262df7cae0c84637fe012fa64e253caf71fbf1586ca4393960af51ce44c4baa97377d25fbdf0d128d558ba738bc870f446e09a899d2a76317bf37f1da2c42

data/Gemfile

@@ -1,10 +1,10 @@
-source 'https://rubygems.org'
-
-gem 'activejob', :require => 'active_job'
-
-group :test do
-  gem 'minitest'
-  gem 'redis-semaphore'
-  gem 'redlock'
-  gem 'suo'
-end
+source 'https://rubygems.org'
+
+gem 'activejob', :require => 'active_job'
+
+group :test do
+  gem 'minitest'
+  gem 'redis-semaphore'
+  gem 'redlock'
+  gem 'suo'
+end

data/LICENSE

@@ -1,20 +1,20 @@
-Copyright (c) 2017 Charlie Savage
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-Software), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+Copyright (c) 2017 Charlie Savage
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+Software), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -1,21 +1,21 @@
-require 'rubygems'
-require 'rake'
-require 'rake/clean'
-require 'rake/testtask'
-require 'rubygems/package_task'
-
-# Set global variable so other tasks can access them
-::PROJECT_ROOT = File.expand_path(".")
-::GEM_NAME = 'activejob-locking'
-
-# Read the spec file
-spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
-
-# Setup Rake tasks for managing the gem
-Gem::PackageTask.new(spec).define
-
-desc 'Run unit tests.'
-Rake::TestTask.new(:test) do |task|
-  task.test_files = FileList['test/test_*.rb']
-  task.verbose = true
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rubygems/package_task'
+
+# Set global variable so other tasks can access them
+::PROJECT_ROOT = File.expand_path(".")
+::GEM_NAME = 'activejob-locking'
+
+# Read the spec file
+spec = Gem::Specification.load("#{GEM_NAME}.gemspec")
+
+# Setup Rake tasks for managing the gem
+Gem::PackageTask.new(spec).define
+
+desc 'Run unit tests.'
+Rake::TestTask.new(:test) do |task|
+  task.test_files = FileList['test/test_*.rb']
+  task.verbose = true
 end

data/lib/activejob/locking/base.rb

@@ -1,51 +1,51 @@
-module ActiveJob
-  module Locking
-    module Base
-      extend ::ActiveSupport::Concern
-
-      module ClassMethods
-        def lock_options
-          @lock_options ||= ActiveJob::Locking::Options.new
-        end
-        delegate :adapter, :enqueue_time, :hosts, :lock_time, :lock_acquire_time, :adapter_options, to: :lock_options
-        delegate :adapter=, :enqueue_time=, :hosts=, :lock_time=, :lock_acquire_time=, :adapter_options=, to: :lock_options
-      end
-
-      included do
-        # We need to serialize the lock token that some gems create because it could be released in a different process
-        def serialize
-          result = super
-          result['lock_token'] = self.adapter.lock_token
-          result
-        end
-
-        def deserialize(job_data)
-          super
-          self.adapter.lock_token = job_data['lock_token']
-        end
-
-        def lock_key(*args)
-          [self.class.name, serialize_arguments(self.arguments)].join('/')
-        end
-
-        def adapter
-          @adapter ||= begin
-            # Make sure arguments are deserialized so calling lock key is safe
-            deserialize_arguments_if_needed
-
-            # Merge local and global options
-            merged_options = ActiveJob::Locking.options.dup.merge(self.class.lock_options)
-
-            # Get the key
-            base_key = self.lock_key(*self.arguments)
-            key = "activejoblocking:#{base_key}"
-
-            # Remember the lock might be acquired in one process and released in another
-            merged_options.adapter.new(key, merged_options)
-          end
-          @adapter
-        end
-      end
-    end
-  end
+module ActiveJob
+  module Locking
+    module Base
+      extend ::ActiveSupport::Concern
+
+      module ClassMethods
+        def lock_options
+          @lock_options ||= ActiveJob::Locking::Options.new
+        end
+        delegate :adapter, :enqueue_time, :hosts, :lock_time, :lock_acquire_time, :adapter_options, to: :lock_options
+        delegate :adapter=, :enqueue_time=, :hosts=, :lock_time=, :lock_acquire_time=, :adapter_options=, to: :lock_options
+      end
+
+      included do
+        # We need to serialize the lock token that some gems create because it could be released in a different process
+        def serialize
+          result = super
+          result['lock_token'] = self.adapter.lock_token
+          result
+        end
+
+        def deserialize(job_data)
+          super
+          self.adapter.lock_token = job_data['lock_token']
+        end
+
+        def lock_key(*args)
+          [self.class.name, serialize_arguments(self.arguments)].join('/')
+        end
+
+        def adapter
+          @adapter ||= begin
+            # Make sure arguments are deserialized so calling lock key is safe
+            deserialize_arguments_if_needed
+
+            # Merge local and global options
+            merged_options = ActiveJob::Locking.options.dup.merge(self.class.lock_options)
+
+            # Get the key
+            base_key = self.lock_key(*self.arguments)
+            key = "activejoblocking:#{base_key}"
+
+            # Remember the lock might be acquired in one process and released in another
+            merged_options.adapter.new(key, merged_options)
+          end
+          @adapter
+        end
+      end
+    end
+  end
 end

data/lib/activejob/locking/options.rb

@@ -1,73 +1,73 @@
-require 'ostruct'
-
-module ActiveJob
-  module Locking
-    class Options
-      attr_accessor :adapter
-      attr_accessor :hosts
-      attr_accessor :lock_time
-      attr_accessor :lock_acquire_time
-      attr_accessor :enqueue_time
-      attr_accessor :adapter_options
-
-      def initialize(options = {})
-        @adapter = options[:adapter]
-        @hosts = options[:hosts]
-        @enqueue_time = options[:enqueue_time]
-        @lock_time = options[:lock_time]
-        @lock_acquire_time = options[:lock_acquire_time]
-        @adapter_options = options[:adapter_options]
-      end
-
-      def enqueue_time=(value)
-        case value
-          when NilClass
-            raise(ArgumentError, 'Enqueue time must be set')
-          when ActiveSupport::Duration
-            @enqueue_time = value.value
-          when 0
-            raise(ArgumentError, 'Enqueue time must be greater than zero')
-          else
-            @enqueue_time = value
-        end
-      end
-
-      def lock_time=(value)
-        case value
-          when NilClass
-            raise(ArgumentError, 'Lock time must be set')
-          when ActiveSupport::Duration
-            @lock_time = value.value
-          when 0
-            raise(ArgumentError, 'Lock time must be greater than zero')
-          else
-            @lock_time = value
-        end
-      end
-
-      def lock_acquire_time=(value)
-        case value
-          when NilClass
-            raise(ArgumentError, 'Lock acquire time must be set')
-          when ActiveSupport::Duration
-            @lock_acquire_time = value.value
-          when 0
-            raise(ArgumentError, 'Lock acquire time must be greater than zero')
-          else
-            @lock_acquire_time = value
-        end
-      end
-
-      def merge(other)
-        result = self.dup
-        result.adapter = other.adapter if other.adapter
-        result.hosts = other.hosts if other.hosts
-        result.enqueue_time = other.enqueue_time if other.enqueue_time
-        result.lock_time = other.lock_time if other.lock_time
-        result.lock_acquire_time = other.lock_acquire_time if other.lock_acquire_time
-        result.adapter_options = other.adapter_options if other.adapter_options
-        result
-      end
-    end
-  end
+require 'ostruct'
+
+module ActiveJob
+  module Locking
+    class Options
+      attr_accessor :adapter
+      attr_accessor :hosts
+      attr_accessor :lock_time
+      attr_accessor :lock_acquire_time
+      attr_accessor :enqueue_time
+      attr_accessor :adapter_options
+
+      def initialize(options = {})
+        @adapter = options[:adapter]
+        @hosts = options[:hosts]
+        @enqueue_time = options[:enqueue_time]
+        @lock_time = options[:lock_time]
+        @lock_acquire_time = options[:lock_acquire_time]
+        @adapter_options = options[:adapter_options]
+      end
+
+      def enqueue_time=(value)
+        case value
+          when NilClass
+            raise(ArgumentError, 'Enqueue time must be set')
+          when ActiveSupport::Duration
+            @enqueue_time = value.value
+          when 0
+            raise(ArgumentError, 'Enqueue time must be greater than zero')
+          else
+            @enqueue_time = value
+        end
+      end
+
+      def lock_time=(value)
+        case value
+          when NilClass
+            raise(ArgumentError, 'Lock time must be set')
+          when ActiveSupport::Duration
+            @lock_time = value.value
+          when 0
+            raise(ArgumentError, 'Lock time must be greater than zero')
+          else
+            @lock_time = value
+        end
+      end
+
+      def lock_acquire_time=(value)
+        case value
+          when NilClass
+            raise(ArgumentError, 'Lock acquire time must be set')
+          when ActiveSupport::Duration
+            @lock_acquire_time = value.value
+          when 0
+            raise(ArgumentError, 'Lock acquire time must be greater than zero')
+          else
+            @lock_acquire_time = value
+        end
+      end
+
+      def merge(other)
+        result = self.dup
+        result.adapter = other.adapter if other.adapter
+        result.hosts = other.hosts if other.hosts
+        result.enqueue_time = other.enqueue_time if other.enqueue_time
+        result.lock_time = other.lock_time if other.lock_time
+        result.lock_acquire_time = other.lock_acquire_time if other.lock_acquire_time
+        result.adapter_options = other.adapter_options if other.adapter_options
+        result
+      end
+    end
+  end
 end

data/lib/activejob/locking/serialized.rb

@@ -1,23 +1,23 @@
-module ActiveJob
-  module Locking
-    module Serialized
-      extend ::ActiveSupport::Concern
-
-      included do
-        include ::ActiveJob::Locking::Base
-
-        around_perform do |job, block|
-          if job.adapter.lock
-            begin
-              block.call
-            ensure
-              job.adapter.unlock
-            end
-          else
-            job.class.set(wait: job.adapter.options.enqueue_time).perform_later(*job.arguments)
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveJob
+  module Locking
+    module Serialized
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::ActiveJob::Locking::Base
+
+        around_perform do |job, block|
+          if job.adapter.lock
+            begin
+              block.call
+            ensure
+              job.adapter.unlock
+            end
+          else
+            job.class.set(wait: job.adapter.options.enqueue_time).perform_later(*job.arguments)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activejob/locking/unique.rb

@@ -1,25 +1,25 @@
-module ActiveJob
-  module Locking
-    module Unique
-      extend ::ActiveSupport::Concern
-
-      included do
-        include ::ActiveJob::Locking::Base
-
-        before_enqueue do |job|
-          lock = job.adapter.lock
-          throw :abort unless lock
-        end
-
-        rescue_from(Exception) do |exception|
-          self.adapter.unlock
-          raise
-        end
-
-        after_perform do |job|
-          job.adapter.unlock
-        end
-      end
-    end
-  end
-end
+module ActiveJob
+  module Locking
+    module Unique
+      extend ::ActiveSupport::Concern
+
+      included do
+        include ::ActiveJob::Locking::Base
+
+        before_enqueue do |job|
+          lock = job.adapter.lock
+          throw :abort unless lock
+        end
+
+        rescue_from(Exception) do |exception|
+          self.adapter.unlock
+          raise
+        end
+
+        after_perform do |job|
+          job.adapter.unlock
+        end
+      end
+    end
+  end
+end

data/test/serialized_tests.rb

@@ -1,63 +1,63 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module SerializedTests
-  def test_one_completed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = SerialJob.lock_acquire_time / 0.9
-    threads = 3.times.map do |i|
-      Thread.new do
-        SerialJob.perform_later(i, sleep_time)
-      end
-    end
-
-    # All the threads will complete after the sleep time has expired - since two jobs get requeued
-    threads.each {|thread| thread.join}
-    assert_equal(2, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    assert(Time.now - start_time > (1 * sleep_time))
-  end
-
-  def test_some_completed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = SerialJob.lock_acquire_time / 1.9
-    threads = 3.times.map do |i|
-      Thread.new do
-        SerialJob.perform_later(i, sleep_time)
-      end
-    end
-
-    # All the threads will complete after the sleep time has expired - since two jobs get requeued
-    threads.each {|thread| thread.join}
-    assert_equal(1, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    assert(Time.now - start_time > (1 * sleep_time))
-  end
-
-  def test_all_completed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = SerialJob.lock_acquire_time / 4
-    threads = 3.times.map do |i|
-      Thread.new do
-        SerialJob.perform_later(i, sleep_time)
-      end
-    end
-
-    # All the threads will complete after the sleep time has expired - since two jobs get requeued
-    threads.each {|thread| thread.join}
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    assert(Time.now - start_time > (1 * sleep_time))
-  end
+require File.expand_path('../test_helper', __FILE__)
+
+module SerializedTests
+  def test_one_completed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = SerialJob.lock_acquire_time / 0.9
+    threads = 3.times.map do |i|
+      Thread.new do
+        SerialJob.perform_later(i, sleep_time)
+      end
+    end
+
+    # All the threads will complete after the sleep time has expired - since two jobs get requeued
+    threads.each {|thread| thread.join}
+    assert_equal(2, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    assert(Time.now - start_time > (1 * sleep_time))
+  end
+
+  def test_some_completed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = SerialJob.lock_acquire_time / 1.9
+    threads = 3.times.map do |i|
+      Thread.new do
+        SerialJob.perform_later(i, sleep_time)
+      end
+    end
+
+    # All the threads will complete after the sleep time has expired - since two jobs get requeued
+    threads.each {|thread| thread.join}
+    assert_equal(1, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    assert(Time.now - start_time > (1 * sleep_time))
+  end
+
+  def test_all_completed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = SerialJob.lock_acquire_time / 4
+    threads = 3.times.map do |i|
+      Thread.new do
+        SerialJob.perform_later(i, sleep_time)
+      end
+    end
+
+    # All the threads will complete after the sleep time has expired - since two jobs get requeued
+    threads.each {|thread| thread.join}
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(3, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    assert(Time.now - start_time > (1 * sleep_time))
+  end
 end

data/test/test_helper.rb

@@ -1,20 +1,20 @@
-require 'bundler'
-Bundler.require(:default, :test)
-
-require 'minitest/autorun'
-
-# To make debugging easier, test within this source tree versus an installed gem
-$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
-require 'activejob-locking'
-
-require 'activejob/locking/adapters/redis-semaphore'
-require 'activejob/locking/adapters/redlock'
-require 'activejob/locking/adapters/suo-redis'
-
-require_relative './jobs/unique_job'
-require_relative './jobs/fail_job'
-require_relative './jobs/serial_job'
-
-def redis_reset
-  Kernel.system('redis-cli FLUSHALL')
+require 'bundler'
+Bundler.require(:default, :test)
+
+require 'minitest/autorun'
+
+# To make debugging easier, test within this source tree versus an installed gem
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'activejob-locking'
+
+require 'activejob/locking/adapters/redis-semaphore'
+require 'activejob/locking/adapters/redlock'
+require 'activejob/locking/adapters/suo-redis'
+
+require_relative './jobs/unique_job'
+require_relative './jobs/fail_job'
+require_relative './jobs/serial_job'
+
+def redis_reset
+  Kernel.system('redis-cli FLUSHALL')
 end

data/test/test_serialized_memory.rb

@@ -1,11 +1,11 @@
-require_relative('./serialized_tests')
-
-class SerializedMemory < MiniTest::Test
-  include SerializedTests
-
-  def setup
-    ActiveJob::Base.queue_adapter = :test
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::Memory
-  end
+require_relative('./serialized_tests')
+
+class SerializedMemory < MiniTest::Test
+  include SerializedTests
+
+  def setup
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::Memory
+  end
 end

data/test/test_serialized_redis_semaphore.rb

@@ -1,12 +1,12 @@
-require_relative('./serialized_tests')
-
-class UniqueRedisSemaphoreTest < MiniTest::Test
-  include SerializedTests
-
-  def setup
-    redis_reset
-    ActiveJob::Base.queue_adapter = :test
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::RedisSemaphore
-  end
+require_relative('./serialized_tests')
+
+class UniqueRedisSemaphoreTest < MiniTest::Test
+  include SerializedTests
+
+  def setup
+    redis_reset
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::RedisSemaphore
+  end
 end

data/test/test_serialized_redlock.rb

@@ -1,14 +1,14 @@
-require_relative('./serialized_tests')
-
-class SerializedRedlockTest < MiniTest::Test
-  include SerializedTests
-
-  def setup
-    redis_reset
-
-    ActiveJob::Base.queue_adapter = :test
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::Redlock
-    ActiveJob::Locking.options.hosts = Redlock::Client::DEFAULT_REDIS_URLS
-  end
+require_relative('./serialized_tests')
+
+class SerializedRedlockTest < MiniTest::Test
+  include SerializedTests
+
+  def setup
+    redis_reset
+
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::Redlock
+    ActiveJob::Locking.options.hosts = Redlock::Client::DEFAULT_REDIS_URLS
+  end
 end

data/test/test_serialized_suo_redis.rb

@@ -1,12 +1,12 @@
-require_relative('./serialized_tests')
-
-class SerializedSuoRedisTest < MiniTest::Test
-  include SerializedTests
-
-  def setup
-    redis_reset
-    ActiveJob::Base.queue_adapter = :test
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::SuoRedis
-  end
+require_relative('./serialized_tests')
+
+class SerializedSuoRedisTest < MiniTest::Test
+  include SerializedTests
+
+  def setup
+    redis_reset
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::SuoRedis
+  end
 end

data/test/test_unique_memory.rb

@@ -1,12 +1,12 @@
-require_relative('./unique_tests')
-
-class UniqueMemoryTest < MiniTest::Test
-  include UniqueTests
-
-  def setup
-    ActiveJob::Locking::Adapters::Memory.reset
-    ActiveJob::Base.queue_adapter = :test
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::Memory
-  end
-end
+require_relative('./unique_tests')
+
+class UniqueMemoryTest < MiniTest::Test
+  include UniqueTests
+
+  def setup
+    ActiveJob::Locking::Adapters::Memory.reset
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::Memory
+  end
+end

data/test/test_unique_redis_semaphore.rb

@@ -1,12 +1,12 @@
-require_relative('./unique_tests')
-
-class UniqueRedisSemaphoreTest < MiniTest::Test
-  include UniqueTests
-
-  def setup
-    redis_reset
-    ActiveJob::Base.queue_adapter = :test
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::RedisSemaphore
-  end
+require_relative('./unique_tests')
+
+class UniqueRedisSemaphoreTest < MiniTest::Test
+  include UniqueTests
+
+  def setup
+    redis_reset
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::RedisSemaphore
+  end
 end

data/test/test_unique_redlock.rb

@@ -1,14 +1,14 @@
-require_relative('./unique_tests')
-
-class UniqueRedlockTest < MiniTest::Test
-  include UniqueTests
-
-  def setup
-    redis_reset
-
-    ActiveJob::Base.queue_adapter = :test
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::Redlock
-    ActiveJob::Locking.options.hosts = Redlock::Client::DEFAULT_REDIS_URLS
-  end
+require_relative('./unique_tests')
+
+class UniqueRedlockTest < MiniTest::Test
+  include UniqueTests
+
+  def setup
+    redis_reset
+
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::Redlock
+    ActiveJob::Locking.options.hosts = Redlock::Client::DEFAULT_REDIS_URLS
+  end
 end

data/test/test_unique_suo_redis.rb

@@ -1,12 +1,12 @@
-require_relative('./unique_tests')
-
-class UniqueSuoRedisTest < MiniTest::Test
-  include UniqueTests
-
-  def setup
-    redis_reset
-    ActiveJob::Base.queue_adapter = :test
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::SuoRedis
-  end
+require_relative('./unique_tests')
+
+class UniqueSuoRedisTest < MiniTest::Test
+  include UniqueTests
+
+  def setup
+    redis_reset
+    ActiveJob::Base.queue_adapter = :test
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Locking.options.adapter = ActiveJob::Locking::Adapters::SuoRedis
+  end
 end

data/test/unique_tests.rb

@@ -1,100 +1,100 @@
-require File.expand_path('../test_helper', __FILE__)
-
-module UniqueTests
-  def test_none_performed
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = false
-
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    sleep_time = UniqueJob.lock_acquire_time
-    threads = 3.times.map do |i|
-      Thread.new do
-        UniqueJob.perform_later(i, sleep_time)
-      end
-    end
-
-    threads.each {|thread| thread.join}
-    assert_equal(1, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-  ensure
-    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
-    ActiveJob::Base.queue_adapter.enqueued_jobs.clear
-  end
-
-  def test_one_performed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    sleep_time = UniqueJob.lock_acquire_time * 2
-    threads = 3.times.map do |i|
-      Thread.new do
-        UniqueJob.perform_later(i, sleep_time)
-      end
-    end
-
-    threads.each {|thread| thread.join}
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(1, ActiveJob::Base.queue_adapter.performed_jobs.count)
-  end
-
-  def test_all_performed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = UniqueJob.lock_acquire_time / 4.0
-    threads = 3.times.map do |i|
-      Thread.new do
-        UniqueJob.perform_later(i, sleep_time)
-      end
-    end
-
-    threads.each {|thread| thread.join}
-
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(threads.count, ActiveJob::Base.queue_adapter.performed_jobs.count)
-    assert(Time.now - start_time > (threads.count * sleep_time))
-  end
-
-  def test_some_performed
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = UniqueJob.lock_acquire_time / 2.0
-    threads = 3.times.map do |i|
-      Thread.new do
-        UniqueJob.perform_later(i, sleep_time)
-      end
-    end
-
-    threads.each {|thread| thread.join}
-
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(threads.count - 1, ActiveJob::Base.queue_adapter.performed_jobs.count)
-    assert(Time.now - start_time > ((threads.count - 1) * sleep_time))
-  end
-
-  def test_fail
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
-
-    start_time = Time.now
-    sleep_time = UniqueJob.lock_acquire_time
-    threads = 3.times.map do |i|
-      Thread.new do
-        begin
-          FailJob.perform_later(i, sleep_time)
-        rescue => e
-          # do nothing
-        end
-      end
-    end
-
-    threads.each {|thread| thread.join}
-
-    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
-    assert_equal(threads.count, ActiveJob::Base.queue_adapter.performed_jobs.count)
-  end
+require File.expand_path('../test_helper', __FILE__)
+
+module UniqueTests
+  def test_none_performed
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = false
+
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    sleep_time = UniqueJob.lock_acquire_time
+    threads = 3.times.map do |i|
+      Thread.new do
+        UniqueJob.perform_later(i, sleep_time)
+      end
+    end
+
+    threads.each {|thread| thread.join}
+    assert_equal(1, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+  ensure
+    ActiveJob::Base.queue_adapter.perform_enqueued_jobs = true
+    ActiveJob::Base.queue_adapter.enqueued_jobs.clear
+  end
+
+  def test_one_performed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    sleep_time = UniqueJob.lock_acquire_time * 2
+    threads = 3.times.map do |i|
+      Thread.new do
+        UniqueJob.perform_later(i, sleep_time)
+      end
+    end
+
+    threads.each {|thread| thread.join}
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(1, ActiveJob::Base.queue_adapter.performed_jobs.count)
+  end
+
+  def test_all_performed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = UniqueJob.lock_acquire_time / 4.0
+    threads = 3.times.map do |i|
+      Thread.new do
+        UniqueJob.perform_later(i, sleep_time)
+      end
+    end
+
+    threads.each {|thread| thread.join}
+
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(threads.count, ActiveJob::Base.queue_adapter.performed_jobs.count)
+    assert(Time.now - start_time > (threads.count * sleep_time))
+  end
+
+  def test_some_performed
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = UniqueJob.lock_acquire_time / 2.0
+    threads = 3.times.map do |i|
+      Thread.new do
+        UniqueJob.perform_later(i, sleep_time)
+      end
+    end
+
+    threads.each {|thread| thread.join}
+
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(threads.count - 1, ActiveJob::Base.queue_adapter.performed_jobs.count)
+    assert(Time.now - start_time > ((threads.count - 1) * sleep_time))
+  end
+
+  def test_fail
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(0, ActiveJob::Base.queue_adapter.performed_jobs.count)
+
+    start_time = Time.now
+    sleep_time = UniqueJob.lock_acquire_time
+    threads = 3.times.map do |i|
+      Thread.new do
+        begin
+          FailJob.perform_later(i, sleep_time)
+        rescue => e
+          # do nothing
+        end
+      end
+    end
+
+    threads.each {|thread| thread.join}
+
+    assert_equal(0, ActiveJob::Base.queue_adapter.enqueued_jobs.count)
+    assert_equal(threads.count, ActiveJob::Base.queue_adapter.performed_jobs.count)
+  end
 end

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: activejob-locking
 version: !ruby/object:Gem::Version
-  version: 0.5.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Charlie Savage
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-10-08 00:00:00.000000000 Z
+date: 2019-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activejob
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.10.0
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 5.10.0
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: redis-mutex
   requirement: !ruby/object:Gem::Requirement
@@ -153,8 +153,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: ActiveJob locking to control how jobs are enqueued and performed.