httpclient 2.2.0.2 → 2.2.1

data/test/test_cookie.rb

@@ -0,0 +1,398 @@
+require 'test/unit'
+require 'uri'
+
+require 'httpclient/cookie'
+
+class TestCookie < Test::Unit::TestCase
+
+  def setup()
+    @c = WebAgent::Cookie.new()
+  end
+
+  def test_s_new()
+    assert_instance_of(WebAgent::Cookie, @c)
+  end
+
+  def test_discard?
+    assert_equal(false, !!(@c.discard?))
+    @c.discard = true
+    assert_equal(true, !!(@c.discard?))
+  end
+
+  def test_match()
+    url = URI.parse('http://www.rubycolor.org/hoge/funi/#919191')
+
+    @c.domain = 'www.rubycolor.org'
+    assert_equal(true, @c.match?(url))
+
+    @c.domain = '.rubycolor.org'
+    assert_equal(true, @c.match?(url))
+
+    @c.domain = 'aaa.www.rubycolor.org'
+    assert_equal(false, @c.match?(url))
+
+    @c.domain = 'aaa.www.rubycolor.org'
+    assert_equal(false, @c.match?(url))
+
+    @c.domain = 'www.rubycolor.org'
+    @c.path = '/'
+    assert_equal(true, @c.match?(url))
+
+    @c.domain = 'www.rubycolor.org'
+    @c.path = '/hoge'
+    assert_equal(true, @c.match?(url))
+
+    @c.domain = 'www.rubycolor.org'
+    @c.path = '/hoge/hoge'
+    assert_equal(false, @c.match?(url))
+
+    @c.domain = 'www.rubycolor.org'
+    @c.path = '/hoge'
+    @c.secure = true
+    assert_equal(false, @c.match?(url))
+
+    url2 = URI.parse('https://www.rubycolor.org/hoge/funi/#919191')
+    @c.domain = 'www.rubycolor.org'
+    @c.path = '/hoge'
+    @c.secure = true
+    assert_equal(true, @c.match?(url2))
+
+    @c.domain = 'www.rubycolor.org'
+    @c.path = '/hoge'
+    @c.secure = nil
+    assert_equal(true, @c.match?(url2)) ## not false!
+
+    url.port = 80
+    @c.domain = 'www.rubycolor.org'
+    @c.path = '/hoge'
+#    @c.port = [80,8080]
+    assert_equal(true, @c.match?(url))
+
+  end
+
+  def test_head_match?()
+    assert_equal(true, @c.head_match?("",""))
+    assert_equal(false, @c.head_match?("a",""))
+    assert_equal(true, @c.head_match?("","a"))
+    assert_equal(true, @c.head_match?("abcde","abcde"))
+    assert_equal(true, @c.head_match?("abcde","abcdef"))
+    assert_equal(false, @c.head_match?("abcdef","abcde"))
+    assert_equal(false, @c.head_match?("abcde","bcde"))
+    assert_equal(false, @c.head_match?("bcde","abcde"))
+  end
+
+  def test_tail_match?()
+    assert_equal(true, @c.tail_match?("",""))
+    assert_equal(false, @c.tail_match?("a",""))
+    assert_equal(true, @c.tail_match?("","a"))
+    assert_equal(true, @c.tail_match?("abcde","abcde"))
+    assert_equal(false, @c.tail_match?("abcde","abcdef"))
+    assert_equal(false, @c.tail_match?("abcdef","abcde"))
+    assert_equal(false, @c.tail_match?("abcde","bcde"))
+    assert_equal(true, @c.tail_match?("bcde","abcde"))
+  end
+
+
+  def test_domain_match()
+    extend WebAgent::CookieUtils
+    assert_equal(true, !!domain_match("hoge.co.jp","."))
+#    assert_equal(true, !!domain_match("locahost",".local"))
+    assert_equal(true, !!domain_match("192.168.10.1","192.168.10.1"))
+    assert_equal(false, !!domain_match("192.168.10.1","192.168.10.2"))
+#    assert_equal(false, !!domain_match("hoge.co.jp",".hoge.co.jp"))
+    # allows; host == rubyforge.org, domain == .rubyforge.org
+    assert_equal(true, !!domain_match("hoge.co.jp",".hoge.co.jp"))
+    assert_equal(true, !!domain_match("www.hoge.co.jp", "www.hoge.co.jp"))
+    assert_equal(false, !!domain_match("www.hoge.co.jp", "www2.hoge.co.jp"))
+    assert_equal(true, !!domain_match("www.hoge.co.jp", ".hoge.co.jp"))
+    assert_equal(true, !!domain_match("www.aa.hoge.co.jp", ".hoge.co.jp"))
+    assert_equal(false, !!domain_match("www.hoge.co.jp", "hoge.co.jp"))
+  end
+
+  def test_join_quotedstr()
+    arr1 = ['hoge=funi', 'hoge2=funi2']
+    assert_equal(arr1, @c.instance_eval{join_quotedstr(arr1,';')})
+    arr2 = ['hoge="fu', 'ni"',  'funi=funi']
+    assert_equal(['hoge="fu;ni"','funi=funi'],
+		 @c.instance_eval{join_quotedstr(arr2,';')})
+    arr3 = ['hoge="funi";hoge2="fu','ni2";hoge3="hoge"',  'funi="funi"']
+    assert_equal(['hoge="funi";hoge2="fu,ni2";hoge3="hoge"',  'funi="funi"'],
+		 @c.instance_eval{join_quotedstr(arr3,',')})
+  end
+
+end
+
+class TestCookieManager < Test::Unit::TestCase
+
+  def setup()
+    @cm = WebAgent::CookieManager.new()
+  end
+
+  def teardown()
+  end
+
+  def test_total_dot_num()
+    assert_equal(0, @cm.total_dot_num(""))
+    assert_equal(0, @cm.total_dot_num("abcde"))
+    assert_equal(1, @cm.total_dot_num("ab.cde"))
+    assert_equal(1, @cm.total_dot_num(".abcde"))
+    assert_equal(1, @cm.total_dot_num("abcde."))
+    assert_equal(2, @cm.total_dot_num("abc.de."))
+    assert_equal(2, @cm.total_dot_num("a.bc.de"))
+    assert_equal(2, @cm.total_dot_num(".abcde."))
+    assert_equal(3, @cm.total_dot_num(".a.bcde."))
+    assert_equal(3, @cm.total_dot_num("a.b.cde."))
+    assert_equal(3, @cm.total_dot_num("a.b.c.de"))
+  end
+  
+  def test_parse()
+    str = "inkid=n92b0ADOgACIgUb9lsjHqAAAHu2a; expires=Wed, 01-Dec-2010 00:00:00 GMT; path=/"
+    @cm.parse(str,URI.parse('http://www.test.jp'))
+    cookie = @cm.cookies[0]
+    assert_instance_of(WebAgent::Cookie, cookie)
+    assert_equal("inkid", cookie.name)
+    assert_equal("n92b0ADOgACIgUb9lsjHqAAAHu2a", cookie.value)
+    assert_equal(Time.gm(2010, 12, 1, 0,0,0), cookie.expires)
+    assert_equal("/", cookie.path)
+  end
+
+  def test_parse2()
+    str = "xmen=off,0,0,1; path=/; domain=.excite.co.jp; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    @cm.parse(str,URI.parse('http://www.excite.co.jp'))
+    cookie = @cm.cookies[0]
+    assert_instance_of(WebAgent::Cookie, cookie)
+    assert_equal("xmen", cookie.name)
+    assert_equal("off,0,0,1", cookie.value)
+    assert_equal("/", cookie.path)
+    assert_equal(".excite.co.jp", cookie.domain)
+    assert_equal(Time.gm(2037,12,31,12,0,0), cookie.expires)
+  end
+
+  def test_parse3()
+    str = "xmen=off,0,0,1; path=/; domain=.excite.co.jp; expires=Wednesday, 31-Dec-2037 12:00:00 GMT;Secure;HTTPOnly"
+    @cm.parse(str,URI.parse('http://www.excite.co.jp'))
+    cookie = @cm.cookies[0]
+    assert_instance_of(WebAgent::Cookie, cookie)
+    assert_equal("xmen", cookie.name)
+    assert_equal("off,0,0,1", cookie.value)
+    assert_equal("/", cookie.path)
+    assert_equal(".excite.co.jp", cookie.domain)
+    assert_equal(Time.gm(2037,12,31,12,0,0), cookie.expires)
+    assert_equal(true, cookie.secure?)
+    assert_equal(true, cookie.http_only?)
+  end
+  
+  def test_parse_double_semicolon()
+    str = "xmen=off,0,0,1;; path=\"/;;\"; domain=.excite.co.jp; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    @cm.parse(str,URI.parse('http://www.excite.co.jp'))
+    cookie = @cm.cookies[0]
+    assert_instance_of(WebAgent::Cookie, cookie)
+    assert_equal("xmen", cookie.name)
+    assert_equal("off,0,0,1", cookie.value)
+    assert_equal("/;;", cookie.path)
+    assert_equal(".excite.co.jp", cookie.domain)
+    assert_equal(Time.gm(2037,12,31,12,0,0), cookie.expires)
+  end
+
+#  def test_make_portlist()
+#    assert_equal([80,8080], @cm.instance_eval{make_portlist("80,8080")})
+#    assert_equal([80], @cm.instance_eval{make_portlist("80")})
+#    assert_equal([80,8080,10080], @cm.instance_eval{make_portlist(" 80, 8080, 10080 \n")})
+#  end
+
+  def test_check_expired_cookies()
+    c1 = WebAgent::Cookie.new()
+    c2 = c1.dup
+    c3 = c1.dup
+    c4 = c1.dup
+    c1.expires = Time.now - 100
+    c2.expires = Time.now + 100
+    c3.expires = Time.now - 10
+    c4.expires = nil
+    cookies = [c1,c2,c3,c4]
+    @cm.cookies = cookies
+    @cm.check_expired_cookies()
+    # expires == nil cookies (session cookie) exists.
+    assert_equal([c2,c4], @cm.cookies)
+  end
+
+  def test_parse_expires
+    str = "inkid=n92b0ADOgACIgUb9lsjHqAAAHu2a; expires=; path=/"
+    @cm.parse(str,URI.parse('http://www.test.jp'))
+    cookie = @cm.cookies[0]
+    assert_equal("inkid", cookie.name)
+    assert_equal("n92b0ADOgACIgUb9lsjHqAAAHu2a", cookie.value)
+    assert_equal(nil, cookie.expires)
+    assert_equal("/", cookie.path)
+    #
+    str = "inkid=n92b0ADOgACIgUb9lsjHqAAAHu2a; path=/; expires="
+    @cm.parse(str,URI.parse('http://www.test.jp'))
+    cookie = @cm.cookies[0]
+    assert_equal("inkid", cookie.name)
+    assert_equal("n92b0ADOgACIgUb9lsjHqAAAHu2a", cookie.value)
+    assert_equal(nil, cookie.expires)
+    assert_equal("/", cookie.path)
+    #
+    str = "inkid=n92b0ADOgACIgUb9lsjHqAAAHu2a; path=/; expires=\"\""
+    @cm.parse(str,URI.parse('http://www.test.jp'))
+    cookie = @cm.cookies[0]
+    assert_equal("inkid", cookie.name)
+    assert_equal("n92b0ADOgACIgUb9lsjHqAAAHu2a", cookie.value)
+    assert_equal(nil, cookie.expires)
+    assert_equal("/", cookie.path)
+  end
+
+  def test_find_cookie()
+    str = "xmen=off,0,0,1; path=/; domain=.excite2.co.jp; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    @cm.parse(str, URI.parse("http://www.excite2.co.jp/"))
+
+    str = "xmen=off,0,0,2; path=/; domain=.excite.co.jp; expires=Wednesday, 31-Dec-2037 12:00:00 GMT"
+    @cm.parse(str, URI.parse("http://www.excite.co.jp/"))
+
+    @cm.cookies[0].use = true
+    @cm.cookies[1].use = true
+
+    url = URI.parse('http://www.excite.co.jp/hoge/funi/')
+    cookie_str = @cm.find(url)
+    assert_equal("xmen=off,0,0,2", cookie_str)
+  end
+
+  def test_load_cookies()
+    begin
+      File.open("tmp_test.tmp","w") {|f|
+	f.write <<EOF
+http://www.zdnet.co.jp/news/0106/08/e_gibson.html	NGUserID	d29b8f49-10875-992421294-1	2145801600	www.zdnet.co.jp	/	9	0			
+http://www.zdnet.co.jp/news/0106/08/e_gibson.html	PACK	zd3-992421294-7436	1293839999	.zdnet.co.jp	/	13	0			
+http://example.org/	key	value	0	.example.org	/	13	0			
+http://example.org/	key	value		.example.org	/	13	0			
+EOF
+      }
+
+      @cm.cookies_file = 'tmp_test.tmp'
+      @cm.load_cookies()
+      c0, c1, c2, c3 = @cm.cookies
+      assert_equal('http://www.zdnet.co.jp/news/0106/08/e_gibson.html', c0.url.to_s)
+      assert_equal('NGUserID', c0.name)
+      assert_equal('d29b8f49-10875-992421294-1', c0.value)
+      assert_equal(Time.at(2145801600), c0.expires)
+      assert_equal('www.zdnet.co.jp', c0.domain)
+      assert_equal('/', c0.path)
+      assert_equal(9, c0.flag)
+      #
+      assert_equal('http://www.zdnet.co.jp/news/0106/08/e_gibson.html', c1.url.to_s)
+      assert_equal('PACK', c1.name)
+      assert_equal('zd3-992421294-7436', c1.value)
+      assert_equal(Time.at(1293839999), c1.expires)
+      assert_equal('.zdnet.co.jp', c1.domain)
+      assert_equal('/', c1.path)
+      assert_equal(13, c1.flag)
+      #
+      assert_equal(nil, c2.expires)
+      assert_equal(nil, c3.expires) # allow empty 'expires' (should not happen)
+    ensure
+      File.unlink("tmp_test.tmp")
+    end
+  end
+
+  def test_save_cookie()
+    str = <<EOF
+http://www.zdnet.co.jp/news/0106/08/e_gibson.html	NGUserID	d29b8f49-10875-992421294-1	2145801600	www.zdnet.co.jp	/	9
+http://www.zdnet.co.jp/news/0106/08/e_gibson.html	PACK	zd3-992421294-7436	2145801600	.zdnet.co.jp	/	13
+EOF
+    begin
+      File.open("tmp_test.tmp","w") {|f|
+	f.write str
+      }
+      @cm.cookies_file = 'tmp_test.tmp'
+      @cm.load_cookies()
+      @cm.instance_eval{@is_saved = false}
+      @cm.cookies_file = 'tmp_test2.tmp'
+      @cm.save_cookies()
+      str2 = ''
+      File.open("tmp_test2.tmp","r") {|f|
+	str2 = f.read()
+      }
+      assert_equal(str, str2)
+      #
+      assert(File.exist?('tmp_test2.tmp'))
+      File.unlink("tmp_test2.tmp")
+      @cm.save_cookies()
+      assert(!File.exist?('tmp_test2.tmp'))
+      @cm.save_cookies(true)
+      assert(File.exist?('tmp_test2.tmp'))
+    ensure
+      File.unlink("tmp_test.tmp")
+      if FileTest.exist?("tmp_test2.tmp")
+	File.unlink("tmp_test2.tmp")
+      end
+    end
+  end
+
+  def test_not_saved_expired_cookies
+    begin
+      @cm.cookies_file = 'tmp_test.tmp'
+      uri = URI.parse('http://www.example.org')
+      @cm.parse("foo=1; path=/", uri)
+      @cm.parse("bar=2; path=/; expires=", uri)
+      @cm.parse("baz=3; path=/; expires=\"\"", uri)
+      @cm.parse("qux=4; path=/; expires=#{(Time.now + 10).asctime}", uri)
+      @cm.parse("quxx=5; path=/; expires=#{(Time.now - 10).asctime}", uri)
+      @cm.save_cookies()
+      @cm.load_cookies
+      assert_equal(1, @cm.cookies.size) # +10 cookies only
+    ensure
+      File.unlink("tmp_test.tmp") if File.exist?("tmp_test.tmp")
+    end
+  end
+
+  def test_add()
+    c = WebAgent::Cookie.new()
+    c.name = "hoge"
+    c.value = "funi"
+    c.url = URI.parse("http://www.inac.co.jp/hoge")
+    @cm.add(c)
+    c = @cm.cookies[0]
+    assert_equal('hoge', c.name)
+    assert_equal('funi', c.value)
+    assert_equal(nil, c.expires)
+  end
+
+  def test_add2()
+    c = WebAgent::Cookie.new()
+    c.name = "hoge"
+    c.value = "funi"
+    c.path = ''
+    c.url = URI.parse("http://www.inac.co.jp/hoge/hoge2/hoge3")
+    @cm.add(c)
+    #
+    c = WebAgent::Cookie.new()
+    c.name = "hoge"
+    c.value = "funi"
+    #c.path = '' NO path given -> same as URL
+    c.url = URI.parse("http://www.inac.co.jp/hoge/hoge2/hoge3")
+    @cm.add(c)
+    #
+    c1, c2 = @cm.cookies
+    assert_equal('', c1.path)
+    assert_equal('/hoge/hoge2', c2.path)
+  end
+
+  def test_check_cookie_accept_domain()
+    @cm.accept_domains = [".example1.co.jp", "www1.example.jp"]
+    @cm.reject_domains = [".example2.co.jp", "www2.example.jp"]
+    check1 = @cm.check_cookie_accept_domain("www.example1.co.jp")
+    assert_equal(true, check1)
+    check2 = @cm.check_cookie_accept_domain("www.example2.co.jp")
+    assert_equal(false, check2)
+    check3 = @cm.check_cookie_accept_domain("www1.example.jp")
+    assert_equal(true, check3)
+    check4 = @cm.check_cookie_accept_domain("www2.example.jp")
+    assert_equal(false, check4)
+    check5 = @cm.check_cookie_accept_domain("aa.www2.example.jp")
+    assert_equal(true, check5)
+    check6 = @cm.check_cookie_accept_domain("aa.www2.example.jp")
+    assert_equal(true, check6)
+    assert_equal(false, @cm.check_cookie_accept_domain(nil))
+  end
+
+end

data/test/test_http-access2.rb

@@ -0,0 +1,497 @@
+require 'http-access2'
+require File.expand_path('helper', File.dirname(__FILE__))
+
+
+module HTTPAccess2
+
+
+class TestClient < Test::Unit::TestCase
+  include Helper
+
+  def setup
+    super
+    setup_server
+    setup_client
+  end
+
+  def teardown
+    super
+  end
+
+  def test_initialize
+    setup_proxyserver
+    escape_noproxy do
+      @proxyio.string = ""
+      @client = HTTPAccess2::Client.new(proxyurl)
+      assert_equal(URI.parse(proxyurl), @client.proxy)
+      assert_equal(200, @client.head(serverurl).status)
+      assert(!@proxyio.string.empty?)
+    end
+  end
+
+  def test_agent_name
+    @client = HTTPAccess2::Client.new(nil, "agent_name_foo")
+    str = ""
+    @client.debug_dev = str
+    @client.get(serverurl)
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_match(/^User-Agent: agent_name_foo/, lines[4])
+  end
+
+  def test_from
+    @client = HTTPAccess2::Client.new(nil, nil, "from_bar")
+    str = ""
+    @client.debug_dev = str
+    @client.get(serverurl)
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_match(/^From: from_bar/, lines[4])
+  end
+
+  def test_debug_dev
+    str = ""
+    @client.debug_dev = str
+    assert(str.empty?)
+    @client.get(serverurl)
+    assert(!str.empty?)
+  end
+
+  def _test_protocol_version_http09
+    @client.protocol_version = 'HTTP/0.9'
+    str = ""
+    @client.debug_dev = str
+    @client.get(serverurl + 'hello')
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_equal("! CONNECTION ESTABLISHED", lines[2])
+    assert_equal("GET /hello HTTP/0.9", lines[3])
+    assert_equal("Connection: close", lines[5])
+    assert_equal("= Response", lines[6])
+    assert_match(/^hello/, lines[7])
+  end
+
+  def test_protocol_version_http10
+    @client.protocol_version = 'HTTP/1.0'
+    str = ""
+    @client.debug_dev = str
+    @client.get(serverurl + 'hello')
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_equal("! CONNECTION ESTABLISHED", lines[2])
+    assert_equal("GET /hello HTTP/1.0", lines[3])
+    assert_equal("Connection: close", lines[5])
+    assert_equal("= Response", lines[6])
+  end
+
+  def test_protocol_version_http11
+    str = ""
+    @client.debug_dev = str
+    @client.get(serverurl)
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_equal("! CONNECTION ESTABLISHED", lines[2])
+    assert_equal("GET / HTTP/1.1", lines[3])
+    assert_equal("Host: localhost:#{serverport}", lines[5])
+    @client.protocol_version = 'HTTP/1.1'
+    str = ""
+    @client.debug_dev = str
+    @client.get(serverurl)
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_equal("! CONNECTION ESTABLISHED", lines[2])
+    assert_equal("GET / HTTP/1.1", lines[3])
+    @client.protocol_version = 'HTTP/1.0'
+    str = ""
+    @client.debug_dev = str
+    @client.get(serverurl)
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_equal("! CONNECTION ESTABLISHED", lines[2])
+    assert_equal("GET / HTTP/1.0", lines[3])
+  end
+
+  def test_proxy
+    setup_proxyserver
+    escape_noproxy do
+      assert_raises(URI::InvalidURIError) do
+       	@client.proxy = "http://"
+      end
+      @client.proxy = ""
+      assert_nil(@client.proxy)
+      @client.proxy = "http://foo:1234"
+      assert_equal(URI.parse("http://foo:1234"), @client.proxy)
+      uri = URI.parse("http://bar:2345")
+      @client.proxy = uri
+      assert_equal(uri, @client.proxy)
+      #
+      @proxyio.string = ""
+      @client.proxy = nil
+      assert_equal(200, @client.head(serverurl).status)
+      assert(@proxyio.string.empty?)
+      #
+      @proxyio.string = ""
+      @client.proxy = proxyurl
+      assert_equal(200, @client.head(serverurl).status)
+      assert(!@proxyio.string.empty?)
+    end
+  end
+
+  def test_noproxy_for_localhost
+    @proxyio.string = ""
+    @client.proxy = proxyurl
+    assert_equal(200, @client.head(serverurl).status)
+    assert(@proxyio.string.empty?)
+  end
+
+  def test_no_proxy
+    setup_proxyserver
+    escape_noproxy do
+      # proxy is not set.
+      @client.no_proxy = 'localhost'
+      @proxyio.string = ""
+      @client.proxy = nil
+      assert_equal(200, @client.head(serverurl).status)
+      assert(/accept/ !~ @proxyio.string)
+      #
+      @proxyio.string = ""
+      @client.proxy = proxyurl
+      assert_equal(200, @client.head(serverurl).status)
+      assert(/accept/ !~ @proxyio.string)
+      #
+      @client.no_proxy = 'foobar'
+      @proxyio.string = ""
+      @client.proxy = proxyurl
+      assert_equal(200, @client.head(serverurl).status)
+      assert(/accept/ =~ @proxyio.string)
+      #
+      @client.no_proxy = 'foobar,localhost:baz'
+      @proxyio.string = ""
+      @client.proxy = proxyurl
+      assert_equal(200, @client.head(serverurl).status)
+      assert(/accept/ !~ @proxyio.string)
+      #
+      @client.no_proxy = 'foobar,localhost:443'
+      @proxyio.string = ""
+      @client.proxy = proxyurl
+      assert_equal(200, @client.head(serverurl).status)
+      assert(/accept/ =~ @proxyio.string)
+      #
+      @client.no_proxy = "foobar,localhost:443:localhost:#{serverport},baz"
+      @proxyio.string = ""
+      @client.proxy = proxyurl
+      assert_equal(200, @client.head(serverurl).status)
+      assert(/accept/ !~ @proxyio.string)
+    end
+  end
+
+  def test_get_content
+    assert_equal('hello', @client.get_content(serverurl + 'hello'))
+    assert_equal('hello', @client.get_content(serverurl + 'redirect1'))
+    assert_equal('hello', @client.get_content(serverurl + 'redirect2'))
+    assert_raises(HTTPClient::Session::BadResponse) do
+      @client.get_content(serverurl + 'notfound')
+    end
+    assert_raises(HTTPClient::Session::BadResponse) do
+      @client.get_content(serverurl + 'redirect_self')
+    end
+    called = false
+    @client.redirect_uri_callback = lambda { |uri, res|
+      newuri = res.header['location'][0]
+      called = true
+      newuri
+    }
+    assert_equal('hello', @client.get_content(serverurl + 'relative_redirect'))
+    assert(called)
+  end
+
+  def test_post_content
+    assert_equal('hello', @client.post_content(serverurl + 'hello'))
+    assert_equal('hello', @client.post_content(serverurl + 'redirect1'))
+    assert_equal('hello', @client.post_content(serverurl + 'redirect2'))
+    assert_raises(HTTPClient::Session::BadResponse) do
+      @client.post_content(serverurl + 'notfound')
+    end
+    assert_raises(HTTPClient::Session::BadResponse) do
+      @client.post_content(serverurl + 'redirect_self')
+    end
+    called = false
+    @client.redirect_uri_callback = lambda { |uri, res|
+      newuri = res.header['location'][0]
+      called = true
+      newuri
+    }
+    assert_equal('hello', @client.post_content(serverurl + 'relative_redirect'))
+    assert(called)
+  end
+
+  def test_head
+    assert_equal("head", @client.head(serverurl + 'servlet').header["x-head"][0])
+    res = @client.head(serverurl + 'servlet', {1=>2, 3=>4})
+    assert_equal('1=2&3=4', res.header["x-query"][0])
+  end
+
+  def test_get
+    assert_equal("get", @client.get(serverurl + 'servlet').content)
+    res = @client.get(serverurl + 'servlet', {1=>2, 3=>4})
+    assert_equal('1=2&3=4', res.header["x-query"][0])
+  end
+
+  def test_post
+    assert_equal("post", @client.post(serverurl + 'servlet').content)
+    res = @client.get(serverurl + 'servlet', {1=>2, 3=>4})
+    assert_equal('1=2&3=4', res.header["x-query"][0])
+  end
+
+  def test_put
+    assert_equal("put", @client.put(serverurl + 'servlet').content)
+    res = @client.get(serverurl + 'servlet', {1=>2, 3=>4})
+    assert_equal('1=2&3=4', res.header["x-query"][0])
+  end
+
+  def test_delete
+    assert_equal("delete", @client.delete(serverurl + 'servlet').content)
+    res = @client.get(serverurl + 'servlet', {1=>2, 3=>4})
+    assert_equal('1=2&3=4', res.header["x-query"][0])
+  end
+
+  def test_options
+    assert_equal("options", @client.options(serverurl + 'servlet').content)
+    res = @client.get(serverurl + 'servlet', {1=>2, 3=>4})
+    assert_equal('1=2&3=4', res.header["x-query"][0])
+  end
+
+  def test_trace
+    assert_equal("trace", @client.trace(serverurl + 'servlet').content)
+    res = @client.get(serverurl + 'servlet', {1=>2, 3=>4})
+    assert_equal('1=2&3=4', res.header["x-query"][0])
+  end
+
+  def test_get_query
+    assert_equal({'1'=>'2'}, check_query_get({1=>2}))
+    assert_equal({'a'=>'A', 'B'=>'b'}, check_query_get({"a"=>"A", "B"=>"b"}))
+    assert_equal({'&'=>'&'}, check_query_get({"&"=>"&"}))
+    assert_equal({'= '=>' =+'}, check_query_get({"= "=>" =+"}))
+    assert_equal(
+      ['=', '&'].sort,
+      check_query_get([["=", "="], ["=", "&"]])['='].to_ary.sort
+    )
+    assert_equal({'123'=>'45'}, check_query_get('123=45'))
+    assert_equal({'12 3'=>'45', ' '=>' '}, check_query_get('12+3=45&+=+'))
+    assert_equal({}, check_query_get(''))
+  end
+
+  def test_post_body
+    assert_equal({'1'=>'2'}, check_query_post({1=>2}))
+    assert_equal({'a'=>'A', 'B'=>'b'}, check_query_post({"a"=>"A", "B"=>"b"}))
+    assert_equal({'&'=>'&'}, check_query_post({"&"=>"&"}))
+    assert_equal({'= '=>' =+'}, check_query_post({"= "=>" =+"}))
+    assert_equal(
+      ['=', '&'].sort,
+      check_query_post([["=", "="], ["=", "&"]])['='].to_ary.sort
+    )
+    assert_equal({'123'=>'45'}, check_query_post('123=45'))
+    assert_equal({'12 3'=>'45', ' '=>' '}, check_query_post('12+3=45&+=+'))
+    assert_equal({}, check_query_post(''))
+    #
+    post_body = StringIO.new("foo=bar&foo=baz")
+    assert_equal(
+      ["bar", "baz"],
+      check_query_post(post_body)["foo"].to_ary.sort
+    )
+  end
+
+  def test_extra_headers
+    str = ""
+    @client.debug_dev = str
+    @client.head(serverurl, nil, {"ABC" => "DEF"})
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_match("ABC: DEF", lines[4])
+    #
+    str = ""
+    @client.debug_dev = str
+    @client.get(serverurl, nil, [["ABC", "DEF"], ["ABC", "DEF"]])
+    lines = str.split(/(?:\r?\n)+/)
+    assert_equal("= Request", lines[0])
+    assert_match("ABC: DEF", lines[4])
+    assert_match("ABC: DEF", lines[5])
+  end
+
+  def test_timeout
+    assert_equal(60, @client.connect_timeout)
+    assert_equal(120, @client.send_timeout)
+    assert_equal(60, @client.receive_timeout)
+  end
+
+  def test_connect_timeout
+    # ToDo
+  end
+
+  def test_send_timeout
+    # ToDo
+  end
+
+  def test_receive_timeout
+    # this test takes 2 sec
+    assert_equal('hello', @client.get_content(serverurl + 'sleep?sec=2'))
+    @client.receive_timeout = 1
+    assert_equal('hello', @client.get_content(serverurl + 'sleep?sec=0'))
+    assert_raise(HTTPClient::ReceiveTimeoutError) do
+      @client.get_content(serverurl + 'sleep?sec=2')
+    end
+    @client.receive_timeout = 3
+    assert_equal('hello', @client.get_content(serverurl + 'sleep?sec=2'))
+  end
+
+  def test_cookies
+    cookiefile = File.join(File.dirname(File.expand_path(__FILE__)),
+      'test_cookies_file')
+    # from [ruby-talk:164079]
+    File.open(cookiefile, "wb") do |f|
+      f << "http://rubyforge.org//account/login.php	session_ser	LjEwMy45Ni40Ni0q%2A-fa0537de8cc31	1131676286	.rubyforge.org	/	13\n"
+    end
+    cm = WebAgent::CookieManager::new(cookiefile)
+    cm.load_cookies
+    cookie = cm.cookies.first
+    url = cookie.url
+    assert(cookie.domain_match(url.host, cookie.domain))
+  end
+
+private
+
+  def check_query_get(query)
+    WEBrick::HTTPUtils.parse_query(
+      @client.get(serverurl + 'servlet', query).header["x-query"][0]
+    )
+  end
+
+  def check_query_post(query)
+    WEBrick::HTTPUtils.parse_query(
+      @client.post(serverurl + 'servlet', query).header["x-query"][0]
+    )
+  end
+
+  def setup_server
+    @server = WEBrick::HTTPServer.new(
+      :BindAddress => "localhost",
+      :Logger => @logger,
+      :Port => 0,
+      :AccessLog => [],
+      :DocumentRoot => File.dirname(File.expand_path(__FILE__))
+    )
+    @serverport = @server.config[:Port]
+    [:hello, :sleep, :redirect1, :redirect2, :redirect3, :redirect_self, :relative_redirect].each do |sym|
+      @server.mount(
+	"/#{sym}",
+	WEBrick::HTTPServlet::ProcHandler.new(method("do_#{sym}").to_proc)
+      )
+    end
+    @server.mount('/servlet', TestServlet.new(@server))
+    @server_thread = start_server_thread(@server)
+  end
+
+  def escape_noproxy
+    backup = HTTPAccess2::Client::NO_PROXY_HOSTS.dup
+    HTTPAccess2::Client::NO_PROXY_HOSTS.clear
+    yield
+  ensure
+    HTTPAccess2::Client::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_redirect1(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::MovedPermanently, serverurl + "hello") 
+  end
+
+  def do_redirect2(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::TemporaryRedirect, serverurl + "redirect3")
+  end
+
+  def do_redirect3(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::Found, serverurl + "hello") 
+  end
+
+  def do_redirect_self(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::Found, serverurl + "redirect_self") 
+  end
+
+  def do_relative_redirect(req, res)
+    res.set_redirect(WEBrick::HTTPStatus::Found, "hello") 
+  end
+
+  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.body = 'post'
+      res["x-query"] = body_response(req)
+    end
+
+    def do_PUT(req, res)
+      res.body = '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_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.collect do |k, v|
+	v.to_ary.each do |ve|
+	  escaped << CGI.escape(k) + '=' + CGI.escape(ve)
+	end
+      end
+      escaped.join('&')
+    end
+  end
+end
+
+
+end