nulogy-resque-scheduler 1.10.15

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,220 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Resque::DelayedQueueTest < Test::Unit::TestCase
+
+  def setup
+    Resque::Scheduler.mute = true
+    Resque.redis.flushall
+  end
+
+  def test_enqueue_at_adds_correct_list_and_zset
+
+    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
+
+  def test_something_in_the_future_doesnt_come_out
+    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
+
+  def test_something_in_the_future_comes_out_if_you_want_it_to
+    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
+
+  def test_enqueue_at_and_enqueue_in_are_equivelent
+    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
+
+  def test_empty_delayed_queue_peek
+    assert_equal([], Resque.delayed_queue_peek(0,20))
+  end
+
+  def test_delayed_queue_peek
+    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(2,3)
+
+    assert_equal(expected_timestamps[2,3], timestamps)
+  end
+
+  def test_delayed_queue_schedule_size
+    assert_equal(0, Resque.delayed_queue_schedule_size)
+    Resque.enqueue_at(Time.now+60, SomeIvarJob)
+    assert_equal(1, Resque.delayed_queue_schedule_size)
+  end
+
+  def test_delayed_timestamp_size
+    t = Time.now + 60
+    assert_equal(0, Resque.delayed_timestamp_size(t))
+    Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal(1, Resque.delayed_timestamp_size(t))
+    assert_equal(0, Resque.delayed_timestamp_size(t.to_i+1))
+  end
+
+  def test_delayed_timestamp_peek
+    t = Time.now + 60
+    assert_equal([], Resque.delayed_timestamp_peek(t, 0, 1), "make sure it's an empty array, not nil")
+    Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 1).length)
+    Resque.enqueue_at(t, SomeIvarJob)
+    assert_equal(1, Resque.delayed_timestamp_peek(t, 0, 1).length)
+    assert_equal(2, Resque.delayed_timestamp_peek(t, 0, 3).length)
+
+    assert_equal({'args' => [], 'class' => 'SomeIvarJob', 'queue' => 'ivar'}, Resque.delayed_timestamp_peek(t, 0, 1).first)
+  end
+
+  def test_handle_delayed_items_with_no_items
+    Resque::Scheduler.expects(:enqueue).never
+    Resque::Scheduler.handle_delayed_items
+  end
+
+  def test_handle_delayed_items_with_items
+    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.expects(:queue_from_class).never # Should NOT need to load the class
+    Resque::Scheduler.handle_delayed_items
+  end
+
+  def test_handle_delayed_items_with_items_in_the_future
+    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.expects(:queue_from_class).never # Should NOT need to load the class
+    Resque::Scheduler.handle_delayed_items(t)
+  end
+  
+  def test_enqueue_delayed_items_for_timestamp
+    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.expects(:queue_from_class).never # Should NOT need to load the class
+
+    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
+
+  def test_works_with_out_specifying_queue__upgrade_case
+    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
+
+  def test_clearing_delayed_queue
+    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
+
+  def test_remove_specific_item
+    t = Time.now + 120
+    Resque.enqueue_at(t, SomeIvarJob)
+
+    assert_equal(1, Resque.remove_delayed(SomeIvarJob))
+  end
+
+  def test_remove_bogus_item_leaves_the_rest_alone
+    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
+
+  def test_remove_specific_item_in_group_of_other_items_at_same_timestamp
+    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
+  
+  def test_remove_specific_item_in_group_of_other_items_at_different_timestamps
+    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
+end

data/test/redis-test.conf

@@ -0,0 +1,115 @@
+# 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>
+
+############################### ADVANCED CONFIG ###############################
+
+# Glue small output buffers together in order to send small replies in a
+# single TCP packet. Uses a bit more CPU but most of the times it is a win
+# in terms of number of queries per second. Use 'yes' if unsure.
+glueoutputbuf yes

data/test/resque-web_test.rb

@@ -0,0 +1,31 @@
+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'}}
+    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

data/test/scheduler_test.rb

@@ -0,0 +1,257 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+class Resque::SchedulerTest < Test::Unit::TestCase
+
+  class FakeJob
+    def self.scheduled(queue, klass, *args); end
+  end
+
+  def setup
+    Resque::Scheduler.dynamic = false
+    Resque.redis.del(:schedules)
+    Resque.redis.del(:schedules_changed)
+    Resque::Scheduler.mute = true
+    Resque::Scheduler.clear_schedule!
+    Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
+  end
+
+  def test_enqueue_from_config_with_every_syntax
+    Resque::Job.stubs(:create).once.returns(true).with('james_queue', SomeIvarJob, '/tmp')
+    Resque::Scheduler.enqueue_from_config('every' => '1m', 'class' => 'SomeIvarJob', 'args' => '/tmp', 'queue' => 'james_queue')
+  end
+
+  def test_enqueue_from_config_puts_stuff_in_the_resque_queue
+    Resque::Job.stubs(:create).once.returns(true).with(:ivar, SomeIvarJob, '/tmp')
+    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp")
+  end
+  
+  def test_enqueue_from_config_with_custom_class_job_in_the_resque_queue
+    FakeJob.stubs(:scheduled).once.returns(true).with(:ivar, 'SomeIvarJob', '/tmp')
+    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'custom_job_class' => 'Resque::SchedulerTest::FakeJob', 'args' => "/tmp")
+  end
+
+  def test_enqueue_from_config_puts_stuff_in_the_resque_queue_when_env_match
+    # The job should be loaded : its rails_env config matches the RAILS_ENV variable:
+    ENV['RAILS_ENV'] = 'production'
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+
+    # we allow multiple rails_env definition, it should work also:
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging, production'}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(2, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+  end
+
+  def test_enqueue_from_config_dont_puts_stuff_in_the_resque_queue_when_env_doesnt_match
+    # RAILS_ENV is not set:
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging'}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+
+    # SET RAILS_ENV to a common value:
+    ENV['RAILS_ENV'] = 'production'
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'staging'}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+  end
+
+  def test_enqueue_from_config_when_rails_env_arg_is_not_set
+    # The job should be loaded, since a missing rails_env means ALL envs.
+    ENV['RAILS_ENV'] = 'production'
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
+    Resque::Scheduler.load_schedule!
+    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+  end
+
+  def test_config_makes_it_into_the_rufus_scheduler
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
+    Resque::Scheduler.load_schedule!
+
+    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    assert Resque::Scheduler.scheduled_jobs.include?(:some_ivar_job)
+  end
+  
+  def test_can_reload_schedule
+    Resque::Scheduler.dynamic = true
+    Resque.schedule = {"some_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
+  
+    Resque::Scheduler.load_schedule!
+
+    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    assert Resque::Scheduler.scheduled_jobs.include?("some_ivar_job")
+    
+    Resque.redis.del(:schedules)
+    Resque.redis.hset(:schedules, "some_ivar_job2", Resque.encode(
+      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"}
+    ))
+    
+    Resque::Scheduler.reload_schedule!
+    
+    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    
+    assert_equal '/tmp/2', Resque.schedule["some_ivar_job2"]["args"]
+    assert Resque::Scheduler.scheduled_jobs.include?("some_ivar_job2")
+  end
+  
+  def test_load_schedule_job
+    Resque::Scheduler.load_schedule_job("some_ivar_job", {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"})
+    
+    assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    assert_equal(1, Resque::Scheduler.scheduled_jobs.size)
+    assert Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
+  end
+  
+  def test_load_schedule_job_with_no_cron
+    Resque::Scheduler.load_schedule_job("some_ivar_job", {'class' => 'SomeIvarJob', 'args' => "/tmp"})
+    
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    assert_equal(0, Resque::Scheduler.scheduled_jobs.size)
+    assert !Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
+  end
+  
+  def test_load_schedule_job_with_blank_cron
+    Resque::Scheduler.load_schedule_job("some_ivar_job", {'cron' => '', 'class' => 'SomeIvarJob', 'args' => "/tmp"})
+    
+    assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    assert_equal(0, Resque::Scheduler.scheduled_jobs.size)
+    assert !Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
+  end
+  
+  def test_update_schedule
+    Resque::Scheduler.dynamic = true
+    Resque.schedule = {
+      "some_ivar_job"    => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"},
+      "another_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/5"},
+      "stay_put_job"     => {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp"}
+    }
+    
+    Resque::Scheduler.load_schedule!
+    
+    Resque.set_schedule("some_ivar_job",
+      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"}
+    )
+    Resque.set_schedule("new_ivar_job",
+      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
+    )
+    Resque.set_schedule("stay_put_job",
+      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp"}
+    )
+    Resque.remove_schedule("another_ivar_job")
+    
+    Resque::Scheduler.update_schedule
+    
+    assert_equal(3, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    assert_equal(3, Resque::Scheduler.scheduled_jobs.size)
+    %w(some_ivar_job new_ivar_job stay_put_job).each do |job_name|
+      assert Resque::Scheduler.scheduled_jobs.keys.include?(job_name)
+      assert Resque.schedule.keys.include?(job_name)
+    end
+    assert !Resque::Scheduler.scheduled_jobs.keys.include?("another_ivar_job")
+    assert !Resque.schedule.keys.include?("another_ivar_job")
+    assert_equal 0, Resque.redis.scard(:schedules_changed)
+  end
+  
+  def test_update_schedule_with_mocks
+    Resque::Scheduler.dynamic = true
+    Resque.schedule = {
+      "some_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"},
+      "another_ivar_job"  => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/5"},
+      "stay_put_job"  => {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp"}
+    }
+    
+    Resque::Scheduler.load_schedule!
+    
+    Resque::Scheduler.rufus_scheduler.expects(:unschedule).with(Resque::Scheduler.scheduled_jobs["some_ivar_job"].job_id)
+    Resque::Scheduler.rufus_scheduler.expects(:unschedule).with(Resque::Scheduler.scheduled_jobs["another_ivar_job"].job_id)
+    
+    Resque.set_schedule("some_ivar_job",
+      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"}
+    )
+    Resque.set_schedule("new_ivar_job",
+      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
+    )
+    Resque.set_schedule("stay_put_job",
+      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp"}
+    )
+    Resque.remove_schedule("another_ivar_job")
+    
+    Resque::Scheduler.update_schedule
+    
+    assert_equal(3, Resque::Scheduler.scheduled_jobs.size)
+    %w(some_ivar_job new_ivar_job stay_put_job).each do |job_name|
+      assert Resque::Scheduler.scheduled_jobs.keys.include?(job_name)
+      assert Resque.schedule.keys.include?(job_name)
+    end
+    assert !Resque::Scheduler.scheduled_jobs.keys.include?("another_ivar_job")
+    assert !Resque.schedule.keys.include?("another_ivar_job")
+    assert_equal 0, Resque.redis.scard(:schedules_changed)
+  end
+  
+  def test_set_schedules
+    Resque::Scheduler.dynamic = true
+    Resque.schedule = {"my_ivar_job" => {
+      'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/75"
+    }}
+    assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/75"}, 
+      Resque.decode(Resque.redis.hget(:schedules, "my_ivar_job")))
+  end
+  
+  def test_set_schedule
+    Resque.set_schedule("some_ivar_job", {
+      'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/22"
+    })
+    assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/22"}, 
+      Resque.decode(Resque.redis.hget(:schedules, "some_ivar_job")))
+    assert Resque.redis.sismember(:schedules_changed, "some_ivar_job")
+  end
+  
+  def test_get_schedule
+    Resque.redis.hset(:schedules, "some_ivar_job2", Resque.encode(
+      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/33"}
+    ))
+    assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/33"}, 
+      Resque.get_schedule("some_ivar_job2"))
+  end
+  
+  def test_remove_schedule
+    Resque.redis.hset(:schedules, "some_ivar_job3", Resque.encode(
+      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/44"}
+    ))
+    Resque.remove_schedule("some_ivar_job3")
+    assert_equal nil, Resque.redis.hget(:schedules, "some_ivar_job3")
+    assert Resque.redis.sismember(:schedules_changed, "some_ivar_job3")
+  end
+
+  def test_adheres_to_lint
+    assert_nothing_raised do
+      Resque::Plugin.lint(Resque::Scheduler)
+      Resque::Plugin.lint(ResqueScheduler)
+    end
+  end
+  
+  def test_uses_rufus_airbrake_handler
+    backup_stdout = $stdout
+    begin
+      e = RuntimeError.new("Problem!")
+      Airbrake.expects(:notify).with(e)
+
+      Resque::Scheduler.airbrake = true
+      Resque::Scheduler.clear_schedule!
+      
+      $stdout = StringIO.new #swallow up the output from the exception handler
+
+      # #handle_exception takes a job, but our custom handler doesn't care about it, so we're
+      # just going to pass nil for the test
+      Resque::Scheduler.rufus_scheduler.handle_exception(nil, e)
+    ensure
+      $stdout = backup_stdout
+    end
+  end
+end