resque-scheduler 2.5.1 → 4.10.2

data/test/scheduler_setup_test.rb

@@ -1,95 +0,0 @@
-require_relative 'test_helper'
-
-context "Resque::Scheduler" do
-  setup do
-    ENV['VERBOSE'] = nil
-    nullify_logger
-    Resque::Scheduler.dynamic = false
-    Resque.redis.flushall
-    Resque::Scheduler.clear_schedule!
-  end
-
-  teardown { restore_devnull_logfile }
-
-  test 'set custom logger' do
-    custom_logger = Logger.new('/dev/null')
-    Resque::Scheduler.logger = custom_logger
-    assert_equal(custom_logger, Resque::Scheduler.logger)
-  end
-
-  test 'configure block' do
-    Resque::Scheduler.mute = false
-    Resque::Scheduler.configure do |c|
-      c.mute = true
-    end
-    assert_equal(Resque::Scheduler.mute, true)
-  end
-
-  context 'when getting the env' do
-    def wipe
-      Resque::Scheduler.env = nil
-      Rails.env = nil
-      ENV['RAILS_ENV'] = nil
-    end
-
-    setup { wipe }
-    teardown { wipe }
-
-    test 'uses the value if set' do
-      Resque::Scheduler.env = 'foo'
-      assert_equal('foo', Resque::Scheduler.env)
-    end
-
-    test 'uses Rails.env if present' do
-      Rails.env = 'bar'
-      assert_equal('bar', Resque::Scheduler.env)
-    end
-
-    test 'uses $RAILS_ENV if present' do
-      ENV['RAILS_ENV'] = 'baz'
-      assert_equal('baz', Resque::Scheduler.env)
-    end
-  end
-
-  context 'logger default settings' do
-    setup { nullify_logger }
-    teardown { restore_devnull_logfile }
-
-    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
-  end
-
-  context 'logger custom settings' do
-    setup { nullify_logger }
-    teardown { restore_devnull_logfile }
-
-    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
-  end
-end

data/test/scheduler_task_test.rb

@@ -1,35 +0,0 @@
-require_relative 'test_helper'
-
-context "Resque::Scheduler" do
-  setup do
-    Resque::Scheduler.dynamic = false
-    Resque.redis.flushall
-    Resque::Scheduler.mute = true
-    Resque::Scheduler.clear_schedule!
-    Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
-    Resque::Scheduler.send(:instance_variable_set, :@shutdown, false)
-  end
-
-  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
-    Resque::Scheduler.expects(:release_master_lock!)
-    fork do
-      sleep(0.5)
-      system("kill -TERM #{Process.ppid}")
-      exit!
-    end
-
-    assert_raises SystemExit do
-      Resque::Scheduler.run
-    end
-
-    Resque::Scheduler.unstub(:release_master_lock!)
-    Resque::Scheduler.release_master_lock!
-  end
-end

data/test/scheduler_test.rb

@@ -1,344 +0,0 @@
-require_relative 'test_helper'
-
-context 'Resque::Scheduler' do
-  setup do
-    Resque::Scheduler.configure do |c|
-      c.dynamic = false
-      c.mute = true
-      c.env = nil
-      c.app_name = nil
-    end
-    Resque.redis.flushall
-    Resque::Scheduler.clear_schedule!
-    Resque::Scheduler.send(:class_variable_set, :@@scheduled_jobs, {})
-  end
-
-  test 'enqueue constantizes' do
-    Resque::Scheduler.env = 'production'
-    config = {
-      'cron' => '* * * * *',
-      'class' => 'SomeRealClass',
-      'args' => '/tmp'
-    }
-    Resque::Job.expects(:create).with(
-      SomeRealClass.queue, SomeRealClass, '/tmp'
-    )
-    Resque::Scheduler.enqueue_from_config(config)
-  end
-
-  test 'enqueue runs hooks' do
-    Resque::Scheduler.env = 'production'
-    config = {
-      'cron' => '* * * * *',
-      'class' => 'SomeRealClass',
-      'args' => '/tmp'
-    }
-
-    Resque::Job.expects(:create).with(
-      SomeRealClass.queue, SomeRealClass, '/tmp'
-    )
-    SomeRealClass.expects(:before_delayed_enqueue_example).with('/tmp')
-    SomeRealClass.expects(:before_enqueue_example).with('/tmp')
-    SomeRealClass.expects(:after_enqueue_example).with('/tmp')
-
-    Resque::Scheduler.enqueue_from_config(config)
-  end
-
-  test 'enqueue_from_config respects queue params' do
-    config = {
-      'cron' => '* * * * *',
-      'class' => 'SomeIvarJob',
-      'queue' => 'high'
-    }
-    Resque.expects(:enqueue_to).with('high', SomeIvarJob)
-    Resque::Scheduler.enqueue_from_config(config)
-  end
-
-  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::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
-    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
-
-  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
-    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)
-    assert_equal(1, Resque::Scheduler.scheduled_jobs.size)
-    assert Resque::Scheduler.scheduled_jobs.keys.include?('some_ivar_job')
-    job = Resque::Scheduler.scheduled_jobs['some_ivar_job']
-    assert job.params.keys.include?(:first_in)
-  end
-
-  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)
-    assert_equal(1, Resque::Scheduler.scheduled_jobs.size)
-    assert Resque::Scheduler.scheduled_jobs.keys.include?('some_ivar_job')
-    job = Resque::Scheduler.scheduled_jobs['some_ivar_job']
-    assert job.params.keys.include?(:allow_overlapping)
-  end
-
-  test 'load_schedule_job without cron' do
-    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
-
-  test 'load_schedule_job with an empty cron' do
-    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
-
-  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"}
-    }
-
-    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
-
-  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"}
-    }
-
-    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
-
-  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
-
-  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" => {
-      '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"
-    }}
-    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")
-  end
-
-  test "get_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"))
-  end
-
-  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")
-    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}
-    )
-    Resque.set_schedule("new_ivar_job",
-      {'cron' => "* * * * *", 'class' => 'SomeJob', 'args' => "/tmp/3"}
-    )
-
-    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(nil, Resque.schedule['some_job'])
-  end
-
-  test "adheres to lint" do
-    assert_nothing_raised do
-      Resque::Plugin.lint(Resque::Scheduler)
-      Resque::Plugin.lint(ResqueScheduler)
-    end
-  end
-
-  test 'procline contains app_name when present' do
-    Resque::Scheduler.app_name = 'foo'
-    assert Resque::Scheduler.send(:build_procline, 'bar') =~ /\[foo\]:/
-  end
-
-  test 'procline omits app_name when absent' do
-    Resque::Scheduler.app_name = nil
-    assert Resque::Scheduler.send(:build_procline, 'bar') =~
-      /#{Resque::Scheduler.send(:internal_name)}: bar/
-  end
-
-  test 'procline contains env when present' do
-    Resque::Scheduler.env = 'derp'
-    assert Resque::Scheduler.send(:build_procline, 'cage') =~ /\[derp\]: cage/
-  end
-
-  test 'procline omits env when absent' do
-    Resque::Scheduler.env = nil
-    assert Resque::Scheduler.send(:build_procline, 'cage') =~
-      /#{Resque::Scheduler.send(:internal_name)}: cage/
-  end
-end

data/test/support/redis_instance.rb

@@ -1,134 +0,0 @@
-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_redis_server_present!
-      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 { stop! }
-      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 ensure_redis_server_present!
-      if !system('redis-server -v')
-        fail "** can't find `redis-server` in your path"
-      end
-    end
-
-    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
-