webrick 1.3.1 → 1.5.0

data/test/webrick/test_httpauth.rb

@@ -1,167 +0,0 @@
-require "test/unit"
-require "net/http"
-require "tempfile"
-require "webrick"
-require "webrick/httpauth/basicauth"
-require_relative "utils"
-
-class TestWEBrickHTTPAuth < Test::Unit::TestCase
-  def test_basic_auth
-    TestWEBrick.start_httpserver{|server, addr, port, log|
-      realm = "WEBrick's realm"
-      path = "/basic_auth"
-
-      server.mount_proc(path){|req, res|
-        WEBrick::HTTPAuth.basic_auth(req, res, realm){|user, pass|
-          user == "webrick" && pass == "supersecretpassword"
-        }
-        res.body = "hoge"
-      }
-      http = Net::HTTP.new(addr, port)
-      g = Net::HTTP::Get.new(path)
-      g.basic_auth("webrick", "supersecretpassword")
-      http.request(g){|res| assert_equal("hoge", res.body, log.call)}
-      g.basic_auth("webrick", "not super")
-      http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
-    }
-  end
-
-  def test_basic_auth2
-    TestWEBrick.start_httpserver{|server, addr, port, log|
-      realm = "WEBrick's realm"
-      path = "/basic_auth2"
-
-      tmpfile = Tempfile.new("test_webrick_auth")
-      tmpfile.close
-      tmp_pass = WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
-      tmp_pass.set_passwd(realm, "webrick", "supersecretpassword")
-      tmp_pass.set_passwd(realm, "foo", "supersecretpassword")
-      tmp_pass.flush
-
-      htpasswd = WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
-      users = []
-      htpasswd.each{|user, pass| users << user }
-      assert_equal(2, users.size, log.call)
-      assert(users.member?("webrick"), log.call)
-      assert(users.member?("foo"), log.call)
-
-      server.mount_proc(path){|req, res|
-        auth = WEBrick::HTTPAuth::BasicAuth.new(
-          :Realm => realm, :UserDB => htpasswd,
-          :Logger => server.logger
-        )
-        auth.authenticate(req, res)
-        res.body = "hoge"
-      }
-      http = Net::HTTP.new(addr, port)
-      g = Net::HTTP::Get.new(path)
-      g.basic_auth("webrick", "supersecretpassword")
-      http.request(g){|res| assert_equal("hoge", res.body, log.call)}
-      g.basic_auth("webrick", "not super")
-      http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
-    }
-  end
-
-  def test_basic_auth3
-    tmpfile = Tempfile.new("test_webrick_auth")
-    tmpfile.puts("webrick:{SHA}GJYFRpBbdchp595jlh3Bhfmgp8k=")
-    tmpfile.flush
-    assert_raise(NotImplementedError){
-      WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
-    }
-    tmpfile.close(true)
-
-    tmpfile = Tempfile.new("test_webrick_auth")
-    tmpfile.puts("webrick:$apr1$IOVMD/..$rmnOSPXr0.wwrLPZHBQZy0")
-    tmpfile.flush
-    assert_raise(NotImplementedError){
-      WEBrick::HTTPAuth::Htpasswd.new(tmpfile.path)
-    }
-    tmpfile.close(true)
-  end
-
-  DIGESTRES_ = /
-    ([a-zA-z\-]+)
-      [\s\t]*(?:\r\n[\s\t]*)*
-      =
-      [\s\t]*(?:\r\n[\s\t]*)*
-      (?:
-       "((?:[^"]+|\\[\x00-\x7F])*)" |
-       ([!\#$%&'*+\-.0-9A-Z^_`a-z|~]+)
-      )/x
-
-  def test_digest_auth
-    TestWEBrick.start_httpserver{|server, addr, port, log|
-      realm = "WEBrick's realm"
-      path = "/digest_auth"
-
-      tmpfile = Tempfile.new("test_webrick_auth")
-      tmpfile.close
-      tmp_pass = WEBrick::HTTPAuth::Htdigest.new(tmpfile.path)
-      tmp_pass.set_passwd(realm, "webrick", "supersecretpassword")
-      tmp_pass.set_passwd(realm, "foo", "supersecretpassword")
-      tmp_pass.flush
-
-      htdigest = WEBrick::HTTPAuth::Htdigest.new(tmpfile.path)
-      users = []
-      htdigest.each{|user, pass| users << user }
-      assert_equal(2, users.size, log.call)
-      assert(users.member?("webrick"), log.call)
-      assert(users.member?("foo"), log.call)
-
-      auth = WEBrick::HTTPAuth::DigestAuth.new(
-        :Realm => realm, :UserDB => htdigest,
-        :Algorithm => 'MD5',
-        :Logger => server.logger
-      )
-      server.mount_proc(path){|req, res|
-        auth.authenticate(req, res)
-        res.body = "hoge"
-      }
-
-      Net::HTTP.start(addr, port) do |http|
-        g = Net::HTTP::Get.new(path)
-        params = {}
-        http.request(g) do |res|
-          assert_equal('401', res.code, log.call)
-          res["www-authenticate"].scan(DIGESTRES_) do |key, quoted, token|
-            params[key.downcase] = token || quoted.delete('\\')
-          end
-           params['uri'] = "http://#{addr}:#{port}#{path}"
-        end
-
-        g['Authorization'] = credentials_for_request('webrick', "supersecretpassword", params)
-        http.request(g){|res| assert_equal("hoge", res.body, log.call)}
-
-        params['algorithm'].downcase! #4936
-        g['Authorization'] = credentials_for_request('webrick', "supersecretpassword", params)
-        http.request(g){|res| assert_equal("hoge", res.body, log.call)}
-
-        g['Authorization'] = credentials_for_request('webrick', "not super", params)
-        http.request(g){|res| assert_not_equal("hoge", res.body, log.call)}
-      end
-    }
-  end
-
-  private
-  def credentials_for_request(user, password, params)
-    cnonce = "hoge"
-    nonce_count = 1
-    ha1 = "#{user}:#{params['realm']}:#{password}"
-    ha2 = "GET:#{params['uri']}"
-    request_digest =
-      "#{Digest::MD5.hexdigest(ha1)}:" \
-      "#{params['nonce']}:#{'%08x' % nonce_count}:#{cnonce}:#{params['qop']}:" \
-      "#{Digest::MD5.hexdigest(ha2)}"
-    "Digest username=\"#{user}\"" \
-      ", realm=\"#{params['realm']}\"" \
-      ", nonce=\"#{params['nonce']}\"" \
-      ", uri=\"#{params['uri']}\"" \
-      ", qop=#{params['qop']}" \
-      ", nc=#{'%08x' % nonce_count}" \
-      ", cnonce=\"#{cnonce}\"" \
-      ", response=\"#{Digest::MD5.hexdigest(request_digest)}\"" \
-      ", opaque=\"#{params['opaque']}\"" \
-      ", algorithm=#{params['algorithm']}"
-  end
-end

data/test/webrick/test_httpproxy.rb

@@ -1,282 +0,0 @@
-require "test/unit"
-require "net/http"
-require "webrick"
-require "webrick/httpproxy"
-begin
-  require "webrick/ssl"
-  require "net/https"
-  require File.expand_path("../openssl/utils.rb", File.dirname(__FILE__))
-rescue LoadError
-  # test_connect will be skipped
-end
-require File.expand_path("utils.rb", File.dirname(__FILE__))
-
-class TestWEBrickHTTPProxy < Test::Unit::TestCase
-  def test_fake_proxy
-    assert_nil(WEBrick::FakeProxyURI.scheme)
-    assert_nil(WEBrick::FakeProxyURI.host)
-    assert_nil(WEBrick::FakeProxyURI.port)
-    assert_nil(WEBrick::FakeProxyURI.path)
-    assert_nil(WEBrick::FakeProxyURI.userinfo)
-    assert_raise(NoMethodError){ WEBrick::FakeProxyURI.foo }
-  end
-
-  def test_proxy
-    # Testing GET or POST to the proxy server
-    # Note that the proxy server works as the origin server.
-    #                    +------+
-    #                    V      |
-    #  client -------> proxy ---+
-    #        GET / POST     GET / POST
-    #
-    proxy_handler_called = request_handler_called = 0
-    config = {
-      :ServerName => "localhost.localdomain",
-      :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1 },
-      :RequestCallback => Proc.new{|req, res| request_handler_called += 1 }
-    }
-    TestWEBrick.start_httpproxy(config){|server, addr, port, log|
-      server.mount_proc("/"){|req, res|
-        res.body = "#{req.request_method} #{req.path} #{req.body}"
-      }
-      http = Net::HTTP.new(addr, port, addr, port)
-
-      req = Net::HTTP::Get.new("/")
-      http.request(req){|res|
-        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
-        assert_equal("GET / ", res.body, log.call)
-      }
-      assert_equal(1, proxy_handler_called, log.call)
-      assert_equal(2, request_handler_called, log.call)
-
-      req = Net::HTTP::Head.new("/")
-      http.request(req){|res|
-        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
-        assert_nil(res.body, log.call)
-      }
-      assert_equal(2, proxy_handler_called, log.call)
-      assert_equal(4, request_handler_called, log.call)
-
-      req = Net::HTTP::Post.new("/")
-      req.body = "post-data"
-      http.request(req){|res|
-        assert_equal("1.1 localhost.localdomain:#{port}", res["via"], log.call)
-        assert_equal("POST / post-data", res.body, log.call)
-      }
-      assert_equal(3, proxy_handler_called, log.call)
-      assert_equal(6, request_handler_called, log.call)
-    }
-  end
-
-  def test_no_proxy
-    # Testing GET or POST to the proxy server without proxy request.
-    #
-    #  client -------> proxy
-    #        GET / POST
-    #
-    proxy_handler_called = request_handler_called = 0
-    config = {
-      :ServerName => "localhost.localdomain",
-      :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1 },
-      :RequestCallback => Proc.new{|req, res| request_handler_called += 1 }
-    }
-    TestWEBrick.start_httpproxy(config){|server, addr, port, log|
-      server.mount_proc("/"){|req, res|
-        res.body = "#{req.request_method} #{req.path} #{req.body}"
-      }
-      http = Net::HTTP.new(addr, port)
-
-      req = Net::HTTP::Get.new("/")
-      http.request(req){|res|
-        assert_nil(res["via"], log.call)
-        assert_equal("GET / ", res.body, log.call)
-      }
-      assert_equal(0, proxy_handler_called, log.call)
-      assert_equal(1, request_handler_called, log.call)
-
-      req = Net::HTTP::Head.new("/")
-      http.request(req){|res|
-        assert_nil(res["via"], log.call)
-        assert_nil(res.body, log.call)
-      }
-      assert_equal(0, proxy_handler_called, log.call)
-      assert_equal(2, request_handler_called, log.call)
-
-      req = Net::HTTP::Post.new("/")
-      req.body = "post-data"
-      http.request(req){|res|
-        assert_nil(res["via"], log.call)
-        assert_equal("POST / post-data", res.body, log.call)
-      }
-      assert_equal(0, proxy_handler_called, log.call)
-      assert_equal(3, request_handler_called, log.call)
-    }
-  end
-
-  def make_certificate(key, cn)
-    subject = OpenSSL::X509::Name.parse("/DC=org/DC=ruby-lang/CN=#{cn}")
-    exts = [
-      ["keyUsage", "keyEncipherment,digitalSignature", true],
-    ]
-    cert = OpenSSL::TestUtils.issue_cert(
-      subject, key, 1, Time.now, Time.now + 3600, exts,
-      nil, nil, OpenSSL::Digest::SHA1.new
-    )
-    return cert
-  end
-
-  def test_connect
-    # Testing CONNECT to proxy server
-    #
-    #  client -----------> proxy -----------> https
-    #    1.     CONNECT          establish TCP
-    #    2.   ---- establish SSL session --->
-    #    3.   ------- GET or POST ---------->
-    #
-    key = OpenSSL::TestUtils::TEST_KEY_RSA1024
-    cert = make_certificate(key, "127.0.0.1")
-    s_config = {
-      :SSLEnable =>true,
-      :ServerName => "localhost",
-      :SSLCertificate => cert,
-      :SSLPrivateKey => key,
-    }
-    config = {
-      :ServerName => "localhost.localdomain",
-      :RequestCallback => Proc.new{|req, res|
-        assert_equal("CONNECT", req.request_method)
-      },
-    }
-    TestWEBrick.start_httpserver(s_config){|s_server, s_addr, s_port, s_log|
-      s_server.mount_proc("/"){|req, res|
-        res.body = "SSL #{req.request_method} #{req.path} #{req.body}"
-      }
-      TestWEBrick.start_httpproxy(config){|server, addr, port, log|
-        http = Net::HTTP.new("127.0.0.1", s_port, addr, port)
-        http.use_ssl = true
-        http.verify_callback = Proc.new do |preverify_ok, store_ctx|
-          store_ctx.current_cert.to_der == cert.to_der
-        end
-
-        req = Net::HTTP::Get.new("/")
-        http.request(req){|res|
-          assert_equal("SSL GET / ", res.body, s_log.call + log.call)
-        }
-
-        req = Net::HTTP::Post.new("/")
-        req.body = "post-data"
-        http.request(req){|res|
-          assert_equal("SSL POST / post-data", res.body, s_log.call + log.call)
-        }
-      }
-    }
-  end if defined?(OpenSSL)
-
-  def test_upstream_proxy
-    # Testing GET or POST through the upstream proxy server
-    # Note that the upstream proxy server works as the origin server.
-    #                                   +------+
-    #                                   V      |
-    #  client -------> proxy -------> proxy ---+
-    #        GET / POST     GET / POST     GET / POST
-    #
-    up_proxy_handler_called = up_request_handler_called = 0
-    proxy_handler_called = request_handler_called = 0
-    up_config = {
-      :ServerName => "localhost.localdomain",
-      :ProxyContentHandler => Proc.new{|req, res| up_proxy_handler_called += 1},
-      :RequestCallback => Proc.new{|req, res| up_request_handler_called += 1}
-    }
-    TestWEBrick.start_httpproxy(up_config){|up_server, up_addr, up_port, up_log|
-      up_server.mount_proc("/"){|req, res|
-        res.body = "#{req.request_method} #{req.path} #{req.body}"
-      }
-      config = {
-        :ServerName => "localhost.localdomain",
-        :ProxyURI => URI.parse("http://localhost:#{up_port}"),
-        :ProxyContentHandler => Proc.new{|req, res| proxy_handler_called += 1},
-        :RequestCallback => Proc.new{|req, res| request_handler_called += 1},
-      }
-      TestWEBrick.start_httpproxy(config){|server, addr, port, log|
-        http = Net::HTTP.new(up_addr, up_port, addr, port)
-
-        req = Net::HTTP::Get.new("/")
-        http.request(req){|res|
-          skip res.message unless res.code == '200'
-          via = res["via"].split(/,\s+/)
-          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
-          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
-          assert_equal("GET / ", res.body)
-        }
-        assert_equal(1, up_proxy_handler_called, up_log.call + log.call)
-        assert_equal(2, up_request_handler_called, up_log.call + log.call)
-        assert_equal(1, proxy_handler_called, up_log.call + log.call)
-        assert_equal(1, request_handler_called, up_log.call + log.call)
-
-        req = Net::HTTP::Head.new("/")
-        http.request(req){|res|
-          via = res["via"].split(/,\s+/)
-          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
-          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
-          assert_nil(res.body, up_log.call + log.call)
-        }
-        assert_equal(2, up_proxy_handler_called, up_log.call + log.call)
-        assert_equal(4, up_request_handler_called, up_log.call + log.call)
-        assert_equal(2, proxy_handler_called, up_log.call + log.call)
-        assert_equal(2, request_handler_called, up_log.call + log.call)
-
-        req = Net::HTTP::Post.new("/")
-        req.body = "post-data"
-        http.request(req){|res|
-          via = res["via"].split(/,\s+/)
-          assert(via.include?("1.1 localhost.localdomain:#{up_port}"), up_log.call + log.call)
-          assert(via.include?("1.1 localhost.localdomain:#{port}"), up_log.call + log.call)
-          assert_equal("POST / post-data", res.body, up_log.call + log.call)
-        }
-        assert_equal(3, up_proxy_handler_called, up_log.call + log.call)
-        assert_equal(6, up_request_handler_called, up_log.call + log.call)
-        assert_equal(3, proxy_handler_called, up_log.call + log.call)
-        assert_equal(3, request_handler_called, up_log.call + log.call)
-
-        if defined?(OpenSSL)
-          # Testing CONNECT to the upstream proxy server
-          #
-          #  client -------> proxy -------> proxy -------> https
-          #    1.   CONNECT        CONNECT      establish TCP
-          #    2.   -------- establish SSL session ------>
-          #    3.   ---------- GET or POST -------------->
-          #
-          key = OpenSSL::TestUtils::TEST_KEY_RSA1024
-          cert = make_certificate(key, "127.0.0.1")
-          s_config = {
-            :SSLEnable =>true,
-            :ServerName => "localhost",
-            :SSLCertificate => cert,
-            :SSLPrivateKey => key,
-          }
-          TestWEBrick.start_httpserver(s_config){|s_server, s_addr, s_port, s_log|
-            s_server.mount_proc("/"){|req2, res|
-              res.body = "SSL #{req2.request_method} #{req2.path} #{req2.body}"
-            }
-            http = Net::HTTP.new("127.0.0.1", s_port, addr, port, up_log.call + log.call + s_log.call)
-            http.use_ssl = true
-            http.verify_callback = Proc.new do |preverify_ok, store_ctx|
-              store_ctx.current_cert.to_der == cert.to_der
-            end
-
-            req2 = Net::HTTP::Get.new("/")
-            http.request(req2){|res|
-              assert_equal("SSL GET / ", res.body, up_log.call + log.call + s_log.call)
-            }
-
-            req2 = Net::HTTP::Post.new("/")
-            req2.body = "post-data"
-            http.request(req2){|res|
-              assert_equal("SSL POST / post-data", res.body, up_log.call + log.call + s_log.call)
-            }
-          }
-        end
-      }
-    }
-  end
-end