with_advisory_lock 7.0.2 → 7.6.0

data/test/dummy/app/models/trilogy_tag.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+class TrilogyTag < TrilogyRecord
+  self.table_name = 'trilogy_tags'
+
+  after_save do
+    TrilogyTagAudit.create(tag_name: name)
+    TrilogyLabel.create(name: name)
+  end
+end

data/test/dummy/app/models/trilogy_tag_audit.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class TrilogyTagAudit < TrilogyRecord
+  self.table_name = 'trilogy_tag_audits'
+end

data/test/dummy/config/application.rb

@@ -14,6 +14,17 @@ module TestSystemApp
   class Application < Rails::Application
     config.load_defaults [Rails::VERSION::MAJOR, Rails::VERSION::MINOR].join('.')
     config.eager_load = true
+
+    # Ignore trilogy models when DATABASE_URL_TRILOGY is not set (e.g., TruffleRuby)
+    unless ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty?
+      config.autoload_lib(ignore: %w[])
+      initializer 'ignore_trilogy_models', before: :set_autoload_paths do |app|
+        trilogy_models = %w[trilogy_record trilogy_tag trilogy_tag_audit trilogy_label]
+        trilogy_models.each do |model|
+          Rails.autoloaders.main.ignore(Rails.root.join('app', 'models', "#{model}.rb"))
+        end
+      end
+    end
     config.serve_static_files = false
     config.public_file_server.enabled = false
     config.public_file_server.headers = { 'Cache-Control' => 'public, max-age=3600' }

data/test/dummy/config/database.yml

@@ -11,3 +11,11 @@ test:
     url: "<%= ENV['DATABASE_URL_MYSQL'] %>"
     properties:
       allowPublicKeyRetrieval: true
+<% if ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty? %>
+  trilogy:
+    <<: *default
+    url: "<%= ENV['DATABASE_URL_TRILOGY'] %>"
+    adapter: trilogy
+    properties:
+      allowPublicKeyRetrieval: true
+<% end %>

data/test/dummy/db/trilogy_schema.rb

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

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

@@ -4,37 +4,29 @@ namespace :db do
   namespace :test do
     desc 'Load schema for all databases'
     task prepare: :environment do
-      # Load schema for primary database
+      # Setup PostgreSQL database
       ActiveRecord::Base.establish_connection(:primary)
-      ActiveRecord::Schema.define(version: 1) do
-        create_table 'tags', force: true do |t|
-          t.string 'name'
-        end
+      load Rails.root.join('db', 'schema.rb')
+      puts 'PostgreSQL database schema loaded'
 
-        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
+      # Setup MySQL database
       ActiveRecord::Base.establish_connection(:secondary)
-      ActiveRecord::Schema.define(version: 1) do
-        create_table 'mysql_tags', force: true do |t|
-          t.string 'name'
-        end
+      load Rails.root.join('db', 'secondary_schema.rb')
+      puts 'MySQL database schema loaded'
 
-        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
+      # Setup Trilogy database (MariaDB) - optional, not supported on TruffleRuby
+      if ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty?
+        ActiveRecord::Base.establish_connection(:trilogy)
+        load Rails.root.join('db', 'trilogy_schema.rb')
+        puts 'Trilogy database schema loaded'
+      else
+        puts 'Skipping Trilogy database (DATABASE_URL_TRILOGY not set)'
       end
+
+      puts 'All test databases prepared successfully'
+    rescue StandardError => e
+      puts "Error preparing test databases: #{e.message}"
+      raise e
     end
   end
 end

data/test/sanity_check_test.rb

@@ -43,7 +43,7 @@ class SanityCheckTest < GemTestCase
     assert_equal 'Mysql2', MysqlLabel.connection.adapter_name
   end
 
-  test 'can write to both databases in same test' do
+  test 'can write to PostgreSQL and MySQL databases in same test' do
     # Create records in both databases
     pg_tag = Tag.create!(name: 'test-pg')
     mysql_tag = MysqlTag.create!(name: 'test-mysql')
@@ -61,3 +61,50 @@ class SanityCheckTest < GemTestCase
     mysql_tag.destroy
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogySanityCheckTest < GemTestCase
+    test 'Trilogy database is isolated from PostgreSQL and MySQL' do
+      # Create tags in all databases
+      pg_tag = Tag.create!(name: 'pg-isolation-test')
+      mysql_tag = MysqlTag.create!(name: 'mysql-isolation-test')
+      trilogy_tag = TrilogyTag.create!(name: 'trilogy-isolation-test')
+
+      # Verify Trilogy tag exists only in Trilogy
+      assert TrilogyTag.exists?(name: 'trilogy-isolation-test')
+      assert_not Tag.exists?(name: 'trilogy-isolation-test')
+      assert_not MysqlTag.exists?(name: 'trilogy-isolation-test')
+
+      # Verify PostgreSQL tag doesn't exist in Trilogy
+      assert_not TrilogyTag.exists?(name: 'pg-isolation-test')
+
+      # Verify MySQL tag doesn't exist in Trilogy
+      assert_not TrilogyTag.exists?(name: 'mysql-isolation-test')
+
+      # Clean up
+      pg_tag.destroy
+      mysql_tag.destroy
+      trilogy_tag.destroy
+    end
+
+    test 'Trilogy models use Trilogy adapter' do
+      assert_equal 'Trilogy', TrilogyTag.connection.adapter_name
+      assert_equal 'Trilogy', TrilogyTagAudit.connection.adapter_name
+      assert_equal 'Trilogy', TrilogyLabel.connection.adapter_name
+    end
+
+    test 'can write to all three databases in same test' do
+      pg_tag = Tag.create!(name: 'test-pg')
+      mysql_tag = MysqlTag.create!(name: 'test-mysql')
+      trilogy_tag = TrilogyTag.create!(name: 'test-trilogy')
+
+      assert pg_tag.persisted?
+      assert mysql_tag.persisted?
+      assert trilogy_tag.persisted?
+
+      pg_tag.destroy
+      mysql_tag.destroy
+      trilogy_tag.destroy
+    end
+  end
+end

data/test/test_helper.rb

@@ -19,10 +19,19 @@ class GemTestCase < ActiveSupport::TestCase
   parallelize(workers: 1)
 
   def self.startup
-    # Validate environment variables when tests actually start running
+    # Validate required environment variables
     %w[DATABASE_URL_PG DATABASE_URL_MYSQL].each do |var|
       abort "Missing required environment variable: #{var}" if ENV[var].nil? || ENV[var].empty?
     end
+
+    # Trilogy is optional (not supported on TruffleRuby)
+    if ENV['DATABASE_URL_TRILOGY'].nil? || ENV['DATABASE_URL_TRILOGY'].empty?
+      puts 'DATABASE_URL_TRILOGY not set, skipping Trilogy tests'
+    end
+  end
+
+  def self.trilogy_available?
+    ENV['DATABASE_URL_TRILOGY'] && !ENV['DATABASE_URL_TRILOGY'].empty?
   end
 
   # Override in test classes to clean only the tables you need

data/test/with_advisory_lock/blocking_test.rb

@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require 'test_helper'
+
+# Universal blocking tests - work on all adapters
+module BlockingTestCases
+  extend ActiveSupport::Concern
+
+  included do
+    setup do
+      @lock_name = 'test_blocking_lock'
+    end
+
+    test 'blocking lock acquires lock successfully' do
+      result = model_class.with_advisory_lock(@lock_name, blocking: true) do
+        'success'
+      end
+      assert_equal('success', result)
+    end
+  end
+end
+
+class PostgreSQLBlockingTest < GemTestCase
+  include BlockingTestCases
+
+  def model_class
+    Tag
+  end
+
+  def setup
+    super
+    Tag.delete_all
+  end
+
+  test 'blocking lock waits for lock to be released' do
+    lock_acquired = false
+    thread1_finished = false
+
+    thread1 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          Tag.with_advisory_lock(@lock_name, blocking: true, transaction: true) do
+            lock_acquired = true
+            sleep(0.5)
+            thread1_finished = true
+          end
+        end
+      end
+    end
+
+    sleep(0.1) until lock_acquired
+
+    thread2_result = nil
+    thread2 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          thread2_result = Tag.with_advisory_lock(@lock_name, blocking: true, transaction: true) do
+            'thread2_success'
+          end
+        end
+      end
+    end
+
+    thread1.join
+    thread2.join
+
+    assert(thread1_finished, 'Thread 1 should have finished')
+    assert_equal('thread2_success', thread2_result, 'Thread 2 should have acquired lock after thread 1 released it')
+  end
+
+  test 'blocking lock can be used with shared locks' do
+    thread1_result = nil
+    thread2_result = nil
+
+    thread1 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          thread1_result = Tag.with_advisory_lock(@lock_name, blocking: true, shared: true, transaction: true) do
+            'shared1'
+          end
+        end
+      end
+    end
+
+    thread2 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          thread2_result = Tag.with_advisory_lock(@lock_name, blocking: true, shared: true, transaction: true) do
+            'shared2'
+          end
+        end
+      end
+    end
+
+    thread1.join
+    thread2.join
+
+    assert_equal('shared1', thread1_result)
+    assert_equal('shared2', thread2_result)
+  end
+end
+
+class MySQLBlockingTest < GemTestCase
+  include BlockingTestCases
+
+  def model_class
+    MysqlTag
+  end
+
+  def setup
+    super
+    MysqlTag.delete_all
+  end
+end
+
+if GemTestCase.trilogy_available?
+  class TrilogyBlockingTest < GemTestCase
+    include BlockingTestCases
+
+    def model_class
+      TrilogyTag
+    end
+
+    def setup
+      super
+      TrilogyTag.delete_all
+    end
+  end
+end
+
+# Requires non-transactional mode: transactional tests pin all threads to a
+# single shared connection, so a "holder" thread would share the session
+class PostgreSQLBlockingTimeoutTest < GemTestCase
+  self.use_transactional_tests = false
+
+  setup do
+    @lock_name = 'blocking_timeout_lock'
+    @release = false
+  end
+
+  teardown do
+    @release = true
+    @holder&.join
+  end
+
+  def hold_lock_elsewhere
+    locked = false
+    @holder = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) do
+          locked = true
+          sleep 0.05 until @release
+        end
+      end
+    end
+    sleep 0.01 until locked
+  end
+
+  test 'blocking lock with timeout returns false when lock is held elsewhere' do
+    hold_lock_elsewhere
+
+    elapsed = Benchmark.realtime do
+      result = Tag.with_advisory_lock(@lock_name, blocking: true, timeout_seconds: 1) { 'unreachable' }
+      assert_equal false, result
+    end
+    assert elapsed >= 0.9, "expected to wait for the timeout, waited #{elapsed}s"
+    assert elapsed < 5.0, "expected timeout after ~1s, waited #{elapsed}s"
+  end
+
+  test 'blocking lock with timeout acquires when lock is free' do
+    result = Tag.with_advisory_lock(@lock_name, blocking: true, timeout_seconds: 1) { 'acquired' }
+    assert_equal 'acquired', result
+  end
+
+  test 'blocking lock with timeout does not leak lock_timeout' do
+    Tag.with_connection do |conn|
+      previous = conn.query_value('SHOW lock_timeout')
+      conn.with_advisory_lock_if_needed(@lock_name, { blocking: true, timeout_seconds: 1 }) { 'x' }
+      assert_equal previous, conn.query_value('SHOW lock_timeout')
+    end
+  end
+
+  test 'blocking lock with timeout failure does not abort enclosing transaction' do
+    hold_lock_elsewhere
+
+    Tag.transaction do
+      result = Tag.with_advisory_lock(@lock_name, blocking: true, timeout_seconds: 1) { 'unreachable' }
+      assert_equal false, result
+      # The savepoint rollback must leave the transaction usable
+      assert Tag.count >= 0
+    end
+  end
+
+  test 'blocking lock with zero timeout uses the try path' do
+    hold_lock_elsewhere
+
+    elapsed = Benchmark.realtime do
+      result = Tag.with_advisory_lock(@lock_name, blocking: true, timeout_seconds: 0) { 'unreachable' }
+      assert_equal false, result
+    end
+    assert elapsed < 1.0, "expected immediate return, waited #{elapsed}s"
+  end
+end
+
+# Deadlock test requires non-transactional mode to work properly
+class PostgreSQLDeadlockTest < GemTestCase
+  self.use_transactional_tests = false
+
+  def setup
+    super
+    @lock_name = 'test_blocking_lock'
+    Tag.delete_all
+  end
+
+  test 'blocking lock detects deadlocks and returns false' do
+    deadlock_detected = false
+    thread1_started = Concurrent::AtomicBoolean.new(false)
+    thread2_started = Concurrent::AtomicBoolean.new(false)
+
+    thread1 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          Tag.with_advisory_lock('lock_a', blocking: true, transaction: true) do
+            thread1_started.make_true
+            sleep(0.1) until thread2_started.true?
+
+            result = Tag.with_advisory_lock('lock_b', blocking: true, transaction: true) do
+              'should_not_reach'
+            end
+            deadlock_detected = true if result == false
+          end
+        end
+      rescue ActiveRecord::StatementInvalid => e
+        deadlock_detected = true if e.message.downcase.include?('deadlock')
+      end
+    end
+
+    thread2 = Thread.new do
+      Tag.connection_pool.with_connection do
+        Tag.transaction do
+          Tag.with_advisory_lock('lock_b', blocking: true, transaction: true) do
+            thread2_started.make_true
+            sleep(0.1) until thread1_started.true?
+
+            result = Tag.with_advisory_lock('lock_a', blocking: true, transaction: true) do
+              'should_not_reach'
+            end
+            deadlock_detected = true if result == false
+          end
+        end
+      rescue ActiveRecord::StatementInvalid => e
+        deadlock_detected = true if e.message.downcase.include?('deadlock')
+      end
+    end
+
+    joined1 = thread1.join(10)
+    joined2 = thread2.join(10)
+
+    unless joined1 && joined2
+      thread1.kill if thread1.alive?
+      thread2.kill if thread2.alive?
+      flunk 'Deadlock detection timed out - threads did not complete within 10 seconds'
+    end
+
+    assert(deadlock_detected, 'Deadlock should have been detected by PostgreSQL')
+  end
+end

data/test/with_advisory_lock/concern_test.rb

@@ -40,6 +40,16 @@ class MySQLConcernTest < GemTestCase
   end
 end
 
+if GemTestCase.trilogy_available?
+  class TrilogyConcernTest < GemTestCase
+    include ConcernTestCases
+
+    def model_class
+      TrilogyTag
+    end
+  end
+end
+
 # This test is adapter-agnostic, so we only need to test it once
 class ActiveRecordQueryCacheTest < GemTestCase
   self.use_transactional_tests = false

data/test/with_advisory_lock/lock_test.rb

@@ -200,13 +200,14 @@ class MySQLLockTest < GemTestCase
 
     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
+      elapsed = Benchmark.realtime do
+        result = model_class.with_advisory_lock(lock_name, timeout_seconds: 1) { 'success' }
+
+        # Should return false and complete within reasonable time (< 3 seconds)
+        # If it were using Ruby polling, it would take longer
+        assert_not result
+      end
 
-      # 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.query_value("SELECT RELEASE_LOCK(#{other_conn.quote(lock_keys.first)})")
@@ -214,3 +215,49 @@ class MySQLLockTest < GemTestCase
     end
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogyLockTest < GemTestCase
+    include LockTestCases
+
+    def model_class
+      TrilogyTag
+    end
+
+    def setup
+      super
+      TrilogyTag.delete_all
+    end
+
+    test 'uses database timeout for Trilogy' do
+      assert model_class.connection.supports_database_timeout?
+    end
+
+    test 'trilogy uses native timeout instead of polling' do
+      # This test verifies that Trilogy bypasses Ruby-level polling
+      # when timeout is specified, relying on GET_LOCK's native timeout
+      lock_name = 'trilogy_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.query_value("SELECT GET_LOCK(#{other_conn.quote(lock_keys.first)}, 0)")
+
+      begin
+        # Attempt to acquire with a short timeout - should fail quickly
+        elapsed = Benchmark.realtime do
+          result = model_class.with_advisory_lock(lock_name, timeout_seconds: 1) { 'success' }
+
+          # Should return false and complete within reasonable time (< 3 seconds)
+          # If it were using Ruby polling, it would take longer
+          assert_not result
+        end
+
+        assert elapsed < 3.0, "Expected quick timeout, but took #{elapsed} seconds"
+      ensure
+        other_conn.query_value("SELECT RELEASE_LOCK(#{other_conn.quote(lock_keys.first)})")
+        model_class.connection_pool.checkin(other_conn)
+      end
+    end
+  end
+end

data/test/with_advisory_lock/multi_adapter_test.rb

@@ -2,16 +2,90 @@
 
 require 'test_helper'
 
+# Database-level assertions so these tests cannot pass without real lock acquisition
+module AdapterLockAssertions
+  def assert_mysql_lock_held(model, lock_name)
+    model.with_connection do |conn|
+      key = conn.lock_keys_for(lock_name).first
+      assert_not_nil conn.query_value("SELECT IS_USED_LOCK(#{conn.quote(key)})"),
+                     "#{model.name} should hold GET_LOCK(#{key.inspect}) at the database level"
+    end
+  end
+
+  def assert_pg_lock_held(model, lock_name)
+    model.with_connection do |conn|
+      assert conn.advisory_lock_exists_for?(lock_name),
+             "#{model.name} should hold the advisory lock in pg_locks"
+    end
+  end
+end
+
 class MultiAdapterIsolationTest < GemTestCase
+  include AdapterLockAssertions
+
   test 'postgresql and mysql adapters do not overlap' do
     lock_name = 'multi-adapter-lock'
 
+    # PostgreSQL lock doesn't block MySQL
     Tag.with_advisory_lock(lock_name) do
-      assert MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+      acquired = MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+        assert_mysql_lock_held(MysqlTag, lock_name)
+        true
+      end
+      assert acquired
     end
 
+    # MySQL lock doesn't block PostgreSQL
     MysqlTag.with_advisory_lock(lock_name) do
-      assert Tag.with_advisory_lock(lock_name, timeout_seconds: 0) { true }
+      acquired = Tag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+        assert_pg_lock_held(Tag, lock_name)
+        true
+      end
+      assert acquired
+    end
+  end
+end
+
+if GemTestCase.trilogy_available?
+  class TrilogyMultiAdapterIsolationTest < GemTestCase
+    include AdapterLockAssertions
+    test 'trilogy adapter does not overlap with postgresql or mysql' do
+      lock_name = 'multi-adapter-lock'
+
+      # PostgreSQL lock doesn't block Trilogy
+      Tag.with_advisory_lock(lock_name) do
+        acquired = TrilogyTag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+          assert_mysql_lock_held(TrilogyTag, lock_name)
+          true
+        end
+        assert acquired
+      end
+
+      # Trilogy lock doesn't block PostgreSQL
+      TrilogyTag.with_advisory_lock(lock_name) do
+        acquired = Tag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+          assert_pg_lock_held(Tag, lock_name)
+          true
+        end
+        assert acquired
+      end
+
+      # MySQL lock doesn't block Trilogy
+      MysqlTag.with_advisory_lock(lock_name) do
+        acquired = TrilogyTag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+          assert_mysql_lock_held(TrilogyTag, lock_name)
+          true
+        end
+        assert acquired
+      end
+
+      TrilogyTag.with_advisory_lock(lock_name) do
+        acquired = MysqlTag.with_advisory_lock(lock_name, timeout_seconds: 0) do
+          assert_mysql_lock_held(MysqlTag, lock_name)
+          true
+        end
+        assert acquired
+      end
     end
   end
 end

data/test/with_advisory_lock/parallelism_test.rb

@@ -99,3 +99,13 @@ class MySQLParallelismTest < GemTestCase
     MysqlTag
   end
 end
+
+if GemTestCase.trilogy_available?
+  class TrilogyParallelismTest < GemTestCase
+    include ParallelismTestCases
+
+    def model_class
+      TrilogyTag
+    end
+  end
+end