resque-scheduler 4.2.1 → 4.5.0

data/test/env_test.rb

@@ -1,47 +0,0 @@
-# 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 'keep set config if no option given' do
-    Resque::Scheduler.configure { |c| c.dynamic = true }
-    env = new_env
-    env.setup
-    assert_equal(true, Resque::Scheduler.dynamic)
-  end
-
-  test 'override config if option given' do
-    Resque::Scheduler.configure { |c| c.dynamic = true }
-    env = new_env(dynamic: false)
-    env.setup
-    assert_equal(false, Resque::Scheduler.dynamic)
-  end
-end

data/test/multi_process_test.rb

@@ -1,125 +0,0 @@
-# vim:fileencoding=utf-8
-require_relative 'test_helper'
-
-context 'Multi Process' do
-  test 'setting schedule= from many process does not corrupt the schedules' do
-    # more info on why we're not using threads:
-    # https://github.com/resque/resque-scheduler/pull/439#discussion_r16788812
-    omit('forking is not supported by jruby but this behaviour' \
-      ' is best tested using forks') if RUBY_ENGINE == 'jruby'
-    schedules_1 = {}
-    schedules_2 = {}
-    schedules = []
-    pids = []
-
-    # This number may need to be increased if this test is not failing
-    processes = 100
-
-    schedule_count = 300
-
-    schedule_count.times do |n|
-      schedules_1["1_job_#{n}"] = { cron: '0 1 0 0 0' }
-      schedules_2["2_job_#{n}"] = { cron: '0 1 0 0 0' }
-    end
-
-    processes.times do |n|
-      pids << fork_with_marshalled_pipe_and_result do
-        sleep n * 0.1
-        Resque.schedule = n.even? ? schedules_2 : schedules_1
-        Resque.schedule
-      end
-    end
-
-    schedules += get_results_from_children(pids)
-
-    assert_equal processes, schedules.size,
-                 'missing some schedules, did a process die?'
-    schedules.each_with_index do |schedule, i|
-      assert_equal schedule_count, schedule.size,
-                   "schedule count is incorrect (schedule[#{i}]: #{schedule})"
-    end
-  end
-
-  test 'concurrent shutdowns and startups do not corrupt the schedule' do
-    omit('forking is not supported by jruby but this behaviour' \
-      ' is best tested using forks') if RUBY_ENGINE == 'jruby'
-    counts = []
-    children = []
-
-    processes = 40
-
-    schedules = {}
-    schedule_count = 300
-    schedule_count.times do |n|
-      schedules["job_#{n}"] = { 'cron' => '0 1 0 0 0' }
-    end
-
-    Resque.schedule = schedules
-
-    processes.times do |n|
-      children << fork_with_marshalled_pipe_and_result do
-        sleep Random.rand(3) * 0.1
-        if n.even?
-          Resque.schedule = schedules
-          Resque.schedule.size
-        else
-          Resque::Scheduler.before_shutdown
-          nil
-        end
-      end
-    end
-
-    counts += get_results_from_children(children).compact
-
-    assert_equal processes / 2, counts.size,
-                 'missing some counts, did a process die?'
-    counts.each_with_index do |c, i|
-      assert_equal schedule_count, c, "schedule count is incorrect (c: #{i})"
-    end
-  end
-
-  private
-
-  def fork_with_marshalled_pipe_and_result
-    pipe_read, pipe_write = IO.pipe
-    pid = fork do
-      pipe_read.close
-      result = begin
-        [yield, nil]
-      rescue StandardError => exc
-        [nil, exc]
-      end
-      pipe_write.syswrite(Marshal.dump(result))
-      # exit true the process to get around fork issues on minitest 5
-      # see https://github.com/seattlerb/minitest/issues/467
-      Process.exit!(true)
-    end
-    pipe_write.close
-
-    [pid, pipe_read]
-  end
-
-  def get_results_from_children(children)
-    results = []
-    children.each do |pid, pipe|
-      wait_for_child_process_to_terminate(pid)
-
-      raise "forked process failed with #{$CHILD_STATUS}" unless $CHILD_STATUS.success?
-      result, exc = Marshal.load(pipe.read)
-      raise exc if exc
-      results << result
-    end
-    results
-  end
-
-  def wait_for_child_process_to_terminate(pid = -1, timeout = 30)
-    Timeout.timeout(timeout) do
-      Process.wait(pid)
-    end
-  rescue Timeout::Error
-    Process.kill('KILL', pid)
-    # collect status so it doesn't stick around as zombie process
-    Process.wait(pid)
-    flunk 'Child process did not terminate in time.'
-  end
-end

data/test/resque-web_test.rb

@@ -1,364 +0,0 @@
-# vim:fileencoding=utf-8
-require_relative 'test_helper'
-
-require 'resque/server/test_helper'
-
-context 'on GET to /schedule' do
-  setup { get '/schedule' }
-
-  test('is 200') { assert last_response.ok? }
-end
-
-context 'on GET to /schedule with scheduled jobs' do
-  setup do
-    Resque::Scheduler.env = 'production'
-    Resque.schedule = {
-      'some_ivar_job' => {
-        'cron' => '* * * * *',
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp',
-        'rails_env' => 'production'
-      },
-      'some_other_job' => {
-        'every' => ['1m', ['1h']],
-        'queue' => 'high',
-        'custom_job_class' => 'SomeOtherJob',
-        'args' => {
-          'b' => 'blah'
-        }
-      },
-      'some_fancy_job' => {
-        'every' => ['1m'],
-        'queue' => 'fancy',
-        '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'
-  end
-
-  test('is 200') { assert last_response.ok? }
-
-  test 'see the scheduled job' do
-    assert last_response.body.include?('SomeIvarJob')
-  end
-
-  test 'include(highlight) 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' }
-
-  test('is 200') { assert last_response.ok? }
-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
-
-  test('is 200') { assert last_response.ok? }
-
-  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
-
-    test('is 200') { assert last_response.ok? }
-
-    test 'see the scheduled job' do
-      assert last_response.body.include?(@t.to_s)
-    end
-  end
-end
-
-module Test
-  RESQUE_SCHEDULE = {
-    'job_without_params' => {
-      'cron' => '* * * * *',
-      'class' => 'JobWithoutParams',
-      'args' => {
-        'host' => 'localhost'
-      },
-      'rails_env' => 'production'
-    },
-    'job_with_params' => {
-      'every' => '1m',
-      'class' => 'JobWithParams',
-      'args' => {
-        'host' => 'localhost'
-      },
-      'parameters' => {
-        'log_level' => {
-          'description' => 'The level of logging',
-          'default' => 'warn'
-        }
-      }
-    }
-  }.freeze
-end
-
-context 'POST /schedule/requeue' do
-  setup do
-    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])
-
-    post '/schedule/requeue', 'job_name' => job_name
-    follow_redirect!
-    assert_equal 'http://example.org/overview', last_request.url
-    assert last_response.ok?
-  end
-
-  test 'job with params' 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
-
-    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}">)
-    )
-
-    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>]
-      )
-      assert last_response.body.include?(
-        '<input type="text" name="log_level" ' <<
-        %(value="#{param_config['default']}">)
-      )
-    end
-  end
-end
-
-context 'POST /schedule/requeue_with_params' do
-  setup do
-    Resque.schedule = Test::RESQUE_SCHEDULE
-    Resque::Scheduler.load_schedule!
-  end
-
-  test 'job with params' do
-    job_name = 'job_with_params'
-    log_level = 'error'
-
-    job_config = Resque.schedule[job_name]
-    args = job_config['args'].merge('log_level' => log_level)
-    job_config = job_config.merge('args' => args)
-
-    Resque::Scheduler.stubs(:enqueue_from_config).once.with(job_config)
-
-    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 last_response.ok?, last_response.errors
-  end
-end
-
-context 'on POST to /delayed/search' do
-  setup do
-    t = Time.now + 60
-    Resque.enqueue_at(t, SomeIvarJob, 'string arg')
-    Resque.enqueue(SomeQuickJob)
-  end
-
-  test 'should find matching scheduled job' do
-    post '/delayed/search', 'search' => 'ivar'
-    assert last_response.status == 200
-    assert last_response.body.include?('SomeIvarJob')
-  end
-
-  test 'the form should encode string params' do
-    post '/delayed/search', 'search' => 'ivar'
-    assert_match('value="[&quot;string arg&quot;]', last_response.body)
-  end
-
-  test 'should find matching queued job' do
-    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 do
-    Resque.reset_delayed_queue
-    Resque.enqueue_at(Time.now + 10, SomeIvarJob, 'arg')
-    Resque.enqueue_at(Time.now + 100, SomeQuickJob)
-  end
-
-  test 'removes the specified job' do
-    job_timestamp, *remaining = Resque.delayed_queue_peek(0, 10)
-    assert_equal 1, remaining.size
-
-    post '/delayed/cancel_now',
-         'timestamp' => job_timestamp,
-         'klass'     => SomeIvarJob.name,
-         'args'      => Resque.encode(['arg'])
-
-    assert_equal 302, last_response.status
-    assert_equal remaining, Resque.delayed_queue_peek(0, 10)
-  end
-
-  test 'does not remove the job if the params do not match' do
-    timestamps = Resque.delayed_queue_peek(0, 10)
-
-    post '/delayed/cancel_now',
-         'timestamp' => timestamps.first,
-         'klass'     => SomeIvarJob.name
-
-    assert_equal 302, last_response.status
-    assert_equal timestamps, Resque.delayed_queue_peek(0, 10)
-  end
-
-  test 'redirects to overview' do
-    post '/delayed/cancel_now'
-    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', timestamp: 0 }
-
-  test 'returns ok status' do
-    assert last_response.status == 200
-  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