with_advisory_lock 5.3.0 → 7.0.1

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

@@ -1,66 +1,33 @@
 # frozen_string_literal: true
 
-require 'erb'
-require 'active_record'
-require 'with_advisory_lock'
-require 'tmpdir'
 require 'securerandom'
-begin
-  require 'activerecord-trilogy-adapter'
-  ActiveSupport.on_load(:active_record) do
-    require "trilogy_adapter/connection"
-    ActiveRecord::Base.public_send :extend, TrilogyAdapter::Connection
-  end
-rescue LoadError
-  # do nothing
-end
-
-ActiveRecord::Base.configurations = {
-  default_env: {
-    url: ENV.fetch('DATABASE_URL', "sqlite3://#{Dir.tmpdir}/with_advisory_lock_test#{RUBY_VERSION}-#{ActiveRecord.gem_version}.sqlite3"),
-    pool: 20,
-    properties: { allowPublicKeyRetrieval: true } # for JRuby madness
-  }
-}
 
+ENV['RAILS_ENV'] = 'test'
 ENV['WITH_ADVISORY_LOCK_PREFIX'] ||= SecureRandom.hex
 
-ActiveRecord::Base.establish_connection
-
-def env_db
-  @env_db ||= ActiveRecord::Base.connection_db_config.adapter.to_sym
-end
+require 'dotenv'
+Dotenv.load
 
-ActiveRecord::Migration.verbose = false
+require_relative 'dummy/config/environment'
+require 'rails/test_help'
 
-require 'test_models'
-require 'minitest'
+require 'with_advisory_lock'
 require 'maxitest/autorun'
 require 'mocha/minitest'
 
 class GemTestCase < ActiveSupport::TestCase
-
   parallelize(workers: 1)
-  def adapter_support
-    @adapter_support ||= WithAdvisoryLock::DatabaseAdapterSupport.new(ActiveRecord::Base.connection)
-  end
-  def is_sqlite3_adapter?; adapter_support.sqlite?; end
-  def is_mysql_adapter?; adapter_support.mysql?; end
-  def is_postgresql_adapter?; adapter_support.postgresql?; end
 
-  setup do
-    ENV['FLOCK_DIR'] = Dir.mktmpdir if is_sqlite3_adapter?
-    ApplicationRecord.connection.truncate_tables(
-      Tag.table_name,
-      TagAudit.table_name,
-      Label.table_name
-    )
+  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
 
-  teardown do
-    FileUtils.remove_entry_secure(ENV['FLOCK_DIR'], true) if is_sqlite3_adapter?
-  end
+  # Override in test classes to clean only the tables you need
+  # This avoids unnecessary database operations
 end
 
-puts "Testing with #{env_db} database, ActiveRecord #{ActiveRecord.gem_version} and #{RUBY_ENGINE} #{RUBY_ENGINE_VERSION} as #{RUBY_VERSION}"
+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

@@ -2,32 +2,78 @@
 
 require 'test_helper'
 
-class WithAdvisoryLockConcernTest < GemTestCase
-  test 'adds with_advisory_lock to ActiveRecord classes' do
-    assert_respond_to(Tag, :with_advisory_lock)
-  end
+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 with_advisory_lock to ActiveRecord instances' do
-    assert_respond_to(Label.new, :with_advisory_lock)
+    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
 
-  test 'adds advisory_lock_exists? to ActiveRecord classes' do
-    assert_respond_to(Tag, :advisory_lock_exists?)
+  def model_class
+    Tag
   end
+end
 
-  test 'adds advisory_lock_exists? to ActiveRecord instances' do
-    assert_respond_to(Label.new, :advisory_lock_exists?)
+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
-    Tag.connection.expects(:uncached).once
-    Tag.with_advisory_lock('a-lock', disable_query_cache: true) { Tag.first }
+    # 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

@@ -2,110 +2,196 @@
 
 require 'test_helper'
 
-class LockTest < GemTestCase
-  setup do
-    @lock_name = 'test lock'
-    @return_val = 1900
-  end
+module LockTestCases
+  extend ActiveSupport::Concern
 
-  test 'returns nil outside an advisory lock request' do
-    assert_nil(Tag.current_advisory_lock)
-  end
+  included do
+    self.use_transactional_tests = false
 
-  test 'returns the name of the last lock acquired' do
-    Tag.with_advisory_lock(@lock_name) do
-      assert_match(/#{@lock_name}/, Tag.current_advisory_lock)
+    setup do
+      @lock_name = 'test lock'
+      @return_val = 1900
     end
-  end
 
-  test 'can obtain a lock with a name that attempts to disrupt a SQL comment' do
-    dangerous_lock_name = 'test */ lock /*'
-    Tag.with_advisory_lock(dangerous_lock_name) do
-      assert_match(/#{Regexp.escape(dangerous_lock_name)}/, Tag.current_advisory_lock)
+    test 'returns nil outside an advisory lock request' do
+      assert_nil(model_class.current_advisory_lock)
     end
-  end
 
-  test 'returns false for an unacquired lock' do
-    refute(Tag.advisory_lock_exists?(@lock_name))
-  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 'returns true for an acquired lock' do
-    Tag.with_advisory_lock(@lock_name) do
-      assert(Tag.advisory_lock_exists?(@lock_name))
+    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
-  end
 
-  test 'returns block return value if lock successful' do
-    assert_equal(@return_val, Tag.with_advisory_lock!(@lock_name) { @return_val })
-  end
+    test 'returns false for an unacquired lock' do
+      refute(model_class.advisory_lock_exists?(@lock_name))
+    end
 
-  test 'returns false on lock acquisition failure' do
-    thread_with_lock = Thread.new do
-      Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) do
-        @locked_elsewhere = true
-        loop { sleep 0.01 }
+    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
 
-    sleep 0.01 until @locked_elsewhere
-    assert_not(Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) { @return_val })
+    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
 
-    thread_with_lock.kill
-  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
 
-  test 'raises an error on lock acquisition failure' do
-    thread_with_lock = Thread.new do
-      Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) do
-        @locked_elsewhere = true
-        loop { sleep 0.01 }
+      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
 
-    sleep 0.01 until @locked_elsewhere
-    assert_raises(WithAdvisoryLock::FailedToAcquireLock) do
-      Tag.with_advisory_lock!(@lock_name, timeout_seconds: 0) { @return_val }
+    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
 
-    thread_with_lock.kill
-  end
+    test 'current_advisory_locks returns empty array outside an advisory lock request' do
+      assert_equal([], model_class.current_advisory_locks)
+    end
 
-  test 'attempts the lock exactly once with no timeout' do
-    expected = SecureRandom.base64
-    actual = Tag.with_advisory_lock(@lock_name, 0) do
-      expected
+    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
 
-    assert_equal(expected, actual)
+    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
 
-  test 'current_advisory_locks returns empty array outside an advisory lock request' do
-    assert_equal([], Tag.current_advisory_locks)
+  def model_class
+    Tag
   end
 
-  test 'current_advisory_locks returns an array with names of the acquired locks' do
-    Tag.with_advisory_lock(@lock_name) do
-      locks = Tag.current_advisory_locks
-      assert_equal(1, locks.size)
-      assert_match(/#{@lock_name}/, locks.first)
-    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
 
-  test 'current_advisory_locks returns array of all nested lock names' do
-    first_lock = 'outer lock'
-    second_lock = 'inner lock'
+class MySQLLockTest < GemTestCase
+  include LockTestCases
 
-    Tag.with_advisory_lock(first_lock) do
-      Tag.with_advisory_lock(second_lock) do
-        locks = Tag.current_advisory_locks
-        assert_equal(2, locks.size)
-        assert_match(/#{first_lock}/, locks.first)
-        assert_match(/#{second_lock}/, locks.last)
-      end
+  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
 
-      locks = Tag.current_advisory_locks
-      assert_equal(1, locks.size)
-      assert_match(/#{first_lock}/, locks.first)
+  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
-    assert_equal([], Tag.current_advisory_locks)
   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
+