resque-scheduler 2.0.0 → 2.3.1

data/test/scheduler_locking_test.rb

@@ -0,0 +1,180 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+module LockTestHelper
+  def lock_is_not_held(lock)
+    Resque.redis.set(lock.key, 'anothermachine:1234')
+  end
+end
+
+context 'Resque::SchedulerLocking' do
+  setup do
+    @subject = Class.new { extend Resque::SchedulerLocking }
+  end
+
+  teardown do
+    Resque.redis.del(@subject.master_lock.key)
+  end
+
+  test 'it 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
+    Resque.redis.stubs(:info).returns('redis_version' => '2.5.12')
+
+    assert_equal @subject.master_lock.class, Resque::Scheduler::Lock::Resilient
+  end
+
+  test 'it should be the master if the lock is held' do
+    @subject.master_lock.acquire!
+    assert @subject.is_master?, 'should be master'
+  end
+
+  test 'it 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'
+  end
+
+  test "release_master_lock should delegate to master_lock" do
+    @subject.master_lock.expects(:release!)
+    @subject.release_master_lock!
+  end
+end
+
+context 'Resque::Scheduler::Lock::Base' do
+  setup do
+    @lock = Resque::Scheduler::Lock::Base.new('test_lock_key')
+  end
+
+  test '#acquire! should be not implemented' do
+    assert_raise(NotImplementedError) do
+      @lock.acquire!
+    end
+  end
+
+  test '#locked? should be not implemented' do
+    assert_raise(NotImplementedError) do
+      @lock.locked?
+    end
+  end
+end
+
+context 'Resque::Scheduler::Lock::Basic' do
+  include LockTestHelper
+
+  setup do
+    @lock = Resque::Scheduler::Lock::Basic.new('test_lock_key')
+  end
+
+  teardown do
+    @lock.release!
+  end
+
+  test 'you should not have the lock if someone else holds it' do
+    lock_is_not_held(@lock)
+
+    assert !@lock.locked?
+  end
+
+  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
+    @lock.acquire!
+
+    assert Resque.redis.ttl(@lock.key) > 0, "lock should expire"
+  end
+
+  test 'releasing should release the master lock' do
+    assert @lock.acquire!, 'should have acquired the master lock'
+    assert @lock.locked?, 'should be locked'
+
+    @lock.release!
+
+    assert !@lock.locked?, 'should not be locked'
+  end
+
+  test 'checking the lock should increase the TTL if we hold it' do
+    @lock.acquire!
+    Resque.redis.setex(@lock.key, 10, @lock.value)
+
+    @lock.locked?
+
+    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
+    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"
+  end
+end
+
+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."
+  else
+    setup do
+      @lock = Resque::Scheduler::Lock::Resilient.new('test_resilient_lock')
+    end
+
+    teardown do
+      @lock.release!
+    end
+
+    test 'you should not have the lock if someone else holds it' do
+      lock_is_not_held(@lock)
+
+      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
+      lock_is_not_held(@lock)
+
+      assert !@lock.acquire!
+    end
+
+    test "the lock should receive a TTL on acquiring" do
+      @lock.acquire!
+
+      assert Resque.redis.ttl(@lock.key) > 0, "lock should expire"
+    end
+
+    test 'releasing should release the master lock' do
+      assert @lock.acquire!, 'should have acquired the master lock'
+      assert @lock.locked?, 'should be locked'
+
+      @lock.release!
+
+      assert !@lock.locked?, 'should not be locked'
+    end
+
+    test 'checking the lock should increase the TTL if we hold it' do
+      @lock.acquire!
+      Resque.redis.setex(@lock.key, 10, @lock.value)
+
+      @lock.locked?
+
+      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
+      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"
+    end
+  end
+end

data/test/scheduler_setup_test.rb

@@ -0,0 +1,59 @@
+require File.dirname(__FILE__) + '/test_helper'
+
+context "Resque::Scheduler" do
+
+  setup do
+    Resque::Scheduler.dynamic = false
+    Resque.redis.flushall
+    Resque::Scheduler.clear_schedule!
+  end
+
+  test 'set custom logger' do
+    custom_logger = Logger.new('/dev/null')
+    Resque::Scheduler.logger = custom_logger
+    assert_equal(custom_logger, Resque::Scheduler.logger)
+  end
+
+  context 'logger default settings' do
+    setup do
+      nullify_logger
+    end
+
+    test 'uses STDOUT' do
+      assert_equal(Resque::Scheduler.logger.instance_variable_get(:@logdev).dev, STDOUT)
+    end
+    test 'not verbose' do
+      assert Resque::Scheduler.logger.level > Logger::DEBUG
+    end
+    test 'not muted' do
+      assert Resque::Scheduler.logger.level < Logger::FATAL
+    end
+
+    teardown do
+      nullify_logger
+    end
+  end
+
+  context 'logger custom settings' do
+    setup do
+      nullify_logger
+    end
+
+    test 'uses logfile' do
+      Resque::Scheduler.logfile = '/dev/null'
+      assert_equal(Resque::Scheduler.logger.instance_variable_get(:@logdev).filename, '/dev/null')
+    end
+    test 'set verbosity' do
+      Resque::Scheduler.verbose = true
+      assert Resque::Scheduler.logger.level == Logger::DEBUG
+    end
+    test 'mute logger' do
+      Resque::Scheduler.mute = true
+      assert Resque::Scheduler.logger.level == Logger::FATAL
+    end
+
+    teardown do
+      nullify_logger
+    end
+  end
+end

data/test/scheduler_test.rb

@@ -4,8 +4,7 @@ context "Resque::Scheduler" do
 
   setup do
     Resque::Scheduler.dynamic = false
-    Resque.redis.del(:schedules)
-    Resque.redis.del(:schedules_changed)
+    Resque.redis.flushall
     Resque::Scheduler.mute = true
     Resque::Scheduler.clear_schedule!
     Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
@@ -47,7 +46,7 @@ context "Resque::Scheduler" do
     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')
   end
 
   test "can reload schedule" do
@@ -61,7 +60,7 @@ context "Resque::Scheduler" do
 
     Resque.redis.del(:schedules)
     Resque.redis.hset(:schedules, "some_ivar_job2", Resque.encode(
-      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"}
+      'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/2"
     ))
 
     Resque::Scheduler.reload_schedule!
@@ -72,15 +71,15 @@ context "Resque::Scheduler" do
     assert Resque::Scheduler.scheduled_jobs.include?("some_ivar_job2")
   end
 
-  test "load_schedule_job loads a schedule" do 
+  test "load_schedule_job loads a schedule" do
     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
-  
-  test "load_schedule_job with every with options" 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"})
 
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -88,8 +87,8 @@ context "Resque::Scheduler" do
     assert Resque::Scheduler.scheduled_jobs.keys.include?("some_ivar_job")
     assert Resque::Scheduler.scheduled_jobs["some_ivar_job"].params.keys.include?(:first_in)
   end
-  
-  test "load_schedule_job with cron with options" 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"})
 
     assert_equal(1, Resque::Scheduler.rufus_scheduler.all_jobs.size)
@@ -193,6 +192,17 @@ context "Resque::Scheduler" do
       Resque.decode(Resque.redis.hget(:schedules, "my_ivar_job")))
   end
 
+  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.reload_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" => {
@@ -222,7 +232,7 @@ context "Resque::Scheduler" do
 
   test "get_schedule returns a schedule" do
     Resque.redis.hset(:schedules, "some_ivar_job2", Resque.encode(
-      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/33"}
+      'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/33"
     ))
     assert_equal({'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/33"},
       Resque.get_schedule("some_ivar_job2"))
@@ -230,7 +240,7 @@ context "Resque::Scheduler" do
 
   test "remove_schedule removes a schedule" do
     Resque.redis.hset(:schedules, "some_ivar_job3", Resque.encode(
-      {'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/44"}
+      'cron' => "* * * * *", 'class' => 'SomeIvarJob', 'args' => "/tmp/44"
     ))
     Resque.remove_schedule("some_ivar_job3")
     assert_equal nil, Resque.redis.hget(:schedules, "some_ivar_job3")
@@ -243,5 +253,4 @@ context "Resque::Scheduler" do
       Resque::Plugin.lint(ResqueScheduler)
     end
   end
-
 end

data/test/support/redis_instance.rb

@@ -0,0 +1,129 @@
+require 'socket'
+require 'timeout'
+require 'fileutils'
+
+class RedisInstance
+  class << self
+    @running = false
+    @port = nil
+    @pid = nil
+
+    def run_if_needed!
+      run! unless running?
+    end
+
+    def run!
+      ensure_pid_directory
+      reassign_redis_clients
+      start_redis_server
+
+      if $?.success?
+        wait_for_pid
+        puts "Booted isolated Redis on port #{port} with PID #{pid}."
+
+        wait_for_redis_boot
+
+        # Ensure we tear down Redis on Ctrl+C / test failure.
+        at_exit do
+          RedisInstance.stop!
+        end
+      else
+        fail "Failed to start Redis on port #{port}."
+      end
+
+      @running = true
+    end
+
+    def stop!
+      $stdout.puts "Sending TERM to Redis (#{pid})..."
+      Process.kill('TERM', pid)
+
+      @port = nil
+      @running = false
+      @pid = nil
+    end
+
+    def running?
+      @running
+    end
+
+    private
+
+    def wait_for_redis_boot
+      Timeout::timeout(10) do
+        begin
+          while Resque.redis.ping != 'PONG'
+          end
+        rescue
+          # silence all errors
+        end
+      end
+    end
+
+    def ensure_pid_directory
+      FileUtils.mkdir_p(File.dirname(pid_file))
+    end
+
+    def reassign_redis_clients
+      Resque.redis = Redis.new(:hostname => '127.0.0.1', :port => port, :thread_safe => true)
+    end
+
+    def start_redis_server
+      IO.popen("redis-server -", "w+") do |server|
+        server.write(config)
+        server.close_write
+      end
+    end
+
+    def pid
+      @pid ||= File.read(pid_file).to_i
+    end
+
+    def wait_for_pid
+      Timeout::timeout(10) do
+        while !File.exist?(pid_file)
+        end
+      end
+    end
+
+    def port
+      @port ||= random_port
+    end
+
+    def pid_file
+      "/tmp/redis-scheduler-test.pid"
+    end
+
+    def config
+      <<-EOF
+        daemonize yes
+        pidfile #{pid_file}
+        port #{port}
+      EOF
+    end
+
+    # Returns a random port in the upper (10000-65535) range.
+    def random_port
+      ports = (10000..65535).to_a
+
+      loop do
+        port = ports[rand(ports.size)]
+        return port if port_available?('127.0.0.1', port)
+      end
+    end
+
+    def port_available?(ip, port, seconds=1)
+      Timeout::timeout(seconds) do
+        begin
+          TCPSocket.new(ip, port).close
+          false
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          true
+        end
+      end
+    rescue Timeout::Error
+      true
+    end
+  end
+end
+

data/test/test_helper.rb

@@ -6,7 +6,7 @@ dir = File.dirname(File.expand_path(__FILE__))
 
 require 'rubygems'
 require 'test/unit'
-require 'mocha'
+require 'mocha/setup'
 require 'resque'
 $LOAD_PATH.unshift File.dirname(File.expand_path(__FILE__)) + '/../lib'
 require 'resque_scheduler'
@@ -23,10 +23,10 @@ if !system("which redis-server")
 end
 
 
-#
-# start our own redis when the tests start,
-# kill it when they end
-#
+# Start our own Redis when the tests start. RedisInstance will take care of
+# starting and stopping.
+require File.dirname(__FILE__) + '/support/redis_instance'
+RedisInstance.run!
 
 at_exit do
   next if $!
@@ -37,17 +37,9 @@ at_exit do
     exit_code = Test::Unit::AutoRunner.run
   end
 
-  pid = `ps -e -o pid,command | grep [r]edis-test`.split(" ")[0]
-  puts "Killing test redis server..."
-  `rm -f #{dir}/dump.rdb`
-  Process.kill("KILL", pid.to_i)
   exit exit_code
 end
 
-puts "Starting redis for testing at localhost:9736..."
-`redis-server #{dir}/redis-test.conf`
-Resque.redis = 'localhost:9736'
-
 ##
 # test/spec/mini 3
 # http://gist.github.com/25455
@@ -65,13 +57,18 @@ def context(*args, &block)
     def self.teardown(&block) define_method(:teardown, &block) end
   end
   (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
-  klass.class_eval &block
+  klass.class_eval(&block)
 end
 
 class FakeCustomJobClass
   def self.scheduled(queue, klass, *args); end
 end
 
+class FakeCustomJobClassEnqueueAt
+  @queue = :test
+  def self.scheduled(queue, klass, *args); end
+end
+
 class SomeJob
   def self.perform(repo_id, path)
   end
@@ -86,3 +83,18 @@ class SomeRealClass
     :some_real_queue
   end
 end
+
+class JobWithParams
+  def self.perform(*args)
+    @args = args
+  end
+end
+
+JobWithoutParams = Class.new(JobWithParams)
+
+def nullify_logger
+  Resque::Scheduler.mute    = nil
+  Resque::Scheduler.verbose = nil
+  Resque::Scheduler.logfile = nil
+  Resque::Scheduler.logger  = nil
+end