Unit-Tests für die Funktionen, die die Nutzung gorilla/mux: URL-Parameter

Problem ist, auch wenn Sie 0 als Wert zu setzen, Kontext, Werte, ist es nicht Wert, dass mux.Vars() liest. mux.Vars() ist mit varsKey (wie Sie bereits gesehen haben), die von Typ contextKey und nicht int.

Sicher, contextKey ist definiert als:

type contextKey int

was bedeutet, dass es int als zugrunde liegende Objekt, aber der Typ spielt das Teil beim Vergleich der Werte in gehen, so int(0) != contextKey(0).

Ich sehe nicht, wie man betrügen könnte, gorilla-mux oder Kontext in der Rückkehr Ihre Werte.

Dass gesagt wird, die paar Möglichkeiten, um dies zu testen in den Sinn kommt (beachten Sie, dass der nachfolgende code ist ungetestet, ich habe es direkt eingegeben hier, so könnte es einige dumme Fehler):

1. Als jemand vorschlug, einen server und senden von HTTP-Anforderungen zu.

2. Anstatt server, nur mit gorilla-mux-Router in Ihren tests. In diesem Szenario, Sie hätten einen router, den Sie passieren, um ListenAndServe, aber das könnte man auch benutzen, mit demselben router-Instanz in tests und call ServeHTTP auf Sie. Router würde aufpassen Einstellung, Kontext, Werte, und Sie wäre in Ihrem Handler.

   func Router() *mux.Router {
       r := mux.Router()
       r.HandleFunc("/employees/{1}", GetRequest)
       (...)
       return r 
   }

   irgendwo in der main-Funktion, die Sie tun würde, so etwas wie dieses:

   http.Handle("/", Router())

   und in den tests, die Sie tun können:

   func TestGetRequest(t *testing.T) {
       r := http.NewRequest("GET", "employees/1", nil)
       w := httptest.NewRecorder()
   
       Router().ServeHTTP(w, r)
       //assertions
   }

3. Wickeln Sie den Handler so, dass Sie akzeptieren URL-Parameter als drittes argument und wrapper aufrufen soll mux.Vars() - und übergeben, URL Parameter handler.

   Mit dieser Lösung, Ihre Handler hätte, Signatur:

   type VarsHandler func (w http.ResponseWriter, r *http.Request, vars map[string]string)

   und Sie würden anpassen müssen, um Anrufe zu entsprechen http.Handler Schnittstelle:

   func (vh VarsHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
       vars := mux.Vars(r)
       vh(w, r, vars)
   }

   - Handler zu registrieren, die Sie verwenden würden:

   func GetRequest(w http.ResponseWriter, r *http.Request, vars map[string]string) {
       //process request using vars
   }
   
   mainRouter := mux.NewRouter().StrictSlash(true)
   mainRouter.HandleFunc("/test/{mystring}", VarsHandler(GetRequest)).Name("/test/{mystring}").Methods("GET")

Welche Sie verwenden, ist Geschmackssache. Ich persönlich würde wahrscheinlich gehen mit option 2 oder 3, mit leichter Präferenz in Richtung 3.

In golang, ich habe etwas anderen Ansatz zu testen.

Ich leicht umschreiben Ihre lib-code:

package main

import (
        "fmt"
        "net/http"

        "github.com/gorilla/mux"
)

func main() {
        startServer()
}

func startServer() {
        mainRouter := mux.NewRouter().StrictSlash(true)
        mainRouter.HandleFunc("/test/{mystring}", GetRequest).Name("/test/{mystring}").Methods("GET")
        http.Handle("/", mainRouter)

        err := http.ListenAndServe(":8080", mainRouter)
        if err != nil {
                fmt.Println("Something is wrong : " + err.Error())
        }
}

func GetRequest(w http.ResponseWriter, r *http.Request) {
        vars := mux.Vars(r)
        myString := vars["mystring"]

        w.WriteHeader(http.StatusOK)
        w.Header().Set("Content-Type", "text/plain")
        w.Write([]byte(myString))
}

Und hier ist der test für ihn:

package main

import (
        "io/ioutil"
        "net/http"
        "testing"
        "time"

        "github.com/stretchr/testify/assert"
)

func TestGetRequest(t *testing.T) {
        go startServer()
        client := &http.Client{
                Timeout: 1 * time.Second,
        }

        r, _ := http.NewRequest("GET", "http://localhost:8080/test/abcd", nil)

        resp, err := client.Do(r)
        if err != nil {
                panic(err)
        }
        assert.Equal(t, http.StatusOK, resp.StatusCode)
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
                panic(err)
        }
        assert.Equal(t, []byte("abcd"), body)
}

Ich denke, dies ist ein besserer Ansatz - Sie sind wirklich das testen, was Sie schrieb, da es sehr einfach zu starten/stoppen Zuhörer in der go!

Das Problem ist Sie können nicht von vars.

var r *http.Request
var key, value string

//runtime panic, map not initialized
mux.Vars(r)[key] = value

Die Lösung ist die Schaffung eines neuen Routers für jeden test.

//api/route.go

package api

import (
    "net/http"
    "github.com/gorilla/mux"
)

type Route struct {
    http.Handler
    Method string
    Path string
}

func (route *Route) Test(w http.ResponseWriter, r *http.Request) {
    m := mux.NewRouter()
    m.Handle(route.Path, route).Methods(route.Method)
    m.ServeHTTP(w, r)
}

In Ihrer handler-Datei.

//api/employees/show.go

package employees

import (
    "github.com/gorilla/mux"
)

func Show(db *sql.DB) *api.Route {
    h := func(w http.ResponseWriter, r http.Request) {
        username := mux.Vars(r)["username"]
        //.. etc ..
    }
    return &api.Route{
        Method: "GET",
        Path: "/employees/{username}",

        //Maybe apply middleware too, who knows.
        Handler: http.HandlerFunc(h),
    }
}

In Ihren tests.

//api/employees/show_test.go

package employees

import (
    "testing"
)

func TestShow(t *testing.T) {
    w := httptest.NewRecorder()
    r, err := http.NewRequest("GET", "/employees/ajcodez", nil)
    Show(db).Test(w, r)
}

Können Sie *api.Route wo ein http.Handler benötigt wird.