sidekiq-scheduler 0.4.1 → 0.6

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    Y2Q1OGQ4ZGNkNzkwMWM2MWQ0MDI0MjY4MTAxMzZkZjAyZjNiMWU4Zg==
+  data.tar.gz: !binary |-
+    Njk5ZjEzZmUwMGRmMDIyNmQzZDZkOTY4Njk0MmY4YzRjZmI5MTY2NA==
+SHA512:
+  metadata.gz: !binary |-
+    YzZhYzlhZDRkYWE3OWYwM2ZhOWY4ZjljYTBlMzE3ZDAyNTM2OGU5MDliNTNk
+    YjA3ODgxNDhkMzRiMmE1ZjMyYjUzMjljZDFiYWEwYzEwMGM3YWRkMzU5NTRl
+    YmRiZmI0ZTQ4ODEwMGQzMzcwNDVjMjE5ZTEyZWY1YjFlNmRmZDc=
+  data.tar.gz: !binary |-
+    NTExMjEzMjA1M2FhNWYzMWY1Zjg1NzY5NTI3N2VhOTBhM2JkMTU0NjBkYzg3
+    ZmEyN2EyMTY1ZGVmNWZhOTQ4NDgzNzdiM2U4YzdiNmM4M2Y5ODE1ODIxZjNi
+    ZGE0ZWUzZjdhMDExYjQyNmEwZGZhMDNiNmI4Zjk3YTEyZWU0YTc=

data/README.md

@@ -1,35 +1,17 @@
 # SidekiqScheduler
 
-# Warning!
-
-The original function of this gem was to add delayed jobs for a fixed amount of time. 
-This has been available directly within Sidekiq since Version 2.0. A lot of this code
-should be considered redundant and might even conflict with the latest Sidekiq release.
-
-Since I have upgraded my projects that made use of this gem to the core Sidekiq functions and
-no longer make active use of this gem this project should be considered largely unmaintained.
-
 ## Description
 
 sidekiq-scheduler is an extension to [Sidekiq](http://github.com/mperham/sidekiq)
-that adds support for queueing jobs in the future.
+that adds support for running scheduled.
 
 This table explains the version requirements for redis
 
 | sidekiq-scheduler version | required redis version|
 |:--------------------------|----------------------:|
-| >= 1.0.0                  | >= 2.2.0              |
+| >= 0.4.0                  | >= 2.2.0              |
 
-Job scheduling is supported in two different way: Recurring (scheduled) and
-Delayed.
-
-Scheduled jobs are like cron jobs, recurring on a regular basis.  Delayed
-jobs are resque jobs that you want to run at some point in the future.
-The syntax is pretty explanatory:
-
-    MyWorker.perform_in(5.days, 'arg1', 'arg2') # run a job in 5 days
-    # or
-    MyWorker.perform_at(5.days.from_now, 'arg1', 'arg2') # run job at a specific time
+Scheduled jobs are like cron jobs, recurring on a regular basis.
 
 ### Documentation
 
@@ -58,7 +40,6 @@ parsing provided by sidekiq you will need to use a configuration file to
 override the scheduler options.
 Available options are:
 
-    :resolution: <seconds between schedule runs>
     :schedule: <the schedule to be run>
     :dynamic: <if true the schedule can we modified in runtime>
 
@@ -74,55 +55,13 @@ NOTE: If the scheduler thread goes down for whatever reason, the delayed items
 that should have fired during the outage will fire once the scheduler is
 started back up again (even if it is on a new machine).
 
-## Delayed jobs
-
-Delayed jobs are one-off jobs that you want to be put into a queue at some point
-in the future. The classic example is sending email:
-
-    MyWorker.perform_in(5.days, current_user.id)
-
-This will store the job for 5 days in the Sidekiq delayed queue at which time
-the scheduler will pull it from the delayed queue and put it in the appropriate 
-work queue for the given job. It will then be processed as soon as a worker is 
-available (just like any other Sidekiq job).
-
-The `5.days` syntax will only work if you are using ActiveSupport (Rails). If you
-are not using Rails, just provide `perform_in` with the number of seconds.
-
-NOTE: The job does not fire **exactly** at the time supplied. Rather, once that
-time is in the past, the job moves from the delayed queue to the actual work
-queue and will be completed as workers are free to process it.
-
-Also supported is `MyWork.perform_at` which takes a timestamp to queue the job.
-
-The delayed queue is stored in redis and is persisted in the same way the
-standard Sidekiq jobs are persisted (redis writing to disk). Delayed jobs differ
-from scheduled jobs in that if your scheduler process is down or workers are
-down when a particular job is supposed to be processed, they will simply "catch up"
-once they are started again.  Jobs are guaranteed to run (provided they make it
-into the delayed queue) after their given queue_at time has passed.
-
-One other thing to note is that insertion into the delayed queue is O(log(n))
-since the jobs are stored in a redis sorted set (zset).  I can't imagine this
-being an issue for someone since redis is stupidly fast even at log(n), but full
-disclosure is always best.
-
-### Removing Delayed jobs
-
-If you have the need to cancel a delayed job, you can do it like this:
-
-    # after you've enqueued a job like:
-    MyWorker.perform_at(5.days.from_now, 'arg1', 'arg2')
-    # remove the job with exactly the same parameters:
-    MyWorker.remove_delayed(<timestamp>, 'arg1', 'arg2')
-
 ## Scheduled Jobs (Recurring Jobs)
 
 Scheduled (or recurring) jobs are logically no different than a standard cron
 job.  They are jobs that run based on a fixed schedule which is set at
 startup.
 
-The schedule is a list of Resque worker classes with arguments and a
+The schedule is a list of Sidekiq worker classes with arguments and a
 schedule frequency (in crontab syntax).  The schedule is just a hash, but
 is most likely stored in a YAML like so:
 
@@ -164,6 +103,20 @@ seconds past the minute).
 A big shout out to [rufus-scheduler](http://github.com/jmettraux/rufus-scheduler)
 for handling the heavy lifting of the actual scheduling engine.
 
+### Loading the schedule
+
+Let's assume your scheduled jobs are defined in a file called "config/scheduler.yml" under your Rails project,
+you could create a Rails initializer called "config/initializer/scheduler.rb" which would load the job definitions:
+
+    require 'sidekiq/scheduler'
+    Sidekiq.schedule = YAML.load_file(File.expand_path("../../../config/scheduler.yml",__FILE__))
+
+If you were running a non Rails project you should add code to load the workers classes before loading the schedule.
+
+    require 'sidekiq/scheduler'
+    Dir[File.expand_path('../lib/workers/*.rb',__FILE__)].each do |file| load file; end
+    Sidekiq.schedule = YAML.load_file(File.expand_path("../../../config/scheduler.yml",__FILE__))
+ 
 ### Time zones
 
 Note that if you use the cron syntax, this will be interpreted as in the server time zone
@@ -204,12 +157,12 @@ Sidekiq uses a jobs array on workers for testing, which is supported by sidekiq-
 
 This work is a partial port of [resque-scheduler](https://github.com/bvandenbos/resque-scheduler) by Ben VandenBos.  
 Modified to work with the Sidekiq queueing library by Morton Jonuschat.
-
-Scheduling of recurring jobs has been addet to v0.4.0, thanks to [Adrian Gomez](https://github.com/adrian-gomez).
+Scheduling of recurring jobs has been added to v0.4.0, thanks to [Adrian Gomez](https://github.com/adrian-gomez).
 
 ## Maintainers
 
 * [Morton Jonuschat](https://github.com/yabawock)
+* [Moove-IT](https://github.com/Moove-it)
 
 ## License
 
@@ -217,5 +170,6 @@ MIT License
 
 ## Copyright
 
-Copyright 2012 Morton Jonuschat  
-Some parts copyright 2010 Ben VandenBos  
+Copyright 2013 Moove-IT
+Copyright 2012 Morton Jonuschat
+Some parts copyright 2010 Ben VandenBos

data/bin/sidekiq-scheduler

@@ -1,21 +1,16 @@
 #!/usr/bin/env ruby
 
-begin
-  require 'sidekiq-scheduler/cli'
-rescue LoadError
-  # Better way to do this in dev?
-  dir = File.expand_path(File.dirname(__FILE__) + '/../lib') 
-  $LOAD_PATH << dir if File.exist?("#{dir}/sidekiq-scheduler.rb")
-  require 'sidekiq-scheduler'
-end
+require 'sidekiq/cli'
 
 begin
   cli = Sidekiq::CLI.instance
   cli.parse
+
+  require 'sidekiq-scheduler/cli'
   cli.run
 rescue => e
   raise e if $DEBUG
   STDERR.puts e.message
   STDERR.puts e.backtrace.join("\n")
   exit 1
-end
+end

data/lib/sidekiq-scheduler.rb

@@ -1,4 +1,2 @@
 require 'sidekiq'
-require 'sidekiq-scheduler/client'
-require 'sidekiq-scheduler/worker'
-require 'sidekiq-scheduler/version'
+require 'sidekiq-scheduler/version'

data/lib/sidekiq-scheduler/cli.rb

@@ -1,8 +1,10 @@
-require 'sidekiq-scheduler/manager'
 require 'sidekiq/cli'
 
+require 'sidekiq-scheduler/manager'
+
 module SidekiqScheduler
   module CLI
+
     def self.included(base)
       base.class_eval do
         alias_method :run_manager, :run
@@ -11,21 +13,23 @@ module SidekiqScheduler
     end
 
     def run_scheduler
-      scheduler_options = { :scheduler => true, :resolution => 5, :schedule => nil }
+      scheduler_options = { :scheduler => true, :schedule => nil }
       scheduler_options.merge!(options)
 
       if options[:config_file]
         file_options = YAML.load_file(options[:config_file])
         options.merge!(file_options)
         options.delete(:config_file)
+        parse_queues(options, options.delete(:queues) || [])
       end
 
       scheduler = SidekiqScheduler::Manager.new(scheduler_options)
-      scheduler.start!
+      scheduler.start
       run_manager
-      scheduler.stop!
+      scheduler.stop
     end
+
   end
 end
 
-Sidekiq::CLI.send(:include, SidekiqScheduler::CLI)
+Sidekiq::CLI.send(:include, SidekiqScheduler::CLI)

data/lib/sidekiq-scheduler/manager.rb

@@ -1,6 +1,5 @@
 require 'celluloid'
 require 'redis'
-require 'multi_json'
 
 require 'sidekiq/util'
 
@@ -9,7 +8,6 @@ require 'sidekiq-scheduler/schedule'
 
 module SidekiqScheduler
 
-  ##
   # The delayed job router in the system.  This
   # manages the scheduled jobs pushed messages
   # from Redis onto the work queues
@@ -20,7 +18,6 @@ module SidekiqScheduler
 
     def initialize(options={})
       @enabled = options[:scheduler]
-      @resolution = options[:resolution] || 5
 
       Sidekiq::Scheduler.dynamic = options[:dynamic] || false
       Sidekiq.schedule = options[:schedule] if options[:schedule]
@@ -38,64 +35,12 @@ module SidekiqScheduler
       elsif @enabled
         Sidekiq::Scheduler.load_schedule!
       end
-
-      schedule(true)
     end
 
     def reset
       clear_scheduled_work
     end
 
-    private
-
-    def clear_scheduled_work
-      redis do |conn|
-        queues = conn.zrange('delayed_queue_schedule', 0, -1).to_a
-        conn.del(*queues.map { |t| "delayed:#{t}" }) unless queues.empty?
-        conn.del('delayed_queue_schedule')
-      end
-    end
-
-    def find_scheduled_work(timestamp)
-      loop do
-        break logger.debug("Finished processing queue for timestamp #{timestamp}") unless msg = redis { |r| r.lpop("delayed:#{timestamp}") }
-        item = MultiJson.decode(msg)
-        item['class'] = constantize(item['class']) # Sidekiq expects the class to be constantized.
-        Sidekiq::Client.push(item)
-      end
-      Sidekiq::Client.remove_scheduler_queue(timestamp)
-    end
-
-    def find_next_timestamp
-      timestamp = redis { |r| r.zrangebyscore('delayed_queue_schedule', '-inf', Time.now.to_i, :limit => [0, 1]) }
-      if timestamp.is_a?(Array)
-        timestamp = timestamp.first
-      end
-      timestamp.to_i unless timestamp.nil?
-    end
-
-    def schedule(run_loop = false)
-      watchdog("Fatal error in sidekiq, scheduler loop died") do
-        return if stopped?
-
-        # Dispatch loop
-        loop do
-          Sidekiq::Scheduler.update_schedule if Sidekiq::Scheduler.dynamic
-          break unless timestamp = find_next_timestamp
-          find_scheduled_work(timestamp)
-        end
-
-        # This is the polling loop that ensures we check Redis every
-        # second for work, even if there was nothing to do this time
-        # around.
-        after(@resolution) do
-          schedule(run_loop)
-        end if run_loop
-      end
-    end
-
-    def stopped?
-      !@enabled
-    end
   end
-end
+
+end

data/lib/sidekiq-scheduler/schedule.rb

@@ -1,3 +1,5 @@
+require 'multi_json'
+
 module SidekiqScheduler
   module Schedule
 
@@ -30,9 +32,6 @@ module SidekiqScheduler
     # :args can be any yaml which will be converted to a ruby literal and
     # passed in a params. (optional)
     #
-    # :rails_envs is the list of envs where the job gets loaded. Envs are
-    # comma separated (optional)
-    #
     # :description is just that, a description of the job (optional). If
     # params is an array, each element in the array is passed as a separate
     # param, otherwise params is passed in as the only parameter to perform.
@@ -89,10 +88,10 @@ module SidekiqScheduler
     # Note: values for class and custom_job_class need to be strings,
     # not constants.
     #
-    #    Resque.set_schedule('some_job', {:class => 'SomeJob',
-    #                                     :every => '15mins',
-    #                                     :queue => 'high',
-    #                                     :args => '/tmp/poop'})
+    #    Sidekiq.set_schedule('some_job', { :class => 'SomeJob',
+    #                                       :every => '15mins',
+    #                                       :queue => 'high',
+    #                                       :args => '/tmp/poop' })
     def set_schedule(name, config)
       existing_config = get_schedule(name)
       unless existing_config && existing_config == config

data/lib/sidekiq-scheduler/version.rb

@@ -1,3 +1,3 @@
 module SidekiqScheduler
-  VERSION = "0.4.1"
-end
+  VERSION = '0.6'
+end

data/lib/sidekiq/scheduler.rb

@@ -111,13 +111,16 @@ module Sidekiq
 
     # Enqueue a job based on a config hash
     def self.enqueue_from_config(job_config)
-      args = job_config[:args] || job_config['args']
-      args = args.is_a?(Hash) ? [args] : Array(args)
-      
-      klass_name = job_config[:class] || job_config['class']
-      klass = klass_name.constantize rescue constantize(klass_name)
+      config = job_config.dup
 
-      Sidekiq::Client.push({ 'class' => klass, 'args' => args })
+      config['class'] = if config['class'].is_a?(String)
+                          config['class'].constantize
+                        else
+                          config['class']
+                        end
+      config['args'] = Array(config['args'])
+
+       Sidekiq::Client.push(config)
     end
 
     def self.rufus_scheduler
@@ -162,5 +165,6 @@ module Sidekiq
         self.scheduled_jobs.delete(name)
       end
     end
+
   end
-end
+end

data/lib/tasks/sidekiq-scheduler_tasks.rake

@@ -1,4 +1,4 @@
 # desc "Explaining what the task does"
 # task :sidekiq-scheduler do
 #   # Task goes here
-# end
+# end

data/test/cli_test.rb

@@ -2,9 +2,12 @@ require 'test_helper'
 require 'sidekiq-scheduler/cli'
 require 'tempfile'
 
-class CliTest < MiniTest::Unit::TestCase
+class CliTest < Minitest::Test
+
   describe 'with cli' do
+
     before do
+      Celluloid.boot
       @cli = Sidekiq::CLI.instance
     end
 
@@ -17,5 +20,7 @@ class CliTest < MiniTest::Unit::TestCase
         assert_equal 30, Sidekiq.options[:resolution]
       end
     end
+
   end
+
 end

data/test/lib/sidekiq/scheduler_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class ManagerTest < MiniTest::Unit::TestCase
+class ManagerTest < Minitest::Test
   describe 'Sidekiq::Scheduler' do
 
     before do
@@ -15,35 +15,37 @@ class ManagerTest < MiniTest::Unit::TestCase
       # The job should be loaded, since a missing rails_env means ALL envs.
       ENV['RAILS_ENV'] = 'production'
       config = {
-          'cron' => '* * * * *',
-          'class' => 'SomeRealClass',
-          'args' => '/tmp'
+        'cron' => '* * * * *',
+        'class' => 'SomeRealClass',
+        'queue' => 'high',
+        'args' => '/tmp'
       }
 
       Sidekiq::Client.expects(:push).with(
-          {
-              'cron' => '* * * * *',
-              'class' => SomeRealClass,
-              'args' => '/tmp'
-          }
+        {
+          'cron' => '* * * * *',
+          'class' => SomeRealClass,
+          'queue' => 'high',
+          'args' => ['/tmp']
+        }
       )
       Sidekiq::Scheduler.enqueue_from_config(config)
     end
 
     it 'enqueue_from_config respects queue params' do
       config = {
-          'cron' => '* * * * *',
-          'class' => 'SomeIvarJob',
-          'queue' => 'high'
+        'cron' => '* * * * *',
+        'class' => 'SomeIvarJob',
+        'queue' => 'high'
       }
 
       Sidekiq::Client.expects(:push).with(
-          {
-              'cron' => '* * * * *',
-              'class' => SomeIvarJob,
-              'args' => '',
-              'queue' => 'high'
-          }
+        {
+          'cron' => '* * * * *',
+          'class' => SomeIvarJob,
+          'args' => [],
+          'queue' => 'high'
+        }
       )
 
       Sidekiq::Scheduler.enqueue_from_config(config)
@@ -52,66 +54,65 @@ class ManagerTest < MiniTest::Unit::TestCase
     it 'config makes it into the rufus_scheduler' do
       assert_equal(0, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
       Sidekiq.schedule = {
-          :some_ivar_job => {
-              'cron' => '* * * * *',
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp'
-          }
+        :some_ivar_job => {
+          'cron' => '* * * * *',
+          'class' => 'SomeIvarJob',
+          'args' => '/tmp'
+        }
       }
 
-
       Sidekiq::Scheduler.load_schedule!
 
       assert_equal(1, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
       assert Sidekiq::Scheduler.scheduled_jobs.include?(:some_ivar_job)
     end
 
+    # THIS
     it 'can reload schedule' do
       Sidekiq::Scheduler.dynamic = true
       Sidekiq.schedule = {
-          :some_ivar_job => {
-              'cron' => '* * * * *',
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp'
-          }
+        :some_ivar_job => {
+          'cron' => '* * * * *',
+          'class' => 'SomeIvarJob',
+          'args' => '/tmp'
+        }
       }
 
       Sidekiq::Scheduler.load_schedule!
 
-      assert_equal(1, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
-      assert Sidekiq::Scheduler.scheduled_jobs.include?(:some_ivar_job)
+      assert Sidekiq::Scheduler.scheduled_jobs.include?('some_ivar_job')
 
       Sidekiq.redis { |r| r.del(:schedules) }
       Sidekiq.redis do |r|
         r.hset(
-            :schedules,
-            'some_ivar_job2',
-            MultiJson.encode(
-                {
-                    'cron' => '* * * * *',
-                    'class' => 'SomeIvarJob',
-                    'args' => '/tmp/2'
-                }
-            )
+          :schedules,
+          'some_ivar_job2',
+          MultiJson.encode(
+            {
+              'cron' => '* * * * *',
+              'class' => 'SomeIvarJob',
+              'args' => '/tmp/2'
+            }
+          )
         )
       end
 
       Sidekiq::Scheduler.reload_schedule!
 
-      assert_equal(1, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
+      assert Sidekiq::Scheduler.scheduled_jobs.include?('some_ivar_job')
+      assert Sidekiq::Scheduler.scheduled_jobs.include?('some_ivar_job2')
 
       assert_equal '/tmp/2', Sidekiq.schedule['some_ivar_job2']['args']
-      assert Sidekiq::Scheduler.scheduled_jobs.include?('some_ivar_job2')
     end
 
     it 'load_schedule_job loads a schedule' do
       Sidekiq::Scheduler.load_schedule_job(
-          'some_ivar_job',
-          {
-              'cron' => '* * * * *',
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp'
-          }
+        'some_ivar_job',
+        {
+          'cron' => '* * * * *',
+          'class' => 'SomeIvarJob',
+          'args' => '/tmp'
+        }
       )
 
       assert_equal(1, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
@@ -121,12 +122,12 @@ class ManagerTest < MiniTest::Unit::TestCase
 
     it 'load_schedule_job with every with options' do
       Sidekiq::Scheduler.load_schedule_job(
-          'some_ivar_job',
-          {
-              'every' => ['30s', {'first_in' => '60s'}],
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp'
-          }
+        'some_ivar_job',
+        {
+          'every' => ['30s', {'first_in' => '60s'}],
+          'class' => 'SomeIvarJob',
+          'args' => '/tmp'
+        }
       )
 
       assert_equal(1, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
@@ -137,12 +138,12 @@ class ManagerTest < MiniTest::Unit::TestCase
 
     it 'load_schedule_job with cron with options' do
       Sidekiq::Scheduler.load_schedule_job(
-          'some_ivar_job',
-          {
-              'cron' => ['* * * * *', {'allow_overlapping' => 'true'}],
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp'
-          }
+        'some_ivar_job',
+        {
+          'cron' => ['* * * * *', {'allow_overlapping' => 'true'}],
+          'class' => 'SomeIvarJob',
+          'args' => '/tmp'
+        }
       )
 
       assert_equal(1, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
@@ -153,11 +154,11 @@ class ManagerTest < MiniTest::Unit::TestCase
 
     it 'does not load the schedule without cron' do
       Sidekiq::Scheduler.load_schedule_job(
-          'some_ivar_job',
-          {
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp'
-          }
+        'some_ivar_job',
+        {
+          'class' => 'SomeIvarJob',
+          'args' => '/tmp'
+        }
       )
 
       assert_equal(0, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
@@ -167,12 +168,12 @@ class ManagerTest < MiniTest::Unit::TestCase
 
     it 'does not load the schedule with an empty cron' do
       Sidekiq::Scheduler.load_schedule_job(
-          'some_ivar_job',
-          {
-              'cron' => '',
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp'
-          }
+        'some_ivar_job',
+        {
+          'cron' => '',
+          'class' => 'SomeIvarJob',
+          'args' => '/tmp'
+        }
       )
 
       assert_equal(0, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
@@ -181,99 +182,46 @@ class ManagerTest < MiniTest::Unit::TestCase
     end
 
     it 'update_schedule' do
-      Sidekiq::Scheduler.dynamic = true
-      Sidekiq.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'}
-          }
-
-      Sidekiq::Scheduler.load_schedule!
-
-      Sidekiq.set_schedule(
-          'some_ivar_job',
-          {
-              'cron' => '* * * * *',
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp/2'
-          }
-      )
-      Sidekiq.set_schedule(
-          'new_ivar_job',
-          {
-              'cron' => '* * * * *',
-              'class' => 'SomeJob',
-              'args' => '/tmp/3'
-          }
-      )
-      Sidekiq.set_schedule(
-          'stay_put_job',
-          {
-              'cron' => '* * * * *',
-              'class' => 'SomeJob',
-              'args' => '/tmp'
-          }
-      )
-      Sidekiq.remove_schedule('another_ivar_job')
-
-      Sidekiq::Scheduler.update_schedule
-
-      assert_equal(3, Sidekiq::Scheduler.rufus_scheduler.all_jobs.size)
-      assert_equal(3, Sidekiq::Scheduler.scheduled_jobs.size)
-
-
-      %w(some_ivar_job new_ivar_job stay_put_job).each do |job_name|
-        assert Sidekiq::Scheduler.scheduled_jobs.keys.include?(job_name)
-        assert Sidekiq.schedule.keys.include?(job_name)
-      end
-      assert !Sidekiq::Scheduler.scheduled_jobs.keys.include?('another_ivar_job')
-      assert !Sidekiq.schedule.keys.include?('another_ivar_job')
-      assert_equal 0, Sidekiq.redis { |r| r.scard(:schedules_changed) }
-    end
-
-    it 'update_schedule with mocks' do
       Sidekiq::Scheduler.dynamic = true
       Sidekiq.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'}
+        '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'}
       }
 
       Sidekiq::Scheduler.load_schedule!
 
-      Sidekiq::Scheduler.rufus_scheduler.expects(:unschedule).with(Sidekiq::Scheduler.scheduled_jobs['some_ivar_job'].job_id)
-      Sidekiq::Scheduler.rufus_scheduler.expects(:unschedule).with(Sidekiq::Scheduler.scheduled_jobs['another_ivar_job'].job_id)
+      Sidekiq::Scheduler.scheduled_jobs['some_ivar_job'].expects(:unschedule)
+      Sidekiq::Scheduler.scheduled_jobs['another_ivar_job'].expects(:unschedule)
 
       Sidekiq.set_schedule(
-          'some_ivar_job',
-          {
-              'cron' => '* * * * *',
-              'class' => 'SomeIvarJob',
-              'args' => '/tmp/2'
-          }
+        'some_ivar_job',
+        {
+          'cron' => '* * * * *',
+          'class' => 'SomeIvarJob',
+          'args' => '/tmp/2'
+        }
       )
       Sidekiq.set_schedule(
-          'new_ivar_job',
-          {
-              'cron' => '* * * * *',
-              'class' => 'SomeJob',
-              'args' => '/tmp/3'
-          }
+        'new_ivar_job',
+        {
+          'cron' => '* * * * *',
+          'class' => 'SomeJob',
+          'args' => '/tmp/3'
+        }
       )
       Sidekiq.set_schedule(
-          'stay_put_job',
-          {
-              'cron' => '* * * * *',
-              'class' => 'SomeJob',
-              'args' => '/tmp'
-          }
+        'stay_put_job',
+        {
+          'cron' => '* * * * *',
+          'class' => 'SomeJob',
+          'args' => '/tmp'
+        }
       )
       Sidekiq.remove_schedule('another_ivar_job')
 
       Sidekiq::Scheduler.update_schedule
 
-      assert_equal(3, Sidekiq::Scheduler.scheduled_jobs.size)
       %w(some_ivar_job new_ivar_job stay_put_job).each do |job_name|
         assert Sidekiq::Scheduler.scheduled_jobs.keys.include?(job_name)
         assert Sidekiq.schedule.keys.include?(job_name)
@@ -282,5 +230,6 @@ class ManagerTest < MiniTest::Unit::TestCase
       assert !Sidekiq.schedule.keys.include?('another_ivar_job')
       assert_equal 0, Sidekiq.redis { |r| r.scard(:schedules_changed) }
     end
+
   end
-end
+end