nogara-resque-scheduler 2.0.1

data/lib/resque_scheduler/plugin.rb

@@ -0,0 +1,25 @@
+module ResqueScheduler
+  module Plugin
+    extend self
+    def hooks(job, pattern)
+      job.methods.grep(/^#{pattern}/).sort
+    end
+
+    def run_hooks(job, pattern, *args)
+      results = hooks(job, pattern).collect do |hook|
+        job.send(hook, *args)
+      end
+
+      results.all? { |result| result != false }
+    end
+
+    def method_missing(method_name, *args, &block)
+      if method_name.to_s =~ /^run_(.*)_hooks$/
+        job = args.shift
+        run_hooks job, $1, *args
+      else
+        super
+      end
+    end
+  end
+end

data/lib/resque_scheduler/server.rb

@@ -0,0 +1,69 @@
+require 'resque_scheduler'
+require 'resque/server'
+
+# Extend Resque::Server to add tabs
+module ResqueScheduler
+
+  module Server
+
+    def self.included(base)
+
+      base.class_eval do
+
+        helpers do
+          def format_time(t)
+            t.strftime("%Y-%m-%d %H:%M:%S %z")
+          end
+
+          def queue_from_class_name(class_name)
+            Resque.queue_from_class(Resque.constantize(class_name))
+          end
+        end
+
+        get "/schedule" do
+          Resque.reload_schedule! if Resque::Scheduler.dynamic
+          # Is there a better way to specify alternate template locations with sinatra?
+          erb File.read(File.join(File.dirname(__FILE__), 'server/views/scheduler.erb'))
+        end
+
+        post "/schedule/requeue" do
+          config = Resque.schedule[params['job_name']]
+          Resque::Scheduler.enqueue_from_config(config)
+          redirect u("/overview")
+        end
+
+        get "/delayed" do
+          # Is there a better way to specify alternate template locations with sinatra?
+          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed.erb'))
+        end
+
+        get "/delayed/:timestamp" do
+          # Is there a better way to specify alternate template locations with sinatra?
+          erb File.read(File.join(File.dirname(__FILE__), 'server/views/delayed_timestamp.erb'))
+        end
+
+        post "/delayed/queue_now" do
+          timestamp = params['timestamp']
+          Resque::Scheduler.enqueue_delayed_items_for_timestamp(timestamp.to_i) if timestamp.to_i > 0
+          redirect u("/overview")
+        end
+
+        post "/delayed/clear" do
+          Resque.reset_delayed_queue
+          redirect u('delayed')
+        end
+
+      end
+
+    end
+
+    Resque::Server.tabs << 'Schedule'
+    Resque::Server.tabs << 'Delayed'
+
+  end
+
+end
+
+Resque::Server.class_eval do
+  include ResqueScheduler::Server
+end

data/lib/resque_scheduler/server/views/delayed.erb

@@ -0,0 +1,48 @@
+<h1>Delayed Jobs</h1>
+<%- size = resque.delayed_queue_schedule_size %>
+<% if size > 0 %>
+  <form method="POST" action="<%=u 'delayed/clear'%>" class='clear-delayed'>
+    <input type='submit' name='' value='Clear Delayed Jobs' />
+  </form>
+<% end %>
+
+<p class='intro'>
+  This list below contains the timestamps for scheduled delayed jobs.
+</p>
+
+<p class='sub'>
+  Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%= size %></b> timestamps
+</p>
+
+<table>
+  <tr>
+    <th></th>
+    <th>Timestamp</th>
+    <th>Job count</th>
+    <th>Class</th>
+    <th>Args</th>
+  </tr>
+  <% resque.delayed_queue_peek(start, 20).each do |timestamp| %>
+    <tr>
+      <td>
+        <form action="<%= u "/delayed/queue_now" %>" method="post">
+          <input type="hidden" name="timestamp" value="<%= timestamp.to_i %>">
+          <input type="submit" value="Queue now">
+        </form>
+      </td>
+      <td><a href="<%= u "delayed/#{timestamp}" %>"><%= format_time(Time.at(timestamp)) %></a></td>
+      <td><%= delayed_timestamp_size = resque.delayed_timestamp_size(timestamp) %></td>
+      <% job = resque.delayed_timestamp_peek(timestamp, 0, 1).first %>
+      <td>
+        <% if job && delayed_timestamp_size == 1 %>
+          <%= h(job['class']) %>
+        <% else %>
+          <a href="<%= u "delayed/#{timestamp}" %>">see details</a>
+        <% end %>
+      </td>
+      <td><%= h(job['args'].inspect) if job && delayed_timestamp_size == 1 %></td>
+    </tr>
+  <% end %>
+</table>
+
+<%= partial :next_more, :start => start, :size => size %>

data/lib/resque_scheduler/server/views/delayed_timestamp.erb

@@ -0,0 +1,26 @@
+<% timestamp = params[:timestamp].to_i %>
+
+<h1>Delayed jobs scheduled for <%= format_time(Time.at(timestamp)) %></h1>
+
+<p class='sub'>Showing <%= start = params[:start].to_i %> to <%= start + 20 %> of <b><%=size = resque.delayed_timestamp_size(timestamp)%></b> jobs</p>
+
+<table class='jobs'>
+  <tr>
+    <th>Class</th>
+    <th>Args</th>
+  </tr>
+  <% jobs = resque.delayed_timestamp_peek(timestamp, start, 20) %>
+  <% jobs.each do |job| %>
+    <tr>
+      <td class='class'><%= job['class'] %></td>
+      <td class='args'><%=h job['args'].inspect %></td>
+    </tr>
+  <% end %>
+  <% if jobs.empty? %>
+    <tr>
+      <td class='no-data' colspan='2'>There are no pending jobs scheduled for this time.</td>
+    </tr>
+  <% end %>
+</table>
+
+<%= partial :next_more, :start => start, :size => size %>

data/lib/resque_scheduler/server/views/scheduler.erb

@@ -0,0 +1,43 @@
+<h1>Schedule</h1>
+
+<p class='intro'>
+  The list below contains all scheduled jobs.  Click &quot;Queue now&quot; to queue
+  a job immediately.
+</p>
+
+<table>
+  <tr>
+    <th></th>
+    <th>Name</th>
+    <th>Description</th>
+    <th>Interval</th>
+    <th>Class</th>
+    <th>Queue</th>
+    <th>Arguments</th>
+  </tr>
+  <% Resque.schedule.keys.sort.each do |name| %>
+    <% config = Resque.schedule[name] %>
+    <tr>
+      <td>
+        <form action="<%= u "/schedule/requeue" %>" method="post">
+          <input type="hidden" name="job_name" value="<%= h name %>">
+          <input type="submit" value="Queue now">
+        </form>
+      </td>
+      <td><%= h name %></td>
+      <td><%= h config['description'] %></td>
+      <td style="white-space:nowrap"><%= if !config['every'].nil? 
+                                           h('every: ' + config['every'])
+                                         elsif !config['cron'].nil?
+                                           h('cron: ' + config['cron']) 
+                                         else
+                                           'Not currently scheduled'
+                                         end %></td>
+      <td><%= (config['class'].nil? && !config['custom_job_class'].nil?) ?
+              h(config['custom_job_class']) :
+              h(config['class']) %></td>
+      <td><%= h config['queue'] || queue_from_class_name(config['class']) %></td>
+      <td><%= h config['args'].inspect %></td>
+    </tr>
+  <% end %>
+</table>

data/lib/resque_scheduler/tasks.rb

@@ -0,0 +1,34 @@
+require 'resque/tasks'
+# will give you the resque tasks
+
+namespace :resque do
+  task :setup
+
+  desc "Start Resque Scheduler"
+  task :scheduler => :scheduler_setup do
+    require 'resque'
+    require 'resque_scheduler'
+
+    if ENV['BACKGROUND']
+      unless Process.respond_to?('daemon')
+        abort "env var BACKGROUND is set, which requires ruby >= 1.9"
+      end
+      Process.daemon(true)
+    end
+
+    File.open(ENV['PIDFILE'], 'w') { |f| f << Process.pid.to_s } if ENV['PIDFILE']
+
+    Resque::Scheduler.dynamic = true if ENV['DYNAMIC_SCHEDULE']
+    Resque::Scheduler.verbose = true if ENV['VERBOSE']
+    Resque::Scheduler.run
+  end
+
+  task :scheduler_setup do
+    if ENV['INITIALIZER_PATH']
+      load ENV['INITIALIZER_PATH'].to_s.strip
+    else
+      Rake::Task['resque:setup'].invoke
+    end
+  end
+
+end

data/lib/resque_scheduler/version.rb

@@ -0,0 +1,3 @@
+module ResqueScheduler
+  VERSION = '2.0.1'
+end

data/resque-scheduler.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.unshift File.expand_path("../lib", __FILE__)
+require "resque_scheduler/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nogara-resque-scheduler"
+  s.version     = ResqueScheduler::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ['Ben VandenBos']
+  s.email       = ['bvandenbos@gmail.com']
+  s.homepage    = "http://github.com/bvandenbos/resque-scheduler"
+  s.summary     = "Light weight job scheduling on top of Resque"
+  s.description = %q{Light weight job scheduling on top of Resque.
+    Adds methods enqueue_at/enqueue_in to schedule jobs in the future.
+    Also supports queueing jobs on a fixed, cron-like schedule.}
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.add_development_dependency "bundler", ">= 1.0.0"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+
+  s.add_runtime_dependency(%q<redis>, [">= 2.0.1"])
+  s.add_runtime_dependency(%q<resque>, [">= 1.20.0"])
+  s.add_runtime_dependency(%q<rufus-scheduler>, [">= 0"])
+end

data/tasks/resque_scheduler.rake

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

data/test/delayed_queue_test.rb

@@ -0,0 +1,329 @@
+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 # 1 second ago (in the past, should come out right away)
+
+    assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue 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.zcard(:delayed_queue_schedule), "The delayed_queue_schedule should have 1 entry now")
+
+    read_timestamp = Resque.next_delayed_timestamp
+
+    # Confirm the timestamp came out correctly
+    assert_equal(timestamp.to_i, read_timestamp, "The timestamp we pull out of redis should match the one we put in")
+    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")
+  end
+
+  test "enqueue_at with queue adds correct list and zset and queue" do
+    timestamp = Time.now - 1 # 1 second ago (in the past, should come out right away)
+
+    assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue 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.zcard(:delayed_queue_schedule), "The delayed_queue_schedule should have 1 entry now")
+
+    read_timestamp = Resque.next_delayed_timestamp
+
+    # Confirm the timestamp came out correctly
+    assert_equal(timestamp.to_i, read_timestamp, "The timestamp we pull out of redis should match the one we put in")
+    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")
+  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)
+
+    assert_equal(0, Resque.redis.llen("delayed:#{timestamp.to_i}").to_i, "delayed queue 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.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
+
+    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")
+  end
+
+  test "empty delayed_queue_peek returns empty array" do
+    assert_equal([], Resque.delayed_queue_peek(0,20))
+  end
+
+  test "delqyed_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
+    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
+  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 "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 "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)
+  end
+
+  test "remove_delayed removes job and returns the count" do
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob)
+
+    assert_equal(1, Resque.remove_delayed(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