giraffesoft-unicorn 0.93.5

data/test/rails/app-2.3.3.1/config/database.yml

@@ -0,0 +1,12 @@
+development:
+  adapter: sqlite3
+  database: db/development.sqlite3
+  timeout: 5000
+test:
+  adapter: sqlite3
+  database: db/test.sqlite3
+  timeout: 5000
+production:
+  adapter: sqlite3
+  database: db/production.sqlite3
+  timeout: 5000

data/test/rails/app-2.3.3.1/config/environment.rb

@@ -0,0 +1,17 @@
+# -*- encoding: binary -*-
+
+unless defined? RAILS_GEM_VERSION
+  RAILS_GEM_VERSION = ENV['UNICORN_RAILS_VERSION']
+end
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  config.frameworks -= [ :active_resource, :action_mailer ]
+  config.action_controller.session_store = :active_record_store
+  config.action_controller.session = {
+    :session_key => "_unicorn_rails_test.#{rand}",
+    :secret => "#{rand}#{rand}#{rand}#{rand}",
+  }
+end

data/test/rails/app-2.3.3.1/config/environments/development.rb

@@ -0,0 +1,7 @@
+# -*- encoding: binary -*-
+
+config.cache_classes = false
+config.whiny_nils = true
+config.action_controller.consider_all_requests_local = true
+config.action_view.debug_rjs                         = true
+config.action_controller.perform_caching             = false

data/test/rails/app-2.3.3.1/config/environments/production.rb

@@ -0,0 +1,6 @@
+# -*- encoding: binary -*-
+
+config.cache_classes = true
+config.action_controller.consider_all_requests_local = false
+config.action_controller.perform_caching             = true
+config.action_view.cache_template_loading            = true

data/test/rails/app-2.3.3.1/config/routes.rb

@@ -0,0 +1,6 @@
+# -*- encoding: binary -*-
+
+ActionController::Routing::Routes.draw do |map|
+  map.connect ':controller/:action/:id'
+  map.connect ':controller/:action/:id.:format'
+end

data/test/rails/app-2.3.3.1/public/404.html

@@ -0,0 +1 @@
+404 Not Found

data/test/rails/app-2.3.3.1/public/500.html

@@ -0,0 +1 @@
+500 Internal Server Error

data/test/rails/app-2.3.3.1/public/x.txt

@@ -0,0 +1 @@
+HELLO

data/test/rails/test_rails.rb

@@ -0,0 +1,280 @@
+# -*- encoding: binary -*-
+
+# Copyright (c) 2009 Eric Wong
+require 'test/test_helper'
+
+# don't call exit(0) since it may be run under rake (but gmake is recommended)
+do_test = true
+
+$unicorn_rails_bin = ENV['UNICORN_RAILS_TEST_BIN'] || "unicorn_rails"
+redirect_test_io { do_test = system($unicorn_rails_bin, '-v') }
+
+unless do_test
+  warn "#$unicorn_rails_bin not found in PATH=#{ENV['PATH']}, " \
+       "skipping this test"
+end
+
+unless which('git')
+  warn "git not found in PATH=#{ENV['PATH']}, skipping this test"
+  do_test = false
+end
+
+if RAILS_GIT_REPO = ENV['RAILS_GIT_REPO']
+  unless File.directory?(RAILS_GIT_REPO)
+    warn "#{RAILS_GIT_REPO} not found, create it with:\n" \
+         "\tgit clone --mirror git://github.com/rails/rails #{RAILS_GIT_REPO}" \
+         "skipping this test for now"
+    do_test = false
+  end
+else
+  warn "RAILS_GIT_REPO not defined, don't know where to git clone from"
+  do_test = false
+end
+
+unless UNICORN_RAILS_TEST_VERSION = ENV['UNICORN_RAILS_TEST_VERSION']
+  warn 'UNICORN_RAILS_TEST_VERSION not defined in environment, ' \
+       'skipping this test'
+  do_test = false
+end
+
+RAILS_ROOT = "#{File.dirname(__FILE__)}/app-#{UNICORN_RAILS_TEST_VERSION}"
+unless File.directory?(RAILS_ROOT)
+  warn "unsupported UNICORN_RAILS_TEST_VERSION=#{UNICORN_RAILS_TEST_VERSION}"
+  do_test = false
+end
+
+ROR_V = UNICORN_RAILS_TEST_VERSION.split(/\./).map { |x| x.to_i }
+RB_V = RUBY_VERSION.split(/\./).map { |x| x.to_i }
+if RB_V[0] >= 1 && RB_V[1] >= 9
+  unless ROR_V[0] >= 2 && ROR_V[1] >= 3
+    warn "skipping Ruby >=1.9 test with Rails <2.3"
+    do_test = false
+  end
+end
+
+class RailsTest < Test::Unit::TestCase
+  trap(:QUIT, 'IGNORE')
+
+  COMMON_TMP = Tempfile.new('unicorn_tmp') unless defined?(COMMON_TMP)
+
+  HEAVY_CFG = <<-EOS
+worker_processes 2
+timeout 30
+logger Logger.new('#{COMMON_TMP.path}')
+  EOS
+
+  def setup
+    @pwd = Dir.pwd
+    @tmpfile = Tempfile.new('unicorn_rails_test')
+    @tmpdir = @tmpfile.path
+    @tmpfile.close!
+    assert_nothing_raised do
+      FileUtils.cp_r(RAILS_ROOT, @tmpdir, :preserve => true)
+    end
+    Dir.chdir(@tmpdir)
+    system('git', 'clone', '-nsq', RAILS_GIT_REPO, 'vendor/rails')
+    Dir.chdir("#@tmpdir/vendor/rails") do
+      system('git', 'reset', '-q', '--hard', "v#{UNICORN_RAILS_TEST_VERSION}")
+    end
+
+    assert(system('rake', 'db:sessions:create'))
+    assert(system('rake', 'db:migrate'))
+
+    @addr = ENV['UNICORN_TEST_ADDR'] || '127.0.0.1'
+    @port = unused_port(@addr)
+    @start_pid = $$
+    @pid = nil
+  end
+
+  def test_launcher
+    tmp_dirs = %w(cache pids sessions sockets)
+    tmp_dirs.each { |dir| assert(! File.exist?("tmp/#{dir}")) }
+    redirect_test_io { @pid = fork { exec 'unicorn_rails', "-l#@addr:#@port" } }
+    wait_master_ready("test_stderr.#$$.log")
+
+    # temp dirs exist
+    tmp_dirs.each { |dir| assert(File.directory?("tmp/#{dir}")) }
+
+    # basic GET
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/foo"))
+    assert_equal "FOO\n", res.body
+    assert_match %r{^text/html\b}, res['Content-Type']
+    assert_equal "4", res['Content-Length']
+    assert_equal "200 OK", res['Status']
+
+    # can we set cookies?
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/foo/xcookie"))
+    assert_equal "200", res.code
+    assert_equal "200 OK", res['Status']
+    cookies = res.get_fields('Set-Cookie')
+    assert_equal 2, cookies.size
+    assert_equal 1, cookies.grep(/\A_unicorn_rails_test\./).size
+    assert_equal 1, cookies.grep(/\Afoo=cookie/).size
+
+    # how about just a session?
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/foo/xnotice"))
+    assert_equal "200", res.code
+    assert_equal "200 OK", res['Status']
+    cookies = res.get_fields('Set-Cookie')
+    assert_equal 1, cookies.size
+    assert_equal 1, cookies.grep(/\A_unicorn_rails_test\./).size
+
+    # posting forms?
+    uri = URI.parse("http://#@addr:#@port/foo/xpost")
+    wait_master_ready("test_stderr.#$$.log")
+    res = Net::HTTP.post_form(uri, {"a" => "b", "c"=>"d"})
+    assert_equal "200", res.code
+    params = res.body.split(/\n/).grep(/^params:/)
+    assert_equal 1, params.size
+    params = eval(params[0].gsub!(/\Aparams:/, ''))
+    assert_equal Hash, params.class
+    assert_equal 'b', params['a']
+    assert_equal 'd', params['c']
+    assert_equal "200 OK", res['Status']
+
+    # try uploading a big file
+    tmp = Tempfile.new('random')
+    sha1 = Digest::SHA1.new
+    assert_nothing_raised do
+      File.open("/dev/urandom", "rb") do |fp|
+        256.times do
+          buf = fp.sysread(4096)
+          sha1.update(buf)
+          tmp.syswrite(buf)
+        end
+      end
+    end
+
+    # fixed in Rack commit 44ed4640f077504a49b7f1cabf8d6ad7a13f6441,
+    # no released version of Rails or Rack has this fix
+    if RB_V[0] >= 1 && RB_V[1] >= 9
+      warn "multipart broken with Rack 1.0.0 and Rails 2.3.2.1 under 1.9"
+    else
+      resp = `curl -isSfN -Ffile=@#{tmp.path} http://#@addr:#@port/foo/xpost`
+      assert $?.success?
+      resp = resp.split(/\r?\n/)
+      grepped = resp.grep(/^sha1: (.{40})/)
+      assert_equal 1, grepped.size
+      assert_equal(sha1.hexdigest, /^sha1: (.{40})/.match(grepped.first)[1])
+
+      grepped = resp.grep(/^Content-Type:\s+(.+)/i)
+      assert_equal 1, grepped.size
+      assert_match %r{^text/plain}, grepped.first.split(/\s*:\s*/)[1]
+      assert_equal 1, resp.grep(/^Status:/i).size
+    end
+
+    # make sure we can get 403 responses, too
+    uri = URI.parse("http://#@addr:#@port/foo/xpost")
+    wait_master_ready("test_stderr.#$$.log")
+    res = Net::HTTP.get_response(uri)
+    assert_equal "403", res.code
+    assert_equal "403 Forbidden", res['Status']
+
+    # non existent controller
+    uri = URI.parse("http://#@addr:#@port/asdf")
+    res = Net::HTTP.get_response(uri)
+    assert_equal "404", res.code
+    assert_equal "404 Not Found", res['Status']
+
+    # static files
+
+    # ensure file we're about to serve is not there yet
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/pid.txt"))
+    assert_equal "404 Not Found", res['Status']
+    assert_equal '404', res.code
+
+    # can we serve text files based on suffix?
+    File.open("public/pid.txt", "wb") { |fp| fp.syswrite("#$$\n") }
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/pid.txt"))
+    assert_equal '200', res.code
+    assert_equal "200 OK", res['Status']
+    assert_match %r{^text/plain}, res['Content-Type']
+    assert_equal "#$$\n", res.body
+
+    # can we serve HTML files based on suffix?
+    assert File.exist?("public/500.html")
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/500.html"))
+    assert_equal '200', res.code
+    assert_equal '200 OK', res['Status']
+    assert_match %r{^text/html}, res['Content-Type']
+    five_hundred_body = res.body
+
+    # lets try pretending 500 is a controller that got cached
+    assert ! File.exist?("public/500")
+    assert_equal five_hundred_body, File.read("public/500.html")
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/500"))
+    assert_equal '200', res.code
+    assert_equal '200 OK', res['Status']
+    assert_match %r{^text/html}, res['Content-Type']
+    assert_equal five_hundred_body, res.body
+  end
+
+  def test_alt_url_root
+    # cbf to actually work on this since I never use this feature (ewong)
+    return unless ROR_V[0] >= 2 && ROR_V[1] >= 3
+    redirect_test_io do
+      @pid = fork { exec 'unicorn_rails', "-l#@addr:#@port", '-P/poo' }
+    end
+    wait_master_ready("test_stderr.#$$.log")
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/poo/foo"))
+    # p res
+    # p res.body
+    # system 'cat', 'log/development.log'
+    assert_equal "200", res.code
+    assert_equal '200 OK', res['Status']
+    assert_equal "FOO\n", res.body
+    assert_match %r{^text/html\b}, res['Content-Type']
+    assert_equal "4", res['Content-Length']
+
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/foo"))
+    assert_equal "404", res.code
+    assert_equal '404 Not Found', res['Status']
+  end
+
+  def test_alt_url_root_config_env
+    # cbf to actually work on this since I never use this feature (ewong)
+    return unless ROR_V[0] >= 2 && ROR_V[1] >= 3
+    tmp = Tempfile.new(nil)
+    tmp.syswrite("ENV['RAILS_RELATIVE_URL_ROOT'] = '/poo'\n")
+    redirect_test_io do
+      @pid = fork { exec 'unicorn_rails', "-l#@addr:#@port", "-c", tmp.path }
+    end
+    wait_master_ready("test_stderr.#$$.log")
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/poo/foo"))
+    assert_equal "200", res.code
+    assert_equal '200 OK', res['Status']
+    assert_equal "FOO\n", res.body
+    assert_match %r{^text/html\b}, res['Content-Type']
+    assert_equal "4", res['Content-Length']
+
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/foo"))
+    assert_equal "404", res.code
+    assert_equal '404 Not Found', res['Status']
+
+    res = Net::HTTP.get_response(URI.parse("http://#@addr:#@port/poo/x.txt"))
+    assert_equal "200", res.code
+    assert_equal "HELLO\n", res.body
+  end
+
+  def teardown
+    return if @start_pid != $$
+
+    if @pid
+      Process.kill(:QUIT, @pid)
+      pid2, status = Process.waitpid2(@pid)
+      assert status.success?
+    end
+
+    Dir.chdir(@pwd)
+    FileUtils.rmtree(@tmpdir)
+    loop do
+      Process.kill('-QUIT', 0)
+      begin
+        Process.waitpid(-1, Process::WNOHANG) or break
+      rescue Errno::ECHILD
+        break
+      end
+    end
+  end
+
+end if do_test

data/test/test_helper.rb

@@ -0,0 +1,296 @@
+# -*- encoding: binary -*-
+
+# Copyright (c) 2005 Zed A. Shaw 
+# You can redistribute it and/or modify it under the same terms as Ruby.
+#
+# Additional work donated by contributors.  See http://mongrel.rubyforge.org/attributions.html 
+# for more information.
+
+STDIN.sync = STDOUT.sync = STDERR.sync = true # buffering makes debugging hard
+
+# Some tests watch a log file or a pid file to spring up to check state
+# Can't rely on inotify on non-Linux and logging to a pipe makes things
+# more complicated
+DEFAULT_TRIES = 1000
+DEFAULT_RES = 0.2
+
+HERE = File.dirname(__FILE__) unless defined?(HERE)
+%w(lib ext).each do |dir|
+  $LOAD_PATH.unshift "#{HERE}/../#{dir}"
+end
+
+require 'test/unit'
+require 'net/http'
+require 'digest/sha1'
+require 'uri'
+require 'stringio'
+require 'pathname'
+require 'tempfile'
+require 'fileutils'
+require 'logger'
+require 'unicorn'
+require 'unicorn_http'
+
+if ENV['DEBUG']
+  require 'ruby-debug'
+  Debugger.start
+end
+
+def redirect_test_io
+  orig_err = STDERR.dup
+  orig_out = STDOUT.dup
+  STDERR.reopen("test_stderr.#{$$}.log", "a")
+  STDOUT.reopen("test_stdout.#{$$}.log", "a")
+  STDERR.sync = STDOUT.sync = true
+
+  at_exit do
+    File.unlink("test_stderr.#{$$}.log") rescue nil
+    File.unlink("test_stdout.#{$$}.log") rescue nil
+  end
+
+  begin
+    yield
+  ensure
+    STDERR.reopen(orig_err)
+    STDOUT.reopen(orig_out)
+  end
+end
+
+# which(1) exit codes cannot be trusted on some systems
+# We use UNIX shell utilities in some tests because we don't trust
+# ourselves to write Ruby 100% correctly :)
+def which(bin)
+  ex = ENV['PATH'].split(/:/).detect do |x|
+    x << "/#{bin}"
+    File.executable?(x)
+  end or warn "`#{bin}' not found in PATH=#{ENV['PATH']}"
+  ex
+end
+
+# Either takes a string to do a get request against, or a tuple of [URI, HTTP] where
+# HTTP is some kind of Net::HTTP request object (POST, HEAD, etc.)
+def hit(uris)
+  results = []
+  uris.each do |u|
+    res = nil
+
+    if u.kind_of? String
+      res = Net::HTTP.get(URI.parse(u))
+    else
+      url = URI.parse(u[0])
+      res = Net::HTTP.new(url.host, url.port).start {|h| h.request(u[1]) }
+    end
+
+    assert res != nil, "Didn't get a response: #{u}"
+    results << res
+  end
+
+  return results
+end
+
+# unused_port provides an unused port on +addr+ usable for TCP that is
+# guaranteed to be unused across all unicorn builds on that system.  It
+# prevents race conditions by using a lock file other unicorn builds
+# will see.  This is required if you perform several builds in parallel
+# with a continuous integration system or run tests in parallel via
+# gmake.  This is NOT guaranteed to be race-free if you run other
+# processes that bind to random ports for testing (but the window
+# for a race condition is very small).  You may also set UNICORN_TEST_ADDR
+# to override the default test address (127.0.0.1).
+def unused_port(addr = '127.0.0.1')
+  retries = 100
+  base = 5000
+  port = sock = nil
+  begin
+    begin
+      port = base + rand(32768 - base)
+      while port == Unicorn::Const::DEFAULT_PORT
+        port = base + rand(32768 - base)
+      end
+
+      sock = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM, 0)
+      sock.bind(Socket.pack_sockaddr_in(port, addr))
+      sock.listen(5)
+    rescue Errno::EADDRINUSE, Errno::EACCES
+      sock.close rescue nil
+      retry if (retries -= 1) >= 0
+    end
+
+    # since we'll end up closing the random port we just got, there's a race
+    # condition could allow the random port we just chose to reselect itself
+    # when running tests in parallel with gmake.  Create a lock file while
+    # we have the port here to ensure that does not happen .
+    lock_path = "#{Dir::tmpdir}/unicorn_test.#{addr}:#{port}.lock"
+    lock = File.open(lock_path, File::WRONLY|File::CREAT|File::EXCL, 0600)
+    at_exit { File.unlink(lock_path) rescue nil }
+  rescue Errno::EEXIST
+    sock.close rescue nil
+    retry
+  end
+  sock.close rescue nil
+  port
+end
+
+def try_require(lib)
+  begin
+    require lib
+    true
+  rescue LoadError
+    false
+  end
+end
+
+# sometimes the server may not come up right away
+def retry_hit(uris = [])
+  tries = DEFAULT_TRIES
+  begin
+    hit(uris)
+  rescue Errno::EINVAL, Errno::ECONNREFUSED => err
+    if (tries -= 1) > 0
+      sleep DEFAULT_RES
+      retry
+    end
+    raise err
+  end
+end
+
+def assert_shutdown(pid)
+  wait_master_ready("test_stderr.#{pid}.log")
+  assert_nothing_raised { Process.kill(:QUIT, pid) }
+  status = nil
+  assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+  assert status.success?, "exited successfully"
+end
+
+def wait_workers_ready(path, nr_workers)
+  tries = DEFAULT_TRIES
+  lines = []
+  while (tries -= 1) > 0
+    begin
+      lines = File.readlines(path).grep(/worker=\d+ ready/)
+      lines.size == nr_workers and return
+    rescue Errno::ENOENT
+    end
+    sleep DEFAULT_RES
+  end
+  raise "#{nr_workers} workers never became ready:" \
+        "\n\t#{lines.join("\n\t")}\n"
+end
+
+def wait_master_ready(master_log)
+  tries = DEFAULT_TRIES
+  while (tries -= 1) > 0
+    begin
+      File.readlines(master_log).grep(/master process ready/)[0] and return
+    rescue Errno::ENOENT
+    end
+    sleep DEFAULT_RES
+  end
+  raise "master process never became ready"
+end
+
+def reexec_usr2_quit_test(pid, pid_file)
+  assert File.exist?(pid_file), "pid file OK"
+  assert ! File.exist?("#{pid_file}.oldbin"), "oldbin pid file"
+  assert_nothing_raised { Process.kill(:USR2, pid) }
+  assert_nothing_raised { retry_hit(["http://#{@addr}:#{@port}/"]) }
+  wait_for_file("#{pid_file}.oldbin")
+  wait_for_file(pid_file)
+
+  old_pid = File.read("#{pid_file}.oldbin").to_i
+  new_pid = File.read(pid_file).to_i
+
+  # kill old master process
+  assert_not_equal pid, new_pid
+  assert_equal pid, old_pid
+  assert_nothing_raised { Process.kill(:QUIT, old_pid) }
+  assert_nothing_raised { retry_hit(["http://#{@addr}:#{@port}/"]) }
+  wait_for_death(old_pid)
+  assert_equal new_pid, File.read(pid_file).to_i
+  assert_nothing_raised { retry_hit(["http://#{@addr}:#{@port}/"]) }
+  assert_nothing_raised { Process.kill(:QUIT, new_pid) }
+end
+
+def reexec_basic_test(pid, pid_file)
+  results = retry_hit(["http://#{@addr}:#{@port}/"])
+  assert_equal String, results[0].class
+  assert_nothing_raised { Process.kill(0, pid) }
+  master_log = "#{@tmpdir}/test_stderr.#{pid}.log"
+  wait_master_ready(master_log)
+  File.truncate(master_log, 0)
+  nr = 50
+  kill_point = 2
+  assert_nothing_raised do
+    nr.times do |i|
+      hit(["http://#{@addr}:#{@port}/#{i}"])
+      i == kill_point and Process.kill(:HUP, pid)
+    end
+  end
+  wait_master_ready(master_log)
+  assert File.exist?(pid_file), "pid=#{pid_file} exists"
+  new_pid = File.read(pid_file).to_i
+  assert_not_equal pid, new_pid
+  assert_nothing_raised { Process.kill(0, new_pid) }
+  assert_nothing_raised { Process.kill(:QUIT, new_pid) }
+end
+
+def wait_for_file(path)
+  tries = DEFAULT_TRIES
+  while (tries -= 1) > 0 && ! File.exist?(path)
+    sleep DEFAULT_RES
+  end
+  assert File.exist?(path), "path=#{path} exists #{caller.inspect}"
+end
+
+def xfork(&block)
+  fork do
+    ObjectSpace.each_object(Tempfile) do |tmp|
+      ObjectSpace.undefine_finalizer(tmp)
+    end
+    yield
+  end
+end
+
+# can't waitpid on detached processes
+def wait_for_death(pid)
+  tries = DEFAULT_TRIES
+  while (tries -= 1) > 0
+    begin
+      Process.kill(0, pid)
+      begin
+        Process.waitpid(pid, Process::WNOHANG)
+      rescue Errno::ECHILD
+      end
+      sleep(DEFAULT_RES)
+    rescue Errno::ESRCH
+      return
+    end
+  end
+  raise "PID:#{pid} never died!"
+end
+
+# executes +cmd+ and chunks its STDOUT
+def chunked_spawn(stdout, *cmd)
+  fork {
+    crd, cwr = IO.pipe
+    crd.binmode
+    cwr.binmode
+    crd.sync = cwr.sync = true
+
+    pid = fork {
+      STDOUT.reopen(cwr)
+      crd.close
+      cwr.close
+      exec(*cmd)
+    }
+    cwr.close
+    begin
+      buf = crd.readpartial(16384)
+      stdout.write("#{'%x' % buf.size}\r\n#{buf}")
+    rescue EOFError
+      stdout.write("0\r\n")
+      pid, status = Process.waitpid(pid)
+      exit status.exitstatus
+    end while true
+  }
+end