resque-scheduler 1.9.10 → 2.0.0.a

data/lib/resque_scheduler.rb

@@ -18,7 +18,7 @@ module ResqueScheduler
   #
   # :name can be anything and is used only to describe the scheduled job
   # :cron can be any cron scheduling string :job can be any resque job class
-  # :every can be used in lieu of :cron. see rufus-scheduler's 'every' usage for
+  # :every can be used in lieu of :cron. see rufus-scheduler's 'every' usage for 
   #   valid syntax. If :cron is present it will take precedence over :every.
   # :class must be a resque worker class
   # :args can be any yaml which will be converted to a ruby literal and passed
@@ -28,6 +28,11 @@ module ResqueScheduler
   #   an array, each element in the array is passed as a separate param,
   #   otherwise params is passed in as the only parameter to perform.
   def schedule=(schedule_hash)
+    if Resque::Scheduler.dynamic
+      schedule_hash.each do |name, job_spec|
+        set_schedule(name, job_spec)
+      end
+    end
     @schedule = schedule_hash
   end
 
@@ -35,37 +40,60 @@ module ResqueScheduler
   def schedule
     @schedule ||= {}
   end
+  
+  # reloads the schedule from redis
+  def reload_schedule!
+    @schedule = get_schedules
+  end
+  
+  # gets the schedule as it exists in redis
+  def get_schedules
+    if redis.exists(:schedules)
+      redis.hgetall(:schedules).tap do |h|
+        h.each do |name, config|
+          h[name] = decode(config)
+        end
+      end
+    else
+      nil
+    end
+  end
+  
+  # create or update a schedule with the provided name and configuration
+  def set_schedule(name, config)
+    existing_config = get_schedule(name)
+    unless existing_config && existing_config == config
+      redis.hset(:schedules, name, encode(config))
+      redis.sadd(:schedules_changed, name)
+    end
+    config
+  end
+  
+  # retrive the schedule configuration for the given name
+  def get_schedule(name)
+    decode(redis.hget(:schedules, name))
+  end
+  
+  # remove a given schedule by name
+  def remove_schedule(name)
+    redis.hdel(:schedules, name)
+    redis.sadd(:schedules_changed, name)
+  end
 
   # This method is nearly identical to +enqueue+ only it also
   # takes a timestamp which will be used to schedule the job
   # for queueing.  Until timestamp is in the past, the job will
   # sit in the schedule list.
   def enqueue_at(timestamp, klass, *args)
-    validate_job!(klass)
     delayed_push(timestamp, job_to_hash(klass, args))
   end
 
-  # Identical to +enqueue_at+, except you can also specify
-  # a queue in which the job will be placed after the
-  # timestamp has passed.
-  def enqueue_at_with_queue(queue, timestamp, klass, *args)
-    validate_job!(klass)
-    delayed_push(timestamp, job_to_hash_with_queue(queue, klass, args))
-  end
-
   # Identical to enqueue_at but takes number_of_seconds_from_now
   # instead of a timestamp.
   def enqueue_in(number_of_seconds_from_now, klass, *args)
     enqueue_at(Time.now + number_of_seconds_from_now, klass, *args)
   end
 
-  # Identical to +enqueue_in+, except you can also specify
-  # a queue in which the job will be placed after the
-  # number of seconds has passed.
-  def enqueue_in_with_queue(queue, number_of_seconds_from_now, klass, *args)
-    enqueue_at_with_queue(queue, Time.now + number_of_seconds_from_now, klass, *args)
-  end
-
   # Used internally to stuff the item into the schedule sorted list.
   # +timestamp+ can be either in seconds or a datetime object
   # Insertion if O(log(n)).
@@ -146,22 +174,18 @@ module ResqueScheduler
   end
 
   def count_all_scheduled_jobs
-    total_jobs = 0
+    total_jobs = 0 
     Array(redis.zrange(:delayed_queue_schedule, 0, -1)).each do |timestamp|
       total_jobs += redis.llen("delayed:#{timestamp}").to_i
-    end
+    end 
     total_jobs
-  end
+  end 
 
   private
     def job_to_hash(klass, args)
       {:class => klass.to_s, :args => args, :queue => queue_from_class(klass)}
     end
 
-    def job_to_hash_with_queue(queue, klass, args)
-      {:class => klass.to_s, :args => args, :queue => queue}
-    end
-
     def clean_up_timestamp(key, timestamp)
       # If the list is empty, remove it.
       if 0 == redis.llen(key).to_i
@@ -170,16 +194,6 @@ module ResqueScheduler
       end
     end
 
-    def validate_job!(klass)
-      if klass.to_s.empty?
-        raise Resque::NoClassError.new("Jobs must be given a class.")
-      end
-
-      unless queue_from_class(klass)
-        raise Resque::NoQueueError.new("Jobs must be placed onto a queue.")
-      end
-    end
-
 end
 
 Resque.extend ResqueScheduler

data/lib/resque_scheduler/server.rb

@@ -1,7 +1,7 @@
 
 # Extend Resque::Server to add tabs
 module ResqueScheduler
-
+  
   module Server
 
     def self.included(base)
@@ -19,6 +19,7 @@ module ResqueScheduler
         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
@@ -26,9 +27,9 @@ module ResqueScheduler
         post "/schedule/requeue" do
           config = Resque.schedule[params['job_name']]
           Resque::Scheduler.enqueue_from_config(config)
-          redirect u("/overview")
+          redirect url("/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'))
@@ -38,11 +39,11 @@ module ResqueScheduler
           # 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")
+          redirect url("/overview")
         end
 
       end
@@ -53,5 +54,5 @@ module ResqueScheduler
     Resque::Server.tabs << 'Delayed'
 
   end
-
-end
+  
+end

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

@@ -19,19 +19,19 @@
   <% resque.delayed_queue_peek(start, start+20).each do |timestamp| %>
     <tr>
       <td>
-        <form action="<%= u "/delayed/queue_now" %>" method="post">
+        <form action="<%= url "/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><a href="<%= url "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>
+          <a href="<%= url "delayed/#{timestamp}" %>">see details</a>
         <% end %>
       </td>
       <td><%= h(job['args'].inspect) if job && delayed_timestamp_size == 1 %></td>

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

@@ -15,11 +15,11 @@
     <th>Queue</th>
     <th>Arguments</th>
   </tr>
-  <% Resque.schedule.keys.map(&:to_s).sort.map(&:to_sym).each do |name| %>
+  <% Resque.schedule.keys.sort.each do |name| %>
     <% config = Resque.schedule[name] %>
     <tr>
       <td>
-        <form action="<%= u "/schedule/requeue" %>" method="post">
+        <form action="<%= url "/schedule/requeue" %>" method="post">
           <input type="hidden" name="job_name" value="<%= h name %>">
           <input type="submit" value="Queue now">
         </form>
@@ -27,8 +27,8 @@
       <td><%= h name %></td>
       <td><%= h config['description'] %></td>
       <td style="white-space:nowrap"><%= (config['cron'].nil? && !config['every'].nil?) ?
-                                         h("every: #{config['every']}") : 
-                                         h("cron: #{config['cron']}") %></td>
+                                         h('every: ' + config['every']) : 
+                                         h('cron: ' + config['cron']) %></td>
       <td><%= (config['class'].nil? && !config['custom_job_class'].nil?) ?
               h(config['custom_job_class']) :
               h(config['class']) %></td>

data/lib/resque_scheduler/tasks.rb

@@ -21,4 +21,4 @@ namespace :resque do
     end
   end
 
-end
+end

data/lib/resque_scheduler/version.rb

@@ -1,3 +1,3 @@
 module ResqueScheduler
-  VERSION = '1.9.10'
+  Version = '2.0.0.a'
 end

data/resque-scheduler.gemspec

@@ -1,32 +1,29 @@
 # -*- encoding: utf-8 -*-
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require 'resque_scheduler/version'
+require File.expand_path("../lib/resque_scheduler/version", __FILE__)
 
-Gem::Specification.new do |spec|
-  spec.name        = 'resque-scheduler'
-  spec.version     = ResqueScheduler::VERSION
-  spec.authors     = ['Ben VandenBos']
-  spec.email       = ['bvandenbos@gmail.com']
-  spec.homepage    = 'http://github.com/resque/resque-scheduler'
-  spec.summary     = 'Light weight job scheduling on top of Resque'
-  spec.description = %q{Light weight job scheduling on top of Resque.
+Gem::Specification.new do |s|
+  s.name        = "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"
 
-  spec.files        = `git ls-files`.split("\n")
-  spec.executables  = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files   = spec.files.grep(%r{^test/})
-  spec.require_path = ['lib']
-
-  spec.add_development_dependency 'bundler', '~> 1.3'
-  spec.add_development_dependency 'mocha'
-  spec.add_development_dependency 'rack-test'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'json' if RUBY_VERSION < '1.9'
-  spec.add_development_dependency 'rubocop' unless RUBY_VERSION < '1.9'
-
-  spec.add_runtime_dependency 'redis', '>= 2.0.1'
-  spec.add_runtime_dependency 'resque', ['>= 1.8.0', '< 1.25.0']
-  spec.add_runtime_dependency 'rufus-scheduler', '>= 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.8.0"])
+  s.add_runtime_dependency(%q<rufus-scheduler>, [">= 0"])
+  s.add_development_dependency(%q<mocha>, [">= 0"])
+  s.add_development_dependency(%q<rack-test>, [">= 0"])
+  
 end

data/test/delayed_queue_test.rb

@@ -28,34 +28,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     # 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_enqueue_at_with_queue_inserts_into_correct_queue
-    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")
@@ -168,10 +141,10 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     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)
 
@@ -180,7 +153,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     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
@@ -233,7 +206,7 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     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")
@@ -244,13 +217,4 @@ class Resque::DelayedQueueTest < Test::Unit::TestCase
     assert_equal(2, Resque.remove_delayed(SomeIvarJob, "bar"))
     assert_equal(2, Resque.count_all_scheduled_jobs)
   end
-
-  def test_invalid_job_class
-    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
 end

data/test/redis-test.conf

@@ -112,4 +112,4 @@ databases 16
 # 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
+glueoutputbuf yes

data/test/resque-web_test.rb

@@ -10,10 +10,9 @@ context "on GET to /schedule" do
 end
 
 context "on GET to /schedule with scheduled jobs" do
-  setup do
+  setup do 
     ENV['rails_env'] = 'production'
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'},
-                       :some_other_job => {'queue' => 'high', 'class' => 'SomeOtherJob', 'args' => {:b => 'blah'}}}
+    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp", 'rails_env' => 'production'}}
     Resque::Scheduler.load_schedule!
     get "/schedule"
   end

data/test/scheduler_args_test.rb

@@ -14,7 +14,7 @@ context "scheduling jobs with arguments" do
   test "calls the worker without arguments when 'args' is blank in the config" do
     Resque::Scheduler.enqueue_from_config(YAML.load(<<-YAML))
       class: SomeIvarJob
-      args:
+      args: 
     YAML
     SomeIvarJob.expects(:perform).once.with()
     Resque.reserve('ivar').perform

data/test/scheduler_test.rb

@@ -7,7 +7,12 @@ class Resque::SchedulerTest < Test::Unit::TestCase
   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_puts_stuff_in_the_resque_queue_without_class_loaded
@@ -20,16 +25,11 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     Resque::Scheduler.enqueue_from_config('every' => '1m', 'class' => 'JamesJob', 'args' => '/tmp', 'queue' => 'james_queue')
   end
 
-  def test_enqueue_from_config_doesnt_crash_on_exception_when_enqueueing
-    Resque::Job.stubs(:create).raises(Resque::NoQueueError, 'test exception').with(:ivar, 'SomeIvarJob', '/tmp')
-    Resque::Scheduler.enqueue_from_config('cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp")
-  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")
@@ -80,11 +80,164 @@ class Resque::SchedulerTest < Test::Unit::TestCase
     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