unicorn 4.4.0 → 4.5.0pre1

data/GIT-VERSION-GEN

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 GVF=GIT-VERSION-FILE
-DEF_VER=v4.4.0.GIT
+DEF_VER=v4.5.0pre1
 
 LF='
 '

data/Rakefile

@@ -49,7 +49,7 @@ task :fm_update do
   require 'net/netrc'
   require 'json'
   version = ENV['VERSION'] or abort "VERSION= needed"
-  uri = URI.parse('http://freecode.com/projects/unicorn/releases.json')
+  uri = URI.parse('https://freecode.com/projects/unicorn/releases.json')
   rc = Net::Netrc.locate('unicorn-fm') or abort "~/.netrc not found"
   api_token = rc.password
   _, subject, body = `git cat-file tag v#{version}`.split(/\n\n/, 3)
@@ -71,7 +71,7 @@ task :fm_update do
   }.to_json
 
   if ! changelog.strip.empty? && version =~ %r{\A[\d\.]+\d+\z}
-    Net::HTTP.start(uri.host, uri.port) do |http|
+    Net::HTTP.start(uri.host, uri.port, :use_ssl => true) do |http|
       p http.post(uri.path, req, {'Content-Type'=>'application/json'})
     end
   else

data/examples/unicorn.conf.rb

@@ -46,6 +46,14 @@ preload_app true
 GC.respond_to?(:copy_on_write_friendly=) and
   GC.copy_on_write_friendly = true
 
+# Enable this flag to have unicorn test client connections by writing the
+# beginning of the HTTP headers before calling the application.  This
+# prevents calling the application for connections that have disconnected
+# while queued.  This is only guaranteed to detect clients on the same
+# host unicorn runs on, and unlikely to detect disconnects even on a
+# fast LAN.
+check_client_connection false
+
 before_fork do |server, worker|
   # the following is highly recomended for Rails + "preload_app true"
   # as there's no need for the master process to hold a connection

data/ext/unicorn_http/unicorn_http.rl

@@ -115,7 +115,7 @@ struct http_parser {
   } len;
 };
 
-static ID id_clear, id_set_backtrace;
+static ID id_clear, id_set_backtrace, id_response_start_sent;
 
 static void finalize_header(struct http_parser *hp);
 
@@ -626,6 +626,7 @@ static VALUE HttpParser_clear(VALUE self)
 
   http_parser_init(hp);
   rb_funcall(hp->env, id_clear, 0);
+  rb_ivar_set(self, id_response_start_sent, Qfalse);
 
   return self;
 }
@@ -1031,6 +1032,7 @@ void Init_unicorn_http(void)
   SET_GLOBAL(g_http_connection, "CONNECTION");
   id_clear = rb_intern("clear");
   id_set_backtrace = rb_intern("set_backtrace");
+  id_response_start_sent = rb_intern("@response_start_sent");
   init_unicorn_httpdate();
 }
 #undef SET_GLOBAL

data/lib/unicorn/configurator.rb

@@ -45,6 +45,7 @@ class Unicorn::Configurator
       },
     :pid => nil,
     :preload_app => false,
+    :check_client_connection => false,
     :rewindable_input => true, # for Rack 2.x: (Rack::VERSION[0] <= 1),
     :client_body_buffer_size => Unicorn::Const::MAX_BODY,
     :trust_x_forwarded => true,
@@ -96,6 +97,14 @@ class Unicorn::Configurator
     if ready_pipe = RACKUP.delete(:ready_pipe)
       server.ready_pipe = ready_pipe
     end
+    if set[:check_client_connection]
+      set[:listeners].each do |address|
+        if set[:listener_opts][address][:tcp_nopush] == true
+          raise ArgumentError,
+            "check_client_connection is incompatible with tcp_nopush:true"
+        end
+      end
+    end
     set.each do |key, value|
       value == :unset and next
       skip.include?(key) and next
@@ -454,6 +463,21 @@ class Unicorn::Configurator
     set_int(:client_body_buffer_size, bytes, 0)
   end
 
+  # When enabled, unicorn will check the client connection by writing
+  # the beginning of the HTTP headers before calling the application.
+  #
+  # This will prevent calling the application for clients who have
+  # disconnected while their connection was queued.
+  #
+  # This only affects clients connecting over Unix domain sockets
+  # and TCP via loopback (127.*.*.*).  It is unlikely to detect
+  # disconnects if the client is on a remote host (even on a fast LAN).
+  #
+  # This option cannot be used in conjunction with :tcp_nopush.
+  def check_client_connection(bool)
+    set_bool(:check_client_connection, bool)
+  end
+
   # Allow redirecting $stderr to a given path.  Unlike doing this from
   # the shell, this allows the unicorn process to know the path its
   # writing to and rotate the file if it is used for logging.  The

data/lib/unicorn/const.rb

@@ -8,7 +8,7 @@
 # improve things much compared to constants.
 module Unicorn::Const
 
-  UNICORN_VERSION = "4.4.0"
+  UNICORN_VERSION = "4.5.0pre1"
 
   # default TCP listen host address (0.0.0.0, all interfaces)
   DEFAULT_HOST = "0.0.0.0"
@@ -29,12 +29,16 @@ module Unicorn::Const
 
   # :stopdoc:
   # common errors we'll send back
-  ERROR_400_RESPONSE = "HTTP/1.1 400 Bad Request\r\n\r\n"
-  ERROR_414_RESPONSE = "HTTP/1.1 414 Request-URI Too Long\r\n\r\n"
-  ERROR_413_RESPONSE = "HTTP/1.1 413 Request Entity Too Large\r\n\r\n"
-  ERROR_500_RESPONSE = "HTTP/1.1 500 Internal Server Error\r\n\r\n"
+  ERROR_400_RESPONSE = "400 Bad Request\r\n\r\n"
+  ERROR_414_RESPONSE = "414 Request-URI Too Long\r\n\r\n"
+  ERROR_413_RESPONSE = "413 Request Entity Too Large\r\n\r\n"
+  ERROR_500_RESPONSE = "500 Internal Server Error\r\n\r\n"
+
   EXPECT_100_RESPONSE = "HTTP/1.1 100 Continue\r\n\r\n"
+  EXPECT_100_RESPONSE_SUFFIXED = "100 Continue\r\n\r\nHTTP/1.1 "
 
+  HTTP_RESPONSE_START = ['HTTP', '/1.1 ']
   HTTP_EXPECT = "HTTP_EXPECT"
+
   # :startdoc:
 end

data/lib/unicorn/http_request.rb

@@ -22,11 +22,14 @@ class Unicorn::HttpParser
 
   NULL_IO = StringIO.new("")
 
+  attr_accessor :response_start_sent
+
   # :stopdoc:
   # A frozen format for this is about 15% faster
   REMOTE_ADDR = 'REMOTE_ADDR'.freeze
   RACK_INPUT = 'rack.input'.freeze
   @@input_class = Unicorn::TeeInput
+  @@check_client_connection = false
 
   def self.input_class
     @@input_class
@@ -35,6 +38,15 @@ class Unicorn::HttpParser
   def self.input_class=(klass)
     @@input_class = klass
   end
+
+  def self.check_client_connection
+    @@check_client_connection
+  end
+
+  def self.check_client_connection=(bool)
+    @@check_client_connection = bool
+  end
+
   # :startdoc:
 
   # Does the majority of the IO processing.  It has been written in
@@ -70,6 +82,13 @@ class Unicorn::HttpParser
       # an Exception thrown from the parser will throw us out of the loop
       false until add_parse(socket.kgio_read!(16384))
     end
+
+    # detect if the socket is valid by writing a partial response:
+    if @@check_client_connection && headers?
+      @response_start_sent = true
+      Unicorn::Const::HTTP_RESPONSE_START.each { |c| socket.write(c) }
+    end
+
     e[RACK_INPUT] = 0 == content_length ?
                     NULL_IO : @@input_class.new(socket, self)
     e.merge!(DEFAULTS)

data/lib/unicorn/http_response.rb

@@ -18,11 +18,13 @@ module Unicorn::HttpResponse
   CRLF = "\r\n"
 
   # writes the rack_response to socket as an HTTP response
-  def http_response_write(socket, status, headers, body)
+  def http_response_write(socket, status, headers, body,
+                          response_start_sent=false)
     status = CODES[status.to_i] || status
 
+    http_response_start = response_start_sent ? '' : 'HTTP/1.1 '
     if headers
-      buf = "HTTP/1.1 #{status}\r\n" \
+      buf = "#{http_response_start}#{status}\r\n" \
             "Date: #{httpdate}\r\n" \
             "Status: #{status}\r\n" \
             "Connection: close\r\n"

data/lib/unicorn/http_server.rb

@@ -17,6 +17,7 @@ class Unicorn::HttpServer
                 :listener_opts, :preload_app,
                 :reexec_pid, :orig_app, :init_listeners,
                 :master_pid, :config, :ready_pipe, :user
+
   attr_reader :pid, :logger
   include Unicorn::SocketHelper
   include Unicorn::HttpResponse
@@ -355,6 +356,14 @@ class Unicorn::HttpServer
     Unicorn::HttpParser.trust_x_forwarded = bool
   end
 
+  def check_client_connection
+    Unicorn::HttpRequest.check_client_connection
+  end
+
+  def check_client_connection=(bool)
+    Unicorn::HttpRequest.check_client_connection = bool
+  end
+
   private
 
   # wait for a signal hander to wake us up and then consume the pipe
@@ -524,23 +533,33 @@ class Unicorn::HttpServer
       Unicorn.log_error(@logger, "app error", e)
       Unicorn::Const::ERROR_500_RESPONSE
     end
+    msg = "HTTP/1.1 #{msg}" unless @request.response_start_sent
     client.kgio_trywrite(msg)
     client.close
     rescue
   end
 
+  def expect_100_response
+    if @request.response_start_sent
+      Unicorn::Const::EXPECT_100_RESPONSE_SUFFIXED
+    else
+      Unicorn::Const::EXPECT_100_RESPONSE
+    end
+  end
+
   # once a client is accepted, it is processed in its entirety here
   # in 3 easy steps: read request, call app, write app response
   def process_client(client)
     status, headers, body = @app.call(env = @request.read(client))
 
     if 100 == status.to_i
-      client.write(Unicorn::Const::EXPECT_100_RESPONSE)
+      client.write(expect_100_response)
       env.delete(Unicorn::Const::HTTP_EXPECT)
       status, headers, body = @app.call(env)
     end
     @request.headers? or headers = nil
-    http_response_write(client, status, headers, body)
+    http_response_write(client, status, headers, body,
+                        @request.response_start_sent)
     client.shutdown # in case of fork() in Rack app
     client.close # flush and uncork socket immediately, no keepalive
   rescue => e

data/test/exec/test_exec.rb

@@ -871,13 +871,14 @@ EOF
     wait_for_death(pid)
   end
 
-  def hup_test_common(preload)
+  def hup_test_common(preload, check_client=false)
     File.open("config.ru", "wb") { |fp| fp.syswrite(HI.gsub("HI", '#$$')) }
     pid_file = Tempfile.new('pid')
     ucfg = Tempfile.new('unicorn_test_config')
     ucfg.syswrite("listen '#@addr:#@port'\n")
     ucfg.syswrite("pid '#{pid_file.path}'\n")
     ucfg.syswrite("preload_app true\n") if preload
+    ucfg.syswrite("check_client_connection true\n") if check_client
     ucfg.syswrite("stderr_path 'test_stderr.#$$.log'\n")
     ucfg.syswrite("stdout_path 'test_stdout.#$$.log'\n")
     pid = xfork {
@@ -942,6 +943,10 @@ EOF
     hup_test_common(false)
   end
 
+  def test_check_client_hup
+    hup_test_common(false, true)
+  end
+
   def test_default_listen_hup_holds_listener
     default_listen_lock do
       res, pid_path = default_listen_setup

data/test/test_helper.rb

@@ -155,9 +155,8 @@ 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) }
+  Process.kill(:QUIT, pid)
+  pid, status = Process.waitpid2(pid)
   assert status.success?, "exited successfully"
 end
 
@@ -191,8 +190,8 @@ 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}/"]) }
+  Process.kill(:USR2, pid)
+  retry_hit(["http://#{@addr}:#{@port}/"])
   wait_for_file("#{pid_file}.oldbin")
   wait_for_file(pid_file)
 
@@ -202,35 +201,33 @@ def reexec_usr2_quit_test(pid, pid_file)
   # 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}/"]) }
+  Process.kill(:QUIT, old_pid)
+  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) }
+  retry_hit(["http://#{@addr}:#{@port}/"])
+  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) }
+  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
+  nr.times do |i|
+    hit(["http://#{@addr}:#{@port}/#{i}"])
+    i == kill_point and Process.kill(:HUP, pid)
   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) }
+  Process.kill(0, new_pid)
+  Process.kill(:QUIT, new_pid)
 end
 
 def wait_for_file(path)

data/test/unit/test_configurator.rb

@@ -9,7 +9,7 @@ TestStruct = Struct.new(
 class TestConfigurator < Test::Unit::TestCase
 
   def test_config_init
-    assert_nothing_raised { Unicorn::Configurator.new {} }
+    Unicorn::Configurator.new {}
   end
 
   def test_expand_addr
@@ -66,7 +66,7 @@ class TestConfigurator < Test::Unit::TestCase
   def test_config_defaults
     cfg = Unicorn::Configurator.new(:use_defaults => true)
     test_struct = TestStruct.new
-    assert_nothing_raised { cfg.commit!(test_struct) }
+    cfg.commit!(test_struct)
     Unicorn::Configurator::DEFAULTS.each do |key,value|
       assert_equal value, test_struct.__send__(key)
     end
@@ -76,7 +76,7 @@ class TestConfigurator < Test::Unit::TestCase
     cfg = Unicorn::Configurator.new(:use_defaults => true)
     skip = [ :logger ]
     test_struct = TestStruct.new
-    assert_nothing_raised { cfg.commit!(test_struct, :skip => skip) }
+    cfg.commit!(test_struct, :skip => skip)
     Unicorn::Configurator::DEFAULTS.each do |key,value|
       next if skip.include?(key)
       assert_equal value, test_struct.__send__(key)
@@ -89,12 +89,9 @@ class TestConfigurator < Test::Unit::TestCase
     expect = { :sndbuf => 1, :rcvbuf => 2, :backlog => 10 }.freeze
     listener = "127.0.0.1:12345"
     tmp.syswrite("listen '#{listener}', #{expect.inspect}\n")
-    cfg = nil
-    assert_nothing_raised do
-      cfg = Unicorn::Configurator.new(:config_file => tmp.path)
-    end
+    cfg = Unicorn::Configurator.new(:config_file => tmp.path)
     test_struct = TestStruct.new
-    assert_nothing_raised { cfg.commit!(test_struct) }
+    cfg.commit!(test_struct)
     assert(listener_opts = test_struct.listener_opts)
     assert_equal expect, listener_opts[listener]
   end
@@ -124,9 +121,7 @@ class TestConfigurator < Test::Unit::TestCase
     expect = { :delay => 0.5 }
     listener = "127.0.0.1:12345"
     tmp.syswrite("listen '#{listener}', #{expect.inspect}\n")
-    assert_nothing_raised do
-      Unicorn::Configurator.new(:config_file => tmp.path)
-    end
+    Unicorn::Configurator.new(:config_file => tmp.path)
   end
 
   def test_listen_option_int_delay
@@ -134,8 +129,30 @@ class TestConfigurator < Test::Unit::TestCase
     expect = { :delay => 5 }
     listener = "127.0.0.1:12345"
     tmp.syswrite("listen '#{listener}', #{expect.inspect}\n")
+    Unicorn::Configurator.new(:config_file => tmp.path)
+  end
+
+  def test_check_client_connection
+    tmp = Tempfile.new('unicorn_config')
+    test_struct = TestStruct.new
+    tmp.syswrite("check_client_connection true\n")
+
     assert_nothing_raised do
-      Unicorn::Configurator.new(:config_file => tmp.path)
+      Unicorn::Configurator.new(:config_file => tmp.path).commit!(test_struct)
+    end
+
+    assert test_struct.check_client_connection
+  end
+
+  def test_check_client_connection_with_tcp_bad
+    tmp = Tempfile.new('unicorn_config')
+    test_struct = TestStruct.new
+    listener = "127.0.0.1:12345"
+    tmp.syswrite("check_client_connection true\n")
+    tmp.syswrite("listen '#{listener}', :tcp_nopush => true\n")
+
+    assert_raises(ArgumentError) do
+      Unicorn::Configurator.new(:config_file => tmp.path).commit!(test_struct)
     end
   end
 

data/test/unit/test_http_parser.rb

@@ -689,10 +689,7 @@ class HttpParserTest < Test::Unit::TestCase
       parser = HttpParser.new
       req = parser.env
       s = "#{m} /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
-      ok = false
-      assert_nothing_raised do
-        ok = parser.headers(req, s)
-      end
+      ok = parser.headers(req, s)
       assert ok
       assert_equal '/forums/1/topics/2375?page=1', req['REQUEST_URI']
       assert_equal 'posts-17408', req['FRAGMENT']
@@ -708,10 +705,7 @@ class HttpParserTest < Test::Unit::TestCase
     req = parser.env
     get = "GET /forums/1/topics/2375?page=1#posts-17408 HTTP/1.1\r\n\r\n"
     parser.buf << get
-    ok = false
-    assert_nothing_raised do
-      ok = parser.parse
-    end
+    ok = parser.parse
     assert ok
     assert_equal '/forums/1/topics/2375?page=1', req['REQUEST_URI']
     assert_equal 'posts-17408', req['FRAGMENT']

data/test/unit/test_http_parser_ng.rb

@@ -34,7 +34,7 @@ class HttpParserNgTest < Test::Unit::TestCase
   def test_connection_TE
     @parser.buf << "GET / HTTP/1.1\r\nHost: example.com\r\nConnection: TE\r\n"
     @parser.buf << "TE: trailers\r\n\r\n"
-    assert_nothing_raised { @parser.parse }
+    @parser.parse
     assert @parser.keepalive?
     assert @parser.next?
   end
@@ -94,10 +94,8 @@ class HttpParserNgTest < Test::Unit::TestCase
   def test_default_keepalive_is_off
     assert ! @parser.keepalive?
     assert ! @parser.next?
-    assert_nothing_raised do
-      @parser.buf << "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
-      @parser.parse
-    end
+    @parser.buf << "GET / HTTP/1.1\r\nHost: example.com\r\n\r\n"
+    @parser.parse
     assert @parser.keepalive?
     @parser.clear
     assert ! @parser.keepalive?
@@ -419,7 +417,7 @@ class HttpParserNgTest < Test::Unit::TestCase
     req = @parser.env
     assert_equal req, @parser.parse
     assert_nil @parser.content_length
-    assert_nothing_raised { @parser.filter_body('', str) }
+    @parser.filter_body('', str)
     assert ! @parser.keepalive?
   end
 
@@ -427,7 +425,7 @@ class HttpParserNgTest < Test::Unit::TestCase
     n = HttpParser::LENGTH_MAX
     @parser.buf << "PUT / HTTP/1.1\r\nContent-Length: #{n}\r\n\r\n"
     req = @parser.env
-    assert_nothing_raised { @parser.headers(req, @parser.buf) }
+    @parser.headers(req, @parser.buf)
     assert_equal n, req['CONTENT_LENGTH'].to_i
     assert ! @parser.keepalive?
   end

data/test/unit/test_request.rb

@@ -30,47 +30,43 @@ class RequestTest < Test::Unit::TestCase
   def test_options
     client = MockRequest.new("OPTIONS * HTTP/1.1\r\n" \
                              "Host: foo\r\n\r\n")
-    res = env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal '', env['REQUEST_PATH']
     assert_equal '', env['PATH_INFO']
     assert_equal '*', env['REQUEST_URI']
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_absolute_uri_with_query
     client = MockRequest.new("GET http://e:3/x?y=z HTTP/1.1\r\n" \
                              "Host: foo\r\n\r\n")
-    res = env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal '/x', env['REQUEST_PATH']
     assert_equal '/x', env['PATH_INFO']
     assert_equal 'y=z', env['QUERY_STRING']
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_absolute_uri_with_fragment
     client = MockRequest.new("GET http://e:3/x#frag HTTP/1.1\r\n" \
                              "Host: foo\r\n\r\n")
-    res = env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal '/x', env['REQUEST_PATH']
     assert_equal '/x', env['PATH_INFO']
     assert_equal '', env['QUERY_STRING']
     assert_equal 'frag', env['FRAGMENT']
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_absolute_uri_with_query_and_fragment
     client = MockRequest.new("GET http://e:3/x?a=b#frag HTTP/1.1\r\n" \
                              "Host: foo\r\n\r\n")
-    res = env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal '/x', env['REQUEST_PATH']
     assert_equal '/x', env['PATH_INFO']
     assert_equal 'a=b', env['QUERY_STRING']
     assert_equal 'frag', env['FRAGMENT']
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_absolute_uri_unsupported_schemes
@@ -82,48 +78,43 @@ class RequestTest < Test::Unit::TestCase
   end
 
   def test_x_forwarded_proto_https
-    res = env = nil
     client = MockRequest.new("GET / HTTP/1.1\r\n" \
                              "X-Forwarded-Proto: https\r\n" \
                              "Host: foo\r\n\r\n")
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal "https", env['rack.url_scheme']
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_x_forwarded_proto_http
-    res = env = nil
     client = MockRequest.new("GET / HTTP/1.1\r\n" \
                              "X-Forwarded-Proto: http\r\n" \
                              "Host: foo\r\n\r\n")
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal "http", env['rack.url_scheme']
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_x_forwarded_proto_invalid
-    res = env = nil
     client = MockRequest.new("GET / HTTP/1.1\r\n" \
                              "X-Forwarded-Proto: ftp\r\n" \
                              "Host: foo\r\n\r\n")
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal "http", env['rack.url_scheme']
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_rack_lint_get
     client = MockRequest.new("GET / HTTP/1.1\r\nHost: foo\r\n\r\n")
-    res = env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal "http", env['rack.url_scheme']
     assert_equal '127.0.0.1', env['REMOTE_ADDR']
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_no_content_stringio
     client = MockRequest.new("GET / HTTP/1.1\r\nHost: foo\r\n\r\n")
-    env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal StringIO, env['rack.input'].class
   end
 
@@ -131,8 +122,7 @@ class RequestTest < Test::Unit::TestCase
     client = MockRequest.new("PUT / HTTP/1.1\r\n" \
                              "Content-Length: 0\r\n" \
                              "Host: foo\r\n\r\n")
-    env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal StringIO, env['rack.input'].class
   end
 
@@ -140,8 +130,7 @@ class RequestTest < Test::Unit::TestCase
     client = MockRequest.new("PUT / HTTP/1.1\r\n" \
                              "Content-Length: 1\r\n" \
                              "Host: foo\r\n\r\n")
-    env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert_equal Unicorn::TeeInput, env['rack.input'].class
   end
 
@@ -152,10 +141,9 @@ class RequestTest < Test::Unit::TestCase
       "Content-Length: 5\r\n" \
       "\r\n" \
       "abcde")
-    res = env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert ! env.include?(:http_body)
-    assert_nothing_raised { res = @lint.call(env) }
+    res = @lint.call(env)
   end
 
   def test_rack_lint_big_put
@@ -179,8 +167,7 @@ class RequestTest < Test::Unit::TestCase
       "\r\n")
     count.times { assert_equal bs, client.syswrite(buf) }
     assert_equal 0, client.sysseek(0)
-    res = env = nil
-    assert_nothing_raised { env = @request.read(client) }
+    env = @request.read(client)
     assert ! env.include?(:http_body)
     assert_equal length, env['rack.input'].size
     count.times {
@@ -189,9 +176,7 @@ class RequestTest < Test::Unit::TestCase
       assert_equal buf, tmp
     }
     assert_nil env['rack.input'].read(bs)
-    assert_nothing_raised { env['rack.input'].rewind }
-    assert_nothing_raised { res = @lint.call(env) }
+    env['rack.input'].rewind
+    res = @lint.call(env)
   end
-
 end
-

data/test/unit/test_server.rb

@@ -92,14 +92,10 @@ class WebServerTest < Test::Unit::TestCase
       @server = HttpServer.new(app, :listeners => [ "127.0.0.1:#@port"] )
       @server.start
     end
-    sock = nil
-    assert_nothing_raised do
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
-    end
-
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
     assert_match %r{\AHTTP/1.[01] 500\b}, sock.sysread(4096)
-    assert_nothing_raised { sock.close }
+    assert_nil sock.close
   end
 
   def test_simple_server
@@ -108,56 +104,48 @@ class WebServerTest < Test::Unit::TestCase
   end
 
   def test_client_shutdown_writes
-    sock = nil
-    buf = nil
     bs = 15609315 * rand
-    assert_nothing_raised do
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("PUT /hello HTTP/1.1\r\n")
-      sock.syswrite("Host: example.com\r\n")
-      sock.syswrite("Transfer-Encoding: chunked\r\n")
-      sock.syswrite("Trailer: X-Foo\r\n")
-      sock.syswrite("\r\n")
-      sock.syswrite("%x\r\n" % [ bs ])
-      sock.syswrite("F" * bs)
-      sock.syswrite("\r\n0\r\nX-")
-      "Foo: bar\r\n\r\n".each_byte do |x|
-        sock.syswrite x.chr
-        sleep 0.05
-      end
-      # we wrote the entire request before shutting down, server should
-      # continue to process our request and never hit EOFError on our sock
-      sock.shutdown(Socket::SHUT_WR)
-      buf = sock.read
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("PUT /hello HTTP/1.1\r\n")
+    sock.syswrite("Host: example.com\r\n")
+    sock.syswrite("Transfer-Encoding: chunked\r\n")
+    sock.syswrite("Trailer: X-Foo\r\n")
+    sock.syswrite("\r\n")
+    sock.syswrite("%x\r\n" % [ bs ])
+    sock.syswrite("F" * bs)
+    sock.syswrite("\r\n0\r\nX-")
+    "Foo: bar\r\n\r\n".each_byte do |x|
+      sock.syswrite x.chr
+      sleep 0.05
     end
+    # we wrote the entire request before shutting down, server should
+    # continue to process our request and never hit EOFError on our sock
+    sock.shutdown(Socket::SHUT_WR)
+    buf = sock.read
     assert_equal 'hello!\n', buf.split(/\r\n\r\n/).last
     next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
     assert_equal 'hello!\n', next_client
     lines = File.readlines("test_stderr.#$$.log")
     assert lines.grep(/^Unicorn::ClientShutdown: /).empty?
-    assert_nothing_raised { sock.close }
+    assert_nil sock.close
   end
 
   def test_client_shutdown_write_truncates
-    sock = nil
-    buf = nil
     bs = 15609315 * rand
-    assert_nothing_raised do
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("PUT /hello HTTP/1.1\r\n")
-      sock.syswrite("Host: example.com\r\n")
-      sock.syswrite("Transfer-Encoding: chunked\r\n")
-      sock.syswrite("Trailer: X-Foo\r\n")
-      sock.syswrite("\r\n")
-      sock.syswrite("%x\r\n" % [ bs ])
-      sock.syswrite("F" * (bs / 2.0))
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("PUT /hello HTTP/1.1\r\n")
+    sock.syswrite("Host: example.com\r\n")
+    sock.syswrite("Transfer-Encoding: chunked\r\n")
+    sock.syswrite("Trailer: X-Foo\r\n")
+    sock.syswrite("\r\n")
+    sock.syswrite("%x\r\n" % [ bs ])
+    sock.syswrite("F" * (bs / 2.0))
 
-      # shutdown prematurely, this will force the server to abort
-      # processing on us even during app dispatch
-      sock.shutdown(Socket::SHUT_WR)
-      IO.select([sock], nil, nil, 60) or raise "Timed out"
-      buf = sock.read
-    end
+    # shutdown prematurely, this will force the server to abort
+    # processing on us even during app dispatch
+    sock.shutdown(Socket::SHUT_WR)
+    IO.select([sock], nil, nil, 60) or raise "Timed out"
+    buf = sock.read
     assert_equal "", buf
     next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
     assert_equal 'hello!\n', next_client
@@ -165,27 +153,24 @@ class WebServerTest < Test::Unit::TestCase
     lines = lines.grep(/^Unicorn::ClientShutdown: bytes_read=\d+/)
     assert_equal 1, lines.size
     assert_match %r{\AUnicorn::ClientShutdown: bytes_read=\d+ true$}, lines[0]
-    assert_nothing_raised { sock.close }
+    assert_nil sock.close
   end
 
   def test_client_malformed_body
-    sock = nil
     bs = 15653984
-    assert_nothing_raised do
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("PUT /hello HTTP/1.1\r\n")
-      sock.syswrite("Host: example.com\r\n")
-      sock.syswrite("Transfer-Encoding: chunked\r\n")
-      sock.syswrite("Trailer: X-Foo\r\n")
-      sock.syswrite("\r\n")
-      sock.syswrite("%x\r\n" % [ bs ])
-      sock.syswrite("F" * bs)
-    end
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("PUT /hello HTTP/1.1\r\n")
+    sock.syswrite("Host: example.com\r\n")
+    sock.syswrite("Transfer-Encoding: chunked\r\n")
+    sock.syswrite("Trailer: X-Foo\r\n")
+    sock.syswrite("\r\n")
+    sock.syswrite("%x\r\n" % [ bs ])
+    sock.syswrite("F" * bs)
     begin
       File.open("/dev/urandom", "rb") { |fp| sock.syswrite(fp.sysread(16384)) }
     rescue
     end
-    assert_nothing_raised { sock.close }
+    assert_nil sock.close
     next_client = Net::HTTP.get(URI.parse("http://127.0.0.1:#@port/"))
     assert_equal 'hello!\n', next_client
     lines = File.readlines("test_stderr.#$$.log")
@@ -240,23 +225,17 @@ class WebServerTest < Test::Unit::TestCase
   end
 
   def test_bad_client_400
-    sock = nil
-    assert_nothing_raised do
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("GET / HTTP/1.0\r\nHost: foo\rbar\r\n\r\n")
-    end
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\nHost: foo\rbar\r\n\r\n")
     assert_match %r{\AHTTP/1.[01] 400\b}, sock.sysread(4096)
-    assert_nothing_raised { sock.close }
+    assert_nil sock.close
   end
 
   def test_http_0_9
-    sock = nil
-    assert_nothing_raised do
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("GET /hello\r\n")
-    end
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("GET /hello\r\n")
     assert_match 'hello!\n', sock.sysread(4096)
-    assert_nothing_raised { sock.close }
+    assert_nil sock.close
   end
 
   def test_header_is_too_long

data/test/unit/test_signals.rb

@@ -51,22 +51,19 @@ class SignalsTest < Test::Unit::TestCase
       opts = @server_opts.merge(:timeout => 3)
       redirect_test_io { HttpServer.new(app, opts).start.join }
     }
-    child = sock = buf = t0 = nil
-    assert_nothing_raised do
-      wait_workers_ready("test_stderr.#{pid}.log", 1)
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
-      buf = sock.readpartial(4096)
-      sock.close
-      buf =~ /\bX-Pid: (\d+)\b/ or raise Exception
-      child = $1.to_i
-      wait_master_ready("test_stderr.#{pid}.log")
-      wait_workers_ready("test_stderr.#{pid}.log", 1)
-      Process.kill(:KILL, pid)
-      Process.waitpid(pid)
-      File.unlink("test_stderr.#{pid}.log", "test_stdout.#{pid}.log")
-      t0 = Time.now
-    end
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    buf = sock.readpartial(4096)
+    assert_nil sock.close
+    buf =~ /\bX-Pid: (\d+)\b/ or raise Exception
+    child = $1.to_i
+    wait_master_ready("test_stderr.#{pid}.log")
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    Process.kill(:KILL, pid)
+    Process.waitpid(pid)
+    File.unlink("test_stderr.#{pid}.log", "test_stdout.#{pid}.log")
+    t0 = Time.now
     assert child
     assert t0
     assert_raises(Errno::ESRCH) { loop { Process.kill(0, child); sleep 0.2 } }
@@ -80,17 +77,14 @@ class SignalsTest < Test::Unit::TestCase
       app = lambda { |env| wr.syswrite('.'); sleep; [ 200, {}, [] ] }
       redirect_test_io { HttpServer.new(app, @server_opts).start.join }
     }
-    sock = buf = nil
     wr.close
-    assert_nothing_raised do
-      wait_workers_ready("test_stderr.#{pid}.log", 1)
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
-      buf = rd.readpartial(1)
-      wait_master_ready("test_stderr.#{pid}.log")
-      Process.kill(:INT, pid)
-      Process.waitpid(pid)
-    end
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    buf = rd.readpartial(1)
+    wait_master_ready("test_stderr.#{pid}.log")
+    Process.kill(:INT, pid)
+    Process.waitpid(pid)
     assert_equal '.', buf
     buf = nil
     assert_raises(EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,
@@ -98,7 +92,6 @@ class SignalsTest < Test::Unit::TestCase
       buf = sock.sysread(4096)
     end
     assert_nil buf
-    ensure
   end
 
   def test_timeout_slow_response
@@ -108,12 +101,9 @@ class SignalsTest < Test::Unit::TestCase
       redirect_test_io { HttpServer.new(app, opts).start.join }
     }
     t0 = Time.now
-    sock = nil
-    assert_nothing_raised do
-      wait_workers_ready("test_stderr.#{pid}.log", 1)
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
-    end
+    wait_workers_ready("test_stderr.#{pid}.log", 1)
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
 
     buf = nil
     assert_raises(EOFError,Errno::ECONNRESET,Errno::EPIPE,Errno::EINVAL,
@@ -134,19 +124,14 @@ class SignalsTest < Test::Unit::TestCase
         Dd.new(@bs, @count) ]
     }
     redirect_test_io { @server = HttpServer.new(app, @server_opts).start }
-    sock = nil
-    assert_nothing_raised do
-      wait_workers_ready("test_stderr.#{$$}.log", 1)
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
-    end
+    wait_workers_ready("test_stderr.#{$$}.log", 1)
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
     buf = ''
     header_len = pid = nil
-    assert_nothing_raised do
-      buf = sock.sysread(16384, buf)
-      pid = buf[/\r\nX-Pid: (\d+)\r\n/, 1].to_i
-      header_len = buf[/\A(.+?\r\n\r\n)/m, 1].size
-    end
+    buf = sock.sysread(16384, buf)
+    pid = buf[/\r\nX-Pid: (\d+)\r\n/, 1].to_i
+    header_len = buf[/\A(.+?\r\n\r\n)/m, 1].size
     assert pid > 0, "pid not positive: #{pid.inspect}"
     read = buf.size
     size_before = @tmp.stat.size
@@ -166,7 +151,7 @@ class SignalsTest < Test::Unit::TestCase
     got = read - header_len
     expect = @bs * @count
     assert_equal(expect, got, "expect=#{expect} got=#{got}")
-    assert_nothing_raised { sock.close }
+    assert_nil sock.close
   end
 
   def test_request_read
@@ -176,15 +161,12 @@ class SignalsTest < Test::Unit::TestCase
       [ 200, {'Content-Type'=>'text/plain', 'X-Pid'=>Process.pid.to_s}, [] ]
     }
     redirect_test_io { @server = HttpServer.new(app, @server_opts).start }
-    pid = nil
-
-    assert_nothing_raised do
-      wait_workers_ready("test_stderr.#{$$}.log", 1)
-      sock = TCPSocket.new('127.0.0.1', @port)
-      sock.syswrite("GET / HTTP/1.0\r\n\r\n")
-      pid = sock.sysread(4096)[/\r\nX-Pid: (\d+)\r\n/, 1].to_i
-      sock.close
-    end
+
+    wait_workers_ready("test_stderr.#{$$}.log", 1)
+    sock = TCPSocket.new('127.0.0.1', @port)
+    sock.syswrite("GET / HTTP/1.0\r\n\r\n")
+    pid = sock.sysread(4096)[/\r\nX-Pid: (\d+)\r\n/, 1].to_i
+    assert_nil sock.close
 
     assert pid > 0, "pid not positive: #{pid.inspect}"
     sock = TCPSocket.new('127.0.0.1', @port)
@@ -201,7 +183,6 @@ class SignalsTest < Test::Unit::TestCase
     # can't check for == since pending signals get merged
     assert size_before < @tmp.stat.size
     assert_equal pid, sock.sysread(4096)[/\r\nX-Pid: (\d+)\r\n/, 1].to_i
-    sock.close
+    assert_nil sock.close
   end
-
 end

data/test/unit/test_socket_helper.rb

@@ -37,16 +37,13 @@ class TestSocketHelper < Test::Unit::TestCase
     [ { :backlog => 5 }, { :sndbuf => 4096 }, { :rcvbuf => 4096 },
       { :backlog => 16, :rcvbuf => 4096, :sndbuf => 4096 }
     ].each do |opts|
-      assert_nothing_raised do
-        tcp_listener = bind_listen(tcp_listener_name, opts)
-        assert TCPServer === tcp_listener
-        tcp_listener.close
-        unix_listener = bind_listen(unix_listener_name, opts)
-        assert UNIXServer === unix_listener
-        unix_listener.close
-      end
+      tcp_listener = bind_listen(tcp_listener_name, opts)
+      assert TCPServer === tcp_listener
+      tcp_listener.close
+      unix_listener = bind_listen(unix_listener_name, opts)
+      assert UNIXServer === unix_listener
+      unix_listener.close
     end
-    #system('cat', @log_tmp.path)
   end
 
   def test_bind_listen_unix
@@ -106,10 +103,10 @@ class TestSocketHelper < Test::Unit::TestCase
     assert_raises(Errno::EADDRINUSE) do
       new_listener = bind_listen(@unix_listener_path)
     end
-    assert_nothing_raised do
-      File.unlink(@unix_listener_path)
-      new_listener = bind_listen(@unix_listener_path)
-    end
+
+    File.unlink(@unix_listener_path)
+    new_listener = bind_listen(@unix_listener_path)
+
     assert UNIXServer === new_listener
     assert new_listener.fileno != @unix_listener.fileno
     assert_equal sock_name(new_listener), sock_name(@unix_listener)
@@ -127,10 +124,8 @@ class TestSocketHelper < Test::Unit::TestCase
   end
 
   def test_server_cast
-    assert_nothing_raised do
-      test_bind_listen_unix
-      test_bind_listen_tcp
-    end
+    test_bind_listen_unix
+    test_bind_listen_tcp
     unix_listener_socket = Socket.for_fd(@unix_listener.fileno)
     assert Socket === unix_listener_socket
     @unix_server = server_cast(unix_listener_socket)

data/test/unit/test_stream_input.rb

@@ -85,8 +85,7 @@ class TestStreamInput < Test::Unit::TestCase
       assert_equal '....', si.read(4), "nr=#{x}"
     }
     assert_nil si.read(1)
-    status = nil
-    assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+    pid, status = Process.waitpid2(pid)
     assert status.success?
   end
 
@@ -101,13 +100,13 @@ class TestStreamInput < Test::Unit::TestCase
       @wr.close
     }
     @wr.close
-    assert_nothing_raised { line = si.gets }
+    line = si.gets
     assert_equal(4096 * 4 * 3 + 5 + $/.size, line.size)
     assert_equal("hello" << ("ffff" * 4096 * 3) << "#$/", line)
-    assert_nothing_raised { line = si.gets }
+    line = si.gets
     assert_equal "foo#$/", line
     assert_nil si.gets
-    assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+    pid, status = Process.waitpid2(pid)
     assert status.success?
   end
 

data/test/unit/test_tee_input.rb

@@ -40,13 +40,13 @@ class TestTeeInput < Test::Unit::TestCase
       @wr.close
     }
     @wr.close
-    assert_nothing_raised { line = ti.gets }
+    line = ti.gets
     assert_equal(4096 * 4 * 3 + 5 + $/.size, line.size)
     assert_equal("hello" << ("ffff" * 4096 * 3) << "#$/", line)
-    assert_nothing_raised { line = ti.gets }
+    line = ti.gets
     assert_equal "foo#$/", line
     assert_nil ti.gets
-    assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+    pid, status = Process.waitpid2(pid)
     assert status.success?
   end
 
@@ -60,12 +60,12 @@ class TestTeeInput < Test::Unit::TestCase
       @wr.close
     }
     @wr.close
-    assert_nothing_raised { line = ti.gets }
+    line = ti.gets
     assert_equal("hello#$/", line)
-    assert_nothing_raised { line = ti.gets }
+    line = ti.gets
     assert_equal "foo", line
     assert_nil ti.gets
-    assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+    pid, status = Process.waitpid2(pid)
     assert status.success?
   end
 
@@ -146,8 +146,7 @@ class TestTeeInput < Test::Unit::TestCase
       assert_equal Unicorn::Const::MAX_BODY + 1, ti.size
     }
     assert_nil ti.read(1)
-    status = nil
-    assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+    pid, status = Process.waitpid2(pid)
     assert status.success?
   end
 
@@ -174,15 +173,15 @@ class TestTeeInput < Test::Unit::TestCase
     assert @parser.body_eof?
     assert_equal 25, ti.len
     assert_equal 0, ti.tmp.pos
-    assert_nothing_raised { ti.rewind }
+    ti.rewind
     assert_equal 0, ti.tmp.pos
     assert_equal 'abcdeabcdeabcdeabcde', ti.read(20)
     assert_equal 20, ti.tmp.pos
-    assert_nothing_raised { ti.rewind }
+    ti.rewind
     assert_equal 0, ti.tmp.pos
     assert_kind_of File, ti.tmp
     status = nil
-    assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+    pid, status = Process.waitpid2(pid)
     assert status.success?
   end
 
@@ -241,8 +240,7 @@ class TestTeeInput < Test::Unit::TestCase
     assert ! @parser.body_eof?
     assert_equal 25, ti.size
     assert_equal "World", @parser.env['HTTP_HELLO']
-    status = nil
-    assert_nothing_raised { pid, status = Process.waitpid2(pid) }
+    pid, status = Process.waitpid2(pid)
     assert status.success?
   end
 

data/test/unit/test_upload.rb

@@ -163,7 +163,7 @@ class UploadTest < Test::Unit::TestCase
     assert_raise(Errno::ECONNRESET, Errno::EPIPE) do
       ::Unicorn::Const::CHUNK_SIZE.times { sock.syswrite(buf) }
     end
-    assert_nothing_raised { sock.gets }
+    sock.gets
     tmp.rewind
     assert_equal length, tmp.read.to_i
   end

metadata

@@ -1,13 +1,15 @@
 --- !ruby/object:Gem::Specification 
 name: unicorn
 version: !ruby/object:Gem::Version 
-  hash: 47
-  prerelease: 
+  hash: -223651717
+  prerelease: 5
   segments: 
   - 4
-  - 4
+  - 5
   - 0
-  version: 4.4.0
+  - pre
+  - 1
+  version: 4.5.0pre1
 platform: ruby
 authors: 
 - Unicorn hackers
@@ -15,7 +17,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2012-10-11 00:00:00 Z
+date: 2012-11-29 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rack
@@ -318,12 +320,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version 
-      hash: 3
+      hash: 25
       segments: 
-      - 0
-      version: "0"
+      - 1
+      - 3
+      - 1
+      version: 1.3.1
 requirements: []
 
 rubyforge_project: mongrel