libgo/go/net/http/request_test.go

   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         "encoding/base64"
  12         "fmt"
  13         "io"
  14         "io/ioutil"
  15         "mime/multipart"
  16         . "net/http"
  17         "net/url"
  18         "os"
  19         "reflect"
  20         "regexp"
  21         "strings"
  22         "testing"
  23 )
  24
  25 func TestQuery(t *testing.T) {
  26         req := &Request{Method: "GET"}
  27         req.URL, _ = url.Parse("http://www.google.com/search?q=foo&q=bar")
  28         if q := req.FormValue("q"); q != "foo" {
  29                 t.Errorf(`req.FormValue("q") = %q, want "foo"`, q)
  30         }
  31 }
  32
  33 func TestParseFormQuery(t *testing.T) {
  34         req, _ := NewRequest("POST", "http://www.google.com/search?q=foo&q=bar&both=x&prio=1&orphan=nope&empty=not",
  35                 strings.NewReader("z=post&both=y&prio=2&=nokey&orphan;empty=&"))
  36         req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
  37
  38         if q := req.FormValue("q"); q != "foo" {
  39                 t.Errorf(`req.FormValue("q") = %q, want "foo"`, q)
  40         }
  41         if z := req.FormValue("z"); z != "post" {
  42                 t.Errorf(`req.FormValue("z") = %q, want "post"`, z)
  43         }
  44         if bq, found := req.PostForm["q"]; found {
  45                 t.Errorf(`req.PostForm["q"] = %q, want no entry in map`, bq)
  46         }
  47         if bz := req.PostFormValue("z"); bz != "post" {
  48                 t.Errorf(`req.PostFormValue("z") = %q, want "post"`, bz)
  49         }
  50         if qs := req.Form["q"]; !reflect.DeepEqual(qs, []string{"foo", "bar"}) {
  51                 t.Errorf(`req.Form["q"] = %q, want ["foo", "bar"]`, qs)
  52         }
  53         if both := req.Form["both"]; !reflect.DeepEqual(both, []string{"y", "x"}) {
  54                 t.Errorf(`req.Form["both"] = %q, want ["y", "x"]`, both)
  55         }
  56         if prio := req.FormValue("prio"); prio != "2" {
  57                 t.Errorf(`req.FormValue("prio") = %q, want "2" (from body)`, prio)
  58         }
  59         if orphan := req.Form["orphan"]; !reflect.DeepEqual(orphan, []string{"", "nope"}) {
  60                 t.Errorf(`req.FormValue("orphan") = %q, want "" (from body)`, orphan)
  61         }
  62         if empty := req.Form["empty"]; !reflect.DeepEqual(empty, []string{"", "not"}) {
  63                 t.Errorf(`req.FormValue("empty") = %q, want "" (from body)`, empty)
  64         }
  65         if nokey := req.Form[""]; !reflect.DeepEqual(nokey, []string{"nokey"}) {
  66                 t.Errorf(`req.FormValue("nokey") = %q, want "nokey" (from body)`, nokey)
  67         }
  68 }
  69
  70 // Tests that we only parse the form automatically for certain methods.
  71 func TestParseFormQueryMethods(t *testing.T) {
  72         for _, method := range []string{"POST", "PATCH", "PUT", "FOO"} {
  73                 req, _ := NewRequest(method, "http://www.google.com/search",
  74                         strings.NewReader("foo=bar"))
  75                 req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
  76                 want := "bar"
  77                 if method == "FOO" {
  78                         want = ""
  79                 }
  80                 if got := req.FormValue("foo"); got != want {
  81                         t.Errorf(`for method %s, FormValue("foo") = %q; want %q`, method, got, want)
  82                 }
  83         }
  84 }
  85
  86 type stringMap map[string][]string
  87 type parseContentTypeTest struct {
  88         shouldError bool
  89         contentType stringMap
  90 }
  91
  92 var parseContentTypeTests = []parseContentTypeTest{
  93         {false, stringMap{"Content-Type": {"text/plain"}}},
  94         // Empty content type is legal - may be treated as
  95         // application/octet-stream (RFC 7231, section 3.1.1.5)
  96         {false, stringMap{}},
  97         {true, stringMap{"Content-Type": {"text/plain; boundary="}}},
  98         {false, stringMap{"Content-Type": {"application/unknown"}}},
  99 }
 100
 101 func TestParseFormUnknownContentType(t *testing.T) {
 102         for i, test := range parseContentTypeTests {
 103                 req := &Request{
 104                         Method: "POST",
 105                         Header: Header(test.contentType),
 106                         Body:   ioutil.NopCloser(strings.NewReader("body")),
 107                 }
 108                 err := req.ParseForm()
 109                 switch {
 110                 case err == nil && test.shouldError:
 111                         t.Errorf("test %d should have returned error", i)
 112                 case err != nil && !test.shouldError:
 113                         t.Errorf("test %d should not have returned error, got %v", i, err)
 114                 }
 115         }
 116 }
 117
 118 func TestParseFormInitializeOnError(t *testing.T) {
 119         nilBody, _ := NewRequest("POST", "http://www.google.com/search?q=foo", nil)
 120         tests := []*Request{
 121                 nilBody,
 122                 {Method: "GET", URL: nil},
 123         }
 124         for i, req := range tests {
 125                 err := req.ParseForm()
 126                 if req.Form == nil {
 127                         t.Errorf("%d. Form not initialized, error %v", i, err)
 128                 }
 129                 if req.PostForm == nil {
 130                         t.Errorf("%d. PostForm not initialized, error %v", i, err)
 131                 }
 132         }
 133 }
 134
 135 func TestMultipartReader(t *testing.T) {
 136         req := &Request{
 137                 Method: "POST",
 138                 Header: Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
 139                 Body:   ioutil.NopCloser(new(bytes.Buffer)),
 140         }
 141         multipart, err := req.MultipartReader()
 142         if multipart == nil {
 143                 t.Errorf("expected multipart; error: %v", err)
 144         }
 145
 146         req = &Request{
 147                 Method: "POST",
 148                 Header: Header{"Content-Type": {`multipart/mixed; boundary="foo123"`}},
 149                 Body:   ioutil.NopCloser(new(bytes.Buffer)),
 150         }
 151         multipart, err = req.MultipartReader()
 152         if multipart == nil {
 153                 t.Errorf("expected multipart; error: %v", err)
 154         }
 155
 156         req.Header = Header{"Content-Type": {"text/plain"}}
 157         multipart, err = req.MultipartReader()
 158         if multipart != nil {
 159                 t.Error("unexpected multipart for text/plain")
 160         }
 161 }
 162
 163 // Issue 9305: ParseMultipartForm should populate PostForm too
 164 func TestParseMultipartFormPopulatesPostForm(t *testing.T) {
 165         postData :=
 166                 `--xxx
 167 Content-Disposition: form-data; name="field1"
 168
 169 value1
 170 --xxx
 171 Content-Disposition: form-data; name="field2"
 172
 173 value2
 174 --xxx
 175 Content-Disposition: form-data; name="file"; filename="file"
 176 Content-Type: application/octet-stream
 177 Content-Transfer-Encoding: binary
 178
 179 binary data
 180 --xxx--
 181 `
 182         req := &Request{
 183                 Method: "POST",
 184                 Header: Header{"Content-Type": {`multipart/form-data; boundary=xxx`}},
 185                 Body:   ioutil.NopCloser(strings.NewReader(postData)),
 186         }
 187
 188         initialFormItems := map[string]string{
 189                 "language": "Go",
 190                 "name":     "gopher",
 191                 "skill":    "go-ing",
 192                 "field2":   "initial-value2",
 193         }
 194
 195         req.Form = make(url.Values)
 196         for k, v := range initialFormItems {
 197                 req.Form.Add(k, v)
 198         }
 199
 200         err := req.ParseMultipartForm(10000)
 201         if err != nil {
 202                 t.Fatalf("unexpected multipart error %v", err)
 203         }
 204
 205         wantForm := url.Values{
 206                 "language": []string{"Go"},
 207                 "name":     []string{"gopher"},
 208                 "skill":    []string{"go-ing"},
 209                 "field1":   []string{"value1"},
 210                 "field2":   []string{"initial-value2", "value2"},
 211         }
 212         if !reflect.DeepEqual(req.Form, wantForm) {
 213                 t.Fatalf("req.Form = %v, want %v", req.Form, wantForm)
 214         }
 215
 216         wantPostForm := url.Values{
 217                 "field1": []string{"value1"},
 218                 "field2": []string{"value2"},
 219         }
 220         if !reflect.DeepEqual(req.PostForm, wantPostForm) {
 221                 t.Fatalf("req.PostForm = %v, want %v", req.PostForm, wantPostForm)
 222         }
 223 }
 224
 225 func TestParseMultipartForm(t *testing.T) {
 226         req := &Request{
 227                 Method: "POST",
 228                 Header: Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
 229                 Body:   ioutil.NopCloser(new(bytes.Buffer)),
 230         }
 231         err := req.ParseMultipartForm(25)
 232         if err == nil {
 233                 t.Error("expected multipart EOF, got nil")
 234         }
 235
 236         req.Header = Header{"Content-Type": {"text/plain"}}
 237         err = req.ParseMultipartForm(25)
 238         if err != ErrNotMultipart {
 239                 t.Error("expected ErrNotMultipart for text/plain")
 240         }
 241 }
 242
 243 func TestRedirect_h1(t *testing.T) { testRedirect(t, h1Mode) }
 244 func TestRedirect_h2(t *testing.T) { testRedirect(t, h2Mode) }
 245 func testRedirect(t *testing.T, h2 bool) {
 246         defer afterTest(t)
 247         cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
 248                 switch r.URL.Path {
 249                 case "/":
 250                         w.Header().Set("Location", "/foo/")
 251                         w.WriteHeader(StatusSeeOther)
 252                 case "/foo/":
 253                         fmt.Fprintf(w, "foo")
 254                 default:
 255                         w.WriteHeader(StatusBadRequest)
 256                 }
 257         }))
 258         defer cst.close()
 259
 260         var end = regexp.MustCompile("/foo/$")
 261         r, err := cst.c.Get(cst.ts.URL)
 262         if err != nil {
 263                 t.Fatal(err)
 264         }
 265         r.Body.Close()
 266         url := r.Request.URL.String()
 267         if r.StatusCode != 200 || !end.MatchString(url) {
 268                 t.Fatalf("Get got status %d at %q, want 200 matching /foo/$", r.StatusCode, url)
 269         }
 270 }
 271
 272 func TestSetBasicAuth(t *testing.T) {
 273         r, _ := NewRequest("GET", "http://example.com/", nil)
 274         r.SetBasicAuth("Aladdin", "open sesame")
 275         if g, e := r.Header.Get("Authorization"), "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="; g != e {
 276                 t.Errorf("got header %q, want %q", g, e)
 277         }
 278 }
 279
 280 func TestMultipartRequest(t *testing.T) {
 281         // Test that we can read the values and files of a
 282         // multipart request with FormValue and FormFile,
 283         // and that ParseMultipartForm can be called multiple times.
 284         req := newTestMultipartRequest(t)
 285         if err := req.ParseMultipartForm(25); err != nil {
 286                 t.Fatal("ParseMultipartForm first call:", err)
 287         }
 288         defer req.MultipartForm.RemoveAll()
 289         validateTestMultipartContents(t, req, false)
 290         if err := req.ParseMultipartForm(25); err != nil {
 291                 t.Fatal("ParseMultipartForm second call:", err)
 292         }
 293         validateTestMultipartContents(t, req, false)
 294 }
 295
 296 func TestMultipartRequestAuto(t *testing.T) {
 297         // Test that FormValue and FormFile automatically invoke
 298         // ParseMultipartForm and return the right values.
 299         req := newTestMultipartRequest(t)
 300         defer func() {
 301                 if req.MultipartForm != nil {
 302                         req.MultipartForm.RemoveAll()
 303                 }
 304         }()
 305         validateTestMultipartContents(t, req, true)
 306 }
 307
 308 func TestMissingFileMultipartRequest(t *testing.T) {
 309         // Test that FormFile returns an error if
 310         // the named file is missing.
 311         req := newTestMultipartRequest(t)
 312         testMissingFile(t, req)
 313 }
 314
 315 // Test that FormValue invokes ParseMultipartForm.
 316 func TestFormValueCallsParseMultipartForm(t *testing.T) {
 317         req, _ := NewRequest("POST", "http://www.google.com/", strings.NewReader("z=post"))
 318         req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
 319         if req.Form != nil {
 320                 t.Fatal("Unexpected request Form, want nil")
 321         }
 322         req.FormValue("z")
 323         if req.Form == nil {
 324                 t.Fatal("ParseMultipartForm not called by FormValue")
 325         }
 326 }
 327
 328 // Test that FormFile invokes ParseMultipartForm.
 329 func TestFormFileCallsParseMultipartForm(t *testing.T) {
 330         req := newTestMultipartRequest(t)
 331         if req.Form != nil {
 332                 t.Fatal("Unexpected request Form, want nil")
 333         }
 334         req.FormFile("")
 335         if req.Form == nil {
 336                 t.Fatal("ParseMultipartForm not called by FormFile")
 337         }
 338 }
 339
 340 // Test that ParseMultipartForm errors if called
 341 // after MultipartReader on the same request.
 342 func TestParseMultipartFormOrder(t *testing.T) {
 343         req := newTestMultipartRequest(t)
 344         if _, err := req.MultipartReader(); err != nil {
 345                 t.Fatalf("MultipartReader: %v", err)
 346         }
 347         if err := req.ParseMultipartForm(1024); err == nil {
 348                 t.Fatal("expected an error from ParseMultipartForm after call to MultipartReader")
 349         }
 350 }
 351
 352 // Test that MultipartReader errors if called
 353 // after ParseMultipartForm on the same request.
 354 func TestMultipartReaderOrder(t *testing.T) {
 355         req := newTestMultipartRequest(t)
 356         if err := req.ParseMultipartForm(25); err != nil {
 357                 t.Fatalf("ParseMultipartForm: %v", err)
 358         }
 359         defer req.MultipartForm.RemoveAll()
 360         if _, err := req.MultipartReader(); err == nil {
 361                 t.Fatal("expected an error from MultipartReader after call to ParseMultipartForm")
 362         }
 363 }
 364
 365 // Test that FormFile errors if called after
 366 // MultipartReader on the same request.
 367 func TestFormFileOrder(t *testing.T) {
 368         req := newTestMultipartRequest(t)
 369         if _, err := req.MultipartReader(); err != nil {
 370                 t.Fatalf("MultipartReader: %v", err)
 371         }
 372         if _, _, err := req.FormFile(""); err == nil {
 373                 t.Fatal("expected an error from FormFile after call to MultipartReader")
 374         }
 375 }
 376
 377 var readRequestErrorTests = []struct {
 378         in  string
 379         err string
 380
 381         header Header
 382 }{
 383         0: {"GET / HTTP/1.1\r\nheader:foo\r\n\r\n", "", Header{"Header": {"foo"}}},
 384         1: {"GET / HTTP/1.1\r\nheader:foo\r\n", io.ErrUnexpectedEOF.Error(), nil},
 385         2: {"", io.EOF.Error(), nil},
 386         3: {
 387                 in:  "HEAD / HTTP/1.1\r\nContent-Length:4\r\n\r\n",
 388                 err: "http: method cannot contain a Content-Length",
 389         },
 390         4: {
 391                 in:     "HEAD / HTTP/1.1\r\n\r\n",
 392                 header: Header{},
 393         },
 394
 395         // Multiple Content-Length values should either be
 396         // deduplicated if same or reject otherwise
 397         // See Issue 16490.
 398         5: {
 399                 in:  "POST / HTTP/1.1\r\nContent-Length: 10\r\nContent-Length: 0\r\n\r\nGopher hey\r\n",
 400                 err: "cannot contain multiple Content-Length headers",
 401         },
 402         6: {
 403                 in:  "POST / HTTP/1.1\r\nContent-Length: 10\r\nContent-Length: 6\r\n\r\nGopher\r\n",
 404                 err: "cannot contain multiple Content-Length headers",
 405         },
 406         7: {
 407                 in:     "PUT / HTTP/1.1\r\nContent-Length: 6 \r\nContent-Length: 6\r\nContent-Length:6\r\n\r\nGopher\r\n",
 408                 err:    "",
 409                 header: Header{"Content-Length": {"6"}},
 410         },
 411         8: {
 412                 in:  "PUT / HTTP/1.1\r\nContent-Length: 1\r\nContent-Length: 6 \r\n\r\n",
 413                 err: "cannot contain multiple Content-Length headers",
 414         },
 415         9: {
 416                 in:  "POST / HTTP/1.1\r\nContent-Length:\r\nContent-Length: 3\r\n\r\n",
 417                 err: "cannot contain multiple Content-Length headers",
 418         },
 419         10: {
 420                 in:     "HEAD / HTTP/1.1\r\nContent-Length:0\r\nContent-Length: 0\r\n\r\n",
 421                 header: Header{"Content-Length": {"0"}},
 422         },
 423 }
 424
 425 func TestReadRequestErrors(t *testing.T) {
 426         for i, tt := range readRequestErrorTests {
 427                 req, err := ReadRequest(bufio.NewReader(strings.NewReader(tt.in)))
 428                 if err == nil {
 429                         if tt.err != "" {
 430                                 t.Errorf("#%d: got nil err; want %q", i, tt.err)
 431                         }
 432
 433                         if !reflect.DeepEqual(tt.header, req.Header) {
 434                                 t.Errorf("#%d: gotHeader: %q wantHeader: %q", i, req.Header, tt.header)
 435                         }
 436                         continue
 437                 }
 438
 439                 if tt.err == "" || !strings.Contains(err.Error(), tt.err) {
 440                         t.Errorf("%d: got error = %v; want %v", i, err, tt.err)
 441                 }
 442         }
 443 }
 444
 445 var newRequestHostTests = []struct {
 446         in, out string
 447 }{
 448         {"http://www.example.com/", "www.example.com"},
 449         {"http://www.example.com:8080/", "www.example.com:8080"},
 450
 451         {"http://192.168.0.1/", "192.168.0.1"},
 452         {"http://192.168.0.1:8080/", "192.168.0.1:8080"},
 453         {"http://192.168.0.1:/", "192.168.0.1"},
 454
 455         {"http://[fe80::1]/", "[fe80::1]"},
 456         {"http://[fe80::1]:8080/", "[fe80::1]:8080"},
 457         {"http://[fe80::1%25en0]/", "[fe80::1%en0]"},
 458         {"http://[fe80::1%25en0]:8080/", "[fe80::1%en0]:8080"},
 459         {"http://[fe80::1%25en0]:/", "[fe80::1%en0]"},
 460 }
 461
 462 func TestNewRequestHost(t *testing.T) {
 463         for i, tt := range newRequestHostTests {
 464                 req, err := NewRequest("GET", tt.in, nil)
 465                 if err != nil {
 466                         t.Errorf("#%v: %v", i, err)
 467                         continue
 468                 }
 469                 if req.Host != tt.out {
 470                         t.Errorf("got %q; want %q", req.Host, tt.out)
 471                 }
 472         }
 473 }
 474
 475 func TestRequestInvalidMethod(t *testing.T) {
 476         _, err := NewRequest("bad method", "http://foo.com/", nil)
 477         if err == nil {
 478                 t.Error("expected error from NewRequest with invalid method")
 479         }
 480         req, err := NewRequest("GET", "http://foo.example/", nil)
 481         if err != nil {
 482                 t.Fatal(err)
 483         }
 484         req.Method = "bad method"
 485         _, err = DefaultClient.Do(req)
 486         if err == nil || !strings.Contains(err.Error(), "invalid method") {
 487                 t.Errorf("Transport error = %v; want invalid method", err)
 488         }
 489
 490         req, err = NewRequest("", "http://foo.com/", nil)
 491         if err != nil {
 492                 t.Errorf("NewRequest(empty method) = %v; want nil", err)
 493         } else if req.Method != "GET" {
 494                 t.Errorf("NewRequest(empty method) has method %q; want GET", req.Method)
 495         }
 496 }
 497
 498 func TestNewRequestContentLength(t *testing.T) {
 499         readByte := func(r io.Reader) io.Reader {
 500                 var b [1]byte
 501                 r.Read(b[:])
 502                 return r
 503         }
 504         tests := []struct {
 505                 r    io.Reader
 506                 want int64
 507         }{
 508                 {bytes.NewReader([]byte("123")), 3},
 509                 {bytes.NewBuffer([]byte("1234")), 4},
 510                 {strings.NewReader("12345"), 5},
 511                 {strings.NewReader(""), 0},
 512                 {NoBody, 0},
 513
 514                 // Not detected. During Go 1.8 we tried to make these set to -1, but
 515                 // due to Issue 18117, we keep these returning 0, even though they're
 516                 // unknown.
 517                 {struct{ io.Reader }{strings.NewReader("xyz")}, 0},
 518                 {io.NewSectionReader(strings.NewReader("x"), 0, 6), 0},
 519                 {readByte(io.NewSectionReader(strings.NewReader("xy"), 0, 6)), 0},
 520         }
 521         for i, tt := range tests {
 522                 req, err := NewRequest("POST", "http://localhost/", tt.r)
 523                 if err != nil {
 524                         t.Fatal(err)
 525                 }
 526                 if req.ContentLength != tt.want {
 527                         t.Errorf("test[%d]: ContentLength(%T) = %d; want %d", i, tt.r, req.ContentLength, tt.want)
 528                 }
 529         }
 530 }
 531
 532 var parseHTTPVersionTests = []struct {
 533         vers         string
 534         major, minor int
 535         ok           bool
 536 }{
 537         {"HTTP/0.9", 0, 9, true},
 538         {"HTTP/1.0", 1, 0, true},
 539         {"HTTP/1.1", 1, 1, true},
 540         {"HTTP/3.14", 3, 14, true},
 541
 542         {"HTTP", 0, 0, false},
 543         {"HTTP/one.one", 0, 0, false},
 544         {"HTTP/1.1/", 0, 0, false},
 545         {"HTTP/-1,0", 0, 0, false},
 546         {"HTTP/0,-1", 0, 0, false},
 547         {"HTTP/", 0, 0, false},
 548         {"HTTP/1,1", 0, 0, false},
 549 }
 550
 551 func TestParseHTTPVersion(t *testing.T) {
 552         for _, tt := range parseHTTPVersionTests {
 553                 major, minor, ok := ParseHTTPVersion(tt.vers)
 554                 if ok != tt.ok || major != tt.major || minor != tt.minor {
 555                         type version struct {
 556                                 major, minor int
 557                                 ok           bool
 558                         }
 559                         t.Errorf("failed to parse %q, expected: %#v, got %#v", tt.vers, version{tt.major, tt.minor, tt.ok}, version{major, minor, ok})
 560                 }
 561         }
 562 }
 563
 564 type getBasicAuthTest struct {
 565         username, password string
 566         ok                 bool
 567 }
 568
 569 type basicAuthCredentialsTest struct {
 570         username, password string
 571 }
 572
 573 var getBasicAuthTests = []struct {
 574         username, password string
 575         ok                 bool
 576 }{
 577         {"Aladdin", "open sesame", true},
 578         {"Aladdin", "open:sesame", true},
 579         {"", "", true},
 580 }
 581
 582 func TestGetBasicAuth(t *testing.T) {
 583         for _, tt := range getBasicAuthTests {
 584                 r, _ := NewRequest("GET", "http://example.com/", nil)
 585                 r.SetBasicAuth(tt.username, tt.password)
 586                 username, password, ok := r.BasicAuth()
 587                 if ok != tt.ok || username != tt.username || password != tt.password {
 588                         t.Errorf("BasicAuth() = %#v, want %#v", getBasicAuthTest{username, password, ok},
 589                                 getBasicAuthTest{tt.username, tt.password, tt.ok})
 590                 }
 591         }
 592         // Unauthenticated request.
 593         r, _ := NewRequest("GET", "http://example.com/", nil)
 594         username, password, ok := r.BasicAuth()
 595         if ok {
 596                 t.Errorf("expected false from BasicAuth when the request is unauthenticated")
 597         }
 598         want := basicAuthCredentialsTest{"", ""}
 599         if username != want.username || password != want.password {
 600                 t.Errorf("expected credentials: %#v when the request is unauthenticated, got %#v",
 601                         want, basicAuthCredentialsTest{username, password})
 602         }
 603 }
 604
 605 var parseBasicAuthTests = []struct {
 606         header, username, password string
 607         ok                         bool
 608 }{
 609         {"Basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true},
 610
 611         // Case doesn't matter:
 612         {"BASIC " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true},
 613         {"basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true},
 614
 615         {"Basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open:sesame")), "Aladdin", "open:sesame", true},
 616         {"Basic " + base64.StdEncoding.EncodeToString([]byte(":")), "", "", true},
 617         {"Basic" + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "", "", false},
 618         {base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "", "", false},
 619         {"Basic ", "", "", false},
 620         {"Basic Aladdin:open sesame", "", "", false},
 621         {`Digest username="Aladdin"`, "", "", false},
 622 }
 623
 624 func TestParseBasicAuth(t *testing.T) {
 625         for _, tt := range parseBasicAuthTests {
 626                 r, _ := NewRequest("GET", "http://example.com/", nil)
 627                 r.Header.Set("Authorization", tt.header)
 628                 username, password, ok := r.BasicAuth()
 629                 if ok != tt.ok || username != tt.username || password != tt.password {
 630                         t.Errorf("BasicAuth() = %#v, want %#v", getBasicAuthTest{username, password, ok},
 631                                 getBasicAuthTest{tt.username, tt.password, tt.ok})
 632                 }
 633         }
 634 }
 635
 636 type logWrites struct {
 637         t   *testing.T
 638         dst *[]string
 639 }
 640
 641 func (l logWrites) WriteByte(c byte) error {
 642         l.t.Fatalf("unexpected WriteByte call")
 643         return nil
 644 }
 645
 646 func (l logWrites) Write(p []byte) (n int, err error) {
 647         *l.dst = append(*l.dst, string(p))
 648         return len(p), nil
 649 }
 650
 651 func TestRequestWriteBufferedWriter(t *testing.T) {
 652         got := []string{}
 653         req, _ := NewRequest("GET", "http://foo.com/", nil)
 654         req.Write(logWrites{t, &got})
 655         want := []string{
 656                 "GET / HTTP/1.1\r\n",
 657                 "Host: foo.com\r\n",
 658                 "User-Agent: " + DefaultUserAgent + "\r\n",
 659                 "\r\n",
 660         }
 661         if !reflect.DeepEqual(got, want) {
 662                 t.Errorf("Writes = %q\n  Want = %q", got, want)
 663         }
 664 }
 665
 666 func TestRequestBadHost(t *testing.T) {
 667         got := []string{}
 668         req, err := NewRequest("GET", "http://foo/after", nil)
 669         if err != nil {
 670                 t.Fatal(err)
 671         }
 672         req.Host = "foo.com with spaces"
 673         req.URL.Host = "foo.com with spaces"
 674         req.Write(logWrites{t, &got})
 675         want := []string{
 676                 "GET /after HTTP/1.1\r\n",
 677                 "Host: foo.com\r\n",
 678                 "User-Agent: " + DefaultUserAgent + "\r\n",
 679                 "\r\n",
 680         }
 681         if !reflect.DeepEqual(got, want) {
 682                 t.Errorf("Writes = %q\n  Want = %q", got, want)
 683         }
 684 }
 685
 686 func TestStarRequest(t *testing.T) {
 687         req, err := ReadRequest(bufio.NewReader(strings.NewReader("M-SEARCH * HTTP/1.1\r\n\r\n")))
 688         if err != nil {
 689                 return
 690         }
 691         if req.ContentLength != 0 {
 692                 t.Errorf("ContentLength = %d; want 0", req.ContentLength)
 693         }
 694         if req.Body == nil {
 695                 t.Errorf("Body = nil; want non-nil")
 696         }
 697
 698         // Request.Write has Client semantics for Body/ContentLength,
 699         // where ContentLength 0 means unknown if Body is non-nil, and
 700         // thus chunking will happen unless we change semantics and
 701         // signal that we want to serialize it as exactly zero.  The
 702         // only way to do that for outbound requests is with a nil
 703         // Body:
 704         clientReq := *req
 705         clientReq.Body = nil
 706
 707         var out bytes.Buffer
 708         if err := clientReq.Write(&out); err != nil {
 709                 t.Fatal(err)
 710         }
 711
 712         if strings.Contains(out.String(), "chunked") {
 713                 t.Error("wrote chunked request; want no body")
 714         }
 715         back, err := ReadRequest(bufio.NewReader(bytes.NewReader(out.Bytes())))
 716         if err != nil {
 717                 t.Fatal(err)
 718         }
 719         // Ignore the Headers (the User-Agent breaks the deep equal,
 720         // but we don't care about it)
 721         req.Header = nil
 722         back.Header = nil
 723         if !reflect.DeepEqual(req, back) {
 724                 t.Errorf("Original request doesn't match Request read back.")
 725                 t.Logf("Original: %#v", req)
 726                 t.Logf("Original.URL: %#v", req.URL)
 727                 t.Logf("Wrote: %s", out.Bytes())
 728                 t.Logf("Read back (doesn't match Original): %#v", back)
 729         }
 730 }
 731
 732 type responseWriterJustWriter struct {
 733         io.Writer
 734 }
 735
 736 func (responseWriterJustWriter) Header() Header  { panic("should not be called") }
 737 func (responseWriterJustWriter) WriteHeader(int) { panic("should not be called") }
 738
 739 // delayedEOFReader never returns (n > 0, io.EOF), instead putting
 740 // off the io.EOF until a subsequent Read call.
 741 type delayedEOFReader struct {
 742         r io.Reader
 743 }
 744
 745 func (dr delayedEOFReader) Read(p []byte) (n int, err error) {
 746         n, err = dr.r.Read(p)
 747         if n > 0 && err == io.EOF {
 748                 err = nil
 749         }
 750         return
 751 }
 752
 753 func TestIssue10884_MaxBytesEOF(t *testing.T) {
 754         dst := ioutil.Discard
 755         _, err := io.Copy(dst, MaxBytesReader(
 756                 responseWriterJustWriter{dst},
 757                 ioutil.NopCloser(delayedEOFReader{strings.NewReader("12345")}),
 758                 5))
 759         if err != nil {
 760                 t.Fatal(err)
 761         }
 762 }
 763
 764 // Issue 14981: MaxBytesReader's return error wasn't sticky. It
 765 // doesn't technically need to be, but people expected it to be.
 766 func TestMaxBytesReaderStickyError(t *testing.T) {
 767         isSticky := func(r io.Reader) error {
 768                 var log bytes.Buffer
 769                 buf := make([]byte, 1000)
 770                 var firstErr error
 771                 for {
 772                         n, err := r.Read(buf)
 773                         fmt.Fprintf(&log, "Read(%d) = %d, %v\n", len(buf), n, err)
 774                         if err == nil {
 775                                 continue
 776                         }
 777                         if firstErr == nil {
 778                                 firstErr = err
 779                                 continue
 780                         }
 781                         if !reflect.DeepEqual(err, firstErr) {
 782                                 return fmt.Errorf("non-sticky error. got log:\n%s", log.Bytes())
 783                         }
 784                         t.Logf("Got log: %s", log.Bytes())
 785                         return nil
 786                 }
 787         }
 788         tests := [...]struct {
 789                 readable int
 790                 limit    int64
 791         }{
 792                 0: {99, 100},
 793                 1: {100, 100},
 794                 2: {101, 100},
 795         }
 796         for i, tt := range tests {
 797                 rc := MaxBytesReader(nil, ioutil.NopCloser(bytes.NewReader(make([]byte, tt.readable))), tt.limit)
 798                 if err := isSticky(rc); err != nil {
 799                         t.Errorf("%d. error: %v", i, err)
 800                 }
 801         }
 802 }
 803
 804 func TestWithContextDeepCopiesURL(t *testing.T) {
 805         req, err := NewRequest("POST", "https://golang.org/", nil)
 806         if err != nil {
 807                 t.Fatal(err)
 808         }
 809
 810         reqCopy := req.WithContext(context.Background())
 811         reqCopy.URL.Scheme = "http"
 812
 813         firstURL, secondURL := req.URL.String(), reqCopy.URL.String()
 814         if firstURL == secondURL {
 815                 t.Errorf("unexpected change to original request's URL")
 816         }
 817
 818         // And also check we don't crash on nil (Issue 20601)
 819         req.URL = nil
 820         reqCopy = req.WithContext(context.Background())
 821         if reqCopy.URL != nil {
 822                 t.Error("expected nil URL in cloned request")
 823         }
 824 }
 825
 826 // verify that NewRequest sets Request.GetBody and that it works
 827 func TestNewRequestGetBody(t *testing.T) {
 828         tests := []struct {
 829                 r io.Reader
 830         }{
 831                 {r: strings.NewReader("hello")},
 832                 {r: bytes.NewReader([]byte("hello"))},
 833                 {r: bytes.NewBuffer([]byte("hello"))},
 834         }
 835         for i, tt := range tests {
 836                 req, err := NewRequest("POST", "http://foo.tld/", tt.r)
 837                 if err != nil {
 838                         t.Errorf("test[%d]: %v", i, err)
 839                         continue
 840                 }
 841                 if req.Body == nil {
 842                         t.Errorf("test[%d]: Body = nil", i)
 843                         continue
 844                 }
 845                 if req.GetBody == nil {
 846                         t.Errorf("test[%d]: GetBody = nil", i)
 847                         continue
 848                 }
 849                 slurp1, err := ioutil.ReadAll(req.Body)
 850                 if err != nil {
 851                         t.Errorf("test[%d]: ReadAll(Body) = %v", i, err)
 852                 }
 853                 newBody, err := req.GetBody()
 854                 if err != nil {
 855                         t.Errorf("test[%d]: GetBody = %v", i, err)
 856                 }
 857                 slurp2, err := ioutil.ReadAll(newBody)
 858                 if err != nil {
 859                         t.Errorf("test[%d]: ReadAll(GetBody()) = %v", i, err)
 860                 }
 861                 if string(slurp1) != string(slurp2) {
 862                         t.Errorf("test[%d]: Body %q != GetBody %q", i, slurp1, slurp2)
 863                 }
 864         }
 865 }
 866
 867 func testMissingFile(t *testing.T, req *Request) {
 868         f, fh, err := req.FormFile("missing")
 869         if f != nil {
 870                 t.Errorf("FormFile file = %v, want nil", f)
 871         }
 872         if fh != nil {
 873                 t.Errorf("FormFile file header = %q, want nil", fh)
 874         }
 875         if err != ErrMissingFile {
 876                 t.Errorf("FormFile err = %q, want ErrMissingFile", err)
 877         }
 878 }
 879
 880 func newTestMultipartRequest(t *testing.T) *Request {
 881         b := strings.NewReader(strings.Replace(message, "\n", "\r\n", -1))
 882         req, err := NewRequest("POST", "/", b)
 883         if err != nil {
 884                 t.Fatal("NewRequest:", err)
 885         }
 886         ctype := fmt.Sprintf(`multipart/form-data; boundary="%s"`, boundary)
 887         req.Header.Set("Content-type", ctype)
 888         return req
 889 }
 890
 891 func validateTestMultipartContents(t *testing.T, req *Request, allMem bool) {
 892         if g, e := req.FormValue("texta"), textaValue; g != e {
 893                 t.Errorf("texta value = %q, want %q", g, e)
 894         }
 895         if g, e := req.FormValue("textb"), textbValue; g != e {
 896                 t.Errorf("textb value = %q, want %q", g, e)
 897         }
 898         if g := req.FormValue("missing"); g != "" {
 899                 t.Errorf("missing value = %q, want empty string", g)
 900         }
 901
 902         assertMem := func(n string, fd multipart.File) {
 903                 if _, ok := fd.(*os.File); ok {
 904                         t.Error(n, " is *os.File, should not be")
 905                 }
 906         }
 907         fda := testMultipartFile(t, req, "filea", "filea.txt", fileaContents)
 908         defer fda.Close()
 909         assertMem("filea", fda)
 910         fdb := testMultipartFile(t, req, "fileb", "fileb.txt", filebContents)
 911         defer fdb.Close()
 912         if allMem {
 913                 assertMem("fileb", fdb)
 914         } else {
 915                 if _, ok := fdb.(*os.File); !ok {
 916                         t.Errorf("fileb has unexpected underlying type %T", fdb)
 917                 }
 918         }
 919
 920         testMissingFile(t, req)
 921 }
 922
 923 func testMultipartFile(t *testing.T, req *Request, key, expectFilename, expectContent string) multipart.File {
 924         f, fh, err := req.FormFile(key)
 925         if err != nil {
 926                 t.Fatalf("FormFile(%q): %q", key, err)
 927         }
 928         if fh.Filename != expectFilename {
 929                 t.Errorf("filename = %q, want %q", fh.Filename, expectFilename)
 930         }
 931         var b bytes.Buffer
 932         _, err = io.Copy(&b, f)
 933         if err != nil {
 934                 t.Fatal("copying contents:", err)
 935         }
 936         if g := b.String(); g != expectContent {
 937                 t.Errorf("contents = %q, want %q", g, expectContent)
 938         }
 939         return f
 940 }
 941
 942 const (
 943         fileaContents = "This is a test file."
 944         filebContents = "Another test file."
 945         textaValue    = "foo"
 946         textbValue    = "bar"
 947         boundary      = `MyBoundary`
 948 )
 949
 950 const message = `
 951 --MyBoundary
 952 Content-Disposition: form-data; name="filea"; filename="filea.txt"
 953 Content-Type: text/plain
 954
 955 ` + fileaContents + `
 956 --MyBoundary
 957 Content-Disposition: form-data; name="fileb"; filename="fileb.txt"
 958 Content-Type: text/plain
 959
 960 ` + filebContents + `
 961 --MyBoundary
 962 Content-Disposition: form-data; name="texta"
 963
 964 ` + textaValue + `
 965 --MyBoundary
 966 Content-Disposition: form-data; name="textb"
 967
 968 ` + textbValue + `
 969 --MyBoundary--
 970 `
 971
 972 func benchmarkReadRequest(b *testing.B, request string) {
 973         request = request + "\n"                             // final \n
 974         request = strings.Replace(request, "\n", "\r\n", -1) // expand \n to \r\n
 975         b.SetBytes(int64(len(request)))
 976         r := bufio.NewReader(&infiniteReader{buf: []byte(request)})
 977         b.ReportAllocs()
 978         b.ResetTimer()
 979         for i := 0; i < b.N; i++ {
 980                 _, err := ReadRequest(r)
 981                 if err != nil {
 982                         b.Fatalf("failed to read request: %v", err)
 983                 }
 984         }
 985 }
 986
 987 // infiniteReader satisfies Read requests as if the contents of buf
 988 // loop indefinitely.
 989 type infiniteReader struct {
 990         buf    []byte
 991         offset int
 992 }
 993
 994 func (r *infiniteReader) Read(b []byte) (int, error) {
 995         n := copy(b, r.buf[r.offset:])
 996         r.offset = (r.offset + n) % len(r.buf)
 997         return n, nil
 998 }
 999
1000 func BenchmarkReadRequestChrome(b *testing.B) {
1001         // https://github.com/felixge/node-http-perf/blob/master/fixtures/get.http
1002         benchmarkReadRequest(b, `GET / HTTP/1.1
1003 Host: localhost:8080
1004 Connection: keep-alive
1005 Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
1006 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
1007 Accept-Encoding: gzip,deflate,sdch
1008 Accept-Language: en-US,en;q=0.8
1009 Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3
1010 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
1011 `)
1012 }
1013
1014 func BenchmarkReadRequestCurl(b *testing.B) {
1015         // curl http://localhost:8080/
1016         benchmarkReadRequest(b, `GET / HTTP/1.1
1017 User-Agent: curl/7.27.0
1018 Host: localhost:8080
1019 Accept: */*
1020 `)
1021 }
1022
1023 func BenchmarkReadRequestApachebench(b *testing.B) {
1024         // ab -n 1 -c 1 http://localhost:8080/
1025         benchmarkReadRequest(b, `GET / HTTP/1.0
1026 Host: localhost:8080
1027 User-Agent: ApacheBench/2.3
1028 Accept: */*
1029 `)
1030 }
1031
1032 func BenchmarkReadRequestSiege(b *testing.B) {
1033         // siege -r 1 -c 1 http://localhost:8080/
1034         benchmarkReadRequest(b, `GET / HTTP/1.1
1035 Host: localhost:8080
1036 Accept: */*
1037 Accept-Encoding: gzip
1038 User-Agent: JoeDog/1.00 [en] (X11; I; Siege 2.70)
1039 Connection: keep-alive
1040 `)
1041 }
1042
1043 func BenchmarkReadRequestWrk(b *testing.B) {
1044         // wrk -t 1 -r 1 -c 1 http://localhost:8080/
1045         benchmarkReadRequest(b, `GET / HTTP/1.1
1046 Host: localhost:8080
1047 `)
1048 }