with_advisory_lock 3.0.0 → 4.6.0

data/lib/with_advisory_lock/base.rb

@@ -16,17 +16,28 @@ module WithAdvisoryLock
 
   FAILED_TO_LOCK = Result.new(false)
 
+  LockStackItem = Struct.new(:name, :shared)
+
   class Base
-    attr_reader :connection, :lock_name, :timeout_seconds
+    attr_reader :connection, :lock_name, :timeout_seconds, :shared, :transaction
+
+    def initialize(connection, lock_name, options)
+      options = { timeout_seconds: options } unless options.respond_to?(:fetch)
+      options.assert_valid_keys :timeout_seconds, :shared, :transaction
 
-    def initialize(connection, lock_name, timeout_seconds)
       @connection = connection
       @lock_name = lock_name
-      @timeout_seconds = timeout_seconds
+      @timeout_seconds = options.fetch(:timeout_seconds, nil)
+      @shared = options.fetch(:shared, false)
+      @transaction = options.fetch(:transaction, false)
     end
 
     def lock_str
-      @lock_str ||= "#{ENV['WITH_ADVISORY_LOCK_PREFIX'].to_s}#{lock_name.to_s}"
+      @lock_str ||= "#{ENV['WITH_ADVISORY_LOCK_PREFIX']}#{lock_name}"
+    end
+
+    def lock_stack_item
+      @lock_stack_item ||= LockStackItem.new(lock_str, shared)
     end
 
     def self.lock_stack
@@ -36,7 +47,7 @@ module WithAdvisoryLock
     delegate :lock_stack, to: 'self.class'
 
     def already_locked?
-      lock_stack.include? lock_str
+      lock_stack.include? lock_stack_item
     end
 
     def with_advisory_lock_if_needed(&block)
@@ -61,7 +72,7 @@ module WithAdvisoryLock
 
     def yield_with_lock_and_timeout(&block)
       give_up_at = Time.now + @timeout_seconds if @timeout_seconds
-      while @timeout_seconds.nil? || Time.now < give_up_at do
+      while @timeout_seconds.nil? || Time.now < give_up_at
         r = yield_with_lock(&block)
         return r if r.lock_was_acquired?
         # Randomizing sleep time may help reduce contention.
@@ -73,7 +84,7 @@ module WithAdvisoryLock
     def yield_with_lock
       if try_lock
         begin
-          lock_stack.push(lock_str)
+          lock_stack.push(lock_stack_item)
           result = block_given? ? yield : nil
           Result.new(true, result)
         ensure

data/lib/with_advisory_lock/concern.rb

@@ -6,13 +6,14 @@ module WithAdvisoryLock
     delegate :with_advisory_lock, :advisory_lock_exists?, to: 'self.class'
 
     module ClassMethods
-      def with_advisory_lock(lock_name, timeout_seconds=nil, &block)
-        result = with_advisory_lock_result(lock_name, timeout_seconds, &block)
+      def with_advisory_lock(lock_name, options = {}, &block)
+        result = with_advisory_lock_result(lock_name, options, &block)
         result.lock_was_acquired? ? result.result : false
       end
 
-      def with_advisory_lock_result(lock_name, timeout_seconds=nil, &block)
-        impl = impl_class.new(connection, lock_name, timeout_seconds)
+      def with_advisory_lock_result(lock_name, options = {}, &block)
+        class_options = options.extract!(:force_nested_lock_support) if options.respond_to?(:fetch)
+        impl = impl_class(class_options).new(connection, lock_name, options)
         impl.with_advisory_lock_if_needed(&block)
       end
 
@@ -22,17 +23,28 @@ module WithAdvisoryLock
       end
 
       def current_advisory_lock
-        WithAdvisoryLock::Base.lock_stack.first
+        lock_stack_key = WithAdvisoryLock::Base.lock_stack.first
+        lock_stack_key && lock_stack_key[0]
       end
 
       private
 
-      def impl_class
+      def impl_class(options = nil)
         adapter = WithAdvisoryLock::DatabaseAdapterSupport.new(connection)
         if adapter.postgresql?
           WithAdvisoryLock::PostgreSQL
         elsif adapter.mysql?
-          WithAdvisoryLock::MySQL
+          nested_lock = if options.respond_to?(:fetch) && [true, false].include?(options.fetch(:force_nested_lock_support, nil))
+                          options.fetch(:force_nested_lock_support)
+                        else
+                          adapter.mysql_nested_lock_support?
+                        end
+
+          if nested_lock
+            WithAdvisoryLock::MySQL
+          else
+            WithAdvisoryLock::MySQLNoNesting
+          end
         else
           WithAdvisoryLock::Flock
         end

data/lib/with_advisory_lock/database_adapter_support.rb

@@ -1,15 +1,59 @@
 module WithAdvisoryLock
   class DatabaseAdapterSupport
+    # Caches nested lock support by MySQL reported version
+    @@mysql_nl_cache       = {}
+    @@mysql_nl_cache_mutex = Mutex.new
+
     def initialize(connection)
-      @sym_name = connection.adapter_name.downcase.to_sym
+      @connection = connection
+      @sym_name   = connection.adapter_name.downcase.to_sym
     end
 
     def mysql?
-      [:mysql, :mysql2].include? @sym_name
+      %i[mysql mysql2].include? @sym_name
+    end
+
+    # Nested lock support for MySQL was introduced in 5.7.5
+    # Checking by version number is complicated by MySQL compatible DBs (like MariaDB) having their own versioning schemes
+    # Therefore, we check for nested lock support by simply trying a nested lock, then testing and caching the outcome
+    def mysql_nested_lock_support?
+      return false unless mysql?
+
+      # We select the MySQL version this way and cache on it, as MySQL will report versions like "5.7.5", and MariaDB will
+      # report versions like "10.3.8-MariaDB", which allow us to cache on features without introducing problems.
+      version = @connection.select_value("SELECT version()")
+
+      @@mysql_nl_cache_mutex.synchronize do
+        return @@mysql_nl_cache[version] if @@mysql_nl_cache.keys.include?(version)
+
+        lock_1 = "\"nested-test-1-#{SecureRandom.hex}\""
+        lock_2 = "\"nested-test-2-#{SecureRandom.hex}\""
+
+        get_1  = @connection.select_value("SELECT GET_LOCK(#{lock_1}, 0) AS t#{SecureRandom.hex}")
+        get_2  = @connection.select_value("SELECT GET_LOCK(#{lock_2}, 0) AS t#{SecureRandom.hex}")
+
+        # Both locks should succeed in old and new MySQL versions with "1"
+        raise RuntimeError, "Unexpected nested lock acquire result #{get_1}, #{get_2}" unless [get_1, get_2] == [1, 1]
+
+        release_1 = @connection.select_value("SELECT RELEASE_LOCK(#{lock_1}) AS t#{SecureRandom.hex}")
+        release_2 = @connection.select_value("SELECT RELEASE_LOCK(#{lock_2}) AS t#{SecureRandom.hex}")
+
+        # In MySQL <  5.7.5 release_1 will return  nil (not currently locked) and release_2 will return 1 (successfully unlocked)
+        # In MySQL >= 5.7.5 release_1 and release_2 will return 1 (both successfully unlocked)
+        # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock for more
+        @@mysql_nl_cache[version] = case [release_1, release_2]
+                                    when [1, 1]
+                                      true
+                                    when [nil, 1]
+                                      false
+                                    else
+                                      raise RuntimeError, "Unexpected nested lock release result #{release_1}, #{release_2}"
+                                    end
+      end
     end
 
     def postgresql?
-      [:postgresql, :empostgresql, :postgis].include? @sym_name
+      %i[postgresql empostgresql postgis].include? @sym_name
     end
 
     def sqlite?

data/lib/with_advisory_lock/flock.rb

@@ -2,7 +2,6 @@ require 'fileutils'
 
 module WithAdvisoryLock
   class Flock < Base
-
     def filename
       @filename ||= begin
         safe = lock_str.to_s.gsub(/[^a-z0-9]/i, '')
@@ -20,7 +19,10 @@ module WithAdvisoryLock
     end
 
     def try_lock
-      0 == file_io.flock(File::LOCK_EX|File::LOCK_NB)
+      if transaction
+        raise ArgumentError, 'transaction level locks are not supported on SQLite'
+      end
+      0 == file_io.flock((shared ? File::LOCK_SH : File::LOCK_EX) | File::LOCK_NB)
     end
 
     def release_lock

data/lib/with_advisory_lock/mysql.rb

@@ -1,11 +1,11 @@
 module WithAdvisoryLock
+  # MySQL > 5.7.5 supports nested locks
   class MySQL < Base
-    # See http://dev.mysql.com/doc/refman/5.0/en/miscellaneous-functions.html#function_get-lock
+    # See https://dev.mysql.com/doc/refman/5.7/en/miscellaneous-functions.html#function_get-lock
     def try_lock
-      unless lock_stack.empty?
-        raise NestedAdvisoryLockError.new(
-          "MySQL doesn't support nested Advisory Locks",
-          lock_stack.dup)
+      raise ArgumentError, 'shared locks are not supported on MySQL' if shared
+      if transaction
+        raise ArgumentError, 'transaction level locks are not supported on MySQL'
       end
       execute_successful?("GET_LOCK(#{quoted_lock_str}, 0)")
     end
@@ -19,11 +19,6 @@ module WithAdvisoryLock
       connection.select_value(sql).to_i > 0
     end
 
-    # MySQL doesn't support nested locks:
-    def already_locked?
-      lock_stack.last == lock_str
-    end
-
     # MySQL wants a string as the lock key.
     def quoted_lock_str
       connection.quote(lock_str)

data/lib/with_advisory_lock/mysql_no_nesting.rb

@@ -0,0 +1,20 @@
+module WithAdvisoryLock
+  # For MySQL < 5.7.5 that does not support nested locks
+  class MySQLNoNesting < MySQL
+    # See http://dev.mysql.com/doc/refman/5.0/en/miscellaneous-functions.html#function_get-lock
+    def try_lock
+      unless lock_stack.empty?
+        raise NestedAdvisoryLockError.new(
+          "MySQL < 5.7.5 doesn't support nested Advisory Locks",
+          lock_stack.dup
+        )
+      end
+      super
+    end
+
+    # MySQL doesn't support nested locks:
+    def already_locked?
+      lock_stack.last == lock_stack_item
+    end
+  end
+end

data/lib/with_advisory_lock/nested_advisory_lock_error.rb

@@ -8,7 +8,7 @@ module WithAdvisoryLock
     end
 
     def to_s
-      super + (lock_stack ? ": lock stack = #{lock_stack}" : "")
+      super + (lock_stack ? ": lock stack = #{lock_stack}" : '')
     end
   end
 end

data/lib/with_advisory_lock/postgresql.rb

@@ -2,15 +2,27 @@ module WithAdvisoryLock
   class PostgreSQL < Base
     # See http://www.postgresql.org/docs/9.1/static/functions-admin.html#FUNCTIONS-ADVISORY-LOCKS
     def try_lock
-      execute_successful?('pg_try_advisory_lock')
+      pg_function = "pg_try_advisory#{transaction ? '_xact' : ''}_lock#{shared ? '_shared' : ''}"
+      execute_successful?(pg_function)
     end
 
     def release_lock
-      execute_successful?('pg_advisory_unlock')
+      return if transaction
+      pg_function = "pg_advisory_unlock#{shared ? '_shared' : ''}"
+      execute_successful?(pg_function)
+    rescue ActiveRecord::StatementInvalid => e
+      raise unless e.message =~ / ERROR: +current transaction is aborted,/
+      begin
+        connection.rollback_db_transaction
+        execute_successful?(pg_function)
+      ensure
+        connection.begin_db_transaction
+      end
     end
 
     def execute_successful?(pg_function)
-      sql = "SELECT #{pg_function}(#{lock_keys.join(',')}) AS #{unique_column_name}"
+      comment = lock_name.gsub(/(\/\*)|(\*\/)/, '--')
+      sql = "SELECT #{pg_function}(#{lock_keys.join(',')}) AS #{unique_column_name} /* #{comment} */"
       result = connection.select_value(sql)
       # MRI returns 't', jruby returns true. YAY!
       (result == 't' || result == true)
@@ -27,4 +39,3 @@ module WithAdvisoryLock
     end
   end
 end
-

data/lib/with_advisory_lock/version.rb

@@ -1,3 +1,3 @@
 module WithAdvisoryLock
-  VERSION = Gem::Version.new('3.0.0')
+  VERSION = Gem::Version.new('4.6.0')
 end

data/lib/with_advisory_lock.rb

@@ -1,4 +1,5 @@
 require 'with_advisory_lock/version'
+require 'active_support'
 
 module WithAdvisoryLock
   extend ActiveSupport::Autoload
@@ -8,10 +9,11 @@ module WithAdvisoryLock
   autoload :DatabaseAdapterSupport
   autoload :Flock
   autoload :MySQL, 'with_advisory_lock/mysql'
+  autoload :MySQLNoNesting, 'with_advisory_lock/mysql_no_nesting'
   autoload :NestedAdvisoryLockError
   autoload :PostgreSQL, 'with_advisory_lock/postgresql'
 end
 
 ActiveSupport.on_load :active_record do
-  ActiveRecord::Base.send :include, WithAdvisoryLock::Concern
+  include WithAdvisoryLock::Concern
 end

data/test/lock_test.rb

@@ -11,9 +11,17 @@ describe 'class methods' do
     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}/
+        Tag.current_advisory_lock.must_match(/#{lock_name}/)
       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
+
+    end
   end
 
   describe '.advisory_lock_exists?' do

data/test/minitest_helper.rb

@@ -24,11 +24,6 @@ rescue LoadError
 end
 require 'minitest/autorun'
 require 'minitest/great_expectations'
-if ActiveRecord::VERSION::MAJOR > 3
-  # minitest-reporters-1.0.5/lib/minitest/old_activesupport_fix.rb:7:in `remove_method': method `run' not defined in ActiveSupport::Testing::SetupAndTeardown::ForMinitest (NameError)
-  require 'minitest/reporters'
-  Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
-end
 require 'mocha/setup'
 
 class MiniTest::Spec

data/test/nesting_test.rb

@@ -15,46 +15,79 @@ describe "lock nesting" do
     impl = WithAdvisoryLock::Base.new(nil, nil, nil)
     impl.lock_stack.must_be_empty
     Tag.with_advisory_lock("first") do
-      impl.lock_stack.must_equal %w(first)
+      impl.lock_stack.map(&:name).must_equal %w(first)
       # Even MySQL should be OK with this:
       Tag.with_advisory_lock("first") do
-        impl.lock_stack.must_equal %w(first)
+        impl.lock_stack.map(&:name).must_equal %w(first)
       end
-      impl.lock_stack.must_equal %w(first)
+      impl.lock_stack.map(&:name).must_equal %w(first)
     end
     impl.lock_stack.must_be_empty
   end
 
-  it "raises errors with MySQL when acquiring nested lock" do
-    skip unless env_db == :mysql
+  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.must_equal %w(first)
+    exc.lock_stack.map(&:name).must_equal %w(first)
   end
 
-  it "supports nested advisory locks with !MySQL" do
-    skip if env_db == :mysql
+  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
+      end
+      impl.lock_stack.map(&:name).must_equal %w(first)
+    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.must_equal %w(first)
+      impl.lock_stack.map(&:name).must_equal %w(first)
       Tag.with_advisory_lock("second") do
-        impl.lock_stack.must_equal %w(first second)
+        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.must_equal %w(first second)
+          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.must_equal %w(first second)
+            impl.lock_stack.map(&:name).must_equal %w(first second)
           end
         end
       end
-      impl.lock_stack.must_equal %w(first)
+      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)
+  end
 end

data/test/options_test.rb

@@ -0,0 +1,64 @@
+require 'minitest_helper'
+
+describe 'options parsing' do
+  def parse_options(options)
+    WithAdvisoryLock::Base.new(mock, mock, options)
+  end
+
+  specify 'defaults (empty hash)' do
+    impl = parse_options({})
+    impl.timeout_seconds.must_be_nil
+    impl.shared.must_equal false
+    impl.transaction.must_equal false
+  end
+
+  specify '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
+  end
+
+  specify '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
+  end
+
+  specify 'hash with invalid key errors' do
+    proc {
+      parse_options(foo: 42)
+    }.must_raise ArgumentError
+  end
+
+  specify '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
+  end
+
+  specify '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
+  end
+
+  specify '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
+  end
+
+  specify '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
+  end
+end

data/test/parallelism_test.rb

@@ -4,7 +4,7 @@ require 'forwardable'
 describe 'parallelism' do
   class FindOrCreateWorker
     extend Forwardable
-    def_delegators :@thread, :join, :wakeup, :join, :status, :to_s
+    def_delegators :@thread, :join, :wakeup, :status, :to_s
 
     def initialize(name, use_advisory_lock)
       @name = name
@@ -54,14 +54,17 @@ describe 'parallelism' do
     @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
     @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.
-  end unless env_db == :sqlite # < SQLite, understandably, throws "The database file is locked (database is locked)"
+  end
 
   it "doesn't create multiple duplicate rows with advisory locks" do
     @use_advisory_lock = true
@@ -72,4 +75,3 @@ describe 'parallelism' do
     Label.all.size.must_equal @iterations # <- any duplicated rows will NOT make me happy.
   end
 end
-

data/test/shared_test.rb

@@ -0,0 +1,131 @@
+require 'minitest_helper'
+
+describe 'shared locks' do
+  def supported?
+    env_db != :mysql
+  end
+
+  class SharedTestWorker
+    def initialize(shared)
+      @shared = shared
+
+      @locked = nil
+      @cleanup = false
+      @thread = Thread.new { work }
+    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
+
+    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
+        sleep 0.01 until @cleanup
+      end
+    end
+  end
+
+  it 'does not allow two exclusive locks' do
+    one = SharedTestWorker.new(false)
+    one.locked?.must_equal true
+
+    two = SharedTestWorker.new(false)
+    two.locked?.must_equal false
+
+    one.cleanup!
+    two.cleanup!
+  end
+
+  describe 'not supported' do
+    before 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'
+    end
+  end
+
+  describe 'supported' do
+    before do
+      skip unless supported?
+    end
+
+    it 'does allow two shared locks' do
+      one = SharedTestWorker.new(true)
+      one.locked?.must_equal true
+
+      two = SharedTestWorker.new(true)
+      two.locked?.must_equal true
+
+      one.cleanup!
+      two.cleanup!
+    end
+
+    it 'does not allow exclusive lock with shared lock' do
+      one = SharedTestWorker.new(true)
+      one.locked?.must_equal true
+
+      two = SharedTestWorker.new(false)
+      two.locked?.must_equal false
+
+      three = SharedTestWorker.new(true)
+      three.locked?.must_equal true
+
+      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
+
+      two = SharedTestWorker.new(true)
+      two.locked?.must_equal false
+
+      one.cleanup!
+      two.cleanup!
+    end
+
+    describe 'PostgreSQL' do
+      before 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
+
+      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
+        end
+        pg_lock_modes.must_equal %w[]
+      end
+    end
+  end
+end