func testContentType(t *testing.T, r *http.Request, rec *httptest.ResponseRecorder, expected string) { ct := rec.Header().Get("content-type") if !strings.EqualFold(ct, expected) { t.Errorf("Unexpected content-type for %q: %s, expected: %s", r.URL.String(), ct, expected) } }
func recorderToResponse(recorder *httptest.ResponseRecorder) *http.Response { return &http.Response{ StatusCode: recorder.Code, Body: jsh.CreateReadCloser(recorder.Body.Bytes()), Header: recorder.Header(), } }
// checkIndex is like assertIndex but returns an error func checkIndex(resp *httptest.ResponseRecorder) error { header := resp.Header().Get("X-Consul-Index") if header == "" || header == "0" { return fmt.Errorf("Bad: %v", header) } return nil }
func (m *MockRender) Header() http.Header { r := httptest.ResponseRecorder{} m.Called() return r.Header() }
func ReadHeadersFromResponse(writer *httptest.ResponseRecorder) map[string]string { headers := map[string]string{} for k, v := range writer.Header() { log.Println(k, v) headers[k] = strings.Join(v, " ") } return headers }
// Write the contents of a ResponseRecorder to a ResponseWriter func writeRecorder(w http.ResponseWriter, recorder *httptest.ResponseRecorder) { for key, values := range recorder.HeaderMap { for _, value := range values { w.Header().Set(key, value) } } recorder.Body.WriteTo(w) recorder.Flush() }
func (s *Stack) Write(response *Response, rec *httptest.ResponseRecorder) { for key, values := range rec.Header() { for _, value := range values { response.header.Add(key, value) } } response.buffer.Write(rec.Body.Bytes()) response.code = rec.Code }
// Test that the headers and body match. func assertHttpMatchRecorder(t *testing.T, recorder *httptest.ResponseRecorder, expectedStatus int, expectedHeaders http.Header, expectedBody string) { assert.Equal(t, expectedStatus, recorder.Code) // Verify that headers match. Order shouldn't matter. assert.Equal(t, recorder.Header(), expectedHeaders) // Convert the body to a string. assert.Equal(t, expectedBody, recorder.Body.String()) }
func assertJSONResponse(t *testing.T, expectedCode int, expectedResponse string, w *httptest.ResponseRecorder) { assert.Equal(t, expectedCode, w.Code) assert.Equal(t, "application/json", w.Header().Get("content-type")) var expected, actual interface{} require.NoError(t, json.Unmarshal([]byte(expectedResponse), &expected)) require.NoError(t, json.Unmarshal(w.Body.Bytes(), &actual)) assert.Equal(t, expected, actual) }
// respFromRecorder builds an http response from a httptest recorder func respFromRecorder(w *httptest.ResponseRecorder) *http.Response { resp := http.Response{} resp.StatusCode = w.Code resp.Header = w.Header() // TODO: fill in the rest of response b := w.Body.Bytes() resp.Body = ioutil.NopCloser(bytes.NewReader(b)) return &resp }
func assertResponseWithStatusAndMessage(t *testing.T, res *httptest.ResponseRecorder, code int, status, message string) { var apiMessage responses.APIMessage json.NewDecoder(res.Body).Decode(&apiMessage) assert.Equal(t, code, res.Code) assert.Equal(t, "application/json; charset=UTF-8", res.Header().Get("Content-Type")) assert.Equal(t, status, apiMessage.Status) assert.Equal(t, message, apiMessage.Message) }
// copyResponse copies all relevant info from rec to rw. func copyResponse(rw http.ResponseWriter, rec *httptest.ResponseRecorder) { // copy the headers for k, v := range rec.Header() { rw.Header()[k] = v } // copy the code rw.WriteHeader(rec.Code) // copy the body rw.Write(rec.Body.Bytes()) }
// DoRequest invokes a request on the given handler with the given // parameters. func DoRequest(c *gc.C, p DoRequestParams) *httptest.ResponseRecorder { if p.Method == "" { p.Method = "GET" } if p.Do == nil { p.Do = http.DefaultClient.Do } srv := httptest.NewServer(p.Handler) defer srv.Close() if p.JSONBody != nil { data, err := json.Marshal(p.JSONBody) c.Assert(err, jc.ErrorIsNil) p.Body = bytes.NewReader(data) } // Note: we avoid NewRequest's odious reader wrapping by using // a custom nopCloser function. req, err := http.NewRequest(p.Method, srv.URL+p.URL, nopCloser(p.Body)) c.Assert(err, jc.ErrorIsNil) if p.JSONBody != nil { req.Header.Set("Content-Type", "application/json") } for key, val := range p.Header { req.Header[key] = val } if p.ContentLength != 0 { req.ContentLength = p.ContentLength } else { req.ContentLength = bodyContentLength(p.Body) } if p.Username != "" || p.Password != "" { req.SetBasicAuth(p.Username, p.Password) } for _, cookie := range p.Cookies { req.AddCookie(cookie) } resp, err := p.Do(req) if p.ExpectError != "" { c.Assert(err, gc.ErrorMatches, p.ExpectError) return nil } c.Assert(err, jc.ErrorIsNil) defer resp.Body.Close() // TODO(rog) don't return a ResponseRecorder because we're not actually // using httptest.NewRecorder ? var rec httptest.ResponseRecorder rec.HeaderMap = resp.Header rec.Code = resp.StatusCode rec.Body = new(bytes.Buffer) _, err = io.Copy(rec.Body, resp.Body) c.Assert(err, jc.ErrorIsNil) return &rec }
// getIndex parses X-Consul-Index func getIndex(t *testing.T, resp *httptest.ResponseRecorder) uint64 { header := resp.Header().Get("X-Consul-Index") if header == "" { t.Fatalf("Bad: %v", header) } val, err := strconv.Atoi(header) if err != nil { t.Fatalf("Bad: %v", header) } return uint64(val) }
func ReadHeadersFromResponse(writer *httptest.ResponseRecorder) (map[string]string, []models.YaagAnnotationHeader) { headers := map[string]string{} yaagAnnotations := []models.YaagAnnotationHeader{} for k, v := range writer.Header() { if strings.HasPrefix(k, "Yaag-Annotation") { yaagAnnotations = append(yaagAnnotations, annotations.New(k, strings.Join(v, " "))) } else { headers[k] = strings.Join(v, " ") } } return headers, yaagAnnotations }
func (m mockCacher) Put(key string, r *httptest.ResponseRecorder) *CachedResponse { specHeaders := make(map[string]string) for k, v := range r.Header() { specHeaders[k] = strings.Join(v, ", ") } m.data[key] = &CachedResponse{ StatusCode: r.Code, Body: r.Body.Bytes(), Headers: specHeaders, } return m.data[key] }
func compressedRequest(w *httptest.ResponseRecorder, compression string) { CompressHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Length", strconv.Itoa(9*1024)) for i := 0; i < 1024; i++ { io.WriteString(w, "Gorilla!\n") } })).ServeHTTP(w, &http.Request{ Method: "GET", Header: http.Header{ "Accept-Encoding": []string{compression}, }, }) }
// DoRequest is the same as Do except that it returns // an httptest.ResponseRecorder instead of an http.Response. // This function exists for backward compatibility reasons. func DoRequest(c *gc.C, p DoRequestParams) *httptest.ResponseRecorder { resp := Do(c, p) if p.ExpectError != "" { return nil } defer resp.Body.Close() var rec httptest.ResponseRecorder rec.HeaderMap = resp.Header rec.Code = resp.StatusCode rec.Body = new(bytes.Buffer) _, err := io.Copy(rec.Body, resp.Body) c.Assert(err, jc.ErrorIsNil) return &rec }
func checkResponseRecorder(t *testing.T, rr *httptest.ResponseRecorder, code int, header map[string][]string, body string) { if !rr.Flushed { t.Fatal("ResponseRecorder not flushed") } if a, e := rr.Code, code; a != e { t.Error(a, "!=", e) } if a, e := map[string][]string(rr.Header()), header; !reflect.DeepEqual(a, e) { t.Error(a, "!=", e) } if a, e := rr.Body.Bytes(), []byte(body); !bytes.Equal(a, e) { t.Error(a, "!=", e) } }
func checkHeaders(t *testing.T, res *httptest.ResponseRecorder, requiredHeaders map[string]string) { for headerKey, expectedHeaderValue := range requiredHeaders { actualHeaderValue := res.Header().Get(headerKey) if actualHeaderValue != expectedHeaderValue { // N.B. the http library does not distinguish between header // entries that have an empty "" value, and non-existing entries if expectedHeaderValue != "" { t.Errorf("Expected header %q to be %q but it was %q", headerKey, expectedHeaderValue, actualHeaderValue) t.Logf("Full headers: %q", res.Header()) } else { t.Errorf("Expected header %q to not be present, or to be an empty string (\"\"), but it was %q", headerKey, actualHeaderValue) } } } }
func TestWildcardCompeting(t *testing.T) { var ( method string = "GET" mux *Mux = New() patternOne string = "/*" pathOne string = "/bar/baz" wantOne string = "bar/baz" patternTwo string = "/foo/*" pathTwo string = "/foo/baz" wantTwo string = "baz" patternThree string = "/foo/bar/*" pathThree string = "/foo/bar/bar/baz" wantThree string = "bar/baz" req *http.Request res *httptest.ResponseRecorder ) handler := func(res http.ResponseWriter, _ *http.Request, ctx *Context) { res.WriteHeader(http.StatusOK) res.Write([]byte(ctx.Params["*"])) } mux.On(method, patternOne, handler) mux.On(method, patternTwo, handler) mux.On(method, patternThree, handler) req, _ = http.NewRequest(method, pathOne, nil) res = httptest.NewRecorder() mux.ServeHTTP(res, req) if body := res.Body.String(); body != wantOne { t.Errorf( "%s %s (%s) got %s want %s", method, pathOne, patternOne, body, wantOne) } req, _ = http.NewRequest(method, pathTwo, nil) res = httptest.NewRecorder() mux.ServeHTTP(res, req) if body := res.Body.String(); body != wantTwo { t.Errorf( "%s %s (%s) got %s want %s", method, pathTwo, patternTwo, body, wantTwo) } req, _ = http.NewRequest(method, pathThree, nil) res = httptest.NewRecorder() mux.ServeHTTP(res, req) if body := res.Body.String(); body != wantThree { t.Errorf( "%s %s (%s) got %s want %s", method, pathThree, patternThree, body, wantThree) } }
// AssertJSONResponse asserts that the given response recorder has // recorded the given HTTP status, response body and content type. If // expectBody is of type BodyAsserter it will be called with the response // body to ensure the response is correct. func AssertJSONResponse(c *gc.C, rec *httptest.ResponseRecorder, expectStatus int, expectBody interface{}) { c.Assert(rec.Code, gc.Equals, expectStatus, gc.Commentf("body: %s", rec.Body.Bytes())) // Ensure the response includes the expected body. if expectBody == nil { c.Assert(rec.Body.Bytes(), gc.HasLen, 0) return } c.Assert(rec.Header().Get("Content-Type"), gc.Equals, "application/json") if assertBody, ok := expectBody.(BodyAsserter); ok { var data json.RawMessage err := json.Unmarshal(rec.Body.Bytes(), &data) c.Assert(err, jc.ErrorIsNil, gc.Commentf("body: %s", rec.Body.Bytes())) assertBody(c, data) return } c.Assert(rec.Body.String(), jc.JSONEquals, expectBody) }
func checkStatusCode(t *testing.T, res *httptest.ResponseRecorder, statusCode int) { respBody, err := ioutil.ReadAll(res.Body) if err != nil { t.Fatalf("Could not read response body: %v", err) } // make sure we get at least a few bytes of a response body... // even http 303 should have some body, see // https://tools.ietf.org/html/rfc7231#section-6.4.4 if len(respBody) < 20 { t.Error("Expected a response body (at least 20 bytes), but get less (or none).") t.Logf("Headers: %s", res.Header()) t.Logf("Response received:\n%s", string(respBody)) } if res.Code != statusCode { t.Errorf("Expected status code %v but got %v", statusCode, res.Code) t.Logf("Headers: %s", res.Header()) t.Logf("Response received:\n%s", string(respBody)) } }
func TestWildcardParams(t *testing.T) { var ( method string = "GET" mux *Mux = New() pattern string = "/foo/{bar}/*" path string = "/foo/ABC/baz" want string = "ABC" req *http.Request res *httptest.ResponseRecorder ) handler := func(res http.ResponseWriter, _ *http.Request, ctx *Context) { res.WriteHeader(http.StatusOK) res.Write([]byte(ctx.Params["bar"])) } mux.On(method, pattern, handler) req, _ = http.NewRequest(method, path, nil) res = httptest.NewRecorder() mux.ServeHTTP(res, req) if body := res.Body.String(); body != want { t.Errorf("%s %s (%s) got %s want %s", method, path, pattern, body, want) } }
func TestNotFoundCustom(t *testing.T) { var ( method string = "GET" mux *Mux = New() pathFound string = "/foo/bar" pathLost string = "/foo/bar/baz" patternFound string = "/foo/bar" patternLost string = "/*" req *http.Request res *httptest.ResponseRecorder wantFound int = http.StatusOK wantLost int = http.StatusTeapot ) handlerFound := http.HandlerFunc(func(http.ResponseWriter, *http.Request) { res.WriteHeader(http.StatusOK) res.Write([]byte("found!")) }) handlerLost := http.HandlerFunc(func(http.ResponseWriter, *http.Request) { res.WriteHeader(http.StatusTeapot) res.Write([]byte("not found!")) }) // Test found to make sure wildcard doesn't overtake everything. req, _ = http.NewRequest(method, pathFound, nil) res = httptest.NewRecorder() mux.On(method, patternFound, handlerFound) mux.ServeHTTP(res, req) if res.Code != wantFound { t.Errorf( "%s %s (%s) got %d want %d", method, pathFound, patternFound, res.Code, wantFound) } // Test lost to make sure wildcard can gets non-pattern-matching paths. req, _ = http.NewRequest(method, pathLost, nil) res = httptest.NewRecorder() mux.On(method, patternLost, handlerLost) mux.ServeHTTP(res, req) if res.Code != wantLost { t.Errorf( "%s %s (%s) got %d want %d", method, pathLost, patternLost, res.Code, wantLost) } }
func NewResponse(resp *httptest.ResponseRecorder) *Response { content := resp.Body.Bytes() contentType := resp.Header().Get("Content-Type") contentEncoding := resp.Header().Get("Content-Encoding") return &Response{ StatusCode: resp.Code, Header: NewHeader(resp.Header()), Body: NewBody(content, contentType, contentEncoding), } }
// Put stores a CachedResponse for a given key and response func (c DiskCacher) Put(key string, resp *httptest.ResponseRecorder) *CachedResponse { c.mutex.Lock() defer c.mutex.Unlock() skipDisk := resp.Header().Get("_chameleon-seeded-skip-disk") != "" if skipDisk { resp.Header().Del("_chameleon-seeded-skip-disk") } skipDisk = skipDisk || c.memory specHeaders := make(map[string]string) for k, v := range resp.Header() { specHeaders[k] = strings.Join(v, ", ") } if !skipDisk { specs := c.loadSpecs() newSpec := Spec{ Key: key, SpecResponse: SpecResponse{ StatusCode: resp.Code, ContentFile: key, Headers: specHeaders, }, } specs = append(specs, newSpec) contentFilePath := path.Join(c.dataDir, key) err := c.FileSystem.WriteFile(contentFilePath, resp.Body.Bytes()) if err != nil { panic(err) } specBytes, err := json.MarshalIndent(specs, "", " ") err = c.FileSystem.WriteFile(c.specPath, specBytes) if err != nil { panic(err) } } c.cache[key] = &CachedResponse{ StatusCode: resp.Code, Headers: specHeaders, Body: resp.Body.Bytes(), } return c.cache[key] }
func (m prettyJSONContentMarshaler) Unmarshal(data []byte, i interface{}) error { return json.Unmarshal(data, i) } var _ = Describe("RestHandler", func() { var usePointerResources bool requestHandlingTests := func() { var ( source *fixtureSource post1Json map[string]interface{} post1LinkedJSON []map[string]interface{} post2Json map[string]interface{} post3Json map[string]interface{} api *API rec *httptest.ResponseRecorder ) BeforeEach(func() { source = &fixtureSource{map[string]*Post{ "1": &Post{ ID: "1", Title: "Hello, World!", Author: &User{ ID: "1", Name: "Dieter", }, Comments: []Comment{Comment{
"github.com/cloudfoundry-incubator/notifications/testing/mocks" "github.com/cloudfoundry-incubator/notifications/v2/collections" "github.com/cloudfoundry-incubator/notifications/v2/web/senders" "github.com/ryanmoran/stack" . "github.com/onsi/ginkgo" . "github.com/onsi/gomega" ) var _ = Describe("GetHandler", func() { var ( handler senders.GetHandler sendersCollection *mocks.SendersCollection context stack.Context writer *httptest.ResponseRecorder request *http.Request database *mocks.Database conn *mocks.Connection ) BeforeEach(func() { conn = mocks.NewConnection() database = mocks.NewDatabase() database.ConnectionCall.Returns.Connection = conn context = stack.NewContext() context.Set("client_id", "some-client-id") context.Set("database", database) sendersCollection = mocks.NewSendersCollection()
// assertIndex tests that X-Consul-Index is set and non-zero func assertIndex(t *testing.T, resp *httptest.ResponseRecorder) { header := resp.Header().Get("X-Consul-Index") if header == "" || header == "0" { t.Fatalf("Bad: %v", header) } }