scheduler_locking_test.rb

# vim:fileencoding=utf-8
require_relative 'test_helper'

module LockTestHelper
  def lock_is_not_held(lock)
    Resque.redis.set(lock.key, 'anothermachine:1234')
  end
end

module LockSharedTests
  # rubocop:disable Metrics/MethodLength
  # rubocop:disable Metrics/AbcSize
  def self.included(mod)
    mod.class_eval do
      test 'you should not have the lock if someone else holds it' do
        lock_is_not_held(@lock)

        assert !@lock.locked?
      end

      test 'you should not be able to acquire the lock if someone ' \
          'else holds it' do
        lock_is_not_held(@lock)

        assert !@lock.acquire!
      end

      test 'the lock should receive a TTL on acquiring' do
        @lock.acquire!

        assert Resque.redis.ttl(@lock.key) > 0, 'lock should expire'
      end

      test 'releasing should release the master lock' do
        assert @lock.acquire!, 'should have acquired the master lock'
        assert @lock.locked?, 'should be locked'

        @lock.release!

        assert !@lock.locked?, 'should not be locked'
      end

      test 'checking the lock should increase the TTL if we hold it' do
        @lock.acquire!
        Resque.redis.setex(@lock.key, 10, @lock.value)

        @lock.locked?

        assert Resque.redis.ttl(@lock.key) > 10, 'TTL should have been updated'
      end

      test 'checking the lock should not increase the TTL if we do not hold it' do
        Resque.redis.setex(@lock.key, 10, @lock.value)
        lock_is_not_held(@lock)

        @lock.locked?

        assert Resque.redis.ttl(@lock.key) <= 10,
               'TTL should not have been updated'
      end

      test 'setting the lock timeout changes the key TTL if we hold it' do
        @lock.acquire!

        @lock.stubs(:locked?).returns(true)
        @lock.timeout = 120
        ttl = Resque.redis.ttl(@lock.key)
        assert_send [ttl, :>, 100]

        @lock.stubs(:locked?).returns(true)
        @lock.timeout = 180
        ttl = Resque.redis.ttl(@lock.key)
        assert_send [ttl, :>, 120]
      end
    end
  end
  # rubocop:enable Metrics/AbcSize
  # rubocop:enable Metrics/MethodLength
end

context '#master_lock_key' do
  setup do
    @subject = Class.new { extend Resque::Scheduler::Locking }
  end

  teardown do
    Resque.redis.del(@subject.master_lock.key)
  end

  test 'should have resque prefix' do
    assert_equal(
      @subject.master_lock.key, 'resque:resque_scheduler_master_lock'
    )
  end

  context 'with a prefix set via ENV' do
    setup do
      ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] = 'my.prefix'
      @subject = Class.new { extend Resque::Scheduler::Locking }
    end

    teardown do
      Resque.redis.del(@subject.master_lock.key)
    end

    test 'should have ENV prefix' do
      assert_equal(
        @subject.master_lock.key,
        'resque:my.prefix:resque_scheduler_master_lock'
      )
    end
  end

  context 'with a namespace set for resque' do
    setup do
      Resque.redis.namespace = 'my.namespace'
      @subject = Class.new { extend Resque::Scheduler::Locking }
    end

    teardown do
      Resque.redis.namespace = 'resque'
      Resque.redis.del(@subject.master_lock.key)
    end

    test 'should have resque prefix' do
      assert_equal(
        @subject.master_lock.key, 'my.namespace:resque_scheduler_master_lock'
      )
    end

    context 'with a prefix set via ENV' do
      setup do
        Resque.redis.namespace = 'my.namespace'
        ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] = 'my.prefix'
        @subject = Class.new { extend Resque::Scheduler::Locking }
      end

      teardown do
        Resque.redis.namespace = 'resque'
        Resque.redis.del(@subject.master_lock.key)
      end

      test 'should have ENV prefix' do
        assert_equal(
          @subject.master_lock.key,
          'my.namespace:my.prefix:resque_scheduler_master_lock'
        )
      end
    end
  end
end

context 'Resque::Scheduler::Locking' do
  setup do
    @subject = Class.new { extend Resque::Scheduler::Locking }
  end

  teardown do
    Resque.redis.del(@subject.master_lock.key)
  end

  test 'should use the basic lock mechanism for <= Redis 2.4' do
    Resque.data_store.redis.stubs(:info).returns('redis_version' => '2.4.16')

    assert_equal @subject.master_lock.class, Resque::Scheduler::Lock::Basic
  end

  test 'should use the resilient lock mechanism for > Redis 2.4 and < 2.6.12' do
    Resque.data_store.redis.stubs(:info).returns('redis_version' => '2.5.12')

    assert_equal(
      @subject.master_lock.class, Resque::Scheduler::Lock::Resilient
    )
  end

  test 'should use the resilient lock mechanism for >= Redis 2.6.12' do
    Resque.data_store.redis.stubs(:info).returns('redis_version' => '2.8.0')

    assert_equal(
      @subject.master_lock.class, Resque::Scheduler::Lock::ResilientModern
    )
  end

  test 'should be the master if the lock is held' do
    @subject.master_lock.acquire!
    assert @subject.master?, 'should be master'
  end

  test 'should not be the master if the lock is held by someone else' do
    Resque.redis.set(@subject.master_lock.key, 'somethingelse:1234')
    assert !@subject.master?, 'should not be master'
  end

  test 'release_master_lock should delegate to master_lock' do
    @subject.master_lock.expects(:release)
    @subject.release_master_lock
  end

  test 'release_master_lock! should delegate to master_lock' do
    @subject.expects(:warn)
    @subject.master_lock.expects(:release!)
    @subject.release_master_lock!
  end
end

context 'Resque::Scheduler::Lock::Base' do
  setup do
    @lock = Resque::Scheduler::Lock::Base.new('test_lock_key')
  end

  test '#acquire! should be not implemented' do
    assert_raises NotImplementedError do
      @lock.acquire!
    end
  end

  test '#locked? should be not implemented' do
    assert_raises NotImplementedError do
      @lock.locked?
    end
  end
end

context 'Resque::Scheduler::Lock::Basic' do
  include LockTestHelper

  setup do
    @lock = Resque::Scheduler::Lock::Basic.new('test_lock_key')
  end

  teardown do
    @lock.release!
  end

  include LockSharedTests
end

context 'Resque::Scheduler::Lock::Resilient' do
  include LockTestHelper

  if !Resque::Scheduler.supports_lua?
    puts '*** Skipping Resque::Scheduler::Lock::Resilient ' \
         'tests, as they require Redis >= 2.5.'
  else
    setup do
      @lock = Resque::Scheduler::Lock::Resilient.new('test_resilient_lock')
    end

    teardown do
      @lock.release!
    end

    include LockSharedTests

    test 'refreshes sha cache when the sha cannot be found on ' \
         'the redis server' do
      assert @lock.acquire!
      assert @lock.locked?

      Resque.data_store.redis.script(:flush)

      assert @lock.locked?
      assert_false @lock.acquire!
    end

    test 'setting lock timeout is a noop if not held' do
      @lock.acquire!
      @lock.timeout = 100
      @lock.stubs(:locked?).returns(false)
      @lock.timeout = 120
      assert_equal 100, @lock.timeout
    end

    test 'setting lock timeout nils out lock script' do
      @lock.acquire!
      @lock.timeout = 100
      assert_equal nil, @lock.instance_variable_get(:@locked_sha)
    end

    test 'setting lock timeout does not nil out lock script if not held' do
      @lock.acquire!
      @lock.locked?
      @lock.stubs(:locked?).returns(false)
      @lock.timeout = 100
      assert_not_nil @lock.instance_variable_get(:@locked_sha)
    end

    test 'setting lock timeout nils out acquire script' do
      @lock.acquire!
      @lock.timeout = 100
      assert_equal nil, @lock.instance_variable_get(:@acquire_sha)
    end

    test 'setting lock timeout does not nil out acquire script if not held' do
      @lock.acquire!
      @lock.stubs(:locked?).returns(false)
      @lock.timeout = 100
      assert_not_nil @lock.instance_variable_get(:@acquire_sha)
    end
  end
end

context 'Resque::Scheduler::Lock::ResilientModern' do
  include LockTestHelper

  if !Resque::Scheduler.supports_get_x_options?
    puts '*** Skipping Resque::Scheduler::Lock::ResilientModern ' \
         'tests, as they require Redis >= 2.6.2.'
  else
    setup do
      @lock = Resque::Scheduler::Lock::ResilientModern.new('test_resilient_modern_lock')
    end

    teardown do
      @lock.release!
    end

    include LockSharedTests
  end
end