resque-scheduler 2.5.5 → 3.0.0

data/test/scheduler_hooks_test.rb

@@ -1,23 +1,24 @@
+# vim:fileencoding=utf-8
 require_relative 'test_helper'
 
-context "scheduling jobs with hooks" do
-  setup do
-    Resque.redis.flushall
-  end
+context 'scheduling jobs with hooks' do
+  setup { Resque.redis.flushall }
 
-  test "before_schedule hook that does not return false should be enqueued" do
+  test 'before_schedule hook that does not return false should be enqueued' do
     enqueue_time = Time.now
     SomeRealClass.expects(:before_schedule_example).with(:foo)
     SomeRealClass.expects(:after_schedule_example).with(:foo)
     Resque.enqueue_at(enqueue_time.to_i, SomeRealClass, :foo)
-    assert_equal(1, Resque.delayed_timestamp_size(enqueue_time.to_i), "job should be enqueued")
+    assert_equal(1, Resque.delayed_timestamp_size(enqueue_time.to_i),
+                 'job should be enqueued')
   end
 
-  test "before_schedule hook that returns false should not be enqueued" do
+  test 'before_schedule hook that returns false should not be enqueued' do
     enqueue_time = Time.now
     SomeRealClass.expects(:before_schedule_example).with(:foo).returns(false)
     SomeRealClass.expects(:after_schedule_example).never
     Resque.enqueue_at(enqueue_time.to_i, SomeRealClass, :foo)
-    assert_equal(0, Resque.delayed_timestamp_size(enqueue_time.to_i), "job should not be enqueued")
+    assert_equal(0, Resque.delayed_timestamp_size(enqueue_time.to_i),
+                 'job should not be enqueued')
   end
 end

data/test/scheduler_locking_test.rb

@@ -1,3 +1,4 @@
+# vim:fileencoding=utf-8
 require_relative 'test_helper'
 
 module LockTestHelper
@@ -8,36 +9,41 @@ end
 
 context '#master_lock_key' do
   setup do
-    @subject = Class.new { extend Resque::SchedulerLocking }
+    @subject = Class.new { extend Resque::Scheduler::Locking }
   end
 
   teardown do
     Resque.redis.del(@subject.master_lock.key)
   end
 
-  test 'it should have resque prefix' do
-    assert_equal @subject.master_lock.key, 'resque:resque_scheduler_master_lock'
+  test 'should have resque prefix' do
+    assert_equal(
+      @subject.master_lock.key, 'resque:resque_scheduler_master_lock'
+    )
   end
 
   context 'with a prefix set via ENV' do
     setup do
       ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] = 'my.prefix'
-      @subject = Class.new { extend Resque::SchedulerLocking }
+      @subject = Class.new { extend Resque::Scheduler::Locking }
     end
 
     teardown do
       Resque.redis.del(@subject.master_lock.key)
     end
 
-    test 'it should have ENV prefix' do
-      assert_equal @subject.master_lock.key, 'resque:my.prefix:resque_scheduler_master_lock'
+    test 'should have ENV prefix' do
+      assert_equal(
+        @subject.master_lock.key,
+        'resque:my.prefix:resque_scheduler_master_lock'
+      )
     end
   end
 
   context 'with a namespace set for resque' do
     setup do
       Resque.redis.namespace = 'my.namespace'
-      @subject = Class.new { extend Resque::SchedulerLocking }
+      @subject = Class.new { extend Resque::Scheduler::Locking }
     end
 
     teardown do
@@ -45,15 +51,17 @@ context '#master_lock_key' do
       Resque.redis.del(@subject.master_lock.key)
     end
 
-    test 'it should have resque prefix' do
-      assert_equal @subject.master_lock.key, 'my.namespace:resque_scheduler_master_lock'
+    test 'should have resque prefix' do
+      assert_equal(
+        @subject.master_lock.key, 'my.namespace:resque_scheduler_master_lock'
+      )
     end
 
     context 'with a prefix set via ENV' do
       setup do
         Resque.redis.namespace = 'my.namespace'
         ENV['RESQUE_SCHEDULER_MASTER_LOCK_PREFIX'] = 'my.prefix'
-        @subject = Class.new { extend Resque::SchedulerLocking }
+        @subject = Class.new { extend Resque::Scheduler::Locking }
       end
 
       teardown do
@@ -61,45 +69,50 @@ context '#master_lock_key' do
         Resque.redis.del(@subject.master_lock.key)
       end
 
-      test 'it should have ENV prefix' do
-        assert_equal @subject.master_lock.key, 'my.namespace:my.prefix:resque_scheduler_master_lock'
+      test 'should have ENV prefix' do
+        assert_equal(
+          @subject.master_lock.key,
+          'my.namespace:my.prefix:resque_scheduler_master_lock'
+        )
       end
     end
   end
 end
 
-context 'Resque::SchedulerLocking' do
+context 'Resque::Scheduler::Locking' do
   setup do
-    @subject = Class.new { extend Resque::SchedulerLocking }
+    @subject = Class.new { extend Resque::Scheduler::Locking }
   end
 
   teardown do
     Resque.redis.del(@subject.master_lock.key)
   end
 
-  test 'it should use the basic lock mechanism for <= Redis 2.4' do
+  test 'should use the basic lock mechanism for <= Redis 2.4' do
     Resque.redis.stubs(:info).returns('redis_version' => '2.4.16')
 
     assert_equal @subject.master_lock.class, Resque::Scheduler::Lock::Basic
   end
 
-  test 'it should use the resilient lock mechanism for > Redis 2.4' do
+  test 'should use the resilient lock mechanism for > Redis 2.4' do
     Resque.redis.stubs(:info).returns('redis_version' => '2.5.12')
 
-    assert_equal @subject.master_lock.class, Resque::Scheduler::Lock::Resilient
+    assert_equal(
+      @subject.master_lock.class, Resque::Scheduler::Lock::Resilient
+    )
   end
 
-  test 'it should be the master if the lock is held' do
+  test 'should be the master if the lock is held' do
     @subject.master_lock.acquire!
-    assert @subject.is_master?, 'should be master'
+    assert @subject.master?, 'should be master'
   end
 
-  test 'it should not be the master if the lock is held by someone else' do
+  test 'should not be the master if the lock is held by someone else' do
     Resque.redis.set(@subject.master_lock.key, 'somethingelse:1234')
-    assert !@subject.is_master?, 'should not be master'
+    assert !@subject.master?, 'should not be master'
   end
 
-  test "release_master_lock should delegate to master_lock" do
+  test 'release_master_lock should delegate to master_lock' do
     @subject.master_lock.expects(:release!)
     @subject.release_master_lock!
   end
@@ -111,13 +124,13 @@ context 'Resque::Scheduler::Lock::Base' do
   end
 
   test '#acquire! should be not implemented' do
-    assert_raise(NotImplementedError) do
+    assert_raises NotImplementedError do
       @lock.acquire!
     end
   end
 
   test '#locked? should be not implemented' do
-    assert_raise(NotImplementedError) do
+    assert_raises NotImplementedError do
       @lock.locked?
     end
   end
@@ -140,16 +153,17 @@ context 'Resque::Scheduler::Lock::Basic' do
     assert !@lock.locked?
   end
 
-  test 'you should not be able to acquire the lock if someone else holds it' do
+  test 'you should not be able to acquire the lock if someone ' \
+       'else holds it' do
     lock_is_not_held(@lock)
 
     assert !@lock.acquire!
   end
 
-  test "the lock should receive a TTL on acquiring" do
+  test 'the lock should receive a TTL on acquiring' do
     @lock.acquire!
 
-    assert Resque.redis.ttl(@lock.key) > 0, "lock should expire"
+    assert Resque.redis.ttl(@lock.key) > 0, 'lock should expire'
   end
 
   test 'releasing should release the master lock' do
@@ -167,7 +181,7 @@ context 'Resque::Scheduler::Lock::Basic' do
 
     @lock.locked?
 
-    assert Resque.redis.ttl(@lock.key) > 10, "TTL should have been updated"
+    assert Resque.redis.ttl(@lock.key) > 10, 'TTL should have been updated'
   end
 
   test 'checking the lock should not increase the TTL if we do not hold it' do
@@ -176,7 +190,8 @@ context 'Resque::Scheduler::Lock::Basic' do
 
     @lock.locked?
 
-    assert Resque.redis.ttl(@lock.key) <= 10, "TTL should not have been updated"
+    assert Resque.redis.ttl(@lock.key) <= 10,
+           'TTL should not have been updated'
   end
 end
 
@@ -184,7 +199,8 @@ context 'Resque::Scheduler::Lock::Resilient' do
   include LockTestHelper
 
   if !Resque::Scheduler.supports_lua?
-    puts "*** Skipping Resque::Scheduler::Lock::Resilient tests, as they require Redis >= 2.5."
+    puts '*** Skipping Resque::Scheduler::Lock::Resilient ' \
+         'tests, as they require Redis >= 2.5.'
   else
     setup do
       @lock = Resque::Scheduler::Lock::Resilient.new('test_resilient_lock')
@@ -200,16 +216,17 @@ context 'Resque::Scheduler::Lock::Resilient' do
       assert !@lock.locked?, 'you should not have the lock'
     end
 
-    test 'you should not be able to acquire the lock if someone else holds it' do
+    test 'you should not be able to acquire the lock if someone ' \
+         'else holds it' do
       lock_is_not_held(@lock)
 
       assert !@lock.acquire!
     end
 
-    test "the lock should receive a TTL on acquiring" do
+    test 'the lock should receive a TTL on acquiring' do
       @lock.acquire!
 
-      assert Resque.redis.ttl(@lock.key) > 0, "lock should expire"
+      assert Resque.redis.ttl(@lock.key) > 0, 'lock should expire'
     end
 
     test 'releasing should release the master lock' do
@@ -227,16 +244,18 @@ context 'Resque::Scheduler::Lock::Resilient' do
 
       @lock.locked?
 
-      assert Resque.redis.ttl(@lock.key) > 10, "TTL should have been updated"
+      assert Resque.redis.ttl(@lock.key) > 10, 'TTL should have been updated'
     end
 
-    test 'checking the lock should not increase the TTL if we do not hold it' do
+    test 'checking the lock should not increase the TTL if we do ' \
+         'not hold it' do
       Resque.redis.setex(@lock.key, 10, @lock.value)
       lock_is_not_held(@lock)
 
       @lock.locked?
 
-      assert Resque.redis.ttl(@lock.key) <= 10, "TTL should not have been updated"
+      assert Resque.redis.ttl(@lock.key) <= 10,
+             'TTL should not have been updated'
     end
 
     test 'setting the lock timeout changes the key TTL if we hold it' do

data/test/scheduler_setup_test.rb

@@ -1,6 +1,7 @@
+# vim:fileencoding=utf-8
 require_relative 'test_helper'
 
-context "Resque::Scheduler" do
+context 'Resque::Scheduler' do
   setup do
     ENV['VERBOSE'] = nil
     nullify_logger
@@ -13,16 +14,16 @@ context "Resque::Scheduler" do
 
   test 'set custom logger' do
     custom_logger = MonoLogger.new('/dev/null')
-    Resque::Scheduler.logger = custom_logger
-    assert_equal(custom_logger, Resque::Scheduler.logger)
+    Resque::Scheduler.send(:logger=, custom_logger)
+    assert_equal(custom_logger, Resque::Scheduler.send(:logger))
   end
 
   test 'configure block' do
-    Resque::Scheduler.mute = false
+    Resque::Scheduler.quiet = false
     Resque::Scheduler.configure do |c|
-      c.mute = true
+      c.quiet = true
     end
-    assert_equal(Resque::Scheduler.mute, true)
+    assert_equal(Resque::Scheduler.quiet, true)
   end
 
   context 'when getting the env' do
@@ -57,16 +58,17 @@ context "Resque::Scheduler" do
 
     test 'uses STDOUT' do
       assert_equal(
-        Resque::Scheduler.logger.instance_variable_get(:@logdev).dev, $stdout
+        Resque::Scheduler.send(:logger)
+          .instance_variable_get(:@logdev).dev, $stdout
       )
     end
 
     test 'not verbose' do
-      assert Resque::Scheduler.logger.level > MonoLogger::DEBUG
+      assert Resque::Scheduler.send(:logger).level > MonoLogger::DEBUG
     end
 
-    test 'not muted' do
-      assert Resque::Scheduler.logger.level < MonoLogger::FATAL
+    test 'not quieted' do
+      assert Resque::Scheduler.send(:logger).level < MonoLogger::FATAL
     end
   end
 
@@ -77,19 +79,54 @@ context "Resque::Scheduler" do
     test 'uses logfile' do
       Resque::Scheduler.logfile = '/dev/null'
       assert_equal(
-        Resque::Scheduler.logger.instance_variable_get(:@logdev).filename,
+        Resque::Scheduler.send(:logger)
+          .instance_variable_get(:@logdev).filename,
         '/dev/null'
       )
     end
 
     test 'set verbosity' do
       Resque::Scheduler.verbose = true
-      assert Resque::Scheduler.logger.level == MonoLogger::DEBUG
+      assert Resque::Scheduler.send(:logger).level == MonoLogger::DEBUG
     end
 
-    test 'mute logger' do
-      Resque::Scheduler.mute = true
-      assert Resque::Scheduler.logger.level == MonoLogger::FATAL
+    test 'quiet logger' do
+      Resque::Scheduler.quiet = true
+      assert Resque::Scheduler.send(:logger).level == MonoLogger::FATAL
+    end
+  end
+
+  context 'logger with json formatter' do
+    setup do
+      nullify_logger
+      Resque::Scheduler.logformat = 'json'
+      $stdout = StringIO.new
+    end
+
+    teardown do
+      $stdout = STDOUT
+    end
+
+    test 'logs with json' do
+      Resque::Scheduler.log! 'whatever'
+      assert $stdout.string =~ /"msg":"whatever"/
+    end
+  end
+
+  context 'logger with text formatter' do
+    setup do
+      nullify_logger
+      Resque::Scheduler.logformat = 'text'
+      $stdout = StringIO.new
+    end
+
+    teardown do
+      $stdout = STDOUT
+    end
+
+    test 'logs with text' do
+      Resque::Scheduler.log! 'another thing'
+      assert $stdout.string =~ /: another thing/
     end
   end
 end

data/test/scheduler_task_test.rb

@@ -1,28 +1,33 @@
+# vim:fileencoding=utf-8
 require_relative 'test_helper'
 
-context "Resque::Scheduler" do
+context 'Resque::Scheduler' do
   setup do
-    Resque::Scheduler.dynamic = false
+    Resque::Scheduler.configure do |c|
+      c.dynamic = false
+      c.poll_sleep_amount = 0.1
+    end
     Resque.redis.flushall
-    Resque::Scheduler.mute = true
+    Resque::Scheduler.quiet = true
     Resque::Scheduler.clear_schedule!
-    Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
+    Resque::Scheduler.send(:instance_variable_set, :@scheduled_jobs, {})
     Resque::Scheduler.send(:instance_variable_set, :@shutdown, false)
   end
 
-  test "shutdown raises Interrupt when sleeping" do
+  test 'shutdown raises Interrupt when sleeping' do
     Thread.current.expects(:raise).with(Interrupt)
     Resque::Scheduler.send(:instance_variable_set, :@th, Thread.current)
     Resque::Scheduler.send(:instance_variable_set, :@sleeping, true)
     Resque::Scheduler.shutdown
   end
 
-  test "sending TERM to scheduler breaks out of poll_sleep" do
+  test 'sending TERM to scheduler breaks out of poll_sleep' do
     Resque::Scheduler.expects(:release_master_lock!)
-    fork do
-      sleep(0.5)
-      system("kill -TERM #{Process.ppid}")
-      exit!
+
+    @pid = Process.pid
+    Thread.new do
+      sleep(0.05)
+      Process.kill(:TERM, @pid)
     end
 
     assert_raises SystemExit do

data/test/scheduler_test.rb

@@ -1,16 +1,17 @@
+# vim:fileencoding=utf-8
 require_relative 'test_helper'
 
 context 'Resque::Scheduler' do
   setup do
     Resque::Scheduler.configure do |c|
       c.dynamic = false
-      c.mute = true
+      c.quiet = true
       c.env = nil
       c.app_name = nil
     end
     Resque.redis.flushall
     Resque::Scheduler.clear_schedule!
-    Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
+    Resque::Scheduler.send(:instance_variable_set, :@scheduled_jobs, {})
   end
 
   test 'enqueue constantizes' do
@@ -54,45 +55,56 @@ context 'Resque::Scheduler' do
     Resque::Scheduler.enqueue_from_config(config)
   end
 
-  test "config makes it into the rufus_scheduler" do
+  test 'config makes it into the rufus_scheduler' do
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
 
-    Resque.schedule = {:some_ivar_job => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
+    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
 
-  test "can reload schedule" do
+  test 'can reload schedule' do
     Resque::Scheduler.dynamic = true
-    Resque.schedule = {"some_ivar_job" => {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp"}}
+    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")
+    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.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")
+    assert_equal '/tmp/2', Resque.schedule['some_ivar_job2']['args']
+    assert Resque::Scheduler.scheduled_jobs.include?('some_ivar_job2')
   end
 
   test 'load_schedule_job loads a schedule' do
     Resque::Scheduler.load_schedule_job(
-      'some_ivar_job', {
-        'cron' => '* * * * *',
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp'
-      }
+      'some_ivar_job',
+      'cron' => '* * * * *',
+      'class' => 'SomeIvarJob',
+      'args' => '/tmp'
     )
 
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -102,11 +114,10 @@ context 'Resque::Scheduler' do
 
   test 'load_schedule_job with every with options' do
     Resque::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, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -118,11 +129,10 @@ context 'Resque::Scheduler' do
 
   test 'load_schedule_job with cron with options' do
     Resque::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, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -134,10 +144,9 @@ context 'Resque::Scheduler' do
 
   test 'load_schedule_job without cron' do
     Resque::Scheduler.load_schedule_job(
-      'some_ivar_job', {
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp'
-      }
+      'some_ivar_job',
+      'class' => 'SomeIvarJob',
+      'args' => '/tmp'
     )
 
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -147,11 +156,10 @@ context 'Resque::Scheduler' do
 
   test 'load_schedule_job with an empty cron' do
     Resque::Scheduler.load_schedule_job(
-      'some_ivar_job', {
-        'cron' => '',
-        'class' => 'SomeIvarJob',
-        'args' => '/tmp'
-      }
+      'some_ivar_job',
+      'cron' => '',
+      'class' => 'SomeIvarJob',
+      'args' => '/tmp'
     )
 
     assert_equal(0, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -159,26 +167,35 @@ context 'Resque::Scheduler' do
     assert !Resque::Scheduler.scheduled_jobs.keys.include?('some_ivar_job')
   end
 
-  test "update_schedule" do
+  test 'update_schedule' do
     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"}
+      '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(
+      'some_ivar_job',
+      'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/2 '
     )
-    Resque.set_schedule("new_ivar_job",
-      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
+    Resque.set_schedule(
+      'new_ivar_job',
+      'cron' => '* * * * *', 'class' => 'SomeJob', 'args' => '/tmp/3 '
     )
-    Resque.set_schedule("stay_put_job",
-      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp"}
+    Resque.set_schedule(
+      'stay_put_job',
+      'cron' => '* * * * *', 'class' => 'SomeJob', 'args' => '/tmp '
     )
-    Resque.remove_schedule("another_ivar_job")
+    Resque.remove_schedule('another_ivar_job')
 
     Resque::Scheduler.update_schedule
 
@@ -188,34 +205,40 @@ context 'Resque::Scheduler' do
       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 !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
 
-  test "update_schedule with mocks" do
+  test 'update_schedule with mocks' do
     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"}
+      '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(
+      'some_ivar_job',
+      'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/2 '
     )
-    Resque.set_schedule("new_ivar_job",
-      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
+    Resque.set_schedule(
+      'new_ivar_job',
+      'cron' => '* * * * *', 'class' => 'SomeJob', 'args' => '/tmp/3 '
     )
-    Resque.set_schedule("stay_put_job",
-      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp"}
+    Resque.set_schedule(
+      'stay_put_job',
+      'cron' => '* * * * *', 'class' => 'SomeJob', 'args' => '/tmp '
     )
-    Resque.remove_schedule("another_ivar_job")
+    Resque.remove_schedule('another_ivar_job')
 
     Resque::Scheduler.update_schedule
 
@@ -224,99 +247,162 @@ context 'Resque::Scheduler' do
       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 !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
 
-  test "schedule= sets the schedule" do
+  test 'concurrent update_schedule calls' do
     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")))
+    Resque::Scheduler.load_schedule!
+    jobs_count = 100
+
+    background_delayed_update = Thread.new do
+      sleep(0.01)
+      Resque::Scheduler.update_schedule
+    end
+
+    (0...jobs_count).each do |i|
+      Resque.set_schedule(
+        "some_ivar_job#{i}",
+        'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => "/tmp/#{i}"
+      )
+    end
+
+    background_delayed_update.join
+    Resque::Scheduler.update_schedule
+    assert_equal(jobs_count, Resque::Scheduler.rufus_scheduler.all_jobs.size)
+    assert_equal(jobs_count, Resque::Scheduler.scheduled_jobs.size)
+    assert_equal 0, Resque.redis.scard(:schedules_changed)
   end
 
-  test "schedule= removes schedules not present in the given schedule argument" do
+  test 'schedule= sets the schedule' do
     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
 
-    Resque.schedule = {"old_job" => {'cron' => "* * * * *", 'class' => 'OldJob'}}
-    assert_equal({"old_job" => {'cron' => "* * * * *", 'class' => 'OldJob'}}, Resque.schedule)
+  test 'schedule= removes schedules not present in the given ' \
+       'schedule argument' do
+    Resque::Scheduler.dynamic = true
+
+    Resque.schedule = {
+      'old_job' => { 'cron' => '* * * * *', 'class' => 'OldJob' }
+    }
+    assert_equal(
+      { 'old_job' => { 'cron' => '* * * * *', 'class' => 'OldJob' } },
+      Resque.schedule
+    )
 
-    Resque.schedule = {"new_job" => {'cron' => "* * * * *", 'class' => 'NewJob'}}
+    Resque.schedule = {
+      'new_job' => { 'cron' => '* * * * *', 'class' => 'NewJob' }
+    }
     Resque.reload_schedule!
-    assert_equal({"new_job" => {'cron' => "* * * * *", 'class' => 'NewJob'}}, Resque.schedule)
+    assert_equal(
+      { 'new_job' => { 'cron' => '* * * * *', 'class' => 'NewJob' } },
+      Resque.schedule
+    )
   end
 
   test "schedule= uses job name as 'class' argument if it's missing" do
     Resque::Scheduler.dynamic = true
-    Resque.schedule = {"SomeIvarJob" => {
-      'cron' => "* * * * *", 'args' => "/tmp/75"
-    }}
-    assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/75"},
-      Resque.decode(Resque.redis.hget(:schedules, "SomeIvarJob")))
+    Resque.schedule = { 'SomeIvarJob' => {
+      'cron' => '* * * * *', 'args' => '/tmp/75'
+    } }
+    assert_equal(
+      { 'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/75' },
+      Resque.decode(Resque.redis.hget(:schedules, 'SomeIvarJob'))
+    )
     assert_equal('SomeIvarJob', Resque.schedule['SomeIvarJob']['class'])
   end
 
-  test "schedule= does not mutate argument" do
-    schedule = {"SomeIvarJob" => {
-      'cron' => "* * * * *", 'args' => "/tmp/75"
-    }}
+  test 'schedule= does not mutate argument' do
+    schedule = { 'SomeIvarJob' => {
+      'cron' => '* * * * *', 'args' => '/tmp/75'
+    } }
     Resque.schedule = schedule
     assert !schedule['SomeIvarJob'].key?('class')
   end
 
-  test "set_schedule can set an individual schedule" do
-    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")
+  test 'set_schedule can set an individual schedule' do
+    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
 
-  test "get_schedule returns a schedule" do
-    Resque.redis.hset(:schedules, "some_ivar_job2", Resque.encode(
-      'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/33"
+  test 'fetch_schedule returns a schedule' do
+    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"))
+    assert_equal(
+      { 'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/33' },
+      Resque.fetch_schedule('some_ivar_job2')
+    )
   end
 
-  test "remove_schedule removes a schedule" do
-    Resque.set_schedule("some_ivar_job3",
-      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/44", 'persist' => true}
+  test 'remove_schedule removes a schedule' do
+    Resque.set_schedule(
+      'some_ivar_job3',
+      'cron' => '* * * * *',
+      'class' => 'SomeIvarJob',
+      'args' => '/tmp/44',
+      'persist' => true
     )
     Resque::Scheduler.load_schedule!
-    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")
+    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')
     assert_equal [], Resque.redis.smembers(:persisted_schedules)
   end
 
-  test "persisted schedules" do
-    Resque.set_schedule("some_ivar_job",
-      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2", 'persist' => true}
+  test 'persisted schedules' do
+    Resque.set_schedule(
+      'some_ivar_job',
+      'cron' => '* * * * *',
+      'class' => 'SomeIvarJob',
+      'args' => '/tmp/2',
+      'persist' => true
     )
-    Resque.set_schedule("new_ivar_job",
-      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
+    Resque.set_schedule(
+      'new_ivar_job',
+      'cron' => '* * * * *',
+      'class' => 'SomeJob',
+      'args' => '/tmp/3 '
     )
 
-    Resque.schedule=({
-      'a_schedule' => {'cron' => "* * * * *", 'class' => 'SomeOtherJob', 'args' => '/tmp'}
-    })
+    Resque.schedule = {
+      'a_schedule' => {
+        'cron' => '* * * * *', 'class' => 'SomeOtherJob', 'args' => '/tmp'
+      }
+    }
     Resque::Scheduler.load_schedule!
 
-    assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"},
-      Resque.schedule['some_ivar_job'])
+    assert_equal(
+      { 'cron' => '* * * * *', 'class' => 'SomeIvarJob', 'args' => '/tmp/2' },
+      Resque.schedule['some_ivar_job']
+    )
     assert_equal(nil, Resque.schedule['some_job'])
   end
 
-  test "adheres to lint" do
+  test 'adheres to lint' do
     assert_nothing_raised do
       Resque::Plugin.lint(Resque::Scheduler)
-      Resque::Plugin.lint(ResqueScheduler)
+      Resque::Plugin.lint(Resque::Scheduler::Extension)
     end
   end
 
@@ -341,4 +427,19 @@ context 'Resque::Scheduler' do
     assert Resque::Scheduler.send(:build_procline, 'cage') =~
       /#{Resque::Scheduler.send(:internal_name)}: cage/
   end
+
+  context 'printing schedule' do
+    setup do
+      Resque::Scheduler.expects(:log!).at_least_once
+    end
+
+    test 'prints schedule' do
+      fake_rufus_scheduler = mock
+      fake_rufus_scheduler.expects(:all_jobs).at_least_once
+        .returns(foo: OpenStruct.new(t: nil, last: nil))
+      Resque::Scheduler.expects(:rufus_scheduler).at_least_once
+        .returns(fake_rufus_scheduler)
+      Resque::Scheduler.print_schedule
+    end
+  end
 end