glebtv-httpclient 3.1.1 → 3.2.0

data/spec/keepalive_spec.rb

@@ -0,0 +1,129 @@
+# coding: utf-8
+require 'spec_helper'
+
+def create_keepalive_disconnected_thread(idx, sock)
+  Thread.new {
+    # return "12345" for the first connection
+    sock.gets
+    sock.gets
+    sock.write("HTTP/1.1 200 OK\r\n")
+    sock.write("Content-Length: 5\r\n")
+    sock.write("\r\n")
+    sock.write("12345")
+    # for the next connection, close while reading the request for emulating
+    # KeepAliveDisconnected
+    sock.gets
+    sock.close
+  }
+end
+
+def create_keepalive_thread(count, sock)
+  Thread.new {
+    Thread.abort_on_exception = true
+    count.times do
+      req = sock.gets
+      while line = sock.gets
+        break if line.chomp.empty?
+      end
+      case req
+      when /chunked/
+        sock.write("HTTP/1.1 200 OK\r\n")
+        sock.write("Transfer-Encoding: chunked\r\n")
+        sock.write("\r\n")
+        sock.write("1a\r\n")
+        sock.write("abcdefghijklmnopqrstuvwxyz\r\n")
+        sock.write("10\r\n")
+        sock.write("1234567890abcdef\r\n")
+        sock.write("0\r\n")
+        sock.write("\r\n")
+      else
+        sock.write("HTTP/1.1 200 OK\r\n")
+        sock.write("Content-Length: 5\r\n")
+        sock.write("\r\n")
+        sock.write("12345")
+      end
+    end
+    sock.close
+  }
+end
+
+describe 'KeepAlive' do
+  it 'disconnected' do
+    client = HTTPClient.new
+    server = TCPServer.open('127.0.0.1', 0)
+    server.listen(30) # set enough backlogs
+    endpoint = "http://127.0.0.1:#{server.addr[1]}/"
+    Thread.new {
+      Thread.abort_on_exception = true
+      # emulate 10 keep-alive connections
+      10.times do |idx|
+        sock = server.accept
+        create_keepalive_disconnected_thread(idx, sock)
+      end
+      # return "23456" for the request which gets KeepAliveDisconnected
+      5.times do
+        sock = server.accept
+        sock.gets
+        sock.gets
+        sock.write("HTTP/1.1 200 OK\r\n")
+        sock.write("\r\n")
+        sock.write("23456")
+        sock.close
+      end
+      # return "34567" for the rest requests
+      while true
+        sock = server.accept
+        sock.gets
+        sock.gets
+        sock.write("HTTP/1.1 200 OK\r\n")
+        sock.write("Connection: close\r\n")
+        sock.write("Content-Length: 5\r\n")
+        sock.write("\r\n")
+        sock.write("34567")
+        sock.close
+      end
+    }
+    # allocate 10 keep-alive connections
+    (0...10).to_a.map {
+      Thread.new {
+        Thread.abort_on_exception = true
+        client.get(endpoint).content.should eq "12345"
+      }
+    }.each { |th| th.join }
+    # send 5 requests, which should get KeepAliveDesconnected.
+    # doing these requests, rest keep-alive connections are invalidated.
+    (0...5).to_a.map {
+      Thread.new {
+        Thread.abort_on_exception = true
+        client.get(endpoint).content.should eq "23456"
+      }
+    }.each { |th| th.join }
+    # rest requests won't get KeepAliveDisconnected; how can I check this?
+    (0...10).to_a.map {
+      Thread.new {
+        Thread.abort_on_exception = true
+        client.get(endpoint).content.should eq "34567"
+      }
+    }.each { |th| th.join }
+  end
+
+  it 'works' do
+    client = HTTPClient.new
+    server = TCPServer.open('localhost', 0)
+    server_thread = Thread.new {
+      Thread.abort_on_exception = true
+      sock = server.accept
+      create_keepalive_thread(10, sock)
+    }
+    url = "http://localhost:#{server.addr[1]}/"
+    # content-length
+    5.times do
+      client.get(url).body.should eq '12345'
+    end
+    # chunked
+    5.times do
+      client.get(url + 'chunked').body.should eq 'abcdefghijklmnopqrstuvwxyz1234567890abcdef'
+    end
+    server_thread.join
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+# coding: utf-8
+
+require 'coveralls'
+Coveralls.wear!
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "..", "lib"))
+
+require "rubygems"
+require "rspec"
+require 'digest/md5'
+require 'uri'
+require 'logger'
+require 'stringio'
+require 'webrick'
+require 'webrick/httpproxy.rb'
+require 'webrick/httputils'
+require 'tempfile'
+require 'zlib'
+require 'httpclient'
+
+require File.join(File.dirname(__FILE__), "support", "base_server.rb")
+require File.join(File.dirname(__FILE__), "support", "test_servlet.rb")
+
+SUPPORT = File.join(File.dirname(__FILE__), "support")
+Dir["#{SUPPORT}/*.rb"].each { |f| require f }
+
+GZIP_CONTENT = "\x1f\x8b\x08\x00\x1a\x96\xe0\x4c\x00\x03\xcb\x48\xcd\xc9\xc9\x07\x00\x86\xa6\x10\x36\x05\x00\x00\x00"
+DEFLATE_CONTENT = "\x78\x9c\xcb\x48\xcd\xc9\xc9\x07\x00\x06\x2c\x02\x15"
+GZIP_CONTENT.force_encoding('BINARY') if GZIP_CONTENT.respond_to?(:force_encoding)
+DEFLATE_CONTENT.force_encoding('BINARY') if DEFLATE_CONTENT.respond_to?(:force_encoding)
+
+LARGE_STR = '1234567890' * 100_000
+
+RSpec.configure do |config|
+  config.before(:all) do
+    @srv = MainServer.new
+    @proxy = ProxyServer.new
+  end
+end

data/spec/support/base_server.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+class BaseServer
+  attr_accessor :server, :port, :logger
+  
+  def u(str = '')
+    "http://localhost:#{@port}/#{str}"
+  end
+  
+  def set_logger
+    @io = StringIO.new
+    @logger = Logger.new(@proxyio)
+    @logger.level = Logger::Severity::DEBUG
+  end
+  
+  def start
+    @port = @server.config[:Port]
+    @thread = start_server_thread(@server)
+  end
+  
+  def start_server_thread(server)
+    t = Thread.new {
+      Thread.current.abort_on_exception = true
+      server.start
+    }
+    while server.status != :Running
+      Thread.pass
+      unless t.alive?
+    t.join
+    raise
+      end
+    end
+    t
+  end
+  
+end

data/spec/support/file.txt

@@ -0,0 +1 @@
+a file for testing uploads

data/spec/support/ht_helpers.rb

@@ -0,0 +1,10 @@
+module HtHelpers
+  def params(str)
+    HTTP::Message.parse(str).inject({}) { |r, (k, v)| r[k] = v.first; r }
+  end
+end
+
+RSpec.configure do |config|
+  config.extend HtHelpers
+  config.include HTTPClient::Util
+end

data/spec/support/main_server.rb

@@ -0,0 +1,155 @@
+# coding: utf-8
+
+class MainServer < BaseServer
+  def initialize
+    set_logger
+    @server = WEBrick::HTTPServer.new(
+      :BindAddress => "localhost",
+      :Logger => @logger,
+      :Port => 0,
+      :AccessLog => [],
+      :DocumentRoot => File.dirname(File.expand_path(__FILE__))
+    )
+    [
+      :hello, :sleep, :servlet_redirect, :servlet_temporary_redirect, :servlet_see_other,
+      :redirect1, :redirect2, :redirect3,
+      :redirect_self, :relative_redirect, :redirect_see_other, :chunked,
+      :largebody, :status, :compressed, :compressed_large, :charset, :continue,
+      :servlet_redirect_413, :servlet_413
+    ].each do |sym|
+      @server.mount(
+        "/#{sym}",
+        WEBrick::HTTPServlet::ProcHandler.new(method("do_#{sym}").to_proc)
+      )
+    end
+    @server.mount('/servlet', TestServlet.new(@server))
+    start
+  end
+
+  def escape_noproxy
+    backup = HTTPClient::NO_PROXY_HOSTS.dup
+    HTTPClient::NO_PROXY_HOSTS.clear
+    yield
+  ensure
+    HTTPClient::NO_PROXY_HOSTS.replace(backup)
+  end
+  
+  def do_hello(req, res)
+    res['content-type'] = 'text/html'
+    res.body = "hello"
+  end
+
+  def do_sleep(req, res)
+    sec = req.query['sec'].to_i
+    sleep sec
+    res['content-type'] = 'text/html'
+    res.body = "hello"
+  end
+
+  def do_servlet_redirect(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::Found, u("servlet"))
+  end
+
+  def do_servlet_redirect_413(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::Found, u("servlet_413"))
+  end
+
+  def do_servlet_413(req, res)
+    res.body = req.body.to_s
+  end
+
+  def do_servlet_temporary_redirect(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::TemporaryRedirect, u("servlet"))
+  end
+
+  def do_servlet_see_other(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::SeeOther, u("servlet"))
+  end
+
+  def do_redirect1(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::MovedPermanently, u("hello"))
+  end
+
+  def do_redirect2(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::TemporaryRedirect, u("redirect3"))
+  end
+
+  def do_redirect3(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::Found, u("hello"))
+  end
+
+  def do_redirect_self(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::Found, u("redirect_self"))
+  end
+
+  def do_relative_redirect(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::Found, "hello")
+  end
+
+  def do_redirect_see_other(req, res)
+    if req.request_method == 'POST'
+      res.set_redirect(WEBrick::HTTPStatus::SeeOther, u("redirect_see_other")) # self
+    else
+      res.body = 'hello'
+    end
+  end
+
+  def do_chunked(req, res)
+    res.chunked = true
+    res['content-type'] = 'text/plain; charset=UTF-8'
+    piper, pipew = IO.pipe
+    res.body = piper
+    pipew << req.query['msg']
+    pipew.close
+  end
+
+  def do_largebody(req, res)
+    res['content-type'] = 'text/html'
+    res.body = "a" * 1_000_000
+  end
+
+  def gzip(string)
+    wio = StringIO.new("w")
+    w_gz = Zlib::GzipWriter.new(wio)
+    w_gz.write(string)
+    w_gz.close
+    compressed = wio.string
+  end
+
+  def do_compressed(req, res)
+    res['content-type'] = 'application/octet-stream'
+    if req.query['enc'] == 'gzip'
+      res['content-encoding'] = 'gzip'
+      res.body = GZIP_CONTENT
+    elsif req.query['enc'] == 'deflate'
+      res['content-encoding'] = 'deflate'
+      res.body = DEFLATE_CONTENT
+    end
+  end
+
+  def do_compressed_large(req, res)
+    res['content-type'] = 'application/octet-stream'
+    str = '1234567890' * 100_000
+    if req.query['enc'] == 'gzip'
+      res['content-encoding'] = 'gzip'
+      res.body = gzip(str)
+    elsif req.query['enc'] == 'deflate'
+      res['content-encoding'] = 'deflate'
+      res.body = Zlib::Deflate.deflate(str)
+    end
+  end
+
+  def do_charset(req, res)
+    res.body = 'あいうえお'.encode("euc-jp")
+    res['Content-Type'] = 'text/plain; charset=euc-jp'
+  end
+
+  def do_status(req, res)
+    res.status = req.query['status'].to_i
+  end
+
+  def do_continue(req, res)
+    req.continue
+    res.body = 'done!'
+  end
+end

data/spec/support/proxy_server.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+class ProxyServer < BaseServer
+  def initialize
+    set_logger
+    @server = WEBrick::HTTPProxyServer.new(
+      :BindAddress => "localhost",
+      :Logger => @logger,
+      :Port => 0,
+      :AccessLog => []
+    )
+    start
+  end
+end

data/spec/support/test_servlet.rb

@@ -0,0 +1,73 @@
+class TestServlet < WEBrick::HTTPServlet::AbstractServlet
+  def get_instance(*arg)
+    self
+  end
+
+  def do_HEAD(req, res)
+    res["x-head"] = 'head'    # use this for test purpose only.
+    res["x-query"] = query_response(req)
+  end
+
+  def do_GET(req, res)
+    res.body = 'get'
+    res["x-query"] = query_response(req)
+  end
+
+  def do_POST(req, res)
+    res["content-type"] = "text/plain" # iso-8859-1, not US-ASCII
+    res.body = 'post,' + req.body.to_s
+    res["x-query"] = body_response(req)
+  end
+
+  def do_PUT(req, res)
+    res["x-query"] = body_response(req)
+    param = WEBrick::HTTPUtils.parse_query(req.body) || {}
+    res["x-size"] = (param['txt'] || '').size
+    res.body = param['txt'] || 'put'
+  end
+
+  def do_DELETE(req, res)
+    res.body = 'delete'
+  end
+
+  def do_OPTIONS(req, res)
+    # check RFC for legal response.
+    res.body = 'options'
+  end
+
+  def do_PROPFIND(req, res)
+    res.body = 'propfind'
+  end
+
+  def do_PROPPATCH(req, res)
+    res.body = 'proppatch'
+    res["x-query"] = body_response(req)
+  end
+
+  def do_TRACE(req, res)
+    # client SHOULD reflect the message received back to the client as the
+    # entity-body of a 200 (OK) response. [RFC2616]
+    res.body = 'trace'
+    res["x-query"] = query_response(req)
+  end
+
+private
+
+  def query_response(req)
+    query_escape(WEBrick::HTTPUtils.parse_query(req.query_string))
+  end
+
+  def body_response(req)
+    query_escape(WEBrick::HTTPUtils.parse_query(req.body))
+  end
+
+  def query_escape(query)
+    escaped = []
+    query.sort_by { |k, v| k }.collect do |k, v|
+      v.to_ary.each do |ve|
+        escaped << CGI.escape(k) + '=' + CGI.escape(ve)
+      end
+    end
+    escaped.join('&')
+  end
+end