Golang HTTP Handler测试

// handlers.go package handlers   // e.g. http.HandleFunc("/health-check", HealthCheckHandler) funcHealthCheckHandler(w http.ResponseWriter, r *http.Request) {     // A very simple health check.     w.WriteHeader(http.StatusOK)     w.Header().Set("Content-Type", "application/json")       // In the future we could report back on the status of our DB, or our cache     // (e.g. Redis) by performing a simple PING, and include them in the response.     io.WriteString(w, `{"alive": true}`) } 

// handlers_test.go package handlers   import (     "net/http"     "testing" )   funcTestHealthCheckHandler(t *testing.T) {     // Create a request to pass to our handler. We don't have any query parameters for now, so we'll     // pass 'nil' as the third parameter.     req, err := http.NewRequest("GET", "/health-check", nil)     if err != nil {         t.Fatal(err)     }       // We create a ResponseRecorder (which satisfies http.ResponseWriter) to record the response.     rr := httptest.NewRecorder()     handler := http.HandlerFunc(HealthCheckHandler)       // Our handlers satisfy http.Handler, so we can call their ServeHTTP method     // directly and pass in our Request and ResponseRecorder.     handler.ServeHTTP(rr, req)       // Check the status code is what we expect.     if status := rr.Code; status != http.StatusOK {         t.Errorf("handler returned wrong status code: got %v want %v",             status, http.StatusOK)     }       // Check the response body is what we expect.     expected := `{"alive": true}`     if rr.Body.String() != expected {         t.Errorf("handler returned unexpected body: got %v want %v",             rr.Body.String(), expected)     } } 

 // e.g. GET /api/projects?page=1&per_page=100     req, err := http.NewRequest("GET", "/api/projects",         // Note: url.Values is a map[string][]string         url.Values{"page": {"1"}, "per_page": {"100"}})     if err != nil {         t.Fatal(err)     }       // Our handler might also expect an API key.     req.Header.Set("Authorization", "Bearer abc123")       // Then: call handler.ServeHTTP(rr, req) like in our first example. 

 // Declare it outside the anonymous function     var tokenstring     testhttp.HandlerFunc(func(w http.ResponseWriter, r *http.Request){         // Note: Use the assignment operator '=' and not the initialize-and-assign         // ':=' operator so we don't shadow our token variable above.         token = GetToken(r)         // We'll also set a header on the response as a trivial example of         // inspecting headers.         w.Header().Set("Content-Type", "application/json")     })       // Check the status, body, etc.       if token != expectedToken {         t.Errorf("token does not match: got %v want %v", token, expectedToken)     }       if ctype := rr.Header().Get("Content-Type"); ctype != "application/json") {         t.Errorf("content type header does not match: got %v want %v",             ctype, "application/json")     }  

funcTestGetProjectsHandler(t *testing.T) {     req, err := http.NewRequest("GET", "/api/users", nil)     if err != nil {         t.Fatal(err)     }       rr := httptest.NewRecorder()     // e.g. func GetUsersHandler(ctx context.Context, w http.ResponseWriter, r *http.Request)     goji.HandlerFunc(GetUsersHandler)       // Create a new context.Context and populate it with data.     ctx = context.Background()     ctx = context.WithValue(ctx, "app.auth.token", "abc123")     ctx = context.WithValue(ctx, "app.user",         &YourUser{ID: "qejqjq", Email: "user@example.com"})       // Pass in our context, *http.Request and ResponseRecorder.     handler.ServeHTTPC(ctx, rr, req)       // Check the status code is what we expect.     if status := rr.Code; status != http.StatusOK {         t.Errorf("handler returned wrong status code: got %v want %v",             status, http.StatusOK)     }       // We could also test that our handler correctly mutates our context.Context:     // this is useful if our handler is a piece of middleware.     if id , ok := ctx.Value("app.req.id").(string); !ok {         t.Errorf("handler did not populate the request ID: got %v", id)     } } 

// handlers_test.go package handlers   // Throws errors on all of its methods. type badProjectStore struct {     // This would be a concrete type that satisfies datastore.ProjectStore.     // We embed it here so that our goodProjectStub type has all the methods     // needed to satisfy datastore.ProjectStore, without having to stub out     // every method (we might not want to test all of them, or some might be     // not need to be stubbed.     *datastore.Project }   func (ps *projectStoreStub) CreateProject(project *datastore.Project) error {     return datastore.NetworkError{errors.New("Bad connection"} }   func (ps *projectStoreStub) GetProject(idstring) (*datastore.Project, error) {     return nil, datastore.NetworkError{errors.New("Bad connection"} }   funcTestGetProjectsHandlerError(t *testing.T) {     var storedatastore.ProjectStore = &badProjectStore{}       // We inject our environment into our handlers.     // Ref: http://elithrar.github.io/article/http-handler-error-handling-revisited/     env := handlers.Env{Store: store, Key: "abc"}       req, err := http.NewRequest("GET", "/api/projects", nil)     if err != nil {         t.Fatal(err)     }       rr := httptest.Recorder()     // Handler is a custom handler type that accepts an env and a http.Handler     // GetProjectsHandler here calls GetProject, and should raise a HTTP 500 if     // it fails.     Handler{env, GetProjectsHandler)     handler.ServeHTTP(rr, req)       // We're now checking that our handler throws an error (a HTTP 500) when it     // should.     if status := rr.Code; status != http.StatusInternalServeError {         t.Errorf("handler returned wrong status code: got %v want %v"             rr.Code, http.StatusOK)     }       // We'll also check that it returns a JSON body with the expected error.     expected := []byte(`{"status": 500, "error": "Bad connection"}`)     if !bytes.Equals(rr.Body.Bytes(), expected) {         t.Errorf("handler returned unexpected body: got %v want %v",         rr.Body.Bytes(), expected)     }