with_advisory_lock 5.1.0 → 7.0.0

data/test/thread_test.rb

@@ -1,61 +0,0 @@
-# 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
-      ActiveRecord::Base.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 }
-    ActiveRecord::Base.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/transaction_test.rb

@@ -1,68 +0,0 @@
-# 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
-        ActiveRecord::Base.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