resque-scheduler 2.5.5 → 3.0.0

data/test/env_test.rb

@@ -0,0 +1,41 @@
+# vim:fileencoding=utf-8
+require_relative 'test_helper'
+
+context 'Env' do
+  def new_env(options = {})
+    Resque::Scheduler::Env.new(options)
+  end
+
+  test 'daemonizes when background is true' do
+    Process.expects(:daemon)
+    env = new_env(background: true)
+    env.setup
+  end
+
+  test 'reconnects redis when background is true' do
+    Process.stubs(:daemon)
+    mock_redis_client = mock('redis_client')
+    mock_redis = mock('redis')
+    mock_redis.expects(:client).returns(mock_redis_client)
+    mock_redis_client.expects(:reconnect)
+    Resque.expects(:redis).returns(mock_redis)
+    env = new_env(background: true)
+    env.setup
+  end
+
+  test 'aborts when background is given and Process does not support daemon' do
+    Process.stubs(:daemon)
+    Process.expects(:respond_to?).with('daemon').returns(false)
+    env = new_env(background: true)
+    env.expects(:abort)
+    env.setup
+  end
+
+  test 'writes pid to pidfile when given' do
+    mock_pidfile = mock('pidfile')
+    mock_pidfile.expects(:puts)
+    File.expects(:open).with('derp.pid', 'w').yields(mock_pidfile)
+    env = new_env(pidfile: 'derp.pid')
+    env.setup
+  end
+end

data/test/resque-web_test.rb

@@ -1,28 +1,28 @@
-require File.dirname(__FILE__) + '/test_helper'
+# vim:fileencoding=utf-8
+require_relative 'test_helper'
 
-# Pull in the server test_helper from resque
-require 'resque/server/test_helper.rb'
+require 'resque/server/test_helper'
 
-context "on GET to /schedule" do
-  setup { get "/schedule" }
+context 'on GET to /schedule' do
+  setup { get '/schedule' }
 
-  should_respond_with_success
+  test('is 200') { assert last_response.ok? }
 end
 
-context "on GET to /schedule with scheduled jobs" do
+context 'on GET to /schedule with scheduled jobs' do
   setup do
     Resque::Scheduler.env = 'production'
     Resque.schedule = {
       'some_ivar_job' => {
-        'cron' => "* * * * *",
+        'cron' => '* * * * *',
         'class' => 'SomeIvarJob',
-        'args' => "/tmp",
+        'args' => '/tmp',
         'rails_env' => 'production'
       },
       'some_other_job' => {
-        'every' => ['5m'],
+        'every' => ['1m', ['1h']],
         'queue' => 'high',
-        'class' => 'SomeOtherJob',
+        'custom_job_class' => 'SomeOtherJob',
         'args' => {
           'b' => 'blah'
         }
@@ -33,13 +33,19 @@ context "on GET to /schedule with scheduled jobs" do
         'class' => 'SomeFancyJob',
         'args' => 'sparkles',
         'rails_env' => 'fancy'
+      },
+      'shared_env_job' => {
+        'cron' => '* * * * *',
+        'class' => 'SomeSharedEnvJob',
+        'args' => '/tmp',
+        'rails_env' => 'fancy, production'
       }
     }
     Resque::Scheduler.load_schedule!
-    get "/schedule"
+    get '/schedule'
   end
 
-  should_respond_with_success
+  test('is 200') { assert last_response.ok? }
 
   test 'see the scheduled job' do
     assert last_response.body.include?('SomeIvarJob')
@@ -48,22 +54,43 @@ context "on GET to /schedule with scheduled jobs" do
   test 'excludes jobs for other envs' do
     assert !last_response.body.include?('SomeFancyJob')
   end
+
+  test 'includes job used in multiple environments' do
+    assert last_response.body.include?('SomeSharedEnvJob')
+  end
+
+  test 'allows delete when dynamic' do
+    Resque::Scheduler.stubs(:dynamic).returns(true)
+    get '/schedule'
+
+    assert last_response.body.include?('Delete')
+  end
+
+  test "doesn't allow delete when static" do
+    Resque::Scheduler.stubs(:dynamic).returns(false)
+    get '/schedule'
+
+    assert !last_response.body.include?('Delete')
+  end
 end
 
-context "on GET to /delayed" do
-  setup { get "/delayed" }
+context 'on GET to /delayed' do
+  setup { get '/delayed' }
 
-  should_respond_with_success
+  test('is 200') { assert last_response.ok? }
 end
 
-context "on GET to /delayed/jobs/:klass" do
+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
+    get(
+      URI('/delayed/jobs/SomeIvarJob?args=' <<
+          URI.encode(%w(foo bar).to_json)).to_s
+    )
   end
 
-  should_respond_with_success
+  test('is 200') { assert last_response.ok? }
 
   test 'see the scheduled job' do
     assert last_response.body.include?(@t.to_s)
@@ -80,10 +107,13 @@ context "on GET to /delayed/jobs/:klass" do
         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
+      get(
+        URI('/delayed/jobs/Foo::Bar?args=' <<
+            URI.encode(%w(foo bar).to_json)).to_s
+      )
     end
 
-    should_respond_with_success
+    test('is 200') { assert last_response.ok? }
 
     test 'see the scheduled job' do
       assert last_response.body.include?(@t.to_s)
@@ -91,17 +121,18 @@ context "on GET to /delayed/jobs/:klass" do
   end
 end
 
-def resque_schedule
-  {
+module Test
+  RESQUE_SCHEDULE = {
     'job_without_params' => {
       'cron' => '* * * * *',
       'class' => 'JobWithoutParams',
       'args' => {
         'host' => 'localhost'
       },
-      'rails_env' => 'production'},
+      'rails_env' => 'production'
+    },
     'job_with_params' => {
-      'cron' => '* * * * *',
+      'every' => '1m',
       'class' => 'JobWithParams',
       'args' => {
         'host' => 'localhost'
@@ -116,20 +147,21 @@ def resque_schedule
   }
 end
 
-context "POST /schedule/requeue" do
+context 'POST /schedule/requeue' do
   setup do
-    Resque.schedule = resque_schedule
+    Resque.schedule = Test::RESQUE_SCHEDULE
     Resque::Scheduler.load_schedule!
   end
 
   test 'job without params' do
     # Regular jobs without params should redirect to /overview
     job_name = 'job_without_params'
-    Resque::Scheduler.stubs(:enqueue_from_config).once.with(Resque.schedule[job_name])
+    Resque::Scheduler.stubs(:enqueue_from_config)
+      .once.with(Resque.schedule[job_name])
 
-    post '/schedule/requeue', {'job_name' => job_name}
+    post '/schedule/requeue', 'job_name' => job_name
     follow_redirect!
-    assert_equal "http://example.org/overview", last_request.url
+    assert_equal 'http://example.org/overview', last_request.url
     assert last_response.ok?
   end
 
@@ -137,24 +169,30 @@ context "POST /schedule/requeue" do
     # If a job has params defined,
     # it should render the template with a form for the job params
     job_name = 'job_with_params'
-    post '/schedule/requeue', {'job_name' => job_name}
+    post '/schedule/requeue', 'job_name' => job_name
 
     assert last_response.ok?, last_response.errors
-    assert last_response.body.include?("This job requires parameters")
-    assert last_response.body.include?("<input type=\"hidden\" name=\"job_name\" value=\"#{job_name}\">")
+    assert last_response.body.include?('This job requires parameters')
+    assert last_response.body.include?(
+      %Q(<input type="hidden" name="job_name" value="#{job_name}">)
+    )
 
-    Resque.schedule[job_name]['parameters'].each do |param_name, param_config|
+    Resque.schedule[job_name]['parameters'].each do |_param_name, param_config|
       assert last_response.body.include?(
-        "<span style=\"border-bottom:1px dotted;\" title=\"#{param_config['description']}\">(?)</span>")
+        '<span style="border-bottom:1px dotted;" ' <<
+        %Q[title="#{param_config['description']}">(?)</span>]
+      )
       assert last_response.body.include?(
-        "<input type=\"text\" name=\"log_level\" value=\"#{param_config['default']}\">")
+        '<input type="text" name="log_level" ' <<
+        %Q(value="#{param_config['default']}">)
+      )
     end
   end
 end
 
-context "POST /schedule/requeue_with_params" do
+context 'POST /schedule/requeue_with_params' do
   setup do
-    Resque.schedule = resque_schedule
+    Resque.schedule = Test::RESQUE_SCHEDULE
     Resque::Scheduler.load_schedule!
   end
 
@@ -168,18 +206,18 @@ context "POST /schedule/requeue_with_params" do
 
     Resque::Scheduler.stubs(:enqueue_from_config).once.with(job_config)
 
-    post '/schedule/requeue_with_params', {
-      'job_name' => job_name,
-      'log_level' => log_level
-    }
+    post '/schedule/requeue_with_params',
+         'job_name' => job_name,
+         'log_level' => log_level
+
     follow_redirect!
-    assert_equal "http://example.org/overview", last_request.url
+    assert_equal 'http://example.org/overview', last_request.url
 
     assert last_response.ok?, last_response.errors
   end
 end
 
-context "on POST to /delayed/search" do
+context 'on POST to /delayed/search' do
   setup do
     t = Time.now + 60
     Resque.enqueue_at(t, SomeIvarJob)
@@ -187,24 +225,107 @@ context "on POST to /delayed/search" do
   end
 
   test 'should find matching scheduled job' do
-    post "/delayed/search" , 'search' => 'ivar'
+    post '/delayed/search' , 'search' => 'ivar'
     assert last_response.status == 200
     assert last_response.body.include?('SomeIvarJob')
   end
 
   test 'should find matching queued job' do
-    post "/delayed/search" , 'search' => 'quick'
+    post '/delayed/search' , 'search' => 'quick'
     assert last_response.status == 200
     assert last_response.body.include?('SomeQuickJob')
   end
 end
 
-context "on POST to /delayed/cancel_now" do
-  setup { post "/delayed/cancel_now" }
+context 'on POST to /delayed/cancel_now' do
+  setup { post '/delayed/cancel_now' }
 
   test 'redirects to overview' do
     assert last_response.status == 302
     assert last_response.header['Location'].include? '/delayed'
   end
+end
+
+context 'on POST to /delayed/clear' do
+  setup { post '/delayed/clear' }
+
+  test 'redirects to delayed' do
+    assert last_response.status == 302
+    assert last_response.header['Location'].include? '/delayed'
+  end
+end
+
+context 'on POST to /delayed/queue_now' do
+  setup { post '/delayed/queue_now' }
+
+  test 'redirects to overview' do
+    assert last_response.status == 302
+    assert last_response.header['Location'].include? '/overview'
+  end
+end
+
+context 'on GET to /delayed/:timestamp' do
+  setup { get '/delayed/1234567890' }
+
+  test 'shows delayed_timestamp view' do
+    assert last_response.status == 200
+  end
+end
+
+context 'DELETE /schedule when dynamic' do
+  setup do
+    Resque.schedule = Test::RESQUE_SCHEDULE
+    Resque::Scheduler.load_schedule!
+    Resque::Scheduler.stubs(:dynamic).returns(true)
+  end
+
+  test 'redirects to schedule page' do
+    delete '/schedule'
+
+    status = last_response.status
+    redirect_location = last_response.original_headers['Location']
+    response_status_msg = "Expected response to be a 302, but was a #{status}."
+    redirect_msg = "Redirect to #{redirect_location} instead of /schedule."
+
+    assert status == 302, response_status_msg
+    assert_match %r{/schedule/?$}, redirect_location, redirect_msg
+  end
+
+  test 'does not show the deleted job' do
+    delete '/schedule', job_name: 'job_with_params'
+    follow_redirect!
+
+    msg = 'The job should not have been shown on the /schedule page.'
+    assert !last_response.body.include?('job_with_params'), msg
+  end
 
+  test 'removes job from redis' do
+    delete '/schedule', job_name: 'job_with_params'
+
+    msg = 'The job was not deleted from redis.'
+    assert_nil Resque.fetch_schedule('job_with_params'), msg
+  end
+end
+
+context 'DELETE /schedule when static' do
+  setup do
+    Resque.schedule = Test::RESQUE_SCHEDULE
+    Resque::Scheduler.load_schedule!
+    Resque::Scheduler.stubs(:dynamic).returns(false)
+  end
+
+  test 'does not remove the job from the UI' do
+    delete '/schedule', job_name: 'job_with_params'
+    follow_redirect!
+
+    msg = 'The job should not have been removed from the /schedule page.'
+    assert last_response.body.include?('job_with_params'), msg
+  end
+
+  test 'does not remove job from redis' do
+    delete '/schedule', job_name: 'job_with_params'
+
+    msg = 'The job should not have been deleted from redis.'
+    assert Resque.fetch_schedule('job_with_params'), msg
+  end
 end

data/test/scheduler_args_test.rb

@@ -1,31 +1,58 @@
-require_relative 'test_helper'
+# vim:fileencoding=utf-8
 
-context "scheduling jobs with arguments" do
+require_relative 'test_helper'
 
+context 'scheduling jobs with arguments' do
   setup do
     Resque::Scheduler.clear_schedule!
-    Resque::Scheduler.dynamic = false
-    Resque::Scheduler.mute = true
-  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")
+    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
@@ -100,24 +127,26 @@ context "scheduling jobs with arguments" do
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
   end
 
-  test "calls the worker without arguments when 'args' is missing from the config" do
+  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()
+    SomeIvarJob.expects(:perform).once.with
     Resque.reserve('ivar').perform
   end
 
-  test "calls the worker without arguments when 'args' is blank in the config" do
+  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()
+    SomeIvarJob.expects(:perform).once.with
     Resque.reserve('ivar').perform
   end
 
-  test "calls the worker with a string when the config lists a string" do
+  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
@@ -126,7 +155,7 @@ context "scheduling jobs with arguments" do
     Resque.reserve('ivar').perform
   end
 
-  test "calls the worker with a Fixnum when the config lists an integer" do
+  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
@@ -135,7 +164,8 @@ context "scheduling jobs with arguments" do
     Resque.reserve('ivar').perform
   end
 
-  test "calls the worker with multiple arguments when the config lists an array" do
+  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:
@@ -146,7 +176,8 @@ context "scheduling jobs with arguments" do
     Resque.reserve('ivar').perform
   end
 
-  test "calls the worker with an array when the config lists a nested array" do
+  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:
@@ -157,7 +188,7 @@ context "scheduling jobs with arguments" do
     Resque.reserve('ivar').perform
   end
 
-  test "calls the worker with a hash when the config lists a hash" do
+  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:
@@ -167,24 +198,25 @@ context "scheduling jobs with arguments" do
     Resque.reserve('ivar').perform
   end
 
-  test "calls the worker with a nested hash when the config lists a nested hash" do
+  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'})
+    SomeIvarJob.expects(:perform).once
+      .with('first_key' => { 'second_key' => 'value' })
     Resque.reserve('ivar').perform
   end
-  
-  test "poll_sleep_amount defaults to 5" do
+
+  test 'poll_sleep_amount defaults to 5' do
     assert_equal 5, Resque::Scheduler.poll_sleep_amount
   end
-  
-  test "poll_sleep_amount is settable" do
+
+  test 'poll_sleep_amount is settable' do
     Resque::Scheduler.poll_sleep_amount = 1
-    assert_equal 1, Resque::Scheduler.poll_sleep_amount    
+    assert_equal 1, Resque::Scheduler.poll_sleep_amount
   end
-  
 end