with_advisory_lock 4.6.0 → 7.0.1

data/test/dummy/config.ru

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+require_relative 'config/environment'
+
+run Rails.application
+Rails.application.load_server

data/test/dummy/db/schema.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table 'tags', force: true do |t|
+    t.string 'name'
+  end
+
+  create_table 'tag_audits', id: false, force: true do |t|
+    t.string 'tag_name'
+  end
+
+  create_table 'labels', id: false, force: true do |t|
+    t.string 'name'
+  end
+end

data/test/dummy/db/secondary_schema.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+ActiveRecord::Schema.define(version: 1) do
+  create_table 'mysql_tags', force: true do |t|
+    t.string 'name'
+  end
+
+  create_table 'mysql_tag_audits', id: false, force: true do |t|
+    t.string 'tag_name'
+  end
+
+  create_table 'mysql_labels', id: false, force: true do |t|
+    t.string 'name'
+  end
+end

data/test/dummy/lib/tasks/db.rake

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+namespace :db do
+  namespace :test do
+    desc 'Load schema for all databases'
+    task prepare: :environment do
+      # Load schema for primary database
+      ActiveRecord::Base.establish_connection(:primary)
+      ActiveRecord::Schema.define(version: 1) do
+        create_table 'tags', force: true do |t|
+          t.string 'name'
+        end
+
+        create_table 'tag_audits', id: false, force: true do |t|
+          t.string 'tag_name'
+        end
+
+        create_table 'labels', id: false, force: true do |t|
+          t.string 'name'
+        end
+      end
+
+      # Load schema for secondary database
+      ActiveRecord::Base.establish_connection(:secondary)
+      ActiveRecord::Schema.define(version: 1) do
+        create_table 'mysql_tags', force: true do |t|
+          t.string 'name'
+        end
+
+        create_table 'mysql_tag_audits', id: false, force: true do |t|
+          t.string 'tag_name'
+        end
+
+        create_table 'mysql_labels', id: false, force: true do |t|
+          t.string 'name'
+        end
+      end
+    end
+  end
+end

data/test/sanity_check_test.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class SanityCheckTest < GemTestCase
+  test 'PostgreSQL and MySQL databases are properly isolated' do
+    # Create a tag in PostgreSQL database
+    pg_tag = Tag.create!(name: 'postgresql-only-tag')
+
+    # Verify it exists in PostgreSQL
+    assert Tag.exists?(name: 'postgresql-only-tag')
+    assert_equal 1, Tag.where(name: 'postgresql-only-tag').count
+
+    # Verify it does NOT exist in MySQL database
+    assert_not MysqlTag.exists?(name: 'postgresql-only-tag')
+    assert_equal 0, MysqlTag.where(name: 'postgresql-only-tag').count
+
+    # Create a tag in MySQL database
+    mysql_tag = MysqlTag.create!(name: 'mysql-only-tag')
+
+    # Verify it exists in MySQL
+    assert MysqlTag.exists?(name: 'mysql-only-tag')
+    assert_equal 1, MysqlTag.where(name: 'mysql-only-tag').count
+
+    # Verify it does NOT exist in PostgreSQL database
+    assert_not Tag.exists?(name: 'mysql-only-tag')
+    assert_equal 0, Tag.where(name: 'mysql-only-tag').count
+
+    # Clean up
+    pg_tag.destroy
+    mysql_tag.destroy
+  end
+
+  test 'PostgreSQL models use PostgreSQL adapter' do
+    assert_equal 'PostgreSQL', Tag.connection.adapter_name
+    assert_equal 'PostgreSQL', TagAudit.connection.adapter_name
+    assert_equal 'PostgreSQL', Label.connection.adapter_name
+  end
+
+  test 'MySQL models use MySQL adapter' do
+    assert_equal 'Mysql2', MysqlTag.connection.adapter_name
+    assert_equal 'Mysql2', MysqlTagAudit.connection.adapter_name
+    assert_equal 'Mysql2', MysqlLabel.connection.adapter_name
+  end
+
+  test 'can write to both databases in same test' do
+    # Create records in both databases
+    pg_tag = Tag.create!(name: 'test-pg')
+    mysql_tag = MysqlTag.create!(name: 'test-mysql')
+
+    # Both should have IDs
+    assert pg_tag.persisted?
+    assert mysql_tag.persisted?
+
+    # IDs should be independent (both could be 1 if tables are empty)
+    assert_kind_of Integer, pg_tag.id
+    assert_kind_of Integer, mysql_tag.id
+
+    # Clean up
+    pg_tag.destroy
+    mysql_tag.destroy
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+ENV['RAILS_ENV'] = 'test'
+ENV['WITH_ADVISORY_LOCK_PREFIX'] ||= SecureRandom.hex
+
+require 'dotenv'
+Dotenv.load
+
+require_relative 'dummy/config/environment'
+require 'rails/test_help'
+
+require 'with_advisory_lock'
+require 'maxitest/autorun'
+require 'mocha/minitest'
+
+class GemTestCase < ActiveSupport::TestCase
+  parallelize(workers: 1)
+
+  def self.startup
+    # Validate environment variables when tests actually start running
+    %w[DATABASE_URL_PG DATABASE_URL_MYSQL].each do |var|
+      abort "Missing required environment variable: #{var}" if ENV[var].nil? || ENV[var].empty?
+    end
+  end
+
+  # Override in test classes to clean only the tables you need
+  # This avoids unnecessary database operations
+end
+
+puts "Testing ActiveRecord #{ActiveRecord.gem_version} and ruby #{RUBY_VERSION}"
+puts "Connection Pool size: #{ActiveRecord::Base.connection_pool.size}"

data/test/with_advisory_lock/concern_test.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module ConcernTestCases
+  extend ActiveSupport::Concern
+
+  included do
+    test 'adds with_advisory_lock to ActiveRecord classes' do
+      assert_respond_to(model_class, :with_advisory_lock)
+    end
+
+    test 'adds with_advisory_lock to ActiveRecord instances' do
+      assert_respond_to(model_class.new, :with_advisory_lock)
+    end
+
+    test 'adds advisory_lock_exists? to ActiveRecord classes' do
+      assert_respond_to(model_class, :advisory_lock_exists?)
+    end
+
+    test 'adds advisory_lock_exists? to ActiveRecord instances' do
+      assert_respond_to(model_class.new, :advisory_lock_exists?)
+    end
+  end
+end
+
+class PostgreSQLConcernTest < GemTestCase
+  include ConcernTestCases
+
+  def model_class
+    Tag
+  end
+end
+
+class MySQLConcernTest < GemTestCase
+  include ConcernTestCases
+
+  def model_class
+    MysqlTag
+  end
+end
+
+# This test is adapter-agnostic, so we only need to test it once
+class ActiveRecordQueryCacheTest < GemTestCase
+  self.use_transactional_tests = false
+
+  test 'does not disable quary cache by default' do
+    Tag.connection.expects(:uncached).never
+    Tag.with_advisory_lock('lock') { Tag.first }
+  end
+
+  test 'can disable ActiveRecord query cache' do
+    # Mocha expects needs to properly handle block return values
+    connection = Tag.connection
+
+    # Create a stub that properly yields and returns the block's result
+    connection.define_singleton_method(:uncached_with_mock) do |&block|
+      @uncached_called = true
+      uncached_without_mock(&block)
+    end
+
+    connection.define_singleton_method(:uncached_called?) do
+      @uncached_called || false
+    end
+
+    connection.singleton_class.alias_method :uncached_without_mock, :uncached
+    connection.singleton_class.alias_method :uncached, :uncached_with_mock
+
+    begin
+      Tag.with_advisory_lock('a-lock', disable_query_cache: true) { Tag.first }
+      assert connection.uncached_called?, 'uncached should have been called'
+    ensure
+      connection.singleton_class.alias_method :uncached, :uncached_without_mock
+      connection.singleton_class.remove_method :uncached_with_mock
+      connection.singleton_class.remove_method :uncached_without_mock
+      connection.singleton_class.remove_method :uncached_called?
+    end
+  end
+end

data/test/with_advisory_lock/lock_test.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+module LockTestCases
+  extend ActiveSupport::Concern
+
+  included do
+    self.use_transactional_tests = false
+
+    setup do
+      @lock_name = 'test lock'
+      @return_val = 1900
+    end
+
+    test 'returns nil outside an advisory lock request' do
+      assert_nil(model_class.current_advisory_lock)
+    end
+
+    test 'returns the name of the last lock acquired' do
+      model_class.with_advisory_lock(@lock_name) do
+        assert_match(/#{@lock_name}/, model_class.current_advisory_lock)
+      end
+    end
+
+    test 'can obtain a lock with a name that attempts to disrupt a SQL comment' do
+      dangerous_lock_name = 'test */ lock /*'
+      model_class.with_advisory_lock(dangerous_lock_name) do
+        assert_match(/#{Regexp.escape(dangerous_lock_name)}/, model_class.current_advisory_lock)
+      end
+    end
+
+    test 'returns false for an unacquired lock' do
+      refute(model_class.advisory_lock_exists?(@lock_name))
+    end
+
+    test 'returns true for an acquired lock' do
+      model_class.with_advisory_lock(@lock_name) do
+        assert(model_class.advisory_lock_exists?(@lock_name))
+      end
+    end
+
+    test 'returns block return value if lock successful' do
+      assert_equal(@return_val, model_class.with_advisory_lock!(@lock_name) { @return_val })
+    end
+
+    test 'returns false on lock acquisition failure' do
+      thread_with_lock = Thread.new do
+        model_class.connection_pool.with_connection do
+          model_class.with_advisory_lock(@lock_name, timeout_seconds: 0) do
+            @locked_elsewhere = true
+            loop { sleep 0.01 }
+          end
+        end
+      end
+
+      sleep 0.01 until @locked_elsewhere
+      model_class.connection.reconnect!
+      assert_not(model_class.with_advisory_lock(@lock_name, timeout_seconds: 0) { @return_val })
+
+      thread_with_lock.kill
+    end
+
+    test 'raises an error on lock acquisition failure' do
+      thread_with_lock = Thread.new do
+        model_class.connection_pool.with_connection do
+          model_class.with_advisory_lock(@lock_name, timeout_seconds: 0) do
+            @locked_elsewhere = true
+            loop { sleep 0.01 }
+          end
+        end
+      end
+
+      sleep 0.01 until @locked_elsewhere
+      model_class.connection.reconnect!
+      assert_raises(WithAdvisoryLock::FailedToAcquireLock) do
+        model_class.with_advisory_lock!(@lock_name, timeout_seconds: 0) { @return_val }
+      end
+
+      thread_with_lock.kill
+    end
+
+    test 'attempts the lock exactly once with no timeout' do
+      expected = SecureRandom.base64
+      actual = model_class.with_advisory_lock(@lock_name, 0) do
+        expected
+      end
+
+      assert_equal(expected, actual)
+    end
+
+    test 'current_advisory_locks returns empty array outside an advisory lock request' do
+      assert_equal([], model_class.current_advisory_locks)
+    end
+
+    test 'current_advisory_locks returns an array with names of the acquired locks' do
+      model_class.with_advisory_lock(@lock_name) do
+        locks = model_class.current_advisory_locks
+        assert_equal(1, locks.size)
+        assert_match(/#{@lock_name}/, locks.first)
+      end
+    end
+
+    test 'current_advisory_locks returns array of all nested lock names' do
+      first_lock = 'outer lock'
+      second_lock = 'inner lock'
+
+      model_class.with_advisory_lock(first_lock) do
+        model_class.with_advisory_lock(second_lock) do
+          locks = model_class.current_advisory_locks
+          assert_equal(2, locks.size)
+          assert_match(/#{first_lock}/, locks.first)
+          assert_match(/#{second_lock}/, locks.last)
+        end
+
+        locks = model_class.current_advisory_locks
+        assert_equal(1, locks.size)
+        assert_match(/#{first_lock}/, locks.first)
+      end
+      assert_equal([], model_class.current_advisory_locks)
+    end
+
+    test 'handles connection disconnection gracefully during lock release' do
+      # This test ensures that if the connection is lost, lock release doesn't fail
+      # The lock will be automatically released by the database when the session ends
+      model_class.with_advisory_lock(@lock_name) do
+        # Simulate connection issues by testing the rescue logic
+        # We can't easily test actual disconnection in unit tests without side effects
+        # but we can test the error handling logic by testing with invalid connection state
+        assert_not_nil model_class.current_advisory_lock
+      end
+
+      # After the block, current_advisory_lock should be nil regardless
+      assert_nil model_class.current_advisory_lock
+    end
+  end
+end
+
+class PostgreSQLLockTest < GemTestCase
+  include LockTestCases
+
+  def model_class
+    Tag
+  end
+
+  def setup
+    super
+    Tag.delete_all
+  end
+
+  test 'does not support database timeout for PostgreSQL' do
+    assert_not model_class.connection.supports_database_timeout?
+  end
+end
+
+class MySQLLockTest < GemTestCase
+  include LockTestCases
+
+  def model_class
+    MysqlTag
+  end
+
+  def setup
+    super
+    MysqlTag.delete_all
+  end
+
+  test 'uses database timeout for MySQL' do
+    assert model_class.connection.supports_database_timeout?
+  end
+
+  test 'mysql uses native timeout instead of polling' do
+    # This test verifies that MySQL bypasses Ruby-level polling
+    # when timeout is specified, relying on GET_LOCK's native timeout
+    lock_name = 'mysql_timeout_test'
+
+    # Hold a lock in another connection - need to use the same prefixed name as the gem
+    other_conn = model_class.connection_pool.checkout
+    lock_keys = other_conn.lock_keys_for(lock_name)
+    other_conn.select_value("SELECT GET_LOCK(#{other_conn.quote(lock_keys.first)}, 0)")
+
+    begin
+      # Attempt to acquire with a short timeout - should fail quickly
+      start_time = Time.now
+      result = model_class.with_advisory_lock(lock_name, timeout_seconds: 1) { 'success' }
+      elapsed = Time.now - start_time
+
+      # Should return false and complete within reasonable time (< 3 seconds)
+      # If it were using Ruby polling, it would take longer
+      assert_not result
+      assert elapsed < 3.0, "Expected quick timeout, but took #{elapsed} seconds"
+    ensure
+      other_conn.select_value("SELECT RELEASE_LOCK(#{other_conn.quote(lock_keys.first)})")
+      model_class.connection_pool.checkin(other_conn)
+    end
+  end
+end

data/test/with_advisory_lock/multi_adapter_test.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class MultiAdapterIsolationTest < GemTestCase
+  test 'postgresql and mysql adapters do not overlap' do
+    lock_name = 'multi-adapter-lock'
+
+    Tag.with_advisory_lock(lock_name) do
+      assert MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+    end
+
+    MysqlTag.with_advisory_lock(lock_name) do
+      assert Tag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+    end
+  end
+end

data/test/with_advisory_lock/mysql_release_lock_test.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+class MySQLReleaseLockTest < GemTestCase
+  self.use_transactional_tests = false
+
+  def model_class
+    MysqlTag
+  end
+
+  def setup
+    super
+    begin
+      skip unless model_class.connection.adapter_name =~ /mysql/i
+      MysqlTag.delete_all
+    rescue ActiveRecord::NoDatabaseError
+      skip "MySQL database not available. Please create the database first."
+    rescue StandardError => e
+      skip "MySQL connection failed: #{e.message}"
+    end
+  end
+
+  test 'release_advisory_lock handles gem signature with lock_keys' do
+    lock_name = 'test_gem_signature'
+    lock_keys = model_class.connection.lock_keys_for(lock_name)
+
+    # Acquire the lock
+    result = model_class.connection.try_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+    assert result, 'Failed to acquire lock'
+
+    # Release using gem signature
+    released = model_class.connection.release_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+    assert released, 'Failed to release lock using gem signature'
+
+    # Verify lock is released by trying to acquire it again
+    result = model_class.connection.try_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+    assert result, 'Lock was not properly released'
+
+    # Clean up
+    model_class.connection.release_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+  end
+
+  test 'release_advisory_lock handles ActiveRecord signature' do
+    # Rails calls release_advisory_lock with a positional argument (lock_id)
+    # This test ensures our override doesn't break Rails' migration locking
+
+    lock_name = 'test_rails_signature'
+
+    # Acquire lock using SQL (ActiveRecord doesn't provide get_advisory_lock method)
+    lock_keys = model_class.connection.lock_keys_for(lock_name)
+    result = model_class.connection.select_value("SELECT GET_LOCK(#{model_class.connection.quote(lock_keys.first)}, 0)")
+    assert_equal 1, result, 'Failed to acquire lock using SQL'
+
+    # Release using ActiveRecord signature (positional argument, as Rails does)
+    released = model_class.connection.release_advisory_lock(lock_keys.first)
+    assert released, 'Failed to release lock using ActiveRecord signature'
+
+    # Verify lock is released
+    lock_keys = model_class.connection.lock_keys_for(lock_name)
+    result = model_class.connection.select_value("SELECT GET_LOCK(#{model_class.connection.quote(lock_keys.first)}, 0)")
+    assert_equal 1, result, 'Lock was not properly released'
+
+    # Clean up
+    model_class.connection.select_value("SELECT RELEASE_LOCK(#{model_class.connection.quote(lock_keys.first)})")
+  end
+
+  test 'release_advisory_lock handles connection errors gracefully' do
+    lock_name = 'test_connection_error'
+    lock_keys = model_class.connection.lock_keys_for(lock_name)
+
+    # Acquire the lock
+    result = model_class.connection.try_advisory_lock(
+      lock_keys,
+      lock_name: lock_name,
+      shared: false,
+      transaction: false
+    )
+    assert result, 'Failed to acquire lock'
+
+    # Simulate connection error handling
+    # The method should handle various connection error types without raising
+    begin
+      # Try to release - even if we can't simulate a real connection error,
+      # the code path exists and should work
+      model_class.connection.release_advisory_lock(
+        lock_keys,
+        lock_name: lock_name,
+        shared: false,
+        transaction: false
+      )
+    rescue StandardError => e
+      # Should not raise connection-related errors
+      refute_match(/Lost connection|MySQL server has gone away|Connection refused/i, e.message)
+      raise
+    end
+  end
+end
+

data/test/with_advisory_lock/parallelism_test.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+require 'forwardable'
+
+class FindOrCreateWorker
+  extend Forwardable
+  def_delegators :@thread, :join, :wakeup, :status, :to_s
+
+  def initialize(model_class, name, use_advisory_lock)
+    @model_class = model_class
+    @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
+        @model_class.with_advisory_lock(@name) { work }
+      else
+        work
+      end
+    end
+  end
+
+  def work
+    @model_class.transaction do
+      @model_class.where(name: @name).first_or_create
+    end
+  end
+end
+
+module ParallelismTestCases
+  extend ActiveSupport::Concern
+
+  included do
+    self.use_transactional_tests = false
+
+    def run_workers
+      @names = @iterations.times.map { |iter| "iteration ##{iter}" }
+      @names.each do |name|
+        workers = @workers.times.map do
+          FindOrCreateWorker.new(model_class, 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
+    end
+
+    setup do
+      ApplicationRecord.connection.reconnect!
+      @workers = 10
+      # Clean the table for this model
+      model_class.delete_all
+    end
+
+    test 'creates multiple duplicate rows without advisory locks' do
+      @use_advisory_lock = false
+      @iterations = 5
+      run_workers
+      # Without advisory locks, we expect race conditions to create duplicates
+      # But modern databases with proper transaction isolation might prevent this
+      # Skip if no duplicates were created (database handled it well)
+      if model_class.all.size == @iterations
+        skip 'Database transaction isolation prevented duplicates - this is actually good behavior'
+      end
+      assert_operator(model_class.all.size, :>, @iterations)
+    end
+
+    test "doesn't create multiple duplicate rows with advisory locks" do
+      @use_advisory_lock = true
+      @iterations = 10
+      run_workers
+      assert_equal(@iterations, model_class.all.size)
+    end
+  end
+end
+
+class PostgreSQLParallelismTest < GemTestCase
+  include ParallelismTestCases
+
+  def model_class
+    Tag
+  end
+end
+
+class MySQLParallelismTest < GemTestCase
+  include ParallelismTestCases
+
+  def model_class
+    MysqlTag
+  end
+end