resque-scheduler 2.2.0 → 4.10.2

data/test/support/redis_instance.rb

@@ -1,129 +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_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
-        raise "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

@@ -1,92 +0,0 @@
-
-# Pretty much copied this file from the resque test_helper since we want
-# to do all the same stuff
-
-dir = File.dirname(File.expand_path(__FILE__))
-
-require 'rubygems'
-require 'test/unit'
-require 'mocha/setup'
-require 'resque'
-$LOAD_PATH.unshift File.dirname(File.expand_path(__FILE__)) + '/../lib'
-require 'resque_scheduler'
-require 'resque_scheduler/server'
-
-#
-# make sure we can run redis
-#
-
-if !system("which redis-server")
-  puts '', "** can't find `redis-server` in your path"
-  puts "** try running `sudo rake install`"
-  abort ''
-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 $!
-
-  if defined?(MiniTest)
-    exit_code = MiniTest::Unit.new.run(ARGV)
-  else
-    exit_code = Test::Unit::AutoRunner.run
-  end
-
-  exit exit_code
-end
-
-##
-# test/spec/mini 3
-# http://gist.github.com/25455
-# chris@ozmm.org
-#
-def context(*args, &block)
-  return super unless (name = args.first) && block
-  require 'test/unit'
-  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
-    def self.test(name, &block)
-      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
-    end
-    def self.xtest(*args) end
-    def self.setup(&block) define_method(:setup, &block) end
-    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)
-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
-end
-
-class SomeIvarJob < SomeJob
-  @queue = :ivar
-end
-
-class SomeRealClass
-  def self.queue
-    :some_real_queue
-  end
-end
-
-def nullify_logger
-  Resque::Scheduler.mute    = nil
-  Resque::Scheduler.verbose = nil
-  Resque::Scheduler.logfile = nil
-  Resque::Scheduler.logger  = nil
-end