resque-scheduler 4.2.1 → 4.5.0

data/test/scheduler_args_test.rb

@@ -1,222 +0,0 @@
-# vim:fileencoding=utf-8
-
-require_relative 'test_helper'
-
-context 'scheduling jobs with arguments' do
-  setup do
-    Resque::Scheduler.clear_schedule!
-    Resque::Scheduler.configure do |c|
-      c.dynamic = false
-      c.quiet = true
-      c.poll_sleep_amount = nil
-    end
-  end
-
-  test 'enqueue_from_config puts stuff in resque without class loaded' do
-    Resque::Job.stubs(:create).once.returns(true)
-               .with('joes_queue', 'UndefinedJob', '/tmp')
-    Resque::Scheduler.enqueue_from_config(
-      'cron' => '* * * * *',
-      'class' => 'UndefinedJob',
-      'args' => '/tmp',
-      'queue' => 'joes_queue'
-    )
-  end
-
-  test 'enqueue_from_config with_every_syntax' do
-    Resque::Job.stubs(:create).once.returns(true)
-               .with('james_queue', 'JamesJob', '/tmp')
-    Resque::Scheduler.enqueue_from_config(
-      'every' => '1m',
-      'class' => 'JamesJob',
-      'args' => '/tmp',
-      'queue' => 'james_queue'
-    )
-  end
-
-  test 'enqueue_from_config puts jobs in the resque queue' do
-    Resque::Job.stubs(:create).once.returns(true)
-               .with(:ivar, SomeIvarJob, '/tmp')
-    Resque::Scheduler.enqueue_from_config(
-      'cron' => '* * * * *',
-      'class' => 'SomeIvarJob',
-      'args' => '/tmp'
-    )
-  end
-
-  test 'enqueue_from_config with custom_class_job in resque' do
-    FakeCustomJobClass.stubs(:scheduled).once.returns(true)
-                      .with(:ivar, 'SomeIvarJob', '/tmp')
-    Resque::Scheduler.enqueue_from_config(
-      'cron' => '* * * * *',
-      'class' => 'SomeIvarJob',
-      'custom_job_class' => 'FakeCustomJobClass',
-      'args' => '/tmp'
-    )
-  end
-
-  test 'enqueue_from_config puts stuff in resque when env matches' do
-    Resque::Scheduler.env = 'production'
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.jobs.size)
-
-    Resque.schedule = {
-      'some_ivar_job' => {
-        'cron' => '* * * * *',
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp',
-        'rails_env' => 'production'
-      }
-    }
-
-    Resque::Scheduler.load_schedule!
-    assert_equal(1, Resque::Scheduler.rufus_scheduler.jobs.size)
-
-    Resque.schedule = {
-      'some_ivar_job' => {
-        'cron' => '* * * * *',
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp',
-        'env' => 'staging, production'
-      }
-    }
-
-    Resque::Scheduler.load_schedule!
-    assert_equal(2, Resque::Scheduler.rufus_scheduler.jobs.size)
-  end
-
-  test 'enqueue_from_config does not enqueue when env does not match' do
-    Resque::Scheduler.env = nil
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.jobs.size)
-    Resque.schedule = {
-      'some_ivar_job' => {
-        'cron' => '* * * * *',
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp',
-        'rails_env' => 'staging'
-      }
-    }
-
-    Resque::Scheduler.load_schedule!
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.jobs.size)
-
-    Resque::Scheduler.env = 'production'
-    Resque.schedule = {
-      'some_ivar_job' => {
-        'cron' => '* * * * *',
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp',
-        'env' => 'staging'
-      }
-    }
-    Resque::Scheduler.load_schedule!
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.jobs.size)
-  end
-
-  test 'enqueue_from_config when env env arg is not set' do
-    Resque::Scheduler.env = 'production'
-    assert_equal(0, Resque::Scheduler.rufus_scheduler.jobs.size)
-
-    Resque.schedule = {
-      'some_ivar_job' => {
-        'cron' => '* * * * *',
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp'
-      }
-    }
-    Resque::Scheduler.load_schedule!
-    assert_equal(1, Resque::Scheduler.rufus_scheduler.jobs.size)
-  end
-
-  test "calls the worker without arguments when 'args' is missing " \
-       'from the config' do
-    Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
-      class: SomeIvarJob
-    YAML
-    SomeIvarJob.expects(:perform).once.with
-    Resque.reserve('ivar').perform
-  end
-
-  test "calls the worker without arguments when 'args' is blank " \
-       'in the config' do
-    Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
-      class: SomeIvarJob
-      args:
-    YAML
-    SomeIvarJob.expects(:perform).once.with
-    Resque.reserve('ivar').perform
-  end
-
-  test 'calls the worker with a string when the config lists a string' do
-    Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
-      class: SomeIvarJob
-      args: string
-    YAML
-    SomeIvarJob.expects(:perform).once.with('string')
-    Resque.reserve('ivar').perform
-  end
-
-  test 'calls the worker with a Fixnum when the config lists an integer' do
-    Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
-      class: SomeIvarJob
-      args: 1
-    YAML
-    SomeIvarJob.expects(:perform).once.with(1)
-    Resque.reserve('ivar').perform
-  end
-
-  test 'calls the worker with multiple arguments when the config ' \
-       'lists an array' do
-    Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
-      class: SomeIvarJob
-      args:
-        - 1
-        - 2
-    YAML
-    SomeIvarJob.expects(:perform).once.with(1, 2)
-    Resque.reserve('ivar').perform
-  end
-
-  test 'calls the worker with an array when the config lists ' \
-       'a nested array' do
-    Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
-      class: SomeIvarJob
-      args:
-        - - 1
-          - 2
-    YAML
-    SomeIvarJob.expects(:perform).once.with([1, 2])
-    Resque.reserve('ivar').perform
-  end
-
-  test 'calls the worker with a hash when the config lists a hash' do
-    Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
-      class: SomeIvarJob
-      args:
-        key: value
-    YAML
-    SomeIvarJob.expects(:perform).once.with('key' => 'value')
-    Resque.reserve('ivar').perform
-  end
-
-  test 'calls the worker with a nested hash when the config lists ' \
-       'a nested hash' do
-    Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
-      class: SomeIvarJob
-      args:
-        first_key:
-          second_key: value
-    YAML
-    SomeIvarJob.expects(:perform).once
-               .with('first_key' => { 'second_key' => 'value' })
-    Resque.reserve('ivar').perform
-  end
-
-  test 'poll_sleep_amount defaults to 5' do
-    assert_equal 5, Resque::Scheduler.poll_sleep_amount
-  end
-
-  test 'poll_sleep_amount is settable' do
-    Resque::Scheduler.poll_sleep_amount = 1
-    assert_equal 1, Resque::Scheduler.poll_sleep_amount
-  end
-end

data/test/scheduler_hooks_test.rb

@@ -1,55 +0,0 @@
-# vim:fileencoding=utf-8
-require_relative 'test_helper'
-
-context 'scheduling jobs with hooks' do
-  setup { Resque.redis.flushall }
-
-  test 'before_schedule hook that does not return false should be enqueued' do
-    enqueue_time = Time.now
-    SomeRealClass.expects(:before_schedule_example).with(:foo)
-    SomeRealClass.expects(:after_schedule_example).with(:foo)
-    Resque.enqueue_at(enqueue_time.to_i, SomeRealClass, :foo)
-    assert_equal(1, Resque.delayed_timestamp_size(enqueue_time.to_i),
-                 'job should be enqueued')
-  end
-
-  test 'before_schedule hook that returns false should not be enqueued' do
-    enqueue_time = Time.now
-    SomeRealClass.expects(:before_schedule_example).with(:foo).returns(false)
-    SomeRealClass.expects(:after_schedule_example).never
-    Resque.enqueue_at(enqueue_time.to_i, SomeRealClass, :foo)
-    assert_equal(0, Resque.delayed_timestamp_size(enqueue_time.to_i),
-                 'job should not be enqueued')
-  end
-
-  test 'default failure hooks are called when enqueueing a job fails' do
-    config = {
-      'cron' => '* * * * *',
-      'class' => 'SomeRealClass',
-      'args' => '/tmp'
-    }
-
-    e = RuntimeError.new('custom error')
-    Resque::Scheduler.expects(:enqueue_from_config).raises(e)
-
-    Resque::Scheduler::FailureHandler.expects(:on_enqueue_failure).with(config, e)
-    Resque::Scheduler.enqueue(config)
-  end
-
-  test 'failure hooks are called when enqueueing a job fails' do
-    with_failure_handler(ExceptionHandlerClass) do
-      config = {
-        'cron' => '* * * * *',
-        'class' => 'SomeRealClass',
-        'args' => '/tmp'
-      }
-
-      e = RuntimeError.new('custom error')
-      Resque::Scheduler.expects(:enqueue_from_config).raises(e)
-
-      ExceptionHandlerClass.expects(:on_enqueue_failure).with(config, e)
-
-      Resque::Scheduler.enqueue(config)
-    end
-  end
-end

data/test/scheduler_locking_test.rb

@@ -1,316 +0,0 @@
-# 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
-
-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.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' do
-    Resque.redis.stubs(:info).returns('redis_version' => '2.5.12')
-
-    assert_equal(
-      @subject.master_lock.class, Resque::Scheduler::Lock::Resilient
-    )
-  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
-
-  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
-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
-
-    test 'you should not have the lock if someone else holds it' do
-      lock_is_not_held(@lock)
-
-      assert !@lock.locked?, 'you should not have the lock'
-    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
-
-    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