resque-scheduler 2.3.1 → 2.4.0

data/test/resque-web_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require_relative 'test_helper'
 
 # Pull in the server test_helper from resque
 require 'resque/server/test_helper.rb'
@@ -45,6 +45,41 @@ context "on GET to /delayed" do
   should_respond_with_success
 end
 
+context "on GET to /delayed/jobs/:klass" do
+  setup do
+    @t = Time.now + 3600
+    Resque.enqueue_at(@t, SomeIvarJob, 'foo', 'bar')
+    get URI("/delayed/jobs/SomeIvarJob?args=" + URI.encode(%w{foo bar}.to_json)).to_s
+  end
+
+  should_respond_with_success
+
+  test 'see the scheduled job' do
+    assert last_response.body.include?(@t.to_s)
+  end
+
+  context 'with a namespaced class' do
+    setup do
+      @t = Time.now + 3600
+      module Foo
+        class Bar
+          def self.queue
+            'bar'
+          end
+        end
+      end
+      Resque.enqueue_at(@t, Foo::Bar, 'foo', 'bar')
+      get URI("/delayed/jobs/Foo::Bar?args=" + URI.encode(%w{foo bar}.to_json)).to_s
+    end
+
+    should_respond_with_success
+
+    test 'see the scheduled job' do
+      assert last_response.body.include?(@t.to_s)
+    end
+  end
+end
+
 def resque_schedule
   {
     'job_without_params' => {

data/test/scheduler_args_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require_relative 'test_helper'
 
 context "scheduling jobs with arguments" do
 
@@ -28,40 +28,74 @@ context "scheduling jobs with arguments" do
     Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'custom_job_class' => 'FakeCustomJobClass', 'args' => "/tmp")
   end
 
-  test "enqueue_from_config puts stuff in resquewhen rails_env matches" do
-    # The job should be loaded : its rails_env config matches the RAILS_ENV variable:
-    ENV['RAILS_ENV'] = 'production'
+  test 'enqueue_from_config puts stuff in resque when env matches' do
+    Resque::Scheduler.env = 'production'
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
 
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'}}
+    Resque.schedule = {
+      'some_ivar_job' => {
+        'cron' => '* * * * *',
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp',
+        'rails_env' => 'production'
+      }
+    }
+
     Resque::Scheduler.load_schedule!
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
 
-    # we allow multiple rails_env definition, it should work also:
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging, production'}}
+    Resque.schedule = {
+      'some_ivar_job' => {
+        'cron' => '* * * * *',
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp',
+        'env' => 'staging, production'
+      }
+    }
+
     Resque::Scheduler.load_schedule!
     assert_equal(2, Resque::Scheduler.rufus_scheduler.all_jobs.size)
   end
 
-  test "enqueue_from_config  doesnt put stuff in resque when rails_env doesnt match" do
-    # RAILS_ENV is not set:
+  test 'enqueue_from_config does not enqueue when env does not match' do
+    Resque::Scheduler.env = nil
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging'}}
+    Resque.schedule = {
+      'some_ivar_job' => {
+        'cron' => '* * * * *',
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp',
+        'rails_env' => 'staging'
+      }
+    }
+
     Resque::Scheduler.load_schedule!
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
 
-    # SET RAILS_ENV to a common value:
-    ENV['RAILS_ENV'] = 'production'
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging'}}
+    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.all_jobs.size)
   end
 
-  test "enqueue_from_config when rails env arg is not set" do
-    # The job should be loaded, since a missing rails_env means ALL envs.
-    ENV['RAILS_ENV'] = 'production'
+  test 'enqueue_from_config when env env arg is not set' do
+    Resque::Scheduler.env = 'production'
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
+
+    Resque.schedule = {
+      'some_ivar_job' => {
+        'cron' => '* * * * *',
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp'
+      }
+    }
     Resque::Scheduler.load_schedule!
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
   end

data/test/scheduler_hooks_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require_relative 'test_helper'
 
 context "scheduling jobs with hooks" do
   setup do

data/test/scheduler_locking_test.rb

@@ -1,4 +1,4 @@
-require File.dirname(__FILE__) + '/test_helper'
+require_relative 'test_helper'
 
 module LockTestHelper
   def lock_is_not_held(lock)
@@ -6,6 +6,68 @@ module LockTestHelper
   end
 end
 
+context '#master_lock_key' do
+  setup do
+    @subject = Class.new { extend Resque::SchedulerLocking }
+  end
+
+  teardown do
+    Resque.redis.del(@subject.master_lock.key)
+  end
+
+  test 'it 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::SchedulerLocking }
+    end
+
+    teardown do
+      Resque.redis.del(@subject.master_lock.key)
+    end
+
+    test 'it 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::SchedulerLocking }
+    end
+
+    teardown do
+      Resque.redis.namespace = 'resque'
+      Resque.redis.del(@subject.master_lock.key)
+    end
+
+    test 'it 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::SchedulerLocking }
+      end
+
+      teardown do
+        Resque.redis.namespace = 'resque'
+        Resque.redis.del(@subject.master_lock.key)
+      end
+
+      test 'it 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::SchedulerLocking' do
   setup do
     @subject = Class.new { extend Resque::SchedulerLocking }

data/test/scheduler_setup_test.rb

@@ -1,59 +1,95 @@
-require File.dirname(__FILE__) + '/test_helper'
+require_relative 'test_helper'
 
 context "Resque::Scheduler" do
-
   setup do
+    ENV['VERBOSE'] = nil
+    nullify_logger
     Resque::Scheduler.dynamic = false
     Resque.redis.flushall
     Resque::Scheduler.clear_schedule!
   end
 
+  teardown { restore_devnull_logfile }
+
   test 'set custom logger' do
     custom_logger = Logger.new('/dev/null')
     Resque::Scheduler.logger = custom_logger
     assert_equal(custom_logger, Resque::Scheduler.logger)
   end
 
-  context 'logger default settings' do
-    setup do
-      nullify_logger
+  test 'configure block' do
+    Resque::Scheduler.mute = false
+    Resque::Scheduler.configure do |c|
+      c.mute = true
     end
+    assert_equal(Resque::Scheduler.mute, true)
+  end
+
+  context 'when getting the env' do
+    def wipe
+      Resque::Scheduler.env = nil
+      Rails.env = nil
+      ENV['RAILS_ENV'] = nil
+    end
+
+    setup { wipe }
+    teardown { wipe }
+
+    test 'uses the value if set' do
+      Resque::Scheduler.env = 'foo'
+      assert_equal('foo', Resque::Scheduler.env)
+    end
+
+    test 'uses Rails.env if present' do
+      Rails.env = 'bar'
+      assert_equal('bar', Resque::Scheduler.env)
+    end
+
+    test 'uses $RAILS_ENV if present' do
+      ENV['RAILS_ENV'] = 'baz'
+      assert_equal('baz', Resque::Scheduler.env)
+    end
+  end
+
+  context 'logger default settings' do
+    setup { nullify_logger }
+    teardown { restore_devnull_logfile }
 
     test 'uses STDOUT' do
-      assert_equal(Resque::Scheduler.logger.instance_variable_get(:@logdev).dev, STDOUT)
+      assert_equal(
+        Resque::Scheduler.logger.instance_variable_get(:@logdev).dev, $stdout
+      )
     end
+
     test 'not verbose' do
       assert Resque::Scheduler.logger.level > Logger::DEBUG
     end
+
     test 'not muted' do
       assert Resque::Scheduler.logger.level < Logger::FATAL
     end
-
-    teardown do
-      nullify_logger
-    end
   end
 
   context 'logger custom settings' do
-    setup do
-      nullify_logger
-    end
+    setup { nullify_logger }
+    teardown { restore_devnull_logfile }
 
     test 'uses logfile' do
       Resque::Scheduler.logfile = '/dev/null'
-      assert_equal(Resque::Scheduler.logger.instance_variable_get(:@logdev).filename, '/dev/null')
+      assert_equal(
+        Resque::Scheduler.logger.instance_variable_get(:@logdev).filename,
+        '/dev/null'
+      )
     end
+
     test 'set verbosity' do
       Resque::Scheduler.verbose = true
       assert Resque::Scheduler.logger.level == Logger::DEBUG
     end
+
     test 'mute logger' do
       Resque::Scheduler.mute = true
       assert Resque::Scheduler.logger.level == Logger::FATAL
     end
-
-    teardown do
-      nullify_logger
-    end
   end
 end

data/test/scheduler_task_test.rb

@@ -0,0 +1,35 @@
+require_relative 'test_helper'
+
+context "Resque::Scheduler" do
+  setup do
+    Resque::Scheduler.dynamic = false
+    Resque.redis.flushall
+    Resque::Scheduler.mute = true
+    Resque::Scheduler.clear_schedule!
+    Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
+    Resque::Scheduler.send(:instance_variable_set, :@shutdown, false)
+  end
+
+  test "shutdown raises Interrupt when sleeping" do
+    Thread.current.expects(:raise).with(Interrupt)
+    Resque::Scheduler.send(:instance_variable_set, :@th, Thread.current)
+    Resque::Scheduler.send(:instance_variable_set, :@sleeping, true)
+    Resque::Scheduler.shutdown
+  end
+
+  test "sending TERM to scheduler breaks out of poll_sleep" do
+    Resque::Scheduler.expects(:release_master_lock!)
+    fork do
+      sleep(0.5)
+      system("kill -TERM #{Process.ppid}")
+      exit!
+    end
+
+    assert_raises SystemExit do
+      Resque::Scheduler.run
+    end
+
+    Resque::Scheduler.unstub(:release_master_lock!)
+    Resque::Scheduler.release_master_lock!
+  end
+end

data/test/scheduler_test.rb

@@ -1,41 +1,56 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "Resque::Scheduler" do
+require_relative 'test_helper'
 
+context 'Resque::Scheduler' do
   setup do
-    Resque::Scheduler.dynamic = false
+    Resque::Scheduler.configure do |c|
+      c.dynamic = false
+      c.mute = true
+      c.env = nil
+      c.app_name = nil
+    end
     Resque.redis.flushall
-    Resque::Scheduler.mute = true
     Resque::Scheduler.clear_schedule!
     Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
   end
 
-  test "enqueue constantizes" do
-    # The job should be loaded, since a missing rails_env means ALL envs.
-    ENV['RAILS_ENV'] = 'production'
-    config = {'cron' => "* * * * *", 'class' => 'SomeRealClass', 'args' => "/tmp"}
-    Resque::Job.expects(:create).with(SomeRealClass.queue, SomeRealClass, '/tmp')
+  test 'enqueue constantizes' do
+    Resque::Scheduler.env = 'production'
+    config = {
+      'cron' => '* * * * *',
+      'class' => 'SomeRealClass',
+      'args' => '/tmp'
+    }
+    Resque::Job.expects(:create).with(
+      SomeRealClass.queue, SomeRealClass, '/tmp'
+    )
     Resque::Scheduler.enqueue_from_config(config)
   end
 
-  test "enqueue runs hooks" do
-    # The job should be loaded, since a missing rails_env means ALL envs.
-    ENV['RAILS_ENV'] = 'production'
-    config = {'cron' => "* * * * *", 'class' => 'SomeRealClass', 'args' => "/tmp"}
+  test 'enqueue runs hooks' do
+    Resque::Scheduler.env = 'production'
+    config = {
+      'cron' => '* * * * *',
+      'class' => 'SomeRealClass',
+      'args' => '/tmp'
+    }
 
-    Resque::Job.expects(:create).with(SomeRealClass.queue, SomeRealClass, '/tmp')
-    SomeRealClass.expects(:before_delayed_enqueue_example).with("/tmp")
-    SomeRealClass.expects(:before_enqueue_example).with("/tmp")
-    SomeRealClass.expects(:after_enqueue_example).with("/tmp")
+    Resque::Job.expects(:create).with(
+      SomeRealClass.queue, SomeRealClass, '/tmp'
+    )
+    SomeRealClass.expects(:before_delayed_enqueue_example).with('/tmp')
+    SomeRealClass.expects(:before_enqueue_example).with('/tmp')
+    SomeRealClass.expects(:after_enqueue_example).with('/tmp')
 
     Resque::Scheduler.enqueue_from_config(config)
   end
 
-  test "enqueue_from_config respects queue params" do
-    config = {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'queue' => 'high'}
-
+  test 'enqueue_from_config respects queue params' do
+    config = {
+      'cron' => '* * * * *',
+      'class' => 'SomeIvarJob',
+      'queue' => 'high'
+    }
     Resque.expects(:enqueue_to).with('high', SomeIvarJob)
-
     Resque::Scheduler.enqueue_from_config(config)
   end
 
@@ -71,46 +86,77 @@ context "Resque::Scheduler" do
     assert Resque::Scheduler.scheduled_jobs.include?("some_ivar_job2")
   end
 
-  test "load_schedule_job loads a schedule" do
-    Resque::Scheduler.load_schedule_job("some_ivar_job", {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"})
+  test 'load_schedule_job loads a schedule' do
+    Resque::Scheduler.load_schedule_job(
+      'some_ivar_job', {
+        'cron' => '* * * * *',
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp'
+      }
+    )
 
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
     assert_equal(1, Resque::Scheduler.scheduled_jobs.size)
-    assert Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
+    assert Resque::Scheduler.scheduled_jobs.keys.include?('some_ivar_job')
   end
 
-  test "load_schedule_job with every with options" do
-    Resque::Scheduler.load_schedule_job("some_ivar_job", {'every' => ['30s', {'first_in' => '60s'}], 'class' => 'SomeIvarJob', 'args' => "/tmp"})
+  test 'load_schedule_job with every with options' do
+    Resque::Scheduler.load_schedule_job(
+      'some_ivar_job', {
+        'every' => ['30s', { 'first_in' => '60s' }],
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp'
+      }
+    )
 
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
     assert_equal(1, Resque::Scheduler.scheduled_jobs.size)
-    assert Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
-    assert Resque::Scheduler.scheduled_jobs["some_ivar_job"].params.keys.include?(:first_in)
+    assert Resque::Scheduler.scheduled_jobs.keys.include?('some_ivar_job')
+    job = Resque::Scheduler.scheduled_jobs['some_ivar_job']
+    assert job.params.keys.include?(:first_in)
   end
 
-  test "load_schedule_job with cron with options" do
-    Resque::Scheduler.load_schedule_job("some_ivar_job", {'cron' => ['* * * * *', {'allow_overlapping' => 'true'}], 'class' => 'SomeIvarJob', 'args' => "/tmp"})
+  test 'load_schedule_job with cron with options' do
+    Resque::Scheduler.load_schedule_job(
+      'some_ivar_job', {
+        'cron' => ['* * * * *', { 'allow_overlapping' => 'true' }],
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp'
+      }
+    )
 
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
     assert_equal(1, Resque::Scheduler.scheduled_jobs.size)
-    assert Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
-    assert Resque::Scheduler.scheduled_jobs["some_ivar_job"].params.keys.include?(:allow_overlapping)
+    assert Resque::Scheduler.scheduled_jobs.keys.include?('some_ivar_job')
+    job = Resque::Scheduler.scheduled_jobs['some_ivar_job']
+    assert job.params.keys.include?(:allow_overlapping)
   end
 
-  test "load_schedule_job without cron" do
-    Resque::Scheduler.load_schedule_job("some_ivar_job", {'class' => 'SomeIvarJob', 'args' => "/tmp"})
+  test 'load_schedule_job without cron' do
+    Resque::Scheduler.load_schedule_job(
+      'some_ivar_job', {
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp'
+      }
+    )
 
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
     assert_equal(0, Resque::Scheduler.scheduled_jobs.size)
-    assert !Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
+    assert !Resque::Scheduler.scheduled_jobs.keys.include?('some_ivar_job')
   end
 
-  test "load_schedule_job with an empty cron" do
-    Resque::Scheduler.load_schedule_job("some_ivar_job", {'cron' => '', 'class' => 'SomeIvarJob', 'args' => "/tmp"})
+  test 'load_schedule_job with an empty cron' do
+    Resque::Scheduler.load_schedule_job(
+      'some_ivar_job', {
+        'cron' => '',
+        'class' => 'SomeIvarJob',
+        'args' => '/tmp'
+      }
+    )
 
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
     assert_equal(0, Resque::Scheduler.scheduled_jobs.size)
-    assert !Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
+    assert !Resque::Scheduler.scheduled_jobs.keys.include?('some_ivar_job')
   end
 
   test "update_schedule" do
@@ -239,12 +285,32 @@ context "Resque::Scheduler" do
   end
 
   test "remove_schedule removes a schedule" do
-    Resque.redis.hset(:schedules, "some_ivar_job3", Resque.encode(
-      'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/44"
-    ))
+    Resque.set_schedule("some_ivar_job3",
+      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/44", 'persist' => true}
+    )
+    Resque::Scheduler.load_schedule!
     Resque.remove_schedule("some_ivar_job3")
     assert_equal nil, Resque.redis.hget(:schedules, "some_ivar_job3")
     assert Resque.redis.sismember(:schedules_changed, "some_ivar_job3")
+    assert_equal [], Resque.redis.smembers(:persisted_schedules)
+  end
+
+  test "persisted schedules" do
+    Resque.set_schedule("some_ivar_job",
+      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2", 'persist' => true}
+    )
+    Resque.set_schedule("new_ivar_job",
+      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
+    )
+
+    Resque.schedule=({
+      'a_schedule' => {'cron' => "* * * * *", 'class' => 'SomeOtherJob', 'args' => '/tmp'}
+    })
+    Resque::Scheduler.load_schedule!
+
+    assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"},
+      Resque.schedule['some_ivar_job'])
+    assert_equal(nil, Resque.schedule['some_job'])
   end
 
   test "adheres to lint" do
@@ -253,4 +319,26 @@ context "Resque::Scheduler" do
       Resque::Plugin.lint(ResqueScheduler)
     end
   end
+
+  test 'procline contains app_name when present' do
+    Resque::Scheduler.app_name = 'foo'
+    assert Resque::Scheduler.send(:build_procline, 'bar') =~ /\[foo\]:/
+  end
+
+  test 'procline omits app_name when absent' do
+    Resque::Scheduler.app_name = nil
+    assert Resque::Scheduler.send(:build_procline, 'bar') =~
+      /#{Resque::Scheduler.send(:internal_name)}: bar/
+  end
+
+  test 'procline contains env when present' do
+    Resque::Scheduler.env = 'derp'
+    assert Resque::Scheduler.send(:build_procline, 'cage') =~ /\[derp\]: cage/
+  end
+
+  test 'procline omits env when absent' do
+    Resque::Scheduler.env = nil
+    assert Resque::Scheduler.send(:build_procline, 'cage') =~
+      /#{Resque::Scheduler.send(:internal_name)}: cage/
+  end
 end