Question

我试图为向Web服务发出请求的包编写测试。我可能因为缺乏对TLS的理解而遇到问题。

目前我的测试看起来像这样：

func TestSimple() {
    server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(200)
        fmt.Fprintf(w, `{ "fake" : "json data here" }`)
    }))
    transport := &http.Transport{
        Proxy: func(req *http.Request) (*url.URL, error) {
            return url.Parse(server.URL)
        },
    }
    // Client is the type in my package that makes requests
    client := Client{
        c: http.Client{Transport: transport},
    }

    client.DoRequest() // ...
}

我的包有一个包变量（我希望它是一个常量..），用于要查询的Web服务的基地址。这是一个https URL。我上面创建的测试服务器是纯HTTP，没有TLS。

默认情况下，我的测试失败并显示错误＆＃34; tls：第一条记录看起来不像是TLS握手。＆＃34;

为了使其工作，我的测试在进行查询之前将包变量更改为普通的http URL而不是https。

这有什么办法吗？我可以将包变量设为常量（https），并设置http.Transport＆＃34;降级＆＃34;到未加密的HTTP，或使用httptest.NewTLSServer()代替？

（当我尝试使用NewTLSServer()时，我从127.0.0.1:45678得到＆＃34; http：TLS握手错误：tls：收到超长记录，长度为20037＆＃34;）

Answer 1

net/http中的大多数行为都可以被模拟，扩展或更改。虽然http.Client是实现HTTP客户端语义的具体类型，但它的所有字段都是导出的，可以自定义。

特别是Client.Transport字段可以被替换，以使客户端做任何事情，从使用自定义协议（例如ftp：//或file：//）到直接连接到本地处理程序（不生成HTTP）协议字节或通过网络发送任何东西。）

客户端函数（例如http.Get）都使用导出的http.DefaultClient包变量（您可以修改），因此使用这些便捷函数的代码 not ，例如，必须更改为在自定义Client变量上调用方法。请注意，尽管在公共库中修改全局行为是不合理的，但在应用程序和测试（包括库测试）中这样做非常有用。

http://play.golang.org/p/afljO086iB包含一个自定义http.RoundTripper，它会重写请求网址，以便将其路由到本地托管的httptest.Server，另一个示例将请求直接传递给http.Handler以及自定义http.ResponseWriter实施，以便创建http.Response。第二种方法不像第一种方法那样勤奋（它不会在响应值中填写多个字段）但效率更高，并且应该足够兼容以与大多数处理程序和客户端调用程序一起使用。 / p>

上面链接的代码也包含在下面：

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "net/http/httptest"
    "net/url"
    "os"
    "path"
    "strings"
)

func Handler(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "hello %s\n", path.Base(r.URL.Path))
}

func main() {
    s := httptest.NewServer(http.HandlerFunc(Handler))
    u, err := url.Parse(s.URL)
    if err != nil {
        log.Fatalln("failed to parse httptest.Server URL:", err)
    }
    http.DefaultClient.Transport = RewriteTransport{URL: u}
    resp, err := http.Get("https://google.com/path-one")
    if err != nil {
        log.Fatalln("failed to send first request:", err)
    }
    fmt.Println("[First Response]")
    resp.Write(os.Stdout)

    fmt.Print("\n", strings.Repeat("-", 80), "\n\n")

    http.DefaultClient.Transport = HandlerTransport{http.HandlerFunc(Handler)}
    resp, err = http.Get("https://google.com/path-two")
    if err != nil {
        log.Fatalln("failed to send second request:", err)
    }
    fmt.Println("[Second Response]")
    resp.Write(os.Stdout)
}

// RewriteTransport is an http.RoundTripper that rewrites requests
// using the provided URL's Scheme and Host, and its Path as a prefix.
// The Opaque field is untouched.
// If Transport is nil, http.DefaultTransport is used
type RewriteTransport struct {
    Transport http.RoundTripper
    URL       *url.URL
}

func (t RewriteTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    // note that url.URL.ResolveReference doesn't work here
    // since t.u is an absolute url
    req.URL.Scheme = t.URL.Scheme
    req.URL.Host = t.URL.Host
    req.URL.Path = path.Join(t.URL.Path, req.URL.Path)
    rt := t.Transport
    if rt == nil {
        rt = http.DefaultTransport
    }
    return rt.RoundTrip(req)
}

type HandlerTransport struct{ h http.Handler }

func (t HandlerTransport) RoundTrip(req *http.Request) (*http.Response, error) {
    r, w := io.Pipe()
    resp := &http.Response{
        Proto:      "HTTP/1.1",
        ProtoMajor: 1,
        ProtoMinor: 1,
        Header:     make(http.Header),
        Body:       r,
        Request:    req,
    }
    ready := make(chan struct{})
    prw := &pipeResponseWriter{r, w, resp, ready}
    go func() {
        defer w.Close()
        t.h.ServeHTTP(prw, req)
    }()
    <-ready
    return resp, nil
}

type pipeResponseWriter struct {
    r     *io.PipeReader
    w     *io.PipeWriter
    resp  *http.Response
    ready chan<- struct{}
}

func (w *pipeResponseWriter) Header() http.Header {
    return w.resp.Header
}

func (w *pipeResponseWriter) Write(p []byte) (int, error) {
    if w.ready != nil {
        w.WriteHeader(http.StatusOK)
    }
    return w.w.Write(p)
}

func (w *pipeResponseWriter) WriteHeader(status int) {
    if w.ready == nil {
        // already called
        return
    }
    w.resp.StatusCode = status
    w.resp.Status = fmt.Sprintf("%d %s", status, http.StatusText(status))
    close(w.ready)
    w.ready = nil
}

Answer 2

您收到错误http: TLS handshake error from 127.0.0.1:45678: tls: oversized record received with length 20037的原因是因为https需要域名（而不是IP地址）。域名是SSL证书分配给。

使用您自己的证书以TLS模式启动httptest服务器

cert, err := tls.LoadX509KeyPair("cert.pem", "key.pem")
if err != nil {
    log.Panic("bad server certs: ", err)
}
certs := []tls.Certificate{cert}

server = httptest.NewUnstartedServer(router)
server.TLS = &tls.Config{Certificates: certs}
server.StartTLS()
serverPort = ":" + strings.Split(server.URL, ":")[2] // it's always https://127.0.0.1:<port>
server.URL = "https://sub.domain.com" + serverPort

为连接提供有效的SSL证书的选项包括：

不提供证书和密钥
提供自签名证书和密钥
提供真实有效的证书和密钥

无证书

如果您不提供自己的证书，则默认加载example.com证书。

自签证书

要创建测试证书，可以使用$GOROOT/src/crypto/tls/generate_cert.go --host "*.domain.name"

您将收到x509: certificate signed by unknown authority警告，因为它已经过自签名，因此您需要让您的客户端跳过这些警告，方法是在http.Transport字段中添加以下内容：

 TLSClientConfig: &tls.Config{InsecureSkipVerify: true}

有效的真实证书

最后，如果您要使用真实证书，请将有效证书和密钥保存在可以加载的位置。

此处的关键是使用server.URL = https://sub.domain.com来提供您自己的域名。

在Go中模拟HTTPS响应

2 个答案:

无证书

自签证书

有效的真实证书