resque-scheduler 2.2.0 → 4.10.2

data/test/delayed_queue_test.rb

@@ -1,383 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-context "DelayedQueue" do
-
-  setup do
-    Resque::Scheduler.mute = true
-    Resque.redis.flushall
-  end
-
-  test "enqueue_at adds correct list and zset" do
-    timestamp = Time.now + 1
-    encoded_job =  Resque.encode({:class => SomeIvarJob.to_s, :args => ["path"], :queue => Resque.queue_from_class(SomeIvarJob)})
-
-    assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
-    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set should be empty to start")
-
-    Resque.enqueue_at(timestamp, SomeIvarJob, "path")
-
-    # Confirm the correct keys were added
-    assert_equal(1, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should have one entry now")
-    assert_equal(1, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps should have one entry now")
-    assert_equal(1, Resque.redis.zcard(:delayed_queue_schedule), "The delayed_queue_schedule should have 1 entry now")
-
-    read_timestamp = timestamp.to_i
-
-    item = Resque.next_item_for_timestamp(read_timestamp)
-
-    # Confirm the item came out correctly
-    assert_equal('SomeIvarJob', item['class'], "Should be the same class that we queued")
-    assert_equal(["path"], item['args'], "Should have the same arguments that we queued")
-
-    # And now confirm the keys are gone
-    assert(!Resque.redis.exists("delayed:#{timestamp.to_i}"))
-    assert_equal(0, Resque.redis.zcard(:delayed_queue_schedule), "delayed queue should be empty")
-    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set should be empty")
-  end
-
-  test "enqueue_at with queue adds correct list and zset and queue" do
-    timestamp = Time.now + 1
-    encoded_job =  Resque.encode({:class => SomeIvarJob.to_s, :args => ["path"], :queue => 'critical'})
-
-    assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
-    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set should be empty to start")
-
-    Resque.enqueue_at_with_queue('critical', timestamp, SomeIvarJob, "path")
-
-    # Confirm the correct keys were added
-    assert_equal(1, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should have one entry now")
-    assert_equal(1, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps should have one entry now")
-    assert_equal(1, Resque.redis.zcard(:delayed_queue_schedule), "The delayed_queue_schedule should have 1 entry now")
-
-    read_timestamp = timestamp.to_i
-
-    item = Resque.next_item_for_timestamp(read_timestamp)
-
-    # Confirm the item came out correctly
-    assert_equal('SomeIvarJob', item['class'], "Should be the same class that we queued")
-    assert_equal(["path"], item['args'], "Should have the same arguments that we queued")
-    assert_equal('critical', item['queue'], "Should have the queue that we asked for")
-
-    # And now confirm the keys are gone
-    assert(!Resque.redis.exists("delayed:#{timestamp.to_i}"))
-    assert_equal(0, Resque.redis.zcard(:delayed_queue_schedule), "delayed queue should be empty")
-    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set should be empty")
-  end
-
-  test "a job in the future doesn't come out" do
-    timestamp = Time.now + 600 # 10 minutes from now (in the future, shouldn't come out)
-    encoded_job =  Resque.encode({:class => SomeIvarJob.to_s, :args => ["path"], :queue => Resque.queue_from_class(SomeIvarJob)})
-
-    assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should be empty to start")
-    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps set should be empty to start")
-
-    Resque.enqueue_at(timestamp, SomeIvarJob, "path")
-
-    # Confirm the correct keys were added
-    assert_equal(1, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue should have one entry now")
-    assert_equal(1, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps should have one entry now")
-    assert_equal(1, Resque.redis.zcard(:delayed_queue_schedule), "The delayed_queue_schedule should have 1 entry now")
-
-    read_timestamp = Resque.next_delayed_timestamp
-
-    assert_nil(read_timestamp, "No timestamps should be ready for queueing")
-  end
-
-  test "a job in the future comes out if you want it to" do
-    timestamp = Time.now + 600 # 10 minutes from now
-
-    Resque.enqueue_at(timestamp, SomeIvarJob, "path")
-
-    read_timestamp = Resque.next_delayed_timestamp(timestamp)
-
-    assert_equal(timestamp.to_i, read_timestamp, "The timestamp we pull out of redis should match the one we put in")
-  end
-
-  test "enqueue_at and enqueue_in are equivelent" do
-    timestamp = Time.now + 60
-    encoded_job =  Resque.encode({:class => SomeIvarJob.to_s, :args => ["path"], :queue => Resque.queue_from_class(SomeIvarJob)})
-
-    Resque.enqueue_at(timestamp, SomeIvarJob, "path")
-    Resque.enqueue_in(timestamp - Time.now, SomeIvarJob, "path")
-
-    assert_equal(1, Resque.redis.zcard(:delayed_queue_schedule), "should have one timestamp in the delayed queue")
-    assert_equal(2, Resque.redis.llen("delayed:#{timestamp.to_i}"), "should have 2 items in the timestamp queue")
-    assert_equal(1, Resque.redis.scard("timestamps:#{encoded_job}"), "job timestamps should have one entry now")
-  end
-
-  test "empty delayed_queue_peek returns empty array" do
-    assert_equal([], Resque.delayed_queue_peek(0,20))
-  end
-
-  test "delayed_queue_peek returns stuff" do
-    t = Time.now
-    expected_timestamps = (1..5).to_a.map do |i|
-      (t + 60 + i).to_i
-    end
-
-    expected_timestamps.each do |timestamp|
-      Resque.delayed_push(timestamp, {:class => SomeIvarJob, :args => 'blah1'})
-    end
-
-    timestamps = Resque.delayed_queue_peek(1,2)
-
-    assert_equal(expected_timestamps[1,2], timestamps)
-  end
-
-  test "delayed_queue_schedule_size returns correct size" do
-    assert_equal(0, Resque.delayed_queue_schedule_size)
-    Resque.enqueue_at(Time.now+60, SomeIvarJob)
-    assert_equal(1, Resque.delayed_queue_schedule_size)
-  end
-
-  test "delayed_timestamp_size returns 0 when nothing is queue" do
-    t = Time.now + 60
-    assert_equal(0, Resque.delayed_timestamp_size(t))
-  end
-
-  test "delayed_timestamp_size returns 1 when one thing is queued" do
-    t = Time.now + 60
-    Resque.enqueue_at(t, SomeIvarJob)
-    assert_equal(1, Resque.delayed_timestamp_size(t))
-  end
-
-  test "delayed_timestamp_peek returns empty array when nothings in it" do
-    t = Time.now + 60
-    assert_equal([], Resque.delayed_timestamp_peek(t, 0, 1), "make sure it's an empty array, not nil")
-  end
-
-  test "delayed_timestamp_peek returns an array containing one job when one thing is queued" do
-    t = Time.now + 60
-    Resque.enqueue_at(t, SomeIvarJob)
-    assert_equal [{'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}], Resque.delayed_timestamp_peek(t, 0, 1)
-  end
-
-  test "delayed_timestamp_peek returns an array of multiple jobs when more than one job is queued" do
-    t = Time.now + 60
-    Resque.enqueue_at(t, SomeIvarJob)
-    Resque.enqueue_at(t, SomeIvarJob)
-    job = {'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}
-    assert_equal([job, job], Resque.delayed_timestamp_peek(t, 0, 2))
-  end
-
-  test "delayed_timestamp_peek only returns an array of one job if only asked for 1" do
-    t = Time.now + 60
-    Resque.enqueue_at(t, SomeIvarJob)
-    Resque.enqueue_at(t, SomeIvarJob)
-    job = {'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}
-    assert_equal([job], Resque.delayed_timestamp_peek(t, 0, 1))
-  end
-
-  test "handle_delayed_items with no items" do
-    Resque::Scheduler.expects(:enqueue).never
-    Resque::Scheduler.handle_delayed_items
-  end
-
-  test "handle_delayed_item with items" do
-    t = Time.now - 60 # in the past
-
-    # 2 SomeIvarJob jobs should be created in the "ivar" queue
-    Resque::Job.expects(:create).twice.with(:ivar, SomeIvarJob)
-    Resque.enqueue_at(t, SomeIvarJob)
-    Resque.enqueue_at(t, SomeIvarJob)
-  end
-
-  test "handle_delayed_items with items in the future" do
-    t = Time.now + 60 # in the future
-    Resque.enqueue_at(t, SomeIvarJob)
-    Resque.enqueue_at(t, SomeIvarJob)
-
-    # 2 SomeIvarJob jobs should be created in the "ivar" queue
-    Resque::Job.expects(:create).twice.with('ivar', SomeIvarJob, nil)
-    Resque::Scheduler.handle_delayed_items(t)
-  end
-
-  test "calls klass#scheduled when enqueuing jobs if it exists" do
-    t = Time.now - 60
-    FakeCustomJobClassEnqueueAt.expects(:scheduled).once.with(:test, FakeCustomJobClassEnqueueAt.to_s, {:foo => "bar"})
-    Resque.enqueue_at(t, FakeCustomJobClassEnqueueAt, :foo => "bar")
-  end
-
-  test "when Resque.inline = true, calls klass#scheduled when enqueuing jobs if it exists" do
-    old_val = Resque.inline
-    begin
-      Resque.inline = true
-      t = Time.now - 60
-      FakeCustomJobClassEnqueueAt.expects(:scheduled).once.with(:test, FakeCustomJobClassEnqueueAt.to_s, {:foo => "bar"})
-      Resque.enqueue_at(t, FakeCustomJobClassEnqueueAt, :foo => "bar")
-    ensure
-      Resque.inline = old_val
-    end
-  end
-
-  test "enqueue_delayed_items_for_timestamp creates jobs and empties the delayed queue" do
-    t = Time.now + 60
-
-    Resque.enqueue_at(t, SomeIvarJob)
-    Resque.enqueue_at(t, SomeIvarJob)
-
-    # 2 SomeIvarJob jobs should be created in the "ivar" queue
-    Resque::Job.expects(:create).twice.with('ivar', SomeIvarJob, nil)
-
-    Resque::Scheduler.enqueue_delayed_items_for_timestamp(t)
-
-    # delayed queue for timestamp should be empty
-    assert_equal(0, Resque.delayed_timestamp_peek(t, 0, 3).length)
-  end
-
-  test "enqueue_delayed creates jobs and empties the delayed queue" do
-    t = Time.now + 60
-
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    Resque.enqueue_at(t, SomeIvarJob, "bar")
-    Resque.enqueue_at(t, SomeIvarJob, "bar")
-
-    # 3 SomeIvarJob jobs should be created in the "ivar" queue
-    Resque::Job.expects(:create).never.with(:ivar, SomeIvarJob, "foo")
-    Resque::Job.expects(:create).twice.with(:ivar, SomeIvarJob, "bar")
-
-    # 2 SomeIvarJob jobs should be enqueued
-    assert_equal(2, Resque.enqueue_delayed(SomeIvarJob, "bar"))
-
-    # delayed queue for timestamp should have one remaining
-    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 3).length)
-  end
-
-  test "handle_delayed_items works with out specifying queue (upgrade case)" do
-    t = Time.now - 60
-    Resque.delayed_push(t, :class => 'SomeIvarJob')
-
-    # Since we didn't specify :queue when calling delayed_push, it will be forced
-    # to load the class to figure out the queue.  This is the upgrade case from 1.0.4
-    # to 1.0.5.
-    Resque::Job.expects(:create).once.with(:ivar, SomeIvarJob, nil)
-
-    Resque::Scheduler.handle_delayed_items
-  end
-
-  test "reset_delayed_queue clears the queue" do
-    t = Time.now + 120
-    4.times { Resque.enqueue_at(t, SomeIvarJob) }
-    4.times { Resque.enqueue_at(Time.now + rand(100), SomeIvarJob) }
-
-    Resque.reset_delayed_queue
-    assert_equal(0, Resque.delayed_queue_schedule_size)
-    assert_equal(0, Resque.redis.keys("timestamps:*").size)
-  end
-
-  test "remove_delayed removes job and returns the count" do
-    t = Time.now + 120
-    encoded_job =  Resque.encode({:class => SomeIvarJob.to_s, :args => [], :queue => Resque.queue_from_class(SomeIvarJob)})
-    Resque.enqueue_at(t, SomeIvarJob)
-
-    assert_equal(1, Resque.remove_delayed(SomeIvarJob))
-    assert_equal(0, Resque.redis.scard("timestamps:#{encoded_job}"))
-  end
-
-  test "scheduled_at returns an array containing job schedule time" do
-    t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob)
-
-    assert_equal([t.to_i], Resque.scheduled_at(SomeIvarJob))
-  end
-
-  test "remove_delayed doesn't remove things it shouldn't" do
-    t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    Resque.enqueue_at(t, SomeIvarJob, "bar")
-    Resque.enqueue_at(t, SomeIvarJob, "bar")
-    Resque.enqueue_at(t, SomeIvarJob, "baz")
-
-    assert_equal(0, Resque.remove_delayed(SomeIvarJob))
-  end
-
-  test "remove_delayed respected param" do
-    t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    Resque.enqueue_at(t, SomeIvarJob, "bar")
-    Resque.enqueue_at(t, SomeIvarJob, "bar")
-    Resque.enqueue_at(t, SomeIvarJob, "baz")
-
-    assert_equal(2, Resque.remove_delayed(SomeIvarJob, "bar"))
-    assert_equal(1, Resque.delayed_queue_schedule_size)
-  end
-
-  test "remove_delayed removes items in different timestamps" do
-    t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    Resque.enqueue_at(t + 1, SomeIvarJob, "bar")
-    Resque.enqueue_at(t + 2, SomeIvarJob, "bar")
-    Resque.enqueue_at(t + 3, SomeIvarJob, "baz")
-
-    assert_equal(2, Resque.remove_delayed(SomeIvarJob, "bar"))
-    assert_equal(2, Resque.count_all_scheduled_jobs)
-  end
-
-  test "remove_delayed_job_from_timestamp removes instances of jobs at a given timestamp" do
-    t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
-    assert_equal 0, Resque.delayed_timestamp_size(t)
-  end
-
-  test "remove_delayed_job_from_timestamp doesn't remove items from other timestamps" do
-    t1 = Time.now + 120
-    t2 = t1 + 1
-    Resque.enqueue_at(t1, SomeIvarJob, "foo")
-    Resque.enqueue_at(t2, SomeIvarJob, "foo")
-    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t2, SomeIvarJob, "foo")
-    assert_equal 1, Resque.delayed_timestamp_size(t1)
-    assert_equal 0, Resque.delayed_timestamp_size(t2)
-  end
-
-  test "remove_delayed_job_from_timestamp removes nothing if there are no matches" do
-    t = Time.now + 120
-    assert_equal 0, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
-  end
-
-  test "remove_delayed_job_from_timestamp only removes items that match args" do
-    t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    Resque.enqueue_at(t, SomeIvarJob, "bar")
-    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
-    assert_equal 1, Resque.delayed_timestamp_size(t)
-  end
-
-  test "remove_delayed_job_from_timestamp returns the number of items removed" do
-    t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
-  end
-
-  test "remove_delayed_job_from_timestamp should cleanup the delayed timestamp list if not jobs are left" do
-    t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    assert_equal 1, Resque.remove_delayed_job_from_timestamp(t, SomeIvarJob, "foo")
-    assert !Resque.redis.exists("delayed:#{t.to_i}")
-    assert Resque.delayed_queue_peek(0, 100).empty?
-  end
-
-  test "invalid job class" do
-    assert_raise Resque::NoClassError do
-      Resque.enqueue_in(10, nil)
-    end
-    assert_raise Resque::NoQueueError do
-      Resque.enqueue_in(10, String) # string serves as invalid Job class
-    end
-  end
-
-  test "inlining jobs with Resque.inline config" do
-    begin
-      Resque.inline = true
-      Resque::Job.expects(:create).once.with(:ivar, SomeIvarJob, "foo", "bar")
-
-      timestamp = Time.now + 120
-      Resque.enqueue_at(timestamp, SomeIvarJob, "foo", "bar")
-
-      assert_equal 0, Resque.count_all_scheduled_jobs
-      assert !Resque.redis.exists("delayed:#{timestamp.to_i}")
-    ensure
-      Resque.inline = false
-    end
-  end
-end

data/test/redis-test.conf

@@ -1,108 +0,0 @@
-# Redis configuration file example
-
-# By default Redis does not run as a daemon. Use 'yes' if you need it.
-# Note that Redis will write a pid file in /var/run/redis.pid when daemonized.
-daemonize yes
-
-# When run as a daemon, Redis write a pid file in /var/run/redis.pid by default.
-# You can specify a custom pid file location here.
-pidfile ./test/redis-test.pid
-
-# Accept connections on the specified port, default is 6379
-port 9736
-
-# If you want you can bind a single interface, if the bind option is not
-# specified all the interfaces will listen for connections.
-#
-# bind 127.0.0.1
-
-# Close the connection after a client is idle for N seconds (0 to disable)
-timeout 300
-
-# Save the DB on disk:
-#
-#   save <seconds> <changes>
-#
-#   Will save the DB if both the given number of seconds and the given
-#   number of write operations against the DB occurred.
-#
-#   In the example below the behaviour will be to save:
-#   after 900 sec (15 min) if at least 1 key changed
-#   after 300 sec (5 min) if at least 10 keys changed
-#   after 60 sec if at least 10000 keys changed
-save 900 1
-save 300 10
-save 60 10000
-
-# The filename where to dump the DB
-dbfilename dump.rdb
-
-# For default save/load DB in/from the working directory
-# Note that you must specify a directory not a file name.
-dir ./test/
-
-# Set server verbosity to 'debug'
-# it can be one of:
-# debug (a lot of information, useful for development/testing)
-# notice (moderately verbose, what you want in production probably)
-# warning (only very important / critical messages are logged)
-loglevel debug
-
-# Specify the log file name. Also 'stdout' can be used to force
-# the demon to log on the standard output. Note that if you use standard
-# output for logging but daemonize, logs will be sent to /dev/null
-logfile stdout
-
-# Set the number of databases. The default database is DB 0, you can select
-# a different one on a per-connection basis using SELECT <dbid> where
-# dbid is a number between 0 and 'databases'-1
-databases 16
-
-################################# REPLICATION #################################
-
-# Master-Slave replication. Use slaveof to make a Redis instance a copy of
-# another Redis server. Note that the configuration is local to the slave
-# so for example it is possible to configure the slave to save the DB with a
-# different interval, or to listen to another port, and so on.
-
-# slaveof <masterip> <masterport>
-
-################################## SECURITY ###################################
-
-# Require clients to issue AUTH <PASSWORD> before processing any other
-# commands.  This might be useful in environments in which you do not trust
-# others with access to the host running redis-server.
-#
-# This should stay commented out for backward compatibility and because most
-# people do not need auth (e.g. they run their own servers).
-
-# requirepass foobared
-
-################################### LIMITS ####################################
-
-# Set the max number of connected clients at the same time. By default there
-# is no limit, and it's up to the number of file descriptors the Redis process
-# is able to open. The special value '0' means no limts.
-# Once the limit is reached Redis will close all the new connections sending
-# an error 'max number of clients reached'.
-
-# maxclients 128
-
-# Don't use more memory than the specified amount of bytes.
-# When the memory limit is reached Redis will try to remove keys with an
-# EXPIRE set. It will try to start freeing keys that are going to expire
-# in little time and preserve keys with a longer time to live.
-# Redis will also try to remove objects from free lists if possible.
-#
-# If all this fails, Redis will start to reply with errors to commands
-# that will use more memory, like SET, LPUSH, and so on, and will continue
-# to reply to most read-only commands like GET.
-#
-# WARNING: maxmemory can be a good idea mainly if you want to use Redis as a
-# 'state' server or cache, not as a real DB. When Redis is used as a real
-# database the memory usage will grow over the weeks, it will be obvious if
-# it is going to use too much memory in the long run, and you'll have the time
-# to upgrade. With maxmemory after the limit is reached you'll start to get
-# errors for write operations, and this may even lead to DB inconsistency.
-
-# maxmemory <bytes>

data/test/resque-web_test.rb

@@ -1,116 +0,0 @@
-require File.dirname(__FILE__) + '/test_helper'
-
-# Pull in the server test_helper from resque
-require 'resque/server/test_helper.rb'
-
-context "on GET to /schedule" do
-  setup { get "/schedule" }
-
-  should_respond_with_success
-end
-
-context "on GET to /schedule with scheduled jobs" do
-  setup do
-    ENV['rails_env'] = 'production'
-    Resque.schedule = {'some_ivar_job' => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'},
-                       'some_other_job' => {'every' => ['5m'], 'queue' => 'high', 'class' => 'SomeOtherJob', 'args' => {'b' => 'blah'}}}
-    Resque::Scheduler.load_schedule!
-    get "/schedule"
-  end
-
-  should_respond_with_success
-
-  test 'see the scheduled job' do
-    assert last_response.body.include?('SomeIvarJob')
-  end
-end
-
-context "on GET to /delayed" do
-  setup { get "/delayed" }
-
-  should_respond_with_success
-end
-
-def resque_schedule
-  {
-    'job_without_params' => {
-      'cron' => "* * * * *",
-      'class' => 'JobWithoutParams',
-      'args' => {"host" => 'localhost'},
-      'rails_env' => 'production'},
-    'job_with_params' => {
-      'cron' => "* * * * *",
-      'class' => 'JobWithParams',
-      'args' => {"host" => 'localhost'},
-      'parameters' => {
-        'log_level' => {
-          'description' => 'The level of logging',
-          'default' => 'warn'
-        }
-      }
-    }
-  }
-end
-
-context "POST /schedule/requeue" do
-  setup do
-    Resque.schedule = 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 = 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