webrick 1.3.1 → 1.4.3

data/test/ruby/envutil.rb

@@ -1,208 +0,0 @@
-require "open3"
-require "timeout"
-
-module EnvUtil
-  def rubybin
-    unless ENV["RUBYOPT"]
-
-    end
-    if ruby = ENV["RUBY"]
-      return ruby
-    end
-    ruby = "ruby"
-    rubyexe = ruby+".exe"
-    3.times do
-      if File.exist? ruby and File.executable? ruby and !File.directory? ruby
-        return File.expand_path(ruby)
-      end
-      if File.exist? rubyexe and File.executable? rubyexe
-        return File.expand_path(rubyexe)
-      end
-      ruby = File.join("..", ruby)
-    end
-    if defined?(RbConfig.ruby)
-      RbConfig.ruby
-    else
-      "ruby"
-    end
-  end
-  module_function :rubybin
-
-  LANG_ENVS = %w"LANG LC_ALL LC_CTYPE"
-
-  def invoke_ruby(args, stdin_data="", capture_stdout=false, capture_stderr=false, opt={})
-    in_c, in_p = IO.pipe
-    out_p, out_c = IO.pipe if capture_stdout
-    err_p, err_c = IO.pipe if capture_stderr && capture_stderr != :merge_to_stdout
-    opt = opt.dup
-    opt[:in] = in_c
-    opt[:out] = out_c if capture_stdout
-    opt[:err] = capture_stderr == :merge_to_stdout ? out_c : err_c if capture_stderr
-    if enc = opt.delete(:encoding)
-      out_p.set_encoding(enc) if out_p
-      err_p.set_encoding(enc) if err_p
-    end
-    timeout = opt.delete(:timeout) || 10
-    c = "C"
-    child_env = {}
-    LANG_ENVS.each {|lc| child_env[lc] = c}
-    if Array === args and Hash === args.first
-      child_env.update(args.shift)
-    end
-    args = [args] if args.kind_of?(String)
-    pid = spawn(child_env, EnvUtil.rubybin, *args, opt)
-    in_c.close
-    out_c.close if capture_stdout
-    err_c.close if capture_stderr && capture_stderr != :merge_to_stdout
-    if block_given?
-      return yield in_p, out_p, err_p
-    else
-      th_stdout = Thread.new { out_p.read } if capture_stdout
-      th_stderr = Thread.new { err_p.read } if capture_stderr && capture_stderr != :merge_to_stdout
-      in_p.write stdin_data.to_str
-      in_p.close
-      if (!th_stdout || th_stdout.join(timeout)) && (!th_stderr || th_stderr.join(timeout))
-        stdout = th_stdout.value if capture_stdout
-        stderr = th_stderr.value if capture_stderr && capture_stderr != :merge_to_stdout
-      else
-        raise Timeout::Error
-      end
-      out_p.close if capture_stdout
-      err_p.close if capture_stderr && capture_stderr != :merge_to_stdout
-      Process.wait pid
-      status = $?
-      return stdout, stderr, status
-    end
-  ensure
-    [in_c, in_p, out_c, out_p, err_c, err_p].each do |io|
-      io.close if io && !io.closed?
-    end
-    [th_stdout, th_stderr].each do |th|
-      (th.kill; th.join) if th
-    end
-  end
-  module_function :invoke_ruby
-
-  alias rubyexec invoke_ruby
-  class << self
-    alias rubyexec invoke_ruby
-  end
-
-  def verbose_warning
-    class << (stderr = "")
-      alias write <<
-    end
-    stderr, $stderr, verbose, $VERBOSE = $stderr, stderr, $VERBOSE, true
-    yield stderr
-  ensure
-    stderr, $stderr, $VERBOSE = $stderr, stderr, verbose
-    return stderr
-  end
-  module_function :verbose_warning
-
-  def suppress_warning
-    verbose, $VERBOSE = $VERBOSE, nil
-    yield
-  ensure
-    $VERBOSE = verbose
-  end
-  module_function :suppress_warning
-
-  def under_gc_stress
-    stress, GC.stress = GC.stress, true
-    yield
-  ensure
-    GC.stress = stress
-  end
-  module_function :under_gc_stress
-end
-
-module Test
-  module Unit
-    module Assertions
-      public
-      def assert_normal_exit(testsrc, message = '', opt = {})
-        if opt.include?(:child_env)
-          opt = opt.dup
-          child_env = [opt.delete(:child_env)] || []
-        else
-          child_env = []
-        end
-        out, _, status = EnvUtil.invoke_ruby(child_env + %W'-W0', testsrc, true, :merge_to_stdout, opt)
-        pid = status.pid
-        faildesc = proc do
-          signo = status.termsig
-          signame = Signal.list.invert[signo]
-          sigdesc = "signal #{signo}"
-          if signame
-            sigdesc = "SIG#{signame} (#{sigdesc})"
-          end
-          if status.coredump?
-            sigdesc << " (core dumped)"
-          end
-          full_message = ''
-          if !message.empty?
-            full_message << message << "\n"
-          end
-          full_message << "pid #{pid} killed by #{sigdesc}"
-          if !out.empty?
-            out << "\n" if /\n\z/ !~ out
-            full_message << "\n#{out.gsub(/^/, '| ')}"
-          end
-          full_message
-        end
-        assert !status.signaled?, faildesc
-      end
-
-      def assert_in_out_err(args, test_stdin = "", test_stdout = [], test_stderr = [], message = nil, opt={})
-        stdout, stderr, status = EnvUtil.invoke_ruby(args, test_stdin, true, true, opt)
-        if block_given?
-          yield(stdout.lines.map {|l| l.chomp }, stderr.lines.map {|l| l.chomp })
-        else
-          if test_stdout.is_a?(Regexp)
-            assert_match(test_stdout, stdout, message)
-          else
-            assert_equal(test_stdout, stdout.lines.map {|l| l.chomp }, message)
-          end
-          if test_stderr.is_a?(Regexp)
-            assert_match(test_stderr, stderr, message)
-          else
-            assert_equal(test_stderr, stderr.lines.map {|l| l.chomp }, message)
-          end
-          status
-        end
-      end
-
-      def assert_ruby_status(args, test_stdin="", message=nil, opt={})
-        _, _, status = EnvUtil.invoke_ruby(args, test_stdin, false, false, opt)
-        m = message ? "#{message} (#{status.inspect})" : "ruby exit status is not success: #{status.inspect}"
-        assert(status.success?, m)
-      end
-
-      def assert_warn(msg)
-        stderr = EnvUtil.verbose_warning { yield }
-        assert(msg === stderr, "warning message #{stderr.inspect} is expected to match #{msg.inspect}")
-      end
-
-    end
-  end
-end
-
-begin
-  require 'rbconfig'
-rescue LoadError
-else
-  module RbConfig
-    @ruby = EnvUtil.rubybin
-    class << self
-      undef ruby if method_defined?(:ruby)
-      attr_reader :ruby
-    end
-    dir = File.dirname(ruby)
-    name = File.basename(ruby, CONFIG['EXEEXT'])
-    CONFIG['bindir'] = dir
-    CONFIG['ruby_install_name'] = name
-    CONFIG['RUBY_INSTALL_NAME'] = name
-    Gem::ConfigMap[:bindir] = dir if defined?(Gem::ConfigMap)
-  end
-end

data/test/webrick/test_cgi.rb

@@ -1,134 +0,0 @@
-require_relative "utils"
-require "webrick"
-require "test/unit"
-
-class TestWEBrickCGI < Test::Unit::TestCase
-  CRLF = "\r\n"
-
-  def start_cgi_server(&block)
-    config = {
-      :CGIInterpreter => TestWEBrick::RubyBin,
-      :DocumentRoot => File.dirname(__FILE__),
-      :DirectoryIndex => ["webrick.cgi"],
-      :RequestCallback => Proc.new{|req, res|
-        def req.meta_vars
-          meta = super
-          meta["RUBYLIB"] = $:.join(File::PATH_SEPARATOR)
-          meta[RbConfig::CONFIG['LIBPATHENV']] = ENV[RbConfig::CONFIG['LIBPATHENV']] if RbConfig::CONFIG['LIBPATHENV']
-          return meta
-        end
-      },
-    }
-    if RUBY_PLATFORM =~ /mswin32|mingw|cygwin|bccwin32/
-      config[:CGIPathEnv] = ENV['PATH'] # runtime dll may not be in system dir.
-    end
-    TestWEBrick.start_httpserver(config){|server, addr, port, log|
-      block.call(server, addr, port, log)
-    }
-  end
-
-  def test_cgi
-    start_cgi_server{|server, addr, port, log|
-      http = Net::HTTP.new(addr, port)
-      req = Net::HTTP::Get.new("/webrick.cgi")
-      http.request(req){|res| assert_equal("/webrick.cgi", res.body, log.call)}
-      req = Net::HTTP::Get.new("/webrick.cgi/path/info")
-      http.request(req){|res| assert_equal("/path/info", res.body, log.call)}
-      req = Net::HTTP::Get.new("/webrick.cgi/%3F%3F%3F?foo=bar")
-      http.request(req){|res| assert_equal("/???", res.body, log.call)}
-      req = Net::HTTP::Get.new("/webrick.cgi/%A4%DB%A4%B2/%A4%DB%A4%B2")
-      http.request(req){|res|
-        assert_equal("/\xA4\xDB\xA4\xB2/\xA4\xDB\xA4\xB2", res.body, log.call)}
-      req = Net::HTTP::Get.new("/webrick.cgi?a=1;a=2;b=x")
-      http.request(req){|res| assert_equal("a=1, a=2, b=x", res.body, log.call)}
-      req = Net::HTTP::Get.new("/webrick.cgi?a=1&a=2&b=x")
-      http.request(req){|res| assert_equal("a=1, a=2, b=x", res.body, log.call)}
-
-      req = Net::HTTP::Post.new("/webrick.cgi?a=x;a=y;b=1")
-      req["Content-Type"] = "application/x-www-form-urlencoded"
-      http.request(req, "a=1;a=2;b=x"){|res|
-        assert_equal("a=1, a=2, b=x", res.body, log.call)}
-      req = Net::HTTP::Post.new("/webrick.cgi?a=x&a=y&b=1")
-      req["Content-Type"] = "application/x-www-form-urlencoded"
-      http.request(req, "a=1&a=2&b=x"){|res|
-        assert_equal("a=1, a=2, b=x", res.body, log.call)}
-      req = Net::HTTP::Get.new("/")
-      http.request(req){|res|
-        ary = res.body.lines.to_a
-        assert_match(%r{/$}, ary[0], log.call)
-        assert_match(%r{/webrick.cgi$}, ary[1], log.call)
-      }
-
-      req = Net::HTTP::Get.new("/webrick.cgi")
-      req["Cookie"] = "CUSTOMER=WILE_E_COYOTE; PART_NUMBER=ROCKET_LAUNCHER_0001"
-      http.request(req){|res|
-        assert_equal(
-          "CUSTOMER=WILE_E_COYOTE\nPART_NUMBER=ROCKET_LAUNCHER_0001\n",
-          res.body, log.call)
-      }
-
-      req = Net::HTTP::Get.new("/webrick.cgi")
-      cookie =  %{$Version="1"; }
-      cookie << %{Customer="WILE_E_COYOTE"; $Path="/acme"; }
-      cookie << %{Part_Number="Rocket_Launcher_0001"; $Path="/acme"; }
-      cookie << %{Shipping="FedEx"; $Path="/acme"}
-      req["Cookie"] = cookie
-      http.request(req){|res|
-        assert_equal("Customer=WILE_E_COYOTE, Shipping=FedEx",
-                     res["Set-Cookie"], log.call)
-        assert_equal("Customer=WILE_E_COYOTE\n" +
-                     "Part_Number=Rocket_Launcher_0001\n" +
-                     "Shipping=FedEx\n", res.body, log.call)
-      }
-    }
-  end
-
-  def test_bad_request
-    start_cgi_server{|server, addr, port, log|
-      sock = TCPSocket.new(addr, port)
-      begin
-        sock << "POST /webrick.cgi HTTP/1.0" << CRLF
-        sock << "Content-Type: application/x-www-form-urlencoded" << CRLF
-        sock << "Content-Length: 1024" << CRLF
-        sock << CRLF
-        sock << "a=1&a=2&b=x"
-        sock.close_write
-        assert_match(%r{\AHTTP/\d.\d 400 Bad Request}, sock.read, log.call)
-      ensure
-        sock.close
-      end
-    }
-  end
-
-  CtrlSeq = [0x7f, *(1..31)].pack("C*").gsub(/\s+/, '')
-  CtrlPat = /#{Regexp.quote(CtrlSeq)}/o
-  DumpPat = /#{Regexp.quote(CtrlSeq.dump[1...-1])}/o
-
-  def test_bad_uri
-    start_cgi_server{|server, addr, port, log|
-      res = TCPSocket.open(addr, port) {|sock|
-        sock << "GET /#{CtrlSeq}#{CRLF}#{CRLF}"
-        sock.close_write
-        sock.read
-      }
-      assert_match(%r{\AHTTP/\d.\d 400 Bad Request}, res)
-      s = log.call.each_line.grep(/ERROR bad URI/)[0]
-      assert_match(DumpPat, s)
-      assert_not_match(CtrlPat, s)
-    }
-  end
-
-  def test_bad_header
-    start_cgi_server{|server, addr, port, log|
-      res = TCPSocket.open(addr, port) {|sock|
-        sock << "GET / HTTP/1.0#{CRLF}#{CtrlSeq}#{CRLF}#{CRLF}"
-        sock.close_write
-        sock.read
-      }
-      assert_match(%r{\AHTTP/\d.\d 400 Bad Request}, res)
-      s = log.call.each_line.grep(/ERROR bad header/)[0]
-      assert_match(DumpPat, s)
-      assert_not_match(CtrlPat, s)
-    }
-  end
-end

data/test/webrick/test_cookie.rb

@@ -1,131 +0,0 @@
-require "test/unit"
-require "webrick/cookie"
-
-class TestWEBrickCookie < Test::Unit::TestCase
-  def test_new
-    cookie = WEBrick::Cookie.new("foo","bar")
-    assert_equal("foo", cookie.name)
-    assert_equal("bar", cookie.value)
-    assert_equal("foo=bar", cookie.to_s)
-  end
-
-  def test_time
-    cookie = WEBrick::Cookie.new("foo","bar")
-    t = 1000000000
-    cookie.max_age = t
-    assert_match(t.to_s, cookie.to_s)
-
-    cookie = WEBrick::Cookie.new("foo","bar")
-    t = Time.at(1000000000)
-    cookie.expires = t
-    assert_equal(Time, cookie.expires.class)
-    assert_equal(t, cookie.expires)
-    ts = t.httpdate
-    cookie.expires = ts
-    assert_equal(Time, cookie.expires.class)
-    assert_equal(t, cookie.expires)
-    assert_match(ts, cookie.to_s)
-  end
-
-  def test_parse
-    data = ""
-    data << '$Version="1"; '
-    data << 'Customer="WILE_E_COYOTE"; $Path="/acme"; '
-    data << 'Part_Number="Rocket_Launcher_0001"; $Path="/acme"; '
-    data << 'Shipping="FedEx"; $Path="/acme"'
-    cookies = WEBrick::Cookie.parse(data)
-    assert_equal(3, cookies.size)
-    assert_equal(1, cookies[0].version)
-    assert_equal("Customer", cookies[0].name)
-    assert_equal("WILE_E_COYOTE", cookies[0].value)
-    assert_equal("/acme", cookies[0].path)
-    assert_equal(1, cookies[1].version)
-    assert_equal("Part_Number", cookies[1].name)
-    assert_equal("Rocket_Launcher_0001", cookies[1].value)
-    assert_equal(1, cookies[2].version)
-    assert_equal("Shipping", cookies[2].name)
-    assert_equal("FedEx", cookies[2].value)
-
-    data = "hoge=moge; __div__session=9865ecfd514be7f7"
-    cookies = WEBrick::Cookie.parse(data)
-    assert_equal(0, cookies[0].version)
-    assert_equal("hoge", cookies[0].name)
-    assert_equal("moge", cookies[0].value)
-    assert_equal("__div__session", cookies[1].name)
-    assert_equal("9865ecfd514be7f7", cookies[1].value)
-  end
-
-  def test_parse_no_whitespace
-    data = [
-      '$Version="1"; ',
-      'Customer="WILE_E_COYOTE";$Path="/acme";', # no SP between cookie-string
-      'Part_Number="Rocket_Launcher_0001";$Path="/acme";', # no SP between cookie-string
-      'Shipping="FedEx";$Path="/acme"'
-    ].join
-    cookies = WEBrick::Cookie.parse(data)
-    assert_equal(1, cookies.size)
-  end
-
-  def test_parse_too_much_whitespaces
-    # According to RFC6265,
-    #   cookie-string = cookie-pair *( ";" SP cookie-pair )
-    # So single 0x20 is needed after ';'. We allow multiple spaces here for
-    # compatibility with older WEBrick versions.
-    data = [
-      '$Version="1"; ',
-      'Customer="WILE_E_COYOTE";$Path="/acme";     ', # no SP between cookie-string
-      'Part_Number="Rocket_Launcher_0001";$Path="/acme";     ', # no SP between cookie-string
-      'Shipping="FedEx";$Path="/acme"'
-    ].join
-    cookies = WEBrick::Cookie.parse(data)
-    assert_equal(3, cookies.size)
-  end
-
-  def test_parse_set_cookie
-    data = %(Customer="WILE_E_COYOTE"; Version="1"; Path="/acme")
-    cookie = WEBrick::Cookie.parse_set_cookie(data)
-    assert_equal("Customer", cookie.name)
-    assert_equal("WILE_E_COYOTE", cookie.value)
-    assert_equal(1, cookie.version)
-    assert_equal("/acme", cookie.path)
-
-    data = %(Shipping="FedEx"; Version="1"; Path="/acme"; Secure)
-    cookie = WEBrick::Cookie.parse_set_cookie(data)
-    assert_equal("Shipping", cookie.name)
-    assert_equal("FedEx", cookie.value)
-    assert_equal(1, cookie.version)
-    assert_equal("/acme", cookie.path)
-    assert_equal(true, cookie.secure)
-  end
-
-  def test_parse_set_cookies
-    data = %(Shipping="FedEx"; Version="1"; Path="/acme"; Secure)
-    data << %(, CUSTOMER=WILE_E_COYOTE; path=/; expires=Wednesday, 09-Nov-99 23:12:40 GMT; path=/; Secure)
-    data << %(, name="Aaron"; Version="1"; path="/acme")
-    cookies = WEBrick::Cookie.parse_set_cookies(data)
-    assert_equal(3, cookies.length)
-
-    fed_ex = cookies.find { |c| c.name == 'Shipping' }
-    assert_not_nil(fed_ex)
-    assert_equal("Shipping", fed_ex.name)
-    assert_equal("FedEx", fed_ex.value)
-    assert_equal(1, fed_ex.version)
-    assert_equal("/acme", fed_ex.path)
-    assert_equal(true, fed_ex.secure)
-
-    name = cookies.find { |c| c.name == 'name' }
-    assert_not_nil(name)
-    assert_equal("name", name.name)
-    assert_equal("Aaron", name.value)
-    assert_equal(1, name.version)
-    assert_equal("/acme", name.path)
-
-    customer = cookies.find { |c| c.name == 'CUSTOMER' }
-    assert_not_nil(customer)
-    assert_equal("CUSTOMER", customer.name)
-    assert_equal("WILE_E_COYOTE", customer.value)
-    assert_equal(0, customer.version)
-    assert_equal("/", customer.path)
-    assert_equal(Time.utc(1999, 11, 9, 23, 12, 40), customer.expires)
-  end
-end