with_advisory_lock 4.6.0 → 5.0.0

data/test/lock_test.rb

@@ -1,47 +1,80 @@
-require 'minitest_helper'
+# frozen_string_literal: true
 
-describe 'class methods' do
-  let(:lock_name) { 'test lock' }
+require 'test_helper'
 
-  describe '.current_advisory_lock' do
-    it 'returns nil outside an advisory lock request' do
-      Tag.current_advisory_lock.must_be_nil
+class LockTest < GemTestCase
+  setup do
+    @lock_name = 'test lock'
+    @return_val = 1900
+  end
+
+  test 'returns nil outside an advisory lock request' do
+    assert_nil(Tag.current_advisory_lock)
+  end
+
+  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)
     end
+  end
 
-    it 'returns the name of the last lock acquired' do
-      Tag.with_advisory_lock(lock_name) do
-        # The lock name may have a prefix if WITH_ADVISORY_LOCK_PREFIX env is set
-        Tag.current_advisory_lock.must_match(/#{lock_name}/)
-      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)
     end
+  end
 
-    it '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
-        Tag.current_advisory_lock.must_match(/#{Regexp.escape(dangerous_lock_name)}/)
-      end
+  test 'returns false for an unacquired lock' do
+    refute(Tag.advisory_lock_exists?(@lock_name))
+  end
 
+  test 'returns true for an acquired lock' do
+    Tag.with_advisory_lock(@lock_name) do
+      assert(Tag.advisory_lock_exists?(@lock_name))
     end
   end
 
-  describe '.advisory_lock_exists?' do
-    it 'returns false for an unacquired lock' do
-      Tag.advisory_lock_exists?(lock_name).must_be_false
+  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 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 }
+      end
     end
 
-    it 'returns the name of the last lock acquired' do
-      Tag.with_advisory_lock(lock_name) do
-        Tag.advisory_lock_exists?(lock_name).must_be_true
+    sleep 0.01 until @locked_elsewhere
+    assert_not(Tag.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
+      Tag.with_advisory_lock(@lock_name, timeout_seconds: 0) do
+        @locked_elsewhere = true
+        loop { sleep 0.01 }
       end
     end
+
+    sleep 0.01 until @locked_elsewhere
+    assert_raises(WithAdvisoryLock::FailedToAcquireLock) do
+      Tag.with_advisory_lock!(@lock_name, timeout_seconds: 0) { @return_val }
+    end
+
+    thread_with_lock.kill
   end
 
-  describe 'zero timeout_seconds' do
-    it 'attempts the lock exactly once with no timeout' do
-      expected = SecureRandom.base64
-      Tag.with_advisory_lock(lock_name, 0) do
-        expected
-      end.must_equal expected
+  test 'attempts the lock exactly once with no timeout' do
+    expected = SecureRandom.base64
+    actual = Tag.with_advisory_lock(@lock_name, 0) do
+      expected
     end
+
+    assert_equal(expected, actual)
   end
 end

data/test/nesting_test.rb

@@ -1,93 +1,28 @@
-require 'minitest_helper'
+# frozen_string_literal: true
 
-describe "lock nesting" do
-  # This simplifies what we expect from the lock name:
-  before :each do
+require 'test_helper'
+
+class LockNestingTest < GemTestCase
+  setup do
     @prior_prefix = ENV['WITH_ADVISORY_LOCK_PREFIX']
     ENV['WITH_ADVISORY_LOCK_PREFIX'] = nil
   end
 
-  after :each do
+  teardown do
     ENV['WITH_ADVISORY_LOCK_PREFIX'] = @prior_prefix
   end
 
-  it "doesn't request the same lock twice" do
+  test "doesn't request the same lock twice" do
     impl = WithAdvisoryLock::Base.new(nil, nil, nil)
-    impl.lock_stack.must_be_empty
-    Tag.with_advisory_lock("first") do
-      impl.lock_stack.map(&:name).must_equal %w(first)
+    assert_empty(impl.lock_stack)
+    Tag.with_advisory_lock('first') do
+      assert_equal(%w[first], impl.lock_stack.map(&:name))
       # Even MySQL should be OK with this:
-      Tag.with_advisory_lock("first") do
-        impl.lock_stack.map(&:name).must_equal %w(first)
-      end
-      impl.lock_stack.map(&:name).must_equal %w(first)
-    end
-    impl.lock_stack.must_be_empty
-  end
-
-  it "raises errors with MySQL < 5.7.5 when acquiring nested lock" do
-    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
-    exc = proc {
-      Tag.with_advisory_lock("first") do
-        Tag.with_advisory_lock("second") do
-        end
-      end
-    }.must_raise WithAdvisoryLock::NestedAdvisoryLockError
-    exc.lock_stack.map(&:name).must_equal %w(first)
-  end
-
-  it "does not raise errors with MySQL < 5.7.5 when acquiring nested error force enabled" do
-    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
-    impl = WithAdvisoryLock::Base.new(nil, nil, nil)
-    impl.lock_stack.must_be_empty
-    Tag.with_advisory_lock("first", force_nested_lock_support: true) do
-      impl.lock_stack.map(&:name).must_equal %w(first)
-      Tag.with_advisory_lock("second", force_nested_lock_support: true) do
-        impl.lock_stack.map(&:name).must_equal %w(first second)
-        Tag.with_advisory_lock("first", force_nested_lock_support: true) do
-          # Shouldn't ask for another lock:
-          impl.lock_stack.map(&:name).must_equal %w(first second)
-          Tag.with_advisory_lock("second", force_nested_lock_support: true) do
-            # Shouldn't ask for another lock:
-            impl.lock_stack.map(&:name).must_equal %w(first second)
-          end
-        end
+      Tag.with_advisory_lock('first') do
+        assert_equal(%w[first], impl.lock_stack.map(&:name))
       end
-      impl.lock_stack.map(&:name).must_equal %w(first)
+      assert_equal(%w[first], impl.lock_stack.map(&:name))
     end
-    impl.lock_stack.must_be_empty
-  end
-
-  it "supports nested advisory locks with !MySQL 5.6" do
-    skip if env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
-    impl = WithAdvisoryLock::Base.new(nil, nil, nil)
-    impl.lock_stack.must_be_empty
-    Tag.with_advisory_lock("first") do
-      impl.lock_stack.map(&:name).must_equal %w(first)
-      Tag.with_advisory_lock("second") do
-        impl.lock_stack.map(&:name).must_equal %w(first second)
-        Tag.with_advisory_lock("first") do
-          # Shouldn't ask for another lock:
-          impl.lock_stack.map(&:name).must_equal %w(first second)
-          Tag.with_advisory_lock("second") do
-            # Shouldn't ask for another lock:
-            impl.lock_stack.map(&:name).must_equal %w(first second)
-          end
-        end
-      end
-      impl.lock_stack.map(&:name).must_equal %w(first)
-    end
-    impl.lock_stack.must_be_empty
-  end
-
-  it "raises with !MySQL 5.6 and nested error force disabled" do
-    skip unless env_db == :mysql && ENV['MYSQL_VERSION'] != '5.7'
-    exc = proc {
-      Tag.with_advisory_lock("first", force_nested_lock_support: false) do
-        Tag.with_advisory_lock("second", force_nested_lock_support: false) do
-        end
-      end
-    }.must_raise WithAdvisoryLock::NestedAdvisoryLockError
-    exc.lock_stack.map(&:name).must_equal %w(first)
+    assert_empty(impl.lock_stack)
   end
 end

data/test/options_test.rb

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

data/test/parallelism_test.rb

@@ -1,35 +1,37 @@
-require 'minitest_helper'
+# frozen_string_literal: true
+
+require 'test_helper'
 require 'forwardable'
 
-describe 'parallelism' do
-  class FindOrCreateWorker
-    extend Forwardable
-    def_delegators :@thread, :join, :wakeup, :status, :to_s
+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 initialize(name, use_advisory_lock)
+    @name = name
+    @use_advisory_lock = use_advisory_lock
+    @thread = Thread.new { work_later }
+  end
 
-    def work_later
-      sleep
-      ActiveRecord::Base.connection_pool.with_connection do
-        if @use_advisory_lock
-          Tag.with_advisory_lock(@name) { work }
-        else
-          work
-        end
+  def work_later
+    sleep
+    ActiveRecord::Base.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
+  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|
@@ -37,9 +39,7 @@ describe 'parallelism' do
         FindOrCreateWorker.new(name, @use_advisory_lock)
       end
       # Wait for all the threads to get ready:
-      until workers.all? { |ea| ea.status == 'sleep' }
-        sleep(0.1)
-      end
+      sleep(0.1) until workers.all? { |ea| ea.status == 'sleep' }
       # OK, GO!
       workers.each(&:wakeup)
       # Then wait for them to finish:
@@ -49,29 +49,27 @@ describe 'parallelism' do
     ActiveRecord::Base.connection_pool.connection
   end
 
-  before :each do
+  setup do
     ActiveRecord::Base.connection.reconnect!
     @workers = 10
   end
 
-  # < SQLite, understandably, throws "The database file is locked (database is locked)"
-
-  it 'creates multiple duplicate rows without advisory locks' do
-    skip if env_db == :sqlite
+  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
-    Tag.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
-    TagAudit.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
-    Label.all.size.must_be :>, @iterations # <- any duplicated rows will make me happy.
+    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
 
-  it "doesn't create multiple duplicate rows with advisory locks" do
+  test "doesn't create multiple duplicate rows with advisory locks" do
     @use_advisory_lock = true
     @iterations = 10
     run_workers
-    Tag.all.size.must_equal @iterations # <- any duplicated rows will NOT make me happy.
-    TagAudit.all.size.must_equal @iterations # <- any duplicated rows will NOT make me happy.
-    Label.all.size.must_equal @iterations # <- any duplicated rows will NOT make me happy.
+    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/shared_test.rb

@@ -1,131 +1,134 @@
-require 'minitest_helper'
+# frozen_string_literal: true
 
-describe 'shared locks' do
-  def supported?
-    env_db != :mysql
-  end
-
-  class SharedTestWorker
-    def initialize(shared)
-      @shared = shared
+require 'test_helper'
+class SharedTestWorker
+  def initialize(shared)
+    @shared = shared
 
-      @locked = nil
-      @cleanup = false
-      @thread = Thread.new { work }
-    end
+    @locked = nil
+    @cleanup = false
+    @thread = Thread.new { work }
+  end
 
-    def locked?
-      sleep 0.01 while @locked.nil? && @thread.alive?
-      @locked
-    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
+  def cleanup!
+    @cleanup = true
+    @thread.join
+    raise if @thread.status.nil?
+  end
 
-    private
+  private
 
-    def work
-      ActiveRecord::Base.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
+  def work
+    ActiveRecord::Base.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
 
-  it 'does not allow two exclusive locks' do
+  test 'does not allow two exclusive locks' do
     one = SharedTestWorker.new(false)
-    one.locked?.must_equal true
+    assert_predicate(one, :locked?)
 
     two = SharedTestWorker.new(false)
-    two.locked?.must_equal false
+    refute(two.locked?)
 
     one.cleanup!
     two.cleanup!
   end
+end
 
-  describe 'not supported' do
-    before do
-      skip if supported?
-    end
+class NotSupportedEnvironmentTest < SharedLocksTest
+  setup do
+    skip if supported?
+  end
 
-    it 'raises an error when attempting to use a shared lock' do
-      one = SharedTestWorker.new(true)
-      one.locked?.must_be_nil
-      exception = proc {
-        one.cleanup!
-      }.must_raise ArgumentError
-      exception.message.must_include 'not supported'
+  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
 
-  describe 'supported' do
-    before do
-      skip unless supported?
-    end
+class SupportedEnvironmentTest < SharedLocksTest
+  setup do
+    skip unless supported?
+  end
 
-    it 'does allow two shared locks' do
-      one = SharedTestWorker.new(true)
-      one.locked?.must_equal true
+  test 'does allow two shared locks' do
+    one = SharedTestWorker.new(true)
+    assert_predicate(one, :locked?)
 
-      two = SharedTestWorker.new(true)
-      two.locked?.must_equal true
+    two = SharedTestWorker.new(true)
+    assert_predicate(two, :locked?)
 
-      one.cleanup!
-      two.cleanup!
-    end
+    one.cleanup!
+    two.cleanup!
+  end
 
-    it 'does not allow exclusive lock with shared lock' do
-      one = SharedTestWorker.new(true)
-      one.locked?.must_equal true
+  test 'does not allow exclusive lock with shared lock' do
+    one = SharedTestWorker.new(true)
+    assert_predicate(one, :locked?)
 
-      two = SharedTestWorker.new(false)
-      two.locked?.must_equal false
+    two = SharedTestWorker.new(false)
+    refute(two.locked?)
 
-      three = SharedTestWorker.new(true)
-      three.locked?.must_equal true
+    three = SharedTestWorker.new(true)
+    assert_predicate(three, :locked?)
 
-      one.cleanup!
-      two.cleanup!
-      three.cleanup!
-    end
+    one.cleanup!
+    two.cleanup!
+    three.cleanup!
+  end
 
-    it 'does not allow shared lock with exclusive lock' do
-      one = SharedTestWorker.new(false)
-      one.locked?.must_equal true
+  test 'does not allow shared lock with exclusive lock' do
+    one = SharedTestWorker.new(false)
+    assert_predicate(one, :locked?)
 
-      two = SharedTestWorker.new(true)
-      two.locked?.must_equal false
+    two = SharedTestWorker.new(true)
+    refute(two.locked?)
 
-      one.cleanup!
-      two.cleanup!
-    end
+    one.cleanup!
+    two.cleanup!
+  end
 
-    describe 'PostgreSQL' do
-      before do
-        skip unless env_db == :postgresql
-      end
+  class PostgreSQLTest < SupportedEnvironmentTest
+    setup do
+      skip unless env_db == :postgresql
+    end
 
-      def pg_lock_modes
-        ActiveRecord::Base.connection.select_values("SELECT mode FROM pg_locks WHERE locktype = 'advisory';")
-      end
+    def pg_lock_modes
+      ActiveRecord::Base.connection.select_values("SELECT mode FROM pg_locks WHERE locktype = 'advisory';")
+    end
 
-      it 'allows shared lock to be upgraded to an exclusive lock' do
-        pg_lock_modes.must_equal %w[]
-        Tag.with_advisory_lock 'test', shared: true do
-          pg_lock_modes.must_equal %w[ShareLock]
-          Tag.with_advisory_lock 'test', shared: false do
-            pg_lock_modes.must_equal %w[ShareLock ExclusiveLock]
-          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
-        pg_lock_modes.must_equal %w[]
       end
+      assert_empty(pg_lock_modes)
     end
   end
 end