recorder_test.go

Documentation: net/http/httptest

		 1  // Copyright 2012 The Go Authors. All rights reserved.
		 2  // Use of this source code is governed by a BSD-style
		 3  // license that can be found in the LICENSE file.
		 4  
		 5  package httptest
		 6  
		 7  import (
		 8  	"fmt"
		 9  	"io"
		10  	"net/http"
		11  	"testing"
		12  )
		13  
		14  func TestRecorder(t *testing.T) {
		15  	type checkFunc func(*ResponseRecorder) error
		16  	check := func(fns ...checkFunc) []checkFunc { return fns }
		17  
		18  	hasStatus := func(wantCode int) checkFunc {
		19  		return func(rec *ResponseRecorder) error {
		20  			if rec.Code != wantCode {
		21  				return fmt.Errorf("Status = %d; want %d", rec.Code, wantCode)
		22  			}
		23  			return nil
		24  		}
		25  	}
		26  	hasResultStatus := func(want string) checkFunc {
		27  		return func(rec *ResponseRecorder) error {
		28  			if rec.Result().Status != want {
		29  				return fmt.Errorf("Result().Status = %q; want %q", rec.Result().Status, want)
		30  			}
		31  			return nil
		32  		}
		33  	}
		34  	hasResultStatusCode := func(wantCode int) checkFunc {
		35  		return func(rec *ResponseRecorder) error {
		36  			if rec.Result().StatusCode != wantCode {
		37  				return fmt.Errorf("Result().StatusCode = %d; want %d", rec.Result().StatusCode, wantCode)
		38  			}
		39  			return nil
		40  		}
		41  	}
		42  	hasResultContents := func(want string) checkFunc {
		43  		return func(rec *ResponseRecorder) error {
		44  			contentBytes, err := io.ReadAll(rec.Result().Body)
		45  			if err != nil {
		46  				return err
		47  			}
		48  			contents := string(contentBytes)
		49  			if contents != want {
		50  				return fmt.Errorf("Result().Body = %s; want %s", contents, want)
		51  			}
		52  			return nil
		53  		}
		54  	}
		55  	hasContents := func(want string) checkFunc {
		56  		return func(rec *ResponseRecorder) error {
		57  			if rec.Body.String() != want {
		58  				return fmt.Errorf("wrote = %q; want %q", rec.Body.String(), want)
		59  			}
		60  			return nil
		61  		}
		62  	}
		63  	hasFlush := func(want bool) checkFunc {
		64  		return func(rec *ResponseRecorder) error {
		65  			if rec.Flushed != want {
		66  				return fmt.Errorf("Flushed = %v; want %v", rec.Flushed, want)
		67  			}
		68  			return nil
		69  		}
		70  	}
		71  	hasOldHeader := func(key, want string) checkFunc {
		72  		return func(rec *ResponseRecorder) error {
		73  			if got := rec.HeaderMap.Get(key); got != want {
		74  				return fmt.Errorf("HeaderMap header %s = %q; want %q", key, got, want)
		75  			}
		76  			return nil
		77  		}
		78  	}
		79  	hasHeader := func(key, want string) checkFunc {
		80  		return func(rec *ResponseRecorder) error {
		81  			if got := rec.Result().Header.Get(key); got != want {
		82  				return fmt.Errorf("final header %s = %q; want %q", key, got, want)
		83  			}
		84  			return nil
		85  		}
		86  	}
		87  	hasNotHeaders := func(keys ...string) checkFunc {
		88  		return func(rec *ResponseRecorder) error {
		89  			for _, k := range keys {
		90  				v, ok := rec.Result().Header[http.CanonicalHeaderKey(k)]
		91  				if ok {
		92  					return fmt.Errorf("unexpected header %s with value %q", k, v)
		93  				}
		94  			}
		95  			return nil
		96  		}
		97  	}
		98  	hasTrailer := func(key, want string) checkFunc {
		99  		return func(rec *ResponseRecorder) error {
	 100  			if got := rec.Result().Trailer.Get(key); got != want {
	 101  				return fmt.Errorf("trailer %s = %q; want %q", key, got, want)
	 102  			}
	 103  			return nil
	 104  		}
	 105  	}
	 106  	hasNotTrailers := func(keys ...string) checkFunc {
	 107  		return func(rec *ResponseRecorder) error {
	 108  			trailers := rec.Result().Trailer
	 109  			for _, k := range keys {
	 110  				_, ok := trailers[http.CanonicalHeaderKey(k)]
	 111  				if ok {
	 112  					return fmt.Errorf("unexpected trailer %s", k)
	 113  				}
	 114  			}
	 115  			return nil
	 116  		}
	 117  	}
	 118  	hasContentLength := func(length int64) checkFunc {
	 119  		return func(rec *ResponseRecorder) error {
	 120  			if got := rec.Result().ContentLength; got != length {
	 121  				return fmt.Errorf("ContentLength = %d; want %d", got, length)
	 122  			}
	 123  			return nil
	 124  		}
	 125  	}
	 126  
	 127  	for _, tt := range [...]struct {
	 128  		name	 string
	 129  		h			func(w http.ResponseWriter, r *http.Request)
	 130  		checks []checkFunc
	 131  	}{
	 132  		{
	 133  			"200 default",
	 134  			func(w http.ResponseWriter, r *http.Request) {},
	 135  			check(hasStatus(200), hasContents("")),
	 136  		},
	 137  		{
	 138  			"first code only",
	 139  			func(w http.ResponseWriter, r *http.Request) {
	 140  				w.WriteHeader(201)
	 141  				w.WriteHeader(202)
	 142  				w.Write([]byte("hi"))
	 143  			},
	 144  			check(hasStatus(201), hasContents("hi")),
	 145  		},
	 146  		{
	 147  			"write sends 200",
	 148  			func(w http.ResponseWriter, r *http.Request) {
	 149  				w.Write([]byte("hi first"))
	 150  				w.WriteHeader(201)
	 151  				w.WriteHeader(202)
	 152  			},
	 153  			check(hasStatus(200), hasContents("hi first"), hasFlush(false)),
	 154  		},
	 155  		{
	 156  			"write string",
	 157  			func(w http.ResponseWriter, r *http.Request) {
	 158  				io.WriteString(w, "hi first")
	 159  			},
	 160  			check(
	 161  				hasStatus(200),
	 162  				hasContents("hi first"),
	 163  				hasFlush(false),
	 164  				hasHeader("Content-Type", "text/plain; charset=utf-8"),
	 165  			),
	 166  		},
	 167  		{
	 168  			"flush",
	 169  			func(w http.ResponseWriter, r *http.Request) {
	 170  				w.(http.Flusher).Flush() // also sends a 200
	 171  				w.WriteHeader(201)
	 172  			},
	 173  			check(hasStatus(200), hasFlush(true), hasContentLength(-1)),
	 174  		},
	 175  		{
	 176  			"Content-Type detection",
	 177  			func(w http.ResponseWriter, r *http.Request) {
	 178  				io.WriteString(w, "<html>")
	 179  			},
	 180  			check(hasHeader("Content-Type", "text/html; charset=utf-8")),
	 181  		},
	 182  		{
	 183  			"no Content-Type detection with Transfer-Encoding",
	 184  			func(w http.ResponseWriter, r *http.Request) {
	 185  				w.Header().Set("Transfer-Encoding", "some encoding")
	 186  				io.WriteString(w, "<html>")
	 187  			},
	 188  			check(hasHeader("Content-Type", "")), // no header
	 189  		},
	 190  		{
	 191  			"no Content-Type detection if set explicitly",
	 192  			func(w http.ResponseWriter, r *http.Request) {
	 193  				w.Header().Set("Content-Type", "some/type")
	 194  				io.WriteString(w, "<html>")
	 195  			},
	 196  			check(hasHeader("Content-Type", "some/type")),
	 197  		},
	 198  		{
	 199  			"Content-Type detection doesn't crash if HeaderMap is nil",
	 200  			func(w http.ResponseWriter, r *http.Request) {
	 201  				// Act as if the user wrote new(httptest.ResponseRecorder)
	 202  				// rather than using NewRecorder (which initializes
	 203  				// HeaderMap)
	 204  				w.(*ResponseRecorder).HeaderMap = nil
	 205  				io.WriteString(w, "<html>")
	 206  			},
	 207  			check(hasHeader("Content-Type", "text/html; charset=utf-8")),
	 208  		},
	 209  		{
	 210  			"Header is not changed after write",
	 211  			func(w http.ResponseWriter, r *http.Request) {
	 212  				hdr := w.Header()
	 213  				hdr.Set("Key", "correct")
	 214  				w.WriteHeader(200)
	 215  				hdr.Set("Key", "incorrect")
	 216  			},
	 217  			check(hasHeader("Key", "correct")),
	 218  		},
	 219  		{
	 220  			"Trailer headers are correctly recorded",
	 221  			func(w http.ResponseWriter, r *http.Request) {
	 222  				w.Header().Set("Non-Trailer", "correct")
	 223  				w.Header().Set("Trailer", "Trailer-A")
	 224  				w.Header().Add("Trailer", "Trailer-B")
	 225  				w.Header().Add("Trailer", "Trailer-C")
	 226  				io.WriteString(w, "<html>")
	 227  				w.Header().Set("Non-Trailer", "incorrect")
	 228  				w.Header().Set("Trailer-A", "valuea")
	 229  				w.Header().Set("Trailer-C", "valuec")
	 230  				w.Header().Set("Trailer-NotDeclared", "should be omitted")
	 231  				w.Header().Set("Trailer:Trailer-D", "with prefix")
	 232  			},
	 233  			check(
	 234  				hasStatus(200),
	 235  				hasHeader("Content-Type", "text/html; charset=utf-8"),
	 236  				hasHeader("Non-Trailer", "correct"),
	 237  				hasNotHeaders("Trailer-A", "Trailer-B", "Trailer-C", "Trailer-NotDeclared"),
	 238  				hasTrailer("Trailer-A", "valuea"),
	 239  				hasTrailer("Trailer-C", "valuec"),
	 240  				hasNotTrailers("Non-Trailer", "Trailer-B", "Trailer-NotDeclared"),
	 241  				hasTrailer("Trailer-D", "with prefix"),
	 242  			),
	 243  		},
	 244  		{
	 245  			"Header set without any write", // Issue 15560
	 246  			func(w http.ResponseWriter, r *http.Request) {
	 247  				w.Header().Set("X-Foo", "1")
	 248  
	 249  				// Simulate somebody using
	 250  				// new(ResponseRecorder) instead of
	 251  				// using the constructor which sets
	 252  				// this to 200
	 253  				w.(*ResponseRecorder).Code = 0
	 254  			},
	 255  			check(
	 256  				hasOldHeader("X-Foo", "1"),
	 257  				hasStatus(0),
	 258  				hasHeader("X-Foo", "1"),
	 259  				hasResultStatus("200 OK"),
	 260  				hasResultStatusCode(200),
	 261  			),
	 262  		},
	 263  		{
	 264  			"HeaderMap vs FinalHeaders", // more for Issue 15560
	 265  			func(w http.ResponseWriter, r *http.Request) {
	 266  				h := w.Header()
	 267  				h.Set("X-Foo", "1")
	 268  				w.Write([]byte("hi"))
	 269  				h.Set("X-Foo", "2")
	 270  				h.Set("X-Bar", "2")
	 271  			},
	 272  			check(
	 273  				hasOldHeader("X-Foo", "2"),
	 274  				hasOldHeader("X-Bar", "2"),
	 275  				hasHeader("X-Foo", "1"),
	 276  				hasNotHeaders("X-Bar"),
	 277  			),
	 278  		},
	 279  		{
	 280  			"setting Content-Length header",
	 281  			func(w http.ResponseWriter, r *http.Request) {
	 282  				body := "Some body"
	 283  				contentLength := fmt.Sprintf("%d", len(body))
	 284  				w.Header().Set("Content-Length", contentLength)
	 285  				io.WriteString(w, body)
	 286  			},
	 287  			check(hasStatus(200), hasContents("Some body"), hasContentLength(9)),
	 288  		},
	 289  		{
	 290  			"nil ResponseRecorder.Body", // Issue 26642
	 291  			func(w http.ResponseWriter, r *http.Request) {
	 292  				w.(*ResponseRecorder).Body = nil
	 293  				io.WriteString(w, "hi")
	 294  			},
	 295  			check(hasResultContents("")), // check we don't crash reading the body
	 296  
	 297  		},
	 298  	} {
	 299  		t.Run(tt.name, func(t *testing.T) {
	 300  			r, _ := http.NewRequest("GET", "http://foo.com/", nil)
	 301  			h := http.HandlerFunc(tt.h)
	 302  			rec := NewRecorder()
	 303  			h.ServeHTTP(rec, r)
	 304  			for _, check := range tt.checks {
	 305  				if err := check(rec); err != nil {
	 306  					t.Error(err)
	 307  				}
	 308  			}
	 309  		})
	 310  	}
	 311  }
	 312  
	 313  // issue 39017 - disallow Content-Length values such as "+3"
	 314  func TestParseContentLength(t *testing.T) {
	 315  	tests := []struct {
	 316  		cl	 string
	 317  		want int64
	 318  	}{
	 319  		{
	 320  			cl:	 "3",
	 321  			want: 3,
	 322  		},
	 323  		{
	 324  			cl:	 "+3",
	 325  			want: -1,
	 326  		},
	 327  		{
	 328  			cl:	 "-3",
	 329  			want: -1,
	 330  		},
	 331  		{
	 332  			// max int64, for safe conversion before returning
	 333  			cl:	 "9223372036854775807",
	 334  			want: 9223372036854775807,
	 335  		},
	 336  		{
	 337  			cl:	 "9223372036854775808",
	 338  			want: -1,
	 339  		},
	 340  	}
	 341  
	 342  	for _, tt := range tests {
	 343  		if got := parseContentLength(tt.cl); got != tt.want {
	 344  			t.Errorf("%q:\n\tgot=%d\n\twant=%d", tt.cl, got, tt.want)
	 345  		}
	 346  	}
	 347  }
	 348  
	 349  // Ensure that httptest.Recorder panics when given a non-3 digit (XXX)
	 350  // status HTTP code. See https://golang.org/issues/45353
	 351  func TestRecorderPanicsOnNonXXXStatusCode(t *testing.T) {
	 352  	badCodes := []int{
	 353  		-100, 0, 99, 1000, 20000,
	 354  	}
	 355  	for _, badCode := range badCodes {
	 356  		badCode := badCode
	 357  		t.Run(fmt.Sprintf("Code=%d", badCode), func(t *testing.T) {
	 358  			defer func() {
	 359  				if r := recover(); r == nil {
	 360  					t.Fatal("Expected a panic")
	 361  				}
	 362  			}()
	 363  
	 364  			handler := func(rw http.ResponseWriter, _ *http.Request) {
	 365  				rw.WriteHeader(badCode)
	 366  			}
	 367  			r, _ := http.NewRequest("GET", "http://example.org/", nil)
	 368  			rw := NewRecorder()
	 369  			handler(rw, r)
	 370  		})
	 371  	}
	 372  }
	 373
View as plain text