Mocking HTTPS-Antworten im Go

Meisten das Verhalten in net/http werden kann, verspottet, erweitert oder verändert werden. Obwohl http.Client einen konkreten Typ implementiert, dass HTTP-client, der Semantik, werden alle Felder exportiert werden und können angepasst werden.

Den Client.Transport Bereich, insbesondere können ersetzt werden, um den Kunden etwas tun mit benutzerdefinierten Protokollen (wie ftp://oder file://), um eine direkte Verbindung zu lokalen Handler (ohne die Generierung der HTTP-Protokoll-bytes oder senden alles über das Netzwerk).

Die client-Funktionen, wie http.Get, alle nutzen die exportierte http.DefaultClient Paket-variable (die Sie ändern können), also code, der nutzt diese Komfort-Funktionen hat nicht, zum Beispiel, müssen geändert werden, um Methoden aufzurufen, die auf einem benutzerdefinierten Client-Variablen. Beachten Sie, dass es unangemessen wäre, zu modifizieren Globale Verhalten in eine öffentlich zugängliche Bibliothek, ist es sehr nützlich, dies zu tun in Anwendungen und tests (einschließlich Bibliothek tests).

http://play.golang.org/p/afljO086iB enthält eine benutzerdefinierte http.RoundTripper schreibt, dass die request-URL, so dass Sie werden weitergeleitet zu einem lokal gehosteten httptest.Server, und ein weiteres Beispiel, das direkt übergibt die Anforderung an eine http.Handler zusammen mit einer benutzerdefinierten http.ResponseWriter umgesetzt werden, um zu erstellen ein http.Response. Der zweite Ansatz ist nicht so fleißig wie der erste (nicht füllen Sie so viele Felder in den Resonanz-Wert) ist aber effizienter, und sollte kompatibel genug, um die Arbeit mit den meisten Handler und client-Anrufer.

Den oben verlinkten code ist unten enthalten sowie:

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
}