resque-scheduler 2.5.5 → 3.0.0

data/script/migrate_to_timestamps_set.rb

@@ -1,14 +1,16 @@
+# vim:fileencoding=utf-8
+
 require 'redis'
 require 'resque'
 
 if ARGV.size != 1
-  puts "migrate_to_timestamps_set.rb <redis-host:redis-port>"
+  puts 'migrate_to_timestamps_set.rb <redis-host:redis-port>'
   exit
 end
 
 Resque.redis = ARGV[0]
 redis = Resque.redis
-Array(redis.keys("delayed:*")).each do |key|
+Array(redis.keys('delayed:*')).each do |key|
   jobs = redis.lrange(key, 0, -1)
-  jobs.each {|job| redis.sadd("timestamps:#{job}", key)}
+  jobs.each { |job| redis.sadd("timestamps:#{job}", key) }
 end

data/tasks/resque_scheduler.rake

@@ -1,2 +1,2 @@
 $LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
-require 'resque_scheduler/tasks'
+require 'resque/scheduler/tasks'

data/test/cli_test.rb

@@ -1,8 +1,15 @@
+# vim:fileencoding=utf-8
 require_relative 'test_helper'
 
 context 'Cli' do
+  def mock_runtime_env
+    mock.tap { |m| m.stubs(:setup) }
+  end
+
   def new_cli(argv = [], env = {})
-    ResqueScheduler::Cli.new(argv, env)
+    Resque::Scheduler::Cli.new(argv, env).tap do |cli|
+      cli.stubs(:runtime_env).returns(mock_runtime_env)
+    end
   end
 
   test 'does not require any positional arguments' do
@@ -10,7 +17,7 @@ context 'Cli' do
   end
 
   test 'initializes verbose from the env' do
-    cli = new_cli([], { 'VERBOSE' => 'foo' })
+    cli = new_cli([], 'VERBOSE' => 'foo')
     assert_equal('foo', cli.send(:options)[:verbose])
   end
 
@@ -31,7 +38,7 @@ context 'Cli' do
   end
 
   test 'initializes background from the env' do
-    cli = new_cli([], { 'BACKGROUND' => '1' })
+    cli = new_cli([], 'BACKGROUND' => '1')
     assert_equal('1', cli.send(:options)[:background])
   end
 
@@ -51,33 +58,8 @@ context 'Cli' do
     assert_equal(true, cli.send(:options)[:background])
   end
 
-  test 'daemonizes when background is true' do
-    Process.expects(:daemon)
-    cli = new_cli(%w(--background))
-    cli.pre_run
-  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)
-    cli = new_cli(%w(--background))
-    cli.pre_run
-  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)
-    cli = new_cli(%w(--background))
-    cli.expects(:abort)
-    cli.pre_run
-  end
-
   test 'initializes pidfile from the env' do
-    cli = new_cli([], { 'PIDFILE' => 'bar' })
+    cli = new_cli([], 'PIDFILE' => 'bar')
     assert_equal('bar', cli.send(:options)[:pidfile])
   end
 
@@ -97,20 +79,12 @@ context 'Cli' do
     assert_equal('foo', cli.send(:options)[:pidfile])
   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)
-    cli = new_cli(%w(--pidfile derp.pid))
-    cli.pre_run
-  end
-
   test 'defaults to nil dynamic' do
     assert_equal(nil, new_cli.send(:options)[:dynamic])
   end
 
   test 'initializes env from the env' do
-    cli = new_cli([], { 'RAILS_ENV' => 'flurb' })
+    cli = new_cli([], 'RAILS_ENV' => 'flurb')
     assert_equal('flurb', cli.send(:options)[:env])
   end
 
@@ -131,7 +105,7 @@ context 'Cli' do
   end
 
   test 'initializes initializer_path from the env' do
-    cli = new_cli([], { 'INITIALIZER_PATH' => 'herp.rb' })
+    cli = new_cli([], 'INITIALIZER_PATH' => 'herp.rb')
     assert_equal('herp.rb', cli.send(:options)[:initializer_path])
   end
 
@@ -157,29 +131,29 @@ context 'Cli' do
     cli.pre_run
   end
 
-  test 'initializes mute/quiet from the env' do
-    cli = new_cli([], { 'QUIET' => '1' })
-    assert_equal('1', cli.send(:options)[:mute])
+  test 'initializes quiet from the env' do
+    cli = new_cli([], 'QUIET' => '1')
+    assert_equal('1', cli.send(:options)[:quiet])
   end
 
-  test 'defaults to unmuted' do
-    assert_equal(false, !!new_cli.send(:options)[:mute])
+  test 'defaults to un-quieted' do
+    assert_equal(false, !!new_cli.send(:options)[:quiet])
   end
 
-  test 'accepts mute/quiet via -q' do
+  test 'accepts quiet via -q' do
     cli = new_cli(%w(-q))
     cli.parse_options
-    assert_equal(true, cli.send(:options)[:mute])
+    assert_equal(true, cli.send(:options)[:quiet])
   end
 
-  test 'accepts mute via --quiet' do
+  test 'accepts quiet via --quiet' do
     cli = new_cli(%w(--quiet))
     cli.parse_options
-    assert_equal(true, cli.send(:options)[:mute])
+    assert_equal(true, cli.send(:options)[:quiet])
   end
 
   test 'initializes logfile from the env' do
-    cli = new_cli([], { 'LOGFILE' => 'derp.log' })
+    cli = new_cli([], 'LOGFILE' => 'derp.log')
     assert_equal('derp.log', cli.send(:options)[:logfile])
   end
 
@@ -200,7 +174,7 @@ context 'Cli' do
   end
 
   test 'initializes logformat from the env' do
-    cli = new_cli([], { 'LOGFORMAT' => 'fancy' })
+    cli = new_cli([], 'LOGFORMAT' => 'fancy')
     assert_equal('fancy', cli.send(:options)[:logformat])
   end
 
@@ -220,29 +194,12 @@ context 'Cli' do
     assert_equal('flimsy', cli.send(:options)[:logformat])
   end
 
-  test 'initializes dynamic from the env' do
-    cli = new_cli([], { 'DYNAMIC_SCHEDULE' => '1' })
-    assert_equal('1', cli.send(:options)[:dynamic])
-  end
-
   test 'defaults to dynamic=false' do
     assert_equal(false, !!new_cli.send(:options)[:dynamic])
   end
 
-  test 'accepts dynamic via -D' do
-    cli = new_cli(%w(-D))
-    cli.parse_options
-    assert_equal(true, cli.send(:options)[:dynamic])
-  end
-
-  test 'accepts dynamic via --dynamic-schedule' do
-    cli = new_cli(%w(--dynamic-schedule))
-    cli.parse_options
-    assert_equal(true, cli.send(:options)[:dynamic])
-  end
-
   test 'initializes app_name from the env' do
-    cli = new_cli([], { 'APP_NAME' => 'sprocket' })
+    cli = new_cli([], 'APP_NAME' => 'sprocket')
     assert_equal('sprocket', cli.send(:options)[:app_name])
   end
 
@@ -264,6 +221,6 @@ context 'Cli' do
 
   test 'runs Resque::Scheduler' do
     Resque::Scheduler.expects(:run)
-    ResqueScheduler::Cli.run!([], {})
+    Resque::Scheduler::Cli.run!([], {})
   end
 end

data/test/delayed_queue_test.rb

@@ -1,179 +1,231 @@
+# vim:fileencoding=utf-8
 require_relative 'test_helper'
 
-context "DelayedQueue" do
-
+context 'DelayedQueue' do
   setup do
-    Resque::Scheduler.mute = true
+    Resque::Scheduler.quiet = true
     Resque.redis.flushall
   end
 
-  test "enqueue_at adds correct list and zset" do
+  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))
+    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")
+    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")
+    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")
+    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('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")
+    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
+  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')
+    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")
+    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")
+    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")
+    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")
+    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")
+    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))
+    timestamp = Time.now + 600
+    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")
+    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")
+    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")
+    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")
+    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
+  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")
+    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")
+    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
+  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))
+    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")
+    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")
+    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))
+  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
+  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'})
+      Resque.delayed_push(timestamp, class: SomeIvarJob, args: 'blah1 ')
     end
 
-    timestamps = Resque.delayed_queue_peek(1,2)
+    timestamps = Resque.delayed_queue_peek(1, 2)
 
-    assert_equal(expected_timestamps[1,2], timestamps)
+    assert_equal(expected_timestamps[1, 2], timestamps)
   end
 
-  test "delayed_queue_schedule_size returns correct size" do
+  test 'delayed_queue_schedule_size returns correct size' do
     assert_equal(0, Resque.delayed_queue_schedule_size)
-    Resque.enqueue_at(Time.now+60, SomeIvarJob)
+    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
+  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
+  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
+  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")
+    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
+  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)
+    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
+  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'}
+    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
+  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'}
+    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
+  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
+  test 'handle_delayed_item with items' do
     t = Time.now - 60 # in the past
 
     # 2 SomeIvarJob jobs should be created in the "ivar" queue
@@ -182,7 +234,7 @@ context "DelayedQueue" do
     Resque.enqueue_at(t, SomeIvarJob)
   end
 
-  test "handle_delayed_items with items in the future" do
+  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)
@@ -192,25 +244,29 @@ context "DelayedQueue" do
     Resque::Scheduler.handle_delayed_items(t)
   end
 
-  test "calls klass#scheduled when enqueuing jobs if it exists" do
+  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")
+    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
+  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")
+      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
+  test 'enqueue_delayed_items_for_timestamp creates jobs ' \
+       'and empties the delayed queue' do
     t = Time.now + 60
 
     Resque.enqueue_at(t, SomeIvarJob)
@@ -225,56 +281,61 @@ context "DelayedQueue" do
     assert_equal(0, Resque.delayed_timestamp_peek(t, 0, 3).length)
   end
 
-  test "enqueue_delayed creates jobs and empties the delayed queue" do
+  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")
+    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")
+    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"))
+    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
+  test 'handle_delayed_items works with out specifying queue ' \
+       '(upgrade case)' do
     t = Time.now - 60
-    Resque.delayed_push(t, :class => 'SomeIvarJob')
+    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.
+    # 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
+  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)
+    assert_equal(0, Resque.redis.keys('timestamps:*').size)
   end
 
-  test "remove_delayed removes job and returns the count" do
+  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))
+    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
+  test 'scheduled_at returns an array containing job schedule time' do
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob)
 
@@ -283,162 +344,184 @@ context "DelayedQueue" do
 
   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")
+    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
+  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")
+    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(2, Resque.remove_delayed(SomeIvarJob, 'bar'))
     assert_equal(1, Resque.delayed_queue_schedule_size)
   end
 
-  test "remove_delayed removes items in different timestamps" do
+  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")
+    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.remove_delayed(SomeIvarJob, 'bar'))
     assert_equal(2, Resque.count_all_scheduled_jobs)
   end
 
-  test "remove_delayed_selection removes multiple items matching arguments at same timestamp" do
+  test 'remove_delayed_selection removes multiple items matching ' \
+       'arguments at same timestamp' do
     t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, "bar", "llama")
-    Resque.enqueue_at(t, SomeIvarJob, "foo")
-    Resque.enqueue_at(t, SomeIvarJob, "bar", "monkey")
-    Resque.enqueue_at(t, SomeIvarJob, "bar", "platypus")
-    Resque.enqueue_at(t, SomeIvarJob, "baz")
-    Resque.enqueue_at(t, SomeIvarJob, "bar", "llama")
-    Resque.enqueue_at(t, SomeIvarJob, "bar", "llama")
-
-    assert_equal(5, Resque.remove_delayed_selection {|args| args[0] == 'bar'})
+    Resque.enqueue_at(t, SomeIvarJob, 'bar', 'llama')
+    Resque.enqueue_at(t, SomeIvarJob, 'foo')
+    Resque.enqueue_at(t, SomeIvarJob, 'bar', 'monkey')
+    Resque.enqueue_at(t, SomeIvarJob, 'bar', 'platypus')
+    Resque.enqueue_at(t, SomeIvarJob, 'baz')
+    Resque.enqueue_at(t, SomeIvarJob, 'bar', 'llama')
+    Resque.enqueue_at(t, SomeIvarJob, 'bar', 'llama')
+
+    assert_equal(5, Resque.remove_delayed_selection { |a| a.first == 'bar' })
     assert_equal(2, Resque.count_all_scheduled_jobs)
   end
 
-  test "remove_delayed_selection removes single item matching arguments" do
+  test 'remove_delayed_selection removes single item matching arguments' 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")
+    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(1, Resque.remove_delayed_selection {|args| args[0] == 'foo'})
+    assert_equal(1, Resque.remove_delayed_selection { |a| a.first == 'foo' })
     assert_equal(3, Resque.count_all_scheduled_jobs)
   end
 
-  test "remove_delayed_selection removes multiple items matching arguments" do
+  test 'remove_delayed_selection removes multiple items matching arguments' 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")
+    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_selection {|args| args[0] == 'bar'})
+    assert_equal(2, Resque.remove_delayed_selection { |a| a.first == 'bar' })
     assert_equal(2, Resque.count_all_scheduled_jobs)
   end
 
-  test "remove_delayed_selection removes multiple items matching arguments as hash" do
+  test 'remove_delayed_selection removes multiple items matching ' \
+       'arguments as hash' do
     t = Time.now + 120
-    Resque.enqueue_at(t, SomeIvarJob, :foo => "foo")
-    Resque.enqueue_at(t + 1, SomeIvarJob, :foo => "bar")
-    Resque.enqueue_at(t + 2, SomeIvarJob, :foo => "bar")
-    Resque.enqueue_at(t + 3, SomeIvarJob, :foo => "baz")
-
-    assert_equal(2, Resque.remove_delayed_selection {|args| args[0]['foo'] == 'bar'})
+    Resque.enqueue_at(t, SomeIvarJob, foo: 'foo')
+    Resque.enqueue_at(t + 1, SomeIvarJob, foo: 'bar')
+    Resque.enqueue_at(t + 2, SomeIvarJob, foo: 'bar')
+    Resque.enqueue_at(t + 3, SomeIvarJob, foo: 'baz')
+
+    assert_equal(
+      2, Resque.remove_delayed_selection { |a| a.first['foo'] == 'bar' }
+    )
     assert_equal(2, Resque.count_all_scheduled_jobs)
   end
 
-  test "remove_delayed_selection ignores jobs with no arguments" do
+  test 'remove_delayed_selection ignores jobs with no arguments' do
     t = Time.now + 120
     Resque.enqueue_at(t, SomeIvarJob)
     Resque.enqueue_at(t + 1, SomeIvarJob)
     Resque.enqueue_at(t + 2, SomeIvarJob)
     Resque.enqueue_at(t + 3, SomeIvarJob)
 
-    assert_equal(0, Resque.remove_delayed_selection {|args| args[0] == 'bar'})
+    assert_equal(0, Resque.remove_delayed_selection { |a| a.first == 'bar' })
     assert_equal(4, Resque.count_all_scheduled_jobs)
   end
 
   test "remove_delayed_selection doesn't remove items it shouldn't" 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")
+    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(0, Resque.remove_delayed_selection {|args| args[0] == 'qux'})
+    assert_equal(0, Resque.remove_delayed_selection { |a| a.first == 'qux' })
     assert_equal(4, Resque.count_all_scheduled_jobs)
   end
 
-  test "remove_delayed_job_from_timestamp removes instances of jobs at a given timestamp" do
+  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")
+    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
+  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")
+    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
+  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")
+    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
+  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")
+    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
+  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")
+    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
+  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")
+    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::NoQueueError do
-      Resque.enqueue_in(10, String) # string serves as invalid Job class
+  test 'invalid job class' do
+    assert_raises Resque::NoQueueError do
+      Resque.enqueue_in(10, String)
     end
   end
 
-  test "inlining jobs with Resque.inline config" do
+  test 'inlining jobs with Resque.inline config' do
     begin
       Resque.inline = true
-      Resque::Job.expects(:create).once.with(:ivar, SomeIvarJob, "foo", "bar")
+      Resque::Job.expects(:create).once.with(:ivar, SomeIvarJob, 'foo', 'bar')
 
       timestamp = Time.now + 120
-      Resque.enqueue_at(timestamp, SomeIvarJob, "foo", "bar")
+      Resque.enqueue_at(timestamp, SomeIvarJob, 'foo', 'bar')
 
       assert_equal 0, Resque.count_all_scheduled_jobs
       assert !Resque.redis.exists("delayed:#{timestamp.to_i}")
@@ -446,4 +529,14 @@ context "DelayedQueue" do
       Resque.inline = false
     end
   end
+
+  test 'delayed?' do
+    Resque.enqueue_at Time.now + 1, SomeIvarJob
+    Resque.enqueue_at Time.now + 1, SomeIvarJob, id: 1
+
+    assert Resque.delayed?(SomeIvarJob, id: 1)
+    assert !Resque.delayed?(SomeIvarJob, id: 2)
+    assert Resque.delayed?(SomeIvarJob)
+    assert !Resque.delayed?(SomeJob)
+  end
 end