github.com/code-reading/golang@v0.0.0-20220303082512-ba5bc0e589a3/go/src/net/http/request_test.go (about) 1 // Copyright 2009 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 http_test 6 7 import ( 8 "bufio" 9 "bytes" 10 "context" 11 "crypto/rand" 12 "encoding/base64" 13 "fmt" 14 "io" 15 "math" 16 "mime/multipart" 17 . "net/http" 18 "net/http/httptest" 19 "net/url" 20 "os" 21 "reflect" 22 "regexp" 23 "strings" 24 "testing" 25 ) 26 27 func TestQuery(t *testing.T) { 28 req := &Request{Method: "GET"} 29 req.URL, _ = url.Parse("http://www.google.com/search?q=foo&q=bar") 30 if q := req.FormValue("q"); q != "foo" { 31 t.Errorf(`req.FormValue("q") = %q, want "foo"`, q) 32 } 33 } 34 35 // Issue #25192: Test that ParseForm fails but still parses the form when an URL 36 // containing a semicolon is provided. 37 func TestParseFormSemicolonSeparator(t *testing.T) { 38 for _, method := range []string{"POST", "PATCH", "PUT", "GET"} { 39 req, _ := NewRequest(method, "http://www.google.com/search?q=foo;q=bar&a=1", 40 strings.NewReader("q")) 41 err := req.ParseForm() 42 if err == nil { 43 t.Fatalf(`for method %s, ParseForm expected an error, got success`, method) 44 } 45 wantForm := url.Values{"a": []string{"1"}} 46 if !reflect.DeepEqual(req.Form, wantForm) { 47 t.Fatalf("for method %s, ParseForm expected req.Form = %v, want %v", method, req.Form, wantForm) 48 } 49 } 50 } 51 52 func TestParseFormQuery(t *testing.T) { 53 req, _ := NewRequest("POST", "http://www.google.com/search?q=foo&q=bar&both=x&prio=1&orphan=nope&empty=not", 54 strings.NewReader("z=post&both=y&prio=2&=nokey&orphan&empty=&")) 55 req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value") 56 57 if q := req.FormValue("q"); q != "foo" { 58 t.Errorf(`req.FormValue("q") = %q, want "foo"`, q) 59 } 60 if z := req.FormValue("z"); z != "post" { 61 t.Errorf(`req.FormValue("z") = %q, want "post"`, z) 62 } 63 if bq, found := req.PostForm["q"]; found { 64 t.Errorf(`req.PostForm["q"] = %q, want no entry in map`, bq) 65 } 66 if bz := req.PostFormValue("z"); bz != "post" { 67 t.Errorf(`req.PostFormValue("z") = %q, want "post"`, bz) 68 } 69 if qs := req.Form["q"]; !reflect.DeepEqual(qs, []string{"foo", "bar"}) { 70 t.Errorf(`req.Form["q"] = %q, want ["foo", "bar"]`, qs) 71 } 72 if both := req.Form["both"]; !reflect.DeepEqual(both, []string{"y", "x"}) { 73 t.Errorf(`req.Form["both"] = %q, want ["y", "x"]`, both) 74 } 75 if prio := req.FormValue("prio"); prio != "2" { 76 t.Errorf(`req.FormValue("prio") = %q, want "2" (from body)`, prio) 77 } 78 if orphan := req.Form["orphan"]; !reflect.DeepEqual(orphan, []string{"", "nope"}) { 79 t.Errorf(`req.FormValue("orphan") = %q, want "" (from body)`, orphan) 80 } 81 if empty := req.Form["empty"]; !reflect.DeepEqual(empty, []string{"", "not"}) { 82 t.Errorf(`req.FormValue("empty") = %q, want "" (from body)`, empty) 83 } 84 if nokey := req.Form[""]; !reflect.DeepEqual(nokey, []string{"nokey"}) { 85 t.Errorf(`req.FormValue("nokey") = %q, want "nokey" (from body)`, nokey) 86 } 87 } 88 89 // Tests that we only parse the form automatically for certain methods. 90 func TestParseFormQueryMethods(t *testing.T) { 91 for _, method := range []string{"POST", "PATCH", "PUT", "FOO"} { 92 req, _ := NewRequest(method, "http://www.google.com/search", 93 strings.NewReader("foo=bar")) 94 req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value") 95 want := "bar" 96 if method == "FOO" { 97 want = "" 98 } 99 if got := req.FormValue("foo"); got != want { 100 t.Errorf(`for method %s, FormValue("foo") = %q; want %q`, method, got, want) 101 } 102 } 103 } 104 105 func TestParseFormUnknownContentType(t *testing.T) { 106 for _, test := range []struct { 107 name string 108 wantErr string 109 contentType Header 110 }{ 111 {"text", "", Header{"Content-Type": {"text/plain"}}}, 112 // Empty content type is legal - may be treated as 113 // application/octet-stream (RFC 7231, section 3.1.1.5) 114 {"empty", "", Header{}}, 115 {"boundary", "mime: invalid media parameter", Header{"Content-Type": {"text/plain; boundary="}}}, 116 {"unknown", "", Header{"Content-Type": {"application/unknown"}}}, 117 } { 118 t.Run(test.name, 119 func(t *testing.T) { 120 req := &Request{ 121 Method: "POST", 122 Header: test.contentType, 123 Body: io.NopCloser(strings.NewReader("body")), 124 } 125 err := req.ParseForm() 126 switch { 127 case err == nil && test.wantErr != "": 128 t.Errorf("unexpected success; want error %q", test.wantErr) 129 case err != nil && test.wantErr == "": 130 t.Errorf("want success, got error: %v", err) 131 case test.wantErr != "" && test.wantErr != fmt.Sprint(err): 132 t.Errorf("got error %q; want %q", err, test.wantErr) 133 } 134 }, 135 ) 136 } 137 } 138 139 func TestParseFormInitializeOnError(t *testing.T) { 140 nilBody, _ := NewRequest("POST", "http://www.google.com/search?q=foo", nil) 141 tests := []*Request{ 142 nilBody, 143 {Method: "GET", URL: nil}, 144 } 145 for i, req := range tests { 146 err := req.ParseForm() 147 if req.Form == nil { 148 t.Errorf("%d. Form not initialized, error %v", i, err) 149 } 150 if req.PostForm == nil { 151 t.Errorf("%d. PostForm not initialized, error %v", i, err) 152 } 153 } 154 } 155 156 func TestMultipartReader(t *testing.T) { 157 tests := []struct { 158 shouldError bool 159 contentType string 160 }{ 161 {false, `multipart/form-data; boundary="foo123"`}, 162 {false, `multipart/mixed; boundary="foo123"`}, 163 {true, `text/plain`}, 164 } 165 166 for i, test := range tests { 167 req := &Request{ 168 Method: "POST", 169 Header: Header{"Content-Type": {test.contentType}}, 170 Body: io.NopCloser(new(bytes.Buffer)), 171 } 172 multipart, err := req.MultipartReader() 173 if test.shouldError { 174 if err == nil || multipart != nil { 175 t.Errorf("test %d: unexpectedly got nil-error (%v) or non-nil-multipart (%v)", i, err, multipart) 176 } 177 continue 178 } 179 if err != nil || multipart == nil { 180 t.Errorf("test %d: unexpectedly got error (%v) or nil-multipart (%v)", i, err, multipart) 181 } 182 } 183 } 184 185 // Issue 9305: ParseMultipartForm should populate PostForm too 186 func TestParseMultipartFormPopulatesPostForm(t *testing.T) { 187 postData := 188 `--xxx 189 Content-Disposition: form-data; name="field1" 190 191 value1 192 --xxx 193 Content-Disposition: form-data; name="field2" 194 195 value2 196 --xxx 197 Content-Disposition: form-data; name="file"; filename="file" 198 Content-Type: application/octet-stream 199 Content-Transfer-Encoding: binary 200 201 binary data 202 --xxx-- 203 ` 204 req := &Request{ 205 Method: "POST", 206 Header: Header{"Content-Type": {`multipart/form-data; boundary=xxx`}}, 207 Body: io.NopCloser(strings.NewReader(postData)), 208 } 209 210 initialFormItems := map[string]string{ 211 "language": "Go", 212 "name": "gopher", 213 "skill": "go-ing", 214 "field2": "initial-value2", 215 } 216 217 req.Form = make(url.Values) 218 for k, v := range initialFormItems { 219 req.Form.Add(k, v) 220 } 221 222 err := req.ParseMultipartForm(10000) 223 if err != nil { 224 t.Fatalf("unexpected multipart error %v", err) 225 } 226 227 wantForm := url.Values{ 228 "language": []string{"Go"}, 229 "name": []string{"gopher"}, 230 "skill": []string{"go-ing"}, 231 "field1": []string{"value1"}, 232 "field2": []string{"initial-value2", "value2"}, 233 } 234 if !reflect.DeepEqual(req.Form, wantForm) { 235 t.Fatalf("req.Form = %v, want %v", req.Form, wantForm) 236 } 237 238 wantPostForm := url.Values{ 239 "field1": []string{"value1"}, 240 "field2": []string{"value2"}, 241 } 242 if !reflect.DeepEqual(req.PostForm, wantPostForm) { 243 t.Fatalf("req.PostForm = %v, want %v", req.PostForm, wantPostForm) 244 } 245 } 246 247 func TestParseMultipartForm(t *testing.T) { 248 req := &Request{ 249 Method: "POST", 250 Header: Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}}, 251 Body: io.NopCloser(new(bytes.Buffer)), 252 } 253 err := req.ParseMultipartForm(25) 254 if err == nil { 255 t.Error("expected multipart EOF, got nil") 256 } 257 258 req.Header = Header{"Content-Type": {"text/plain"}} 259 err = req.ParseMultipartForm(25) 260 if err != ErrNotMultipart { 261 t.Error("expected ErrNotMultipart for text/plain") 262 } 263 } 264 265 // Issue 45789: multipart form should not include directory path in filename 266 func TestParseMultipartFormFilename(t *testing.T) { 267 postData := 268 `--xxx 269 Content-Disposition: form-data; name="file"; filename="../usr/foobar.txt/" 270 Content-Type: text/plain 271 272 --xxx-- 273 ` 274 req := &Request{ 275 Method: "POST", 276 Header: Header{"Content-Type": {`multipart/form-data; boundary=xxx`}}, 277 Body: io.NopCloser(strings.NewReader(postData)), 278 } 279 _, hdr, err := req.FormFile("file") 280 if err != nil { 281 t.Fatal(err) 282 } 283 if hdr.Filename != "foobar.txt" { 284 t.Errorf("expected only the last element of the path, got %q", hdr.Filename) 285 } 286 } 287 288 // Issue #40430: Test that if maxMemory for ParseMultipartForm when combined with 289 // the payload size and the internal leeway buffer size of 10MiB overflows, that we 290 // correctly return an error. 291 func TestMaxInt64ForMultipartFormMaxMemoryOverflow(t *testing.T) { 292 defer afterTest(t) 293 294 payloadSize := 1 << 10 295 cst := httptest.NewServer(HandlerFunc(func(rw ResponseWriter, req *Request) { 296 // The combination of: 297 // MaxInt64 + payloadSize + (internal spare of 10MiB) 298 // triggers the overflow. See issue https://golang.org/issue/40430/ 299 if err := req.ParseMultipartForm(math.MaxInt64); err != nil { 300 Error(rw, err.Error(), StatusBadRequest) 301 return 302 } 303 })) 304 defer cst.Close() 305 fBuf := new(bytes.Buffer) 306 mw := multipart.NewWriter(fBuf) 307 mf, err := mw.CreateFormFile("file", "myfile.txt") 308 if err != nil { 309 t.Fatal(err) 310 } 311 if _, err := mf.Write(bytes.Repeat([]byte("abc"), payloadSize)); err != nil { 312 t.Fatal(err) 313 } 314 if err := mw.Close(); err != nil { 315 t.Fatal(err) 316 } 317 req, err := NewRequest("POST", cst.URL, fBuf) 318 if err != nil { 319 t.Fatal(err) 320 } 321 req.Header.Set("Content-Type", mw.FormDataContentType()) 322 res, err := cst.Client().Do(req) 323 if err != nil { 324 t.Fatal(err) 325 } 326 res.Body.Close() 327 if g, w := res.StatusCode, StatusOK; g != w { 328 t.Fatalf("Status code mismatch: got %d, want %d", g, w) 329 } 330 } 331 332 func TestRedirect_h1(t *testing.T) { testRedirect(t, h1Mode) } 333 func TestRedirect_h2(t *testing.T) { testRedirect(t, h2Mode) } 334 func testRedirect(t *testing.T, h2 bool) { 335 defer afterTest(t) 336 cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) { 337 switch r.URL.Path { 338 case "/": 339 w.Header().Set("Location", "/foo/") 340 w.WriteHeader(StatusSeeOther) 341 case "/foo/": 342 fmt.Fprintf(w, "foo") 343 default: 344 w.WriteHeader(StatusBadRequest) 345 } 346 })) 347 defer cst.close() 348 349 var end = regexp.MustCompile("/foo/$") 350 r, err := cst.c.Get(cst.ts.URL) 351 if err != nil { 352 t.Fatal(err) 353 } 354 r.Body.Close() 355 url := r.Request.URL.String() 356 if r.StatusCode != 200 || !end.MatchString(url) { 357 t.Fatalf("Get got status %d at %q, want 200 matching /foo/$", r.StatusCode, url) 358 } 359 } 360 361 func TestSetBasicAuth(t *testing.T) { 362 r, _ := NewRequest("GET", "http://example.com/", nil) 363 r.SetBasicAuth("Aladdin", "open sesame") 364 if g, e := r.Header.Get("Authorization"), "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="; g != e { 365 t.Errorf("got header %q, want %q", g, e) 366 } 367 } 368 369 func TestMultipartRequest(t *testing.T) { 370 // Test that we can read the values and files of a 371 // multipart request with FormValue and FormFile, 372 // and that ParseMultipartForm can be called multiple times. 373 req := newTestMultipartRequest(t) 374 if err := req.ParseMultipartForm(25); err != nil { 375 t.Fatal("ParseMultipartForm first call:", err) 376 } 377 defer req.MultipartForm.RemoveAll() 378 validateTestMultipartContents(t, req, false) 379 if err := req.ParseMultipartForm(25); err != nil { 380 t.Fatal("ParseMultipartForm second call:", err) 381 } 382 validateTestMultipartContents(t, req, false) 383 } 384 385 // Issue #25192: Test that ParseMultipartForm fails but still parses the 386 // multi-part form when an URL containing a semicolon is provided. 387 func TestParseMultipartFormSemicolonSeparator(t *testing.T) { 388 req := newTestMultipartRequest(t) 389 req.URL = &url.URL{RawQuery: "q=foo;q=bar"} 390 if err := req.ParseMultipartForm(25); err == nil { 391 t.Fatal("ParseMultipartForm expected error due to invalid semicolon, got nil") 392 } 393 defer req.MultipartForm.RemoveAll() 394 validateTestMultipartContents(t, req, false) 395 } 396 397 func TestMultipartRequestAuto(t *testing.T) { 398 // Test that FormValue and FormFile automatically invoke 399 // ParseMultipartForm and return the right values. 400 req := newTestMultipartRequest(t) 401 defer func() { 402 if req.MultipartForm != nil { 403 req.MultipartForm.RemoveAll() 404 } 405 }() 406 validateTestMultipartContents(t, req, true) 407 } 408 409 func TestMissingFileMultipartRequest(t *testing.T) { 410 // Test that FormFile returns an error if 411 // the named file is missing. 412 req := newTestMultipartRequest(t) 413 testMissingFile(t, req) 414 } 415 416 // Test that FormValue invokes ParseMultipartForm. 417 func TestFormValueCallsParseMultipartForm(t *testing.T) { 418 req, _ := NewRequest("POST", "http://www.google.com/", strings.NewReader("z=post")) 419 req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value") 420 if req.Form != nil { 421 t.Fatal("Unexpected request Form, want nil") 422 } 423 req.FormValue("z") 424 if req.Form == nil { 425 t.Fatal("ParseMultipartForm not called by FormValue") 426 } 427 } 428 429 // Test that FormFile invokes ParseMultipartForm. 430 func TestFormFileCallsParseMultipartForm(t *testing.T) { 431 req := newTestMultipartRequest(t) 432 if req.Form != nil { 433 t.Fatal("Unexpected request Form, want nil") 434 } 435 req.FormFile("") 436 if req.Form == nil { 437 t.Fatal("ParseMultipartForm not called by FormFile") 438 } 439 } 440 441 // Test that ParseMultipartForm errors if called 442 // after MultipartReader on the same request. 443 func TestParseMultipartFormOrder(t *testing.T) { 444 req := newTestMultipartRequest(t) 445 if _, err := req.MultipartReader(); err != nil { 446 t.Fatalf("MultipartReader: %v", err) 447 } 448 if err := req.ParseMultipartForm(1024); err == nil { 449 t.Fatal("expected an error from ParseMultipartForm after call to MultipartReader") 450 } 451 } 452 453 // Test that MultipartReader errors if called 454 // after ParseMultipartForm on the same request. 455 func TestMultipartReaderOrder(t *testing.T) { 456 req := newTestMultipartRequest(t) 457 if err := req.ParseMultipartForm(25); err != nil { 458 t.Fatalf("ParseMultipartForm: %v", err) 459 } 460 defer req.MultipartForm.RemoveAll() 461 if _, err := req.MultipartReader(); err == nil { 462 t.Fatal("expected an error from MultipartReader after call to ParseMultipartForm") 463 } 464 } 465 466 // Test that FormFile errors if called after 467 // MultipartReader on the same request. 468 func TestFormFileOrder(t *testing.T) { 469 req := newTestMultipartRequest(t) 470 if _, err := req.MultipartReader(); err != nil { 471 t.Fatalf("MultipartReader: %v", err) 472 } 473 if _, _, err := req.FormFile(""); err == nil { 474 t.Fatal("expected an error from FormFile after call to MultipartReader") 475 } 476 } 477 478 var readRequestErrorTests = []struct { 479 in string 480 err string 481 482 header Header 483 }{ 484 0: {"GET / HTTP/1.1\r\nheader:foo\r\n\r\n", "", Header{"Header": {"foo"}}}, 485 1: {"GET / HTTP/1.1\r\nheader:foo\r\n", io.ErrUnexpectedEOF.Error(), nil}, 486 2: {"", io.EOF.Error(), nil}, 487 3: { 488 in: "HEAD / HTTP/1.1\r\nContent-Length:4\r\n\r\n", 489 err: "http: method cannot contain a Content-Length", 490 }, 491 4: { 492 in: "HEAD / HTTP/1.1\r\n\r\n", 493 header: Header{}, 494 }, 495 496 // Multiple Content-Length values should either be 497 // deduplicated if same or reject otherwise 498 // See Issue 16490. 499 5: { 500 in: "POST / HTTP/1.1\r\nContent-Length: 10\r\nContent-Length: 0\r\n\r\nGopher hey\r\n", 501 err: "cannot contain multiple Content-Length headers", 502 }, 503 6: { 504 in: "POST / HTTP/1.1\r\nContent-Length: 10\r\nContent-Length: 6\r\n\r\nGopher\r\n", 505 err: "cannot contain multiple Content-Length headers", 506 }, 507 7: { 508 in: "PUT / HTTP/1.1\r\nContent-Length: 6 \r\nContent-Length: 6\r\nContent-Length:6\r\n\r\nGopher\r\n", 509 err: "", 510 header: Header{"Content-Length": {"6"}}, 511 }, 512 8: { 513 in: "PUT / HTTP/1.1\r\nContent-Length: 1\r\nContent-Length: 6 \r\n\r\n", 514 err: "cannot contain multiple Content-Length headers", 515 }, 516 9: { 517 in: "POST / HTTP/1.1\r\nContent-Length:\r\nContent-Length: 3\r\n\r\n", 518 err: "cannot contain multiple Content-Length headers", 519 }, 520 10: { 521 in: "HEAD / HTTP/1.1\r\nContent-Length:0\r\nContent-Length: 0\r\n\r\n", 522 header: Header{"Content-Length": {"0"}}, 523 }, 524 11: { 525 in: "HEAD / HTTP/1.1\r\nHost: foo\r\nHost: bar\r\n\r\n\r\n\r\n", 526 err: "too many Host headers", 527 }, 528 } 529 530 func TestReadRequestErrors(t *testing.T) { 531 for i, tt := range readRequestErrorTests { 532 req, err := ReadRequest(bufio.NewReader(strings.NewReader(tt.in))) 533 if err == nil { 534 if tt.err != "" { 535 t.Errorf("#%d: got nil err; want %q", i, tt.err) 536 } 537 538 if !reflect.DeepEqual(tt.header, req.Header) { 539 t.Errorf("#%d: gotHeader: %q wantHeader: %q", i, req.Header, tt.header) 540 } 541 continue 542 } 543 544 if tt.err == "" || !strings.Contains(err.Error(), tt.err) { 545 t.Errorf("%d: got error = %v; want %v", i, err, tt.err) 546 } 547 } 548 } 549 550 var newRequestHostTests = []struct { 551 in, out string 552 }{ 553 {"http://www.example.com/", "www.example.com"}, 554 {"http://www.example.com:8080/", "www.example.com:8080"}, 555 556 {"http://192.168.0.1/", "192.168.0.1"}, 557 {"http://192.168.0.1:8080/", "192.168.0.1:8080"}, 558 {"http://192.168.0.1:/", "192.168.0.1"}, 559 560 {"http://[fe80::1]/", "[fe80::1]"}, 561 {"http://[fe80::1]:8080/", "[fe80::1]:8080"}, 562 {"http://[fe80::1%25en0]/", "[fe80::1%en0]"}, 563 {"http://[fe80::1%25en0]:8080/", "[fe80::1%en0]:8080"}, 564 {"http://[fe80::1%25en0]:/", "[fe80::1%en0]"}, 565 } 566 567 func TestNewRequestHost(t *testing.T) { 568 for i, tt := range newRequestHostTests { 569 req, err := NewRequest("GET", tt.in, nil) 570 if err != nil { 571 t.Errorf("#%v: %v", i, err) 572 continue 573 } 574 if req.Host != tt.out { 575 t.Errorf("got %q; want %q", req.Host, tt.out) 576 } 577 } 578 } 579 580 func TestRequestInvalidMethod(t *testing.T) { 581 _, err := NewRequest("bad method", "http://foo.com/", nil) 582 if err == nil { 583 t.Error("expected error from NewRequest with invalid method") 584 } 585 req, err := NewRequest("GET", "http://foo.example/", nil) 586 if err != nil { 587 t.Fatal(err) 588 } 589 req.Method = "bad method" 590 _, err = DefaultClient.Do(req) 591 if err == nil || !strings.Contains(err.Error(), "invalid method") { 592 t.Errorf("Transport error = %v; want invalid method", err) 593 } 594 595 req, err = NewRequest("", "http://foo.com/", nil) 596 if err != nil { 597 t.Errorf("NewRequest(empty method) = %v; want nil", err) 598 } else if req.Method != "GET" { 599 t.Errorf("NewRequest(empty method) has method %q; want GET", req.Method) 600 } 601 } 602 603 func TestNewRequestContentLength(t *testing.T) { 604 readByte := func(r io.Reader) io.Reader { 605 var b [1]byte 606 r.Read(b[:]) 607 return r 608 } 609 tests := []struct { 610 r io.Reader 611 want int64 612 }{ 613 {bytes.NewReader([]byte("123")), 3}, 614 {bytes.NewBuffer([]byte("1234")), 4}, 615 {strings.NewReader("12345"), 5}, 616 {strings.NewReader(""), 0}, 617 {NoBody, 0}, 618 619 // Not detected. During Go 1.8 we tried to make these set to -1, but 620 // due to Issue 18117, we keep these returning 0, even though they're 621 // unknown. 622 {struct{ io.Reader }{strings.NewReader("xyz")}, 0}, 623 {io.NewSectionReader(strings.NewReader("x"), 0, 6), 0}, 624 {readByte(io.NewSectionReader(strings.NewReader("xy"), 0, 6)), 0}, 625 } 626 for i, tt := range tests { 627 req, err := NewRequest("POST", "http://localhost/", tt.r) 628 if err != nil { 629 t.Fatal(err) 630 } 631 if req.ContentLength != tt.want { 632 t.Errorf("test[%d]: ContentLength(%T) = %d; want %d", i, tt.r, req.ContentLength, tt.want) 633 } 634 } 635 } 636 637 var parseHTTPVersionTests = []struct { 638 vers string 639 major, minor int 640 ok bool 641 }{ 642 {"HTTP/0.9", 0, 9, true}, 643 {"HTTP/1.0", 1, 0, true}, 644 {"HTTP/1.1", 1, 1, true}, 645 {"HTTP/3.14", 3, 14, true}, 646 647 {"HTTP", 0, 0, false}, 648 {"HTTP/one.one", 0, 0, false}, 649 {"HTTP/1.1/", 0, 0, false}, 650 {"HTTP/-1,0", 0, 0, false}, 651 {"HTTP/0,-1", 0, 0, false}, 652 {"HTTP/", 0, 0, false}, 653 {"HTTP/1,1", 0, 0, false}, 654 } 655 656 func TestParseHTTPVersion(t *testing.T) { 657 for _, tt := range parseHTTPVersionTests { 658 major, minor, ok := ParseHTTPVersion(tt.vers) 659 if ok != tt.ok || major != tt.major || minor != tt.minor { 660 type version struct { 661 major, minor int 662 ok bool 663 } 664 t.Errorf("failed to parse %q, expected: %#v, got %#v", tt.vers, version{tt.major, tt.minor, tt.ok}, version{major, minor, ok}) 665 } 666 } 667 } 668 669 type getBasicAuthTest struct { 670 username, password string 671 ok bool 672 } 673 674 type basicAuthCredentialsTest struct { 675 username, password string 676 } 677 678 var getBasicAuthTests = []struct { 679 username, password string 680 ok bool 681 }{ 682 {"Aladdin", "open sesame", true}, 683 {"Aladdin", "open:sesame", true}, 684 {"", "", true}, 685 } 686 687 func TestGetBasicAuth(t *testing.T) { 688 for _, tt := range getBasicAuthTests { 689 r, _ := NewRequest("GET", "http://example.com/", nil) 690 r.SetBasicAuth(tt.username, tt.password) 691 username, password, ok := r.BasicAuth() 692 if ok != tt.ok || username != tt.username || password != tt.password { 693 t.Errorf("BasicAuth() = %#v, want %#v", getBasicAuthTest{username, password, ok}, 694 getBasicAuthTest{tt.username, tt.password, tt.ok}) 695 } 696 } 697 // Unauthenticated request. 698 r, _ := NewRequest("GET", "http://example.com/", nil) 699 username, password, ok := r.BasicAuth() 700 if ok { 701 t.Errorf("expected false from BasicAuth when the request is unauthenticated") 702 } 703 want := basicAuthCredentialsTest{"", ""} 704 if username != want.username || password != want.password { 705 t.Errorf("expected credentials: %#v when the request is unauthenticated, got %#v", 706 want, basicAuthCredentialsTest{username, password}) 707 } 708 } 709 710 var parseBasicAuthTests = []struct { 711 header, username, password string 712 ok bool 713 }{ 714 {"Basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true}, 715 716 // Case doesn't matter: 717 {"BASIC " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true}, 718 {"basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true}, 719 720 {"Basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open:sesame")), "Aladdin", "open:sesame", true}, 721 {"Basic " + base64.StdEncoding.EncodeToString([]byte(":")), "", "", true}, 722 {"Basic" + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "", "", false}, 723 {base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "", "", false}, 724 {"Basic ", "", "", false}, 725 {"Basic Aladdin:open sesame", "", "", false}, 726 {`Digest username="Aladdin"`, "", "", false}, 727 } 728 729 func TestParseBasicAuth(t *testing.T) { 730 for _, tt := range parseBasicAuthTests { 731 r, _ := NewRequest("GET", "http://example.com/", nil) 732 r.Header.Set("Authorization", tt.header) 733 username, password, ok := r.BasicAuth() 734 if ok != tt.ok || username != tt.username || password != tt.password { 735 t.Errorf("BasicAuth() = %#v, want %#v", getBasicAuthTest{username, password, ok}, 736 getBasicAuthTest{tt.username, tt.password, tt.ok}) 737 } 738 } 739 } 740 741 type logWrites struct { 742 t *testing.T 743 dst *[]string 744 } 745 746 func (l logWrites) WriteByte(c byte) error { 747 l.t.Fatalf("unexpected WriteByte call") 748 return nil 749 } 750 751 func (l logWrites) Write(p []byte) (n int, err error) { 752 *l.dst = append(*l.dst, string(p)) 753 return len(p), nil 754 } 755 756 func TestRequestWriteBufferedWriter(t *testing.T) { 757 got := []string{} 758 req, _ := NewRequest("GET", "http://foo.com/", nil) 759 req.Write(logWrites{t, &got}) 760 want := []string{ 761 "GET / HTTP/1.1\r\n", 762 "Host: foo.com\r\n", 763 "User-Agent: " + DefaultUserAgent + "\r\n", 764 "\r\n", 765 } 766 if !reflect.DeepEqual(got, want) { 767 t.Errorf("Writes = %q\n Want = %q", got, want) 768 } 769 } 770 771 func TestRequestBadHost(t *testing.T) { 772 got := []string{} 773 req, err := NewRequest("GET", "http://foo/after", nil) 774 if err != nil { 775 t.Fatal(err) 776 } 777 req.Host = "foo.com with spaces" 778 req.URL.Host = "foo.com with spaces" 779 req.Write(logWrites{t, &got}) 780 want := []string{ 781 "GET /after HTTP/1.1\r\n", 782 "Host: foo.com\r\n", 783 "User-Agent: " + DefaultUserAgent + "\r\n", 784 "\r\n", 785 } 786 if !reflect.DeepEqual(got, want) { 787 t.Errorf("Writes = %q\n Want = %q", got, want) 788 } 789 } 790 791 func TestStarRequest(t *testing.T) { 792 req, err := ReadRequest(bufio.NewReader(strings.NewReader("M-SEARCH * HTTP/1.1\r\n\r\n"))) 793 if err != nil { 794 return 795 } 796 if req.ContentLength != 0 { 797 t.Errorf("ContentLength = %d; want 0", req.ContentLength) 798 } 799 if req.Body == nil { 800 t.Errorf("Body = nil; want non-nil") 801 } 802 803 // Request.Write has Client semantics for Body/ContentLength, 804 // where ContentLength 0 means unknown if Body is non-nil, and 805 // thus chunking will happen unless we change semantics and 806 // signal that we want to serialize it as exactly zero. The 807 // only way to do that for outbound requests is with a nil 808 // Body: 809 clientReq := *req 810 clientReq.Body = nil 811 812 var out bytes.Buffer 813 if err := clientReq.Write(&out); err != nil { 814 t.Fatal(err) 815 } 816 817 if strings.Contains(out.String(), "chunked") { 818 t.Error("wrote chunked request; want no body") 819 } 820 back, err := ReadRequest(bufio.NewReader(bytes.NewReader(out.Bytes()))) 821 if err != nil { 822 t.Fatal(err) 823 } 824 // Ignore the Headers (the User-Agent breaks the deep equal, 825 // but we don't care about it) 826 req.Header = nil 827 back.Header = nil 828 if !reflect.DeepEqual(req, back) { 829 t.Errorf("Original request doesn't match Request read back.") 830 t.Logf("Original: %#v", req) 831 t.Logf("Original.URL: %#v", req.URL) 832 t.Logf("Wrote: %s", out.Bytes()) 833 t.Logf("Read back (doesn't match Original): %#v", back) 834 } 835 } 836 837 type responseWriterJustWriter struct { 838 io.Writer 839 } 840 841 func (responseWriterJustWriter) Header() Header { panic("should not be called") } 842 func (responseWriterJustWriter) WriteHeader(int) { panic("should not be called") } 843 844 // delayedEOFReader never returns (n > 0, io.EOF), instead putting 845 // off the io.EOF until a subsequent Read call. 846 type delayedEOFReader struct { 847 r io.Reader 848 } 849 850 func (dr delayedEOFReader) Read(p []byte) (n int, err error) { 851 n, err = dr.r.Read(p) 852 if n > 0 && err == io.EOF { 853 err = nil 854 } 855 return 856 } 857 858 func TestIssue10884_MaxBytesEOF(t *testing.T) { 859 dst := io.Discard 860 _, err := io.Copy(dst, MaxBytesReader( 861 responseWriterJustWriter{dst}, 862 io.NopCloser(delayedEOFReader{strings.NewReader("12345")}), 863 5)) 864 if err != nil { 865 t.Fatal(err) 866 } 867 } 868 869 // Issue 14981: MaxBytesReader's return error wasn't sticky. It 870 // doesn't technically need to be, but people expected it to be. 871 func TestMaxBytesReaderStickyError(t *testing.T) { 872 isSticky := func(r io.Reader) error { 873 var log bytes.Buffer 874 buf := make([]byte, 1000) 875 var firstErr error 876 for { 877 n, err := r.Read(buf) 878 fmt.Fprintf(&log, "Read(%d) = %d, %v\n", len(buf), n, err) 879 if err == nil { 880 continue 881 } 882 if firstErr == nil { 883 firstErr = err 884 continue 885 } 886 if !reflect.DeepEqual(err, firstErr) { 887 return fmt.Errorf("non-sticky error. got log:\n%s", log.Bytes()) 888 } 889 t.Logf("Got log: %s", log.Bytes()) 890 return nil 891 } 892 } 893 tests := [...]struct { 894 readable int 895 limit int64 896 }{ 897 0: {99, 100}, 898 1: {100, 100}, 899 2: {101, 100}, 900 } 901 for i, tt := range tests { 902 rc := MaxBytesReader(nil, io.NopCloser(bytes.NewReader(make([]byte, tt.readable))), tt.limit) 903 if err := isSticky(rc); err != nil { 904 t.Errorf("%d. error: %v", i, err) 905 } 906 } 907 } 908 909 // Issue 45101: maxBytesReader's Read panicked when n < -1. This test 910 // also ensures that Read treats negative limits as equivalent to 0. 911 func TestMaxBytesReaderDifferentLimits(t *testing.T) { 912 const testStr = "1234" 913 tests := [...]struct { 914 limit int64 915 lenP int 916 wantN int 917 wantErr bool 918 }{ 919 0: { 920 limit: -123, 921 lenP: 0, 922 wantN: 0, 923 wantErr: false, // Ensure we won't return an error when the limit is negative, but we don't need to read. 924 }, 925 1: { 926 limit: -100, 927 lenP: 32 * 1024, 928 wantN: 0, 929 wantErr: true, 930 }, 931 2: { 932 limit: -2, 933 lenP: 1, 934 wantN: 0, 935 wantErr: true, 936 }, 937 3: { 938 limit: -1, 939 lenP: 2, 940 wantN: 0, 941 wantErr: true, 942 }, 943 4: { 944 limit: 0, 945 lenP: 3, 946 wantN: 0, 947 wantErr: true, 948 }, 949 5: { 950 limit: 1, 951 lenP: 4, 952 wantN: 1, 953 wantErr: true, 954 }, 955 6: { 956 limit: 2, 957 lenP: 5, 958 wantN: 2, 959 wantErr: true, 960 }, 961 7: { 962 limit: 3, 963 lenP: 2, 964 wantN: 2, 965 wantErr: false, 966 }, 967 8: { 968 limit: int64(len(testStr)), 969 lenP: len(testStr), 970 wantN: len(testStr), 971 wantErr: false, 972 }, 973 9: { 974 limit: 100, 975 lenP: 6, 976 wantN: len(testStr), 977 wantErr: false, 978 }, 979 } 980 for i, tt := range tests { 981 rc := MaxBytesReader(nil, io.NopCloser(strings.NewReader(testStr)), tt.limit) 982 983 n, err := rc.Read(make([]byte, tt.lenP)) 984 985 if n != tt.wantN { 986 t.Errorf("%d. n: %d, want n: %d", i, n, tt.wantN) 987 } 988 989 if (err != nil) != tt.wantErr { 990 t.Errorf("%d. error: %v", i, err) 991 } 992 } 993 } 994 995 func TestWithContextDeepCopiesURL(t *testing.T) { 996 req, err := NewRequest("POST", "https://golang.org/", nil) 997 if err != nil { 998 t.Fatal(err) 999 } 1000 1001 reqCopy := req.WithContext(context.Background()) 1002 reqCopy.URL.Scheme = "http" 1003 1004 firstURL, secondURL := req.URL.String(), reqCopy.URL.String() 1005 if firstURL == secondURL { 1006 t.Errorf("unexpected change to original request's URL") 1007 } 1008 1009 // And also check we don't crash on nil (Issue 20601) 1010 req.URL = nil 1011 reqCopy = req.WithContext(context.Background()) 1012 if reqCopy.URL != nil { 1013 t.Error("expected nil URL in cloned request") 1014 } 1015 } 1016 1017 // Ensure that Request.Clone creates a deep copy of TransferEncoding. 1018 // See issue 41907. 1019 func TestRequestCloneTransferEncoding(t *testing.T) { 1020 body := strings.NewReader("body") 1021 req, _ := NewRequest("POST", "https://example.org/", body) 1022 req.TransferEncoding = []string{ 1023 "encoding1", 1024 } 1025 1026 clonedReq := req.Clone(context.Background()) 1027 // modify original after deep copy 1028 req.TransferEncoding[0] = "encoding2" 1029 1030 if req.TransferEncoding[0] != "encoding2" { 1031 t.Error("expected req.TransferEncoding to be changed") 1032 } 1033 if clonedReq.TransferEncoding[0] != "encoding1" { 1034 t.Error("expected clonedReq.TransferEncoding to be unchanged") 1035 } 1036 } 1037 1038 func TestNoPanicOnRoundTripWithBasicAuth_h1(t *testing.T) { 1039 testNoPanicWithBasicAuth(t, h1Mode) 1040 } 1041 1042 func TestNoPanicOnRoundTripWithBasicAuth_h2(t *testing.T) { 1043 testNoPanicWithBasicAuth(t, h2Mode) 1044 } 1045 1046 // Issue 34878: verify we don't panic when including basic auth (Go 1.13 regression) 1047 func testNoPanicWithBasicAuth(t *testing.T, h2 bool) { 1048 defer afterTest(t) 1049 cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {})) 1050 defer cst.close() 1051 1052 u, err := url.Parse(cst.ts.URL) 1053 if err != nil { 1054 t.Fatal(err) 1055 } 1056 u.User = url.UserPassword("foo", "bar") 1057 req := &Request{ 1058 URL: u, 1059 Method: "GET", 1060 } 1061 if _, err := cst.c.Do(req); err != nil { 1062 t.Fatalf("Unexpected error: %v", err) 1063 } 1064 } 1065 1066 // verify that NewRequest sets Request.GetBody and that it works 1067 func TestNewRequestGetBody(t *testing.T) { 1068 tests := []struct { 1069 r io.Reader 1070 }{ 1071 {r: strings.NewReader("hello")}, 1072 {r: bytes.NewReader([]byte("hello"))}, 1073 {r: bytes.NewBuffer([]byte("hello"))}, 1074 } 1075 for i, tt := range tests { 1076 req, err := NewRequest("POST", "http://foo.tld/", tt.r) 1077 if err != nil { 1078 t.Errorf("test[%d]: %v", i, err) 1079 continue 1080 } 1081 if req.Body == nil { 1082 t.Errorf("test[%d]: Body = nil", i) 1083 continue 1084 } 1085 if req.GetBody == nil { 1086 t.Errorf("test[%d]: GetBody = nil", i) 1087 continue 1088 } 1089 slurp1, err := io.ReadAll(req.Body) 1090 if err != nil { 1091 t.Errorf("test[%d]: ReadAll(Body) = %v", i, err) 1092 } 1093 newBody, err := req.GetBody() 1094 if err != nil { 1095 t.Errorf("test[%d]: GetBody = %v", i, err) 1096 } 1097 slurp2, err := io.ReadAll(newBody) 1098 if err != nil { 1099 t.Errorf("test[%d]: ReadAll(GetBody()) = %v", i, err) 1100 } 1101 if string(slurp1) != string(slurp2) { 1102 t.Errorf("test[%d]: Body %q != GetBody %q", i, slurp1, slurp2) 1103 } 1104 } 1105 } 1106 1107 func testMissingFile(t *testing.T, req *Request) { 1108 f, fh, err := req.FormFile("missing") 1109 if f != nil { 1110 t.Errorf("FormFile file = %v, want nil", f) 1111 } 1112 if fh != nil { 1113 t.Errorf("FormFile file header = %q, want nil", fh) 1114 } 1115 if err != ErrMissingFile { 1116 t.Errorf("FormFile err = %q, want ErrMissingFile", err) 1117 } 1118 } 1119 1120 func newTestMultipartRequest(t *testing.T) *Request { 1121 b := strings.NewReader(strings.ReplaceAll(message, "\n", "\r\n")) 1122 req, err := NewRequest("POST", "/", b) 1123 if err != nil { 1124 t.Fatal("NewRequest:", err) 1125 } 1126 ctype := fmt.Sprintf(`multipart/form-data; boundary="%s"`, boundary) 1127 req.Header.Set("Content-type", ctype) 1128 return req 1129 } 1130 1131 func validateTestMultipartContents(t *testing.T, req *Request, allMem bool) { 1132 if g, e := req.FormValue("texta"), textaValue; g != e { 1133 t.Errorf("texta value = %q, want %q", g, e) 1134 } 1135 if g, e := req.FormValue("textb"), textbValue; g != e { 1136 t.Errorf("textb value = %q, want %q", g, e) 1137 } 1138 if g := req.FormValue("missing"); g != "" { 1139 t.Errorf("missing value = %q, want empty string", g) 1140 } 1141 1142 assertMem := func(n string, fd multipart.File) { 1143 if _, ok := fd.(*os.File); ok { 1144 t.Error(n, " is *os.File, should not be") 1145 } 1146 } 1147 fda := testMultipartFile(t, req, "filea", "filea.txt", fileaContents) 1148 defer fda.Close() 1149 assertMem("filea", fda) 1150 fdb := testMultipartFile(t, req, "fileb", "fileb.txt", filebContents) 1151 defer fdb.Close() 1152 if allMem { 1153 assertMem("fileb", fdb) 1154 } else { 1155 if _, ok := fdb.(*os.File); !ok { 1156 t.Errorf("fileb has unexpected underlying type %T", fdb) 1157 } 1158 } 1159 1160 testMissingFile(t, req) 1161 } 1162 1163 func testMultipartFile(t *testing.T, req *Request, key, expectFilename, expectContent string) multipart.File { 1164 f, fh, err := req.FormFile(key) 1165 if err != nil { 1166 t.Fatalf("FormFile(%q): %q", key, err) 1167 } 1168 if fh.Filename != expectFilename { 1169 t.Errorf("filename = %q, want %q", fh.Filename, expectFilename) 1170 } 1171 var b bytes.Buffer 1172 _, err = io.Copy(&b, f) 1173 if err != nil { 1174 t.Fatal("copying contents:", err) 1175 } 1176 if g := b.String(); g != expectContent { 1177 t.Errorf("contents = %q, want %q", g, expectContent) 1178 } 1179 return f 1180 } 1181 1182 const ( 1183 fileaContents = "This is a test file." 1184 filebContents = "Another test file." 1185 textaValue = "foo" 1186 textbValue = "bar" 1187 boundary = `MyBoundary` 1188 ) 1189 1190 const message = ` 1191 --MyBoundary 1192 Content-Disposition: form-data; name="filea"; filename="filea.txt" 1193 Content-Type: text/plain 1194 1195 ` + fileaContents + ` 1196 --MyBoundary 1197 Content-Disposition: form-data; name="fileb"; filename="fileb.txt" 1198 Content-Type: text/plain 1199 1200 ` + filebContents + ` 1201 --MyBoundary 1202 Content-Disposition: form-data; name="texta" 1203 1204 ` + textaValue + ` 1205 --MyBoundary 1206 Content-Disposition: form-data; name="textb" 1207 1208 ` + textbValue + ` 1209 --MyBoundary-- 1210 ` 1211 1212 func benchmarkReadRequest(b *testing.B, request string) { 1213 request = request + "\n" // final \n 1214 request = strings.ReplaceAll(request, "\n", "\r\n") // expand \n to \r\n 1215 b.SetBytes(int64(len(request))) 1216 r := bufio.NewReader(&infiniteReader{buf: []byte(request)}) 1217 b.ReportAllocs() 1218 b.ResetTimer() 1219 for i := 0; i < b.N; i++ { 1220 _, err := ReadRequest(r) 1221 if err != nil { 1222 b.Fatalf("failed to read request: %v", err) 1223 } 1224 } 1225 } 1226 1227 // infiniteReader satisfies Read requests as if the contents of buf 1228 // loop indefinitely. 1229 type infiniteReader struct { 1230 buf []byte 1231 offset int 1232 } 1233 1234 func (r *infiniteReader) Read(b []byte) (int, error) { 1235 n := copy(b, r.buf[r.offset:]) 1236 r.offset = (r.offset + n) % len(r.buf) 1237 return n, nil 1238 } 1239 1240 func BenchmarkReadRequestChrome(b *testing.B) { 1241 // https://github.com/felixge/node-http-perf/blob/master/fixtures/get.http 1242 benchmarkReadRequest(b, `GET / HTTP/1.1 1243 Host: localhost:8080 1244 Connection: keep-alive 1245 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8 1246 User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1312.52 Safari/537.17 1247 Accept-Encoding: gzip,deflate,sdch 1248 Accept-Language: en-US,en;q=0.8 1249 Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3 1250 Cookie: __utma=1.1978842379.1323102373.1323102373.1323102373.1; EPi:NumberOfVisits=1,2012-02-28T13:42:18; CrmSession=5b707226b9563e1bc69084d07a107c98; plushContainerWidth=100%25; plushNoTopMenu=0; hudson_auto_refresh=false 1251 `) 1252 } 1253 1254 func BenchmarkReadRequestCurl(b *testing.B) { 1255 // curl http://localhost:8080/ 1256 benchmarkReadRequest(b, `GET / HTTP/1.1 1257 User-Agent: curl/7.27.0 1258 Host: localhost:8080 1259 Accept: */* 1260 `) 1261 } 1262 1263 func BenchmarkReadRequestApachebench(b *testing.B) { 1264 // ab -n 1 -c 1 http://localhost:8080/ 1265 benchmarkReadRequest(b, `GET / HTTP/1.0 1266 Host: localhost:8080 1267 User-Agent: ApacheBench/2.3 1268 Accept: */* 1269 `) 1270 } 1271 1272 func BenchmarkReadRequestSiege(b *testing.B) { 1273 // siege -r 1 -c 1 http://localhost:8080/ 1274 benchmarkReadRequest(b, `GET / HTTP/1.1 1275 Host: localhost:8080 1276 Accept: */* 1277 Accept-Encoding: gzip 1278 User-Agent: JoeDog/1.00 [en] (X11; I; Siege 2.70) 1279 Connection: keep-alive 1280 `) 1281 } 1282 1283 func BenchmarkReadRequestWrk(b *testing.B) { 1284 // wrk -t 1 -r 1 -c 1 http://localhost:8080/ 1285 benchmarkReadRequest(b, `GET / HTTP/1.1 1286 Host: localhost:8080 1287 `) 1288 } 1289 1290 const ( 1291 withTLS = true 1292 noTLS = false 1293 ) 1294 1295 func BenchmarkFileAndServer_1KB(b *testing.B) { 1296 benchmarkFileAndServer(b, 1<<10) 1297 } 1298 1299 func BenchmarkFileAndServer_16MB(b *testing.B) { 1300 benchmarkFileAndServer(b, 1<<24) 1301 } 1302 1303 func BenchmarkFileAndServer_64MB(b *testing.B) { 1304 benchmarkFileAndServer(b, 1<<26) 1305 } 1306 1307 func benchmarkFileAndServer(b *testing.B, n int64) { 1308 f, err := os.CreateTemp(os.TempDir(), "go-bench-http-file-and-server") 1309 if err != nil { 1310 b.Fatalf("Failed to create temp file: %v", err) 1311 } 1312 1313 defer func() { 1314 f.Close() 1315 os.RemoveAll(f.Name()) 1316 }() 1317 1318 if _, err := io.CopyN(f, rand.Reader, n); err != nil { 1319 b.Fatalf("Failed to copy %d bytes: %v", n, err) 1320 } 1321 1322 b.Run("NoTLS", func(b *testing.B) { 1323 runFileAndServerBenchmarks(b, noTLS, f, n) 1324 }) 1325 1326 b.Run("TLS", func(b *testing.B) { 1327 runFileAndServerBenchmarks(b, withTLS, f, n) 1328 }) 1329 } 1330 1331 func runFileAndServerBenchmarks(b *testing.B, tlsOption bool, f *os.File, n int64) { 1332 handler := HandlerFunc(func(rw ResponseWriter, req *Request) { 1333 defer req.Body.Close() 1334 nc, err := io.Copy(io.Discard, req.Body) 1335 if err != nil { 1336 panic(err) 1337 } 1338 1339 if nc != n { 1340 panic(fmt.Errorf("Copied %d Wanted %d bytes", nc, n)) 1341 } 1342 }) 1343 1344 var cst *httptest.Server 1345 if tlsOption == withTLS { 1346 cst = httptest.NewTLSServer(handler) 1347 } else { 1348 cst = httptest.NewServer(handler) 1349 } 1350 1351 defer cst.Close() 1352 b.ResetTimer() 1353 for i := 0; i < b.N; i++ { 1354 // Perform some setup. 1355 b.StopTimer() 1356 if _, err := f.Seek(0, 0); err != nil { 1357 b.Fatalf("Failed to seek back to file: %v", err) 1358 } 1359 1360 b.StartTimer() 1361 req, err := NewRequest("PUT", cst.URL, io.NopCloser(f)) 1362 if err != nil { 1363 b.Fatal(err) 1364 } 1365 1366 req.ContentLength = n 1367 // Prevent mime sniffing by setting the Content-Type. 1368 req.Header.Set("Content-Type", "application/octet-stream") 1369 res, err := cst.Client().Do(req) 1370 if err != nil { 1371 b.Fatalf("Failed to make request to backend: %v", err) 1372 } 1373 1374 res.Body.Close() 1375 b.SetBytes(n) 1376 } 1377 }