with_advisory_lock 4.6.0 → 5.3.0

data/test/with_advisory_lock/options_test.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class OptionsParsingTest < GemTestCase
+  def parse_options(options)
+    WithAdvisoryLock::Base.new(mock, mock, options)
+  end
+
+  test 'defaults (empty hash)' do
+    impl = parse_options({})
+    assert_nil(impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert_not(impl.transaction)
+  end
+
+  test 'nil sets timeout to nil' do
+    impl = parse_options(nil)
+    assert_nil(impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert_not(impl.transaction)
+  end
+
+  test 'integer sets timeout to value' do
+    impl = parse_options(42)
+    assert_equal(42, impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert_not(impl.transaction)
+  end
+
+  test 'hash with invalid key errors' do
+    assert_raises(ArgumentError) do
+      parse_options(foo: 42)
+    end
+  end
+
+  test 'hash with timeout_seconds sets timeout to value' do
+    impl = parse_options(timeout_seconds: 123)
+    assert_equal(123, impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert_not(impl.transaction)
+  end
+
+  test 'hash with shared option sets shared to true' do
+    impl = parse_options(shared: true)
+    assert_nil(impl.timeout_seconds)
+    assert(impl.shared)
+    assert_not(impl.transaction)
+  end
+
+  test 'hash with transaction option set transaction to true' do
+    impl = parse_options(transaction: true)
+    assert_nil(impl.timeout_seconds)
+    assert_not(impl.shared)
+    assert(impl.transaction)
+  end
+
+  test 'hash with multiple keys sets options' do
+    foo = mock
+    bar = mock
+    impl = parse_options(timeout_seconds: foo, shared: bar)
+    assert_equal(foo, impl.timeout_seconds)
+    assert_equal(bar, impl.shared)
+    assert_not(impl.transaction)
+  end
+end

data/test/with_advisory_lock/parallelism_test.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'forwardable'
+
+class FindOrCreateWorker
+  extend Forwardable
+  def_delegators :@thread, :join, :wakeup, :status, :to_s
+
+  def initialize(name, use_advisory_lock)
+    @name = name
+    @use_advisory_lock = use_advisory_lock
+    @thread = Thread.new { work_later }
+  end
+
+  def work_later
+    sleep
+    ApplicationRecord.connection_pool.with_connection do
+      if @use_advisory_lock
+        Tag.with_advisory_lock(@name) { work }
+      else
+        work
+      end
+    end
+  end
+
+  def work
+    Tag.transaction do
+      Tag.where(name: @name).first_or_create
+    end
+  end
+end
+
+class ParallelismTest < GemTestCase
+  def run_workers
+    @names = @iterations.times.map { |iter| "iteration ##{iter}" }
+    @names.each do |name|
+      workers = @workers.times.map do
+        FindOrCreateWorker.new(name, @use_advisory_lock)
+      end
+      # Wait for all the threads to get ready:
+      sleep(0.1) until workers.all? { |ea| ea.status == 'sleep' }
+      # OK, GO!
+      workers.each(&:wakeup)
+      # Then wait for them to finish:
+      workers.each(&:join)
+    end
+    # Ensure we're still connected:
+    ApplicationRecord.connection_pool.connection
+  end
+
+  setup do
+    ApplicationRecord.connection.reconnect!
+    @workers = 10
+  end
+
+  test 'creates multiple duplicate rows without advisory locks' do
+    skip if %i[sqlite3 jdbcsqlite3].include?(env_db)
+    @use_advisory_lock = false
+    @iterations = 1
+    run_workers
+    assert_operator(Tag.all.size,      :>, @iterations) # <- any duplicated rows will make me happy.
+    assert_operator(TagAudit.all.size, :>, @iterations) # <- any duplicated rows will make me happy.
+    assert_operator(Label.all.size,    :>, @iterations) # <- any duplicated rows will make me happy.
+  end
+
+  test "doesn't create multiple duplicate rows with advisory locks" do
+    @use_advisory_lock = true
+    @iterations = 10
+    run_workers
+    assert_equal(@iterations, Tag.all.size)       # <- any duplicated rows will NOT make me happy.
+    assert_equal(@iterations, TagAudit.all.size)  # <- any duplicated rows will NOT make me happy.
+    assert_equal(@iterations, Label.all.size)     # <- any duplicated rows will NOT make me happy.
+  end
+end

data/test/with_advisory_lock/shared_test.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+class SharedTestWorker
+  def initialize(shared)
+    @shared = shared
+
+    @locked = nil
+    @cleanup = false
+    @thread = Thread.new { work }
+  end
+
+  def locked?
+    sleep 0.01 while @locked.nil? && @thread.alive?
+    @locked
+  end
+
+  def cleanup!
+    @cleanup = true
+    @thread.join
+    raise if @thread.status.nil?
+  end
+
+  private
+
+  def work
+    Tag.connection_pool.with_connection do
+      Tag.with_advisory_lock('test', timeout_seconds: 0, shared: @shared) do
+        @locked = true
+        sleep 0.01 until @cleanup
+      end
+      @locked = false
+      sleep 0.01 until @cleanup
+    end
+  end
+end
+
+class SharedLocksTest < GemTestCase
+  def supported?
+    %i[trilogy mysql2 jdbcmysql].exclude?(env_db)
+  end
+
+  test 'does not allow two exclusive locks' do
+    one = SharedTestWorker.new(false)
+    assert_predicate(one, :locked?)
+
+    two = SharedTestWorker.new(false)
+    refute(two.locked?)
+
+    one.cleanup!
+    two.cleanup!
+  end
+end
+
+class NotSupportedEnvironmentTest < SharedLocksTest
+  setup do
+    skip if supported?
+  end
+
+  test 'raises an error when attempting to use a shared lock' do
+    one = SharedTestWorker.new(true)
+    assert_nil(one.locked?)
+
+    exception = assert_raises(ArgumentError) do
+      one.cleanup!
+    end
+
+    assert_match(/#{Regexp.escape('not supported')}/, exception.message)
+  end
+end
+
+class SupportedEnvironmentTest < SharedLocksTest
+  setup do
+    skip unless supported?
+  end
+
+  test 'does allow two shared locks' do
+    one = SharedTestWorker.new(true)
+    assert_predicate(one, :locked?)
+
+    two = SharedTestWorker.new(true)
+    assert_predicate(two, :locked?)
+
+    one.cleanup!
+    two.cleanup!
+  end
+
+  test 'does not allow exclusive lock with shared lock' do
+    one = SharedTestWorker.new(true)
+    assert_predicate(one, :locked?)
+
+    two = SharedTestWorker.new(false)
+    refute(two.locked?)
+
+    three = SharedTestWorker.new(true)
+    assert_predicate(three, :locked?)
+
+    one.cleanup!
+    two.cleanup!
+    three.cleanup!
+  end
+
+  test 'does not allow shared lock with exclusive lock' do
+    one = SharedTestWorker.new(false)
+    assert_predicate(one, :locked?)
+
+    two = SharedTestWorker.new(true)
+    refute(two.locked?)
+
+    one.cleanup!
+    two.cleanup!
+  end
+
+  class PostgreSQLTest < SupportedEnvironmentTest
+    setup do
+      skip unless env_db == :postgresql
+    end
+
+    def pg_lock_modes
+      Tag.connection.select_values("SELECT mode FROM pg_locks WHERE locktype = 'advisory';")
+    end
+
+    test 'allows shared lock to be upgraded to an exclusive lock' do
+      assert_empty(pg_lock_modes)
+      Tag.with_advisory_lock 'test', shared: true do
+        assert_equal(%w[ShareLock], pg_lock_modes)
+        Tag.with_advisory_lock 'test', shared: false do
+          assert_equal(%w[ShareLock ExclusiveLock], pg_lock_modes)
+        end
+      end
+      assert_empty(pg_lock_modes)
+    end
+  end
+end

data/test/with_advisory_lock/thread_test.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class SeparateThreadTest < GemTestCase
+  setup do
+    @lock_name = 'testing 1,2,3' # OMG COMMAS
+    @mutex = Mutex.new
+    @t1_acquired_lock = false
+    @t1_return_value = nil
+
+    @t1 = Thread.new do
+      Label.connection_pool.with_connection do
+        @t1_return_value = Label.with_advisory_lock(@lock_name) do
+          @mutex.synchronize { @t1_acquired_lock = true }
+          sleep
+          't1 finished'
+        end
+      end
+    end
+
+    # Wait for the thread to acquire the lock:
+    sleep(0.1) until @mutex.synchronize { @t1_acquired_lock }
+    Label.connection.reconnect!
+  end
+
+  teardown do
+    @t1.wakeup if @t1.status == 'sleep'
+    @t1.join
+  end
+
+  test '#with_advisory_lock with a 0 timeout returns false immediately' do
+    response = Label.with_advisory_lock(@lock_name, 0) do
+      raise 'should not be yielded to'
+    end
+    assert_not(response)
+  end
+
+  test '#with_advisory_lock yields to the provided block' do
+    assert(@t1_acquired_lock)
+  end
+
+  test '#advisory_lock_exists? returns true when another thread has the lock' do
+    assert(Tag.advisory_lock_exists?(@lock_name))
+  end
+
+  test 'can re-establish the lock after the other thread releases it' do
+    @t1.wakeup
+    @t1.join
+    assert_equal('t1 finished', @t1_return_value)
+
+    # We should now be able to acquire the lock immediately:
+    reacquired = false
+    lock_result = Label.with_advisory_lock(@lock_name, 0) do
+      reacquired = true
+    end
+
+    assert(lock_result)
+    assert(reacquired)
+  end
+end

data/test/with_advisory_lock/transaction_test.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class TransactionScopingTest < GemTestCase
+  def supported?
+    %i[postgresql jdbcpostgresql].include?(env_db)
+  end
+
+  test 'raises an error when attempting to use transaction level locks if not supported' do
+    skip if supported?
+
+    Tag.transaction do
+      exception = assert_raises(ArgumentError) do
+        Tag.with_advisory_lock 'test', transaction: true do
+          raise 'should not get here'
+        end
+      end
+
+      assert_match(/#{Regexp.escape('not supported')}/, exception.message)
+    end
+  end
+
+  class PostgresqlTest < TransactionScopingTest
+    setup do
+      skip unless env_db == :postgresql
+      @pg_lock_count = lambda do
+        ApplicationRecord.connection.select_value("SELECT COUNT(*) FROM pg_locks WHERE locktype = 'advisory';").to_i
+      end
+    end
+
+    test 'session locks release after the block executes' do
+      Tag.transaction do
+        assert_equal(0, @pg_lock_count.call)
+        Tag.with_advisory_lock 'test' do
+          assert_equal(1, @pg_lock_count.call)
+        end
+        assert_equal(0, @pg_lock_count.call)
+      end
+    end
+
+    test 'session locks release when transaction fails inside block' do
+      Tag.transaction do
+        assert_equal(0, @pg_lock_count.call)
+
+        exception = assert_raises(ActiveRecord::StatementInvalid) do
+          Tag.with_advisory_lock 'test' do
+            Tag.connection.execute 'SELECT 1/0;'
+          end
+        end
+
+        assert_match(/#{Regexp.escape('division by zero')}/, exception.message)
+        assert_equal(0, @pg_lock_count.call)
+      end
+    end
+
+    test 'transaction level locks hold until the transaction completes' do
+      Tag.transaction do
+        assert_equal(0, @pg_lock_count.call)
+        Tag.with_advisory_lock 'test', transaction: true do
+          assert_equal(1, @pg_lock_count.call)
+        end
+        assert_equal(1, @pg_lock_count.call)
+      end
+      assert_equal(0, @pg_lock_count.call)
+    end
+  end
+end

data/with_advisory_lock.gemspec

@@ -1,29 +1,35 @@
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'with_advisory_lock/version'
+# frozen_string_literal: true
 
-Gem::Specification.new do |gem|
-  gem.name          = "with_advisory_lock"
-  gem.version       = WithAdvisoryLock::VERSION
-  gem.authors       = ['Matthew McEachen']
-  gem.email         = %w(matthew+github@mceachen.org)
-  gem.homepage      = 'https://github.com/mceachen/with_advisory_lock'
-  gem.summary       = %q{Advisory locking for ActiveRecord}
-  gem.description   = %q{Advisory locking for ActiveRecord}
-  gem.license       = 'MIT'
+require 'English'
+require_relative 'lib/with_advisory_lock/version'
 
-  gem.files         = `git ls-files`.split($/)
-  gem.test_files    = gem.files.grep(%r{^test/})
-  gem.require_paths = %w(lib)
-  gem.required_ruby_version = '>= 2.2.10'
+Gem::Specification.new do |spec|
+  spec.name          = 'with_advisory_lock'
+  spec.version       = WithAdvisoryLock::VERSION
+  spec.authors       = ['Matthew McEachen', 'Abdelkader Boudih']
+  spec.email         = %w[matthew+github@mceachen.org terminale@gmail.com]
+  spec.homepage      = 'https://github.com/ClosureTree/with_advisory_lock'
+  spec.summary       = 'Advisory locking for ActiveRecord'
+  spec.description   = 'Advisory locking for ActiveRecord'
+  spec.license       = 'MIT'
 
-  gem.add_runtime_dependency 'activerecord', '>= 4.2'
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.test_files    = spec.files.grep(%r{^test/})
+  spec.require_paths = %w[lib]
+  spec.metadata      = { 'rubygems_mfa_required' => 'true' }
+  spec.required_ruby_version = '>= 2.7.0'
+  spec.metadata['yard.run'] = 'yri'
 
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/ClosureTree/with_advisory_lock'
+  spec.metadata['changelog_uri'] = 'https://github.com/ClosureTree/with_advisory_lock/blob/master/CHANGELOG.md'
 
-  gem.add_development_dependency 'yard'
-  gem.add_development_dependency 'minitest'
-  gem.add_development_dependency 'minitest-great_expectations'
-  gem.add_development_dependency 'minitest-reporters'
-  gem.add_development_dependency 'mocha'
-  gem.add_development_dependency 'appraisal'
+  spec.add_runtime_dependency 'activerecord', '>= 6.1'
+  spec.add_runtime_dependency 'zeitwerk', '>= 2.6'
+
+  spec.add_development_dependency 'appraisal'
+  spec.add_development_dependency 'maxitest'
+  spec.add_development_dependency 'minitest-reporters'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'yard'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: with_advisory_lock
 version: !ruby/object:Gem::Version
-  version: 4.6.0
+  version: 5.3.0
 platform: ruby
 authors:
 - Matthew McEachen
-autorequire: 
+- Abdelkader Boudih
 bindir: bin
 cert_chain: []
-date: 2019-09-20 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -16,30 +16,30 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.2'
+        version: '6.1'
 - !ruby/object:Gem::Dependency
-  name: yard
+  name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
+        version: '2.6'
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.6'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: appraisal
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest-great_expectations
+  name: maxitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -95,7 +95,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: appraisal
+  name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -111,52 +111,62 @@ dependencies:
 description: Advisory locking for ActiveRecord
 email:
 - matthew+github@mceachen.org
+- terminale@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/ci-mysql5.yml"
+- ".github/workflows/ci-mysql8.yml"
+- ".github/workflows/ci-postgresql.yml"
+- ".github/workflows/ci-sqlite3.yml"
+- ".github/workflows/release.yml"
 - ".gitignore"
+- ".release-please-manifest.json"
+- ".ruby-version"
 - ".tool-versions"
-- ".travis.yml"
 - Appraisals
 - CHANGELOG.md
 - Gemfile
 - LICENSE.txt
+- Makefile
 - README.md
 - Rakefile
-- gemfiles/activerecord_4.2.gemfile
-- gemfiles/activerecord_5.0.gemfile
-- gemfiles/activerecord_5.1.gemfile
-- gemfiles/activerecord_5.2.gemfile
-- gemfiles/activerecord_6.0.gemfile
+- docker-compose.yml
+- gemfiles/activerecord_6.1.gemfile
+- gemfiles/activerecord_7.0.gemfile
+- gemfiles/activerecord_7.1.gemfile
 - lib/with_advisory_lock.rb
 - lib/with_advisory_lock/base.rb
 - lib/with_advisory_lock/concern.rb
 - lib/with_advisory_lock/database_adapter_support.rb
+- lib/with_advisory_lock/failed_to_acquire_lock.rb
 - lib/with_advisory_lock/flock.rb
 - lib/with_advisory_lock/mysql.rb
-- lib/with_advisory_lock/mysql_no_nesting.rb
-- lib/with_advisory_lock/nested_advisory_lock_error.rb
 - lib/with_advisory_lock/postgresql.rb
 - lib/with_advisory_lock/version.rb
-- test/concern_test.rb
-- test/database.yml
-- test/lock_test.rb
-- test/minitest_helper.rb
-- test/nesting_test.rb
-- test/options_test.rb
-- test/parallelism_test.rb
-- test/shared_test.rb
+- release-please-config.json
+- test/test_helper.rb
 - test/test_models.rb
-- test/thread_test.rb
-- test/transaction_test.rb
-- tests.sh
+- test/with_advisory_lock/base_test.rb
+- test/with_advisory_lock/concern_test.rb
+- test/with_advisory_lock/lock_test.rb
+- test/with_advisory_lock/nesting_test.rb
+- test/with_advisory_lock/options_test.rb
+- test/with_advisory_lock/parallelism_test.rb
+- test/with_advisory_lock/shared_test.rb
+- test/with_advisory_lock/thread_test.rb
+- test/with_advisory_lock/transaction_test.rb
 - with_advisory_lock.gemspec
-homepage: https://github.com/mceachen/with_advisory_lock
+homepage: https://github.com/ClosureTree/with_advisory_lock
 licenses:
 - MIT
-metadata: {}
-post_install_message: 
+metadata:
+  rubygems_mfa_required: 'true'
+  yard.run: yri
+  homepage_uri: https://github.com/ClosureTree/with_advisory_lock
+  source_code_uri: https://github.com/ClosureTree/with_advisory_lock
+  changelog_uri: https://github.com/ClosureTree/with_advisory_lock/blob/master/CHANGELOG.md
 rdoc_options: []
 require_paths:
 - lib
@@ -164,26 +174,25 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.10
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.6.7
 specification_version: 4
 summary: Advisory locking for ActiveRecord
 test_files:
-- test/concern_test.rb
-- test/database.yml
-- test/lock_test.rb
-- test/minitest_helper.rb
-- test/nesting_test.rb
-- test/options_test.rb
-- test/parallelism_test.rb
-- test/shared_test.rb
+- test/test_helper.rb
 - test/test_models.rb
-- test/thread_test.rb
-- test/transaction_test.rb
+- test/with_advisory_lock/base_test.rb
+- test/with_advisory_lock/concern_test.rb
+- test/with_advisory_lock/lock_test.rb
+- test/with_advisory_lock/nesting_test.rb
+- test/with_advisory_lock/options_test.rb
+- test/with_advisory_lock/parallelism_test.rb
+- test/with_advisory_lock/shared_test.rb
+- test/with_advisory_lock/thread_test.rb
+- test/with_advisory_lock/transaction_test.rb

data/.travis.yml

@@ -1,38 +0,0 @@
-language: ruby
-
-services:
-  - postgresql
-  - mysql
-
-addons:
-  postgresql: "10"
-
-rvm:
-  - 2.6.4
-  - 2.5.6
-  - 2.4.7
-
-gemfile:
-  - gemfiles/activerecord_6.0.gemfile
-  - gemfiles/activerecord_5.2.gemfile
-  - gemfiles/activerecord_5.1.gemfile
-  - gemfiles/activerecord_5.0.gemfile
-  - gemfiles/activerecord_4.2.gemfile
-
-env:
-  global:
-    - WITH_ADVISORY_LOCK_PREFIX=$TRAVIS_JOB_ID
-  matrix:
-    - DB=postgresql
-    - DB=mysql MYSQL_VERSION=5.7
-    - DB=sqlite
-matrix:
-  exclude:
-    - rvm: 2.4.7
-      gemfile: gemfiles/activerecord_6.0.gemfile
-
-before_install:
-  - mysql -e 'create database with_advisory_lock_test'
-  - psql -c 'create database with_advisory_lock_test' -U postgres
-
-script: bundle exec rake --trace