libgo/go/net/http/requestwrite_test.go

   1 // Copyright 2010 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
   6
   7 import (
   8         "bufio"
   9         "bytes"
  10         "errors"
  11         "fmt"
  12         "io"
  13         "io/ioutil"
  14         "net"
  15         "net/url"
  16         "strings"
  17         "testing"
  18         "time"
  19 )
  20
  21 type reqWriteTest struct {
  22         Req  Request
  23         Body interface{} // optional []byte or func() io.ReadCloser to populate Req.Body
  24
  25         // Any of these three may be empty to skip that test.
  26         WantWrite string // Request.Write
  27         WantProxy string // Request.WriteProxy
  28
  29         WantError error // wanted error from Request.Write
  30 }
  31
  32 var reqWriteTests = []reqWriteTest{
  33         // HTTP/1.1 => chunked coding; no body; no trailer
  34         0: {
  35                 Req: Request{
  36                         Method: "GET",
  37                         URL: &url.URL{
  38                                 Scheme: "http",
  39                                 Host:   "www.techcrunch.com",
  40                                 Path:   "/",
  41                         },
  42                         Proto:      "HTTP/1.1",
  43                         ProtoMajor: 1,
  44                         ProtoMinor: 1,
  45                         Header: Header{
  46                                 "Accept":           {"text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"},
  47                                 "Accept-Charset":   {"ISO-8859-1,utf-8;q=0.7,*;q=0.7"},
  48                                 "Accept-Encoding":  {"gzip,deflate"},
  49                                 "Accept-Language":  {"en-us,en;q=0.5"},
  50                                 "Keep-Alive":       {"300"},
  51                                 "Proxy-Connection": {"keep-alive"},
  52                                 "User-Agent":       {"Fake"},
  53                         },
  54                         Body:  nil,
  55                         Close: false,
  56                         Host:  "www.techcrunch.com",
  57                         Form:  map[string][]string{},
  58                 },
  59
  60                 WantWrite: "GET / HTTP/1.1\r\n" +
  61                         "Host: www.techcrunch.com\r\n" +
  62                         "User-Agent: Fake\r\n" +
  63                         "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n" +
  64                         "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n" +
  65                         "Accept-Encoding: gzip,deflate\r\n" +
  66                         "Accept-Language: en-us,en;q=0.5\r\n" +
  67                         "Keep-Alive: 300\r\n" +
  68                         "Proxy-Connection: keep-alive\r\n\r\n",
  69
  70                 WantProxy: "GET http://www.techcrunch.com/ HTTP/1.1\r\n" +
  71                         "Host: www.techcrunch.com\r\n" +
  72                         "User-Agent: Fake\r\n" +
  73                         "Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8\r\n" +
  74                         "Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7\r\n" +
  75                         "Accept-Encoding: gzip,deflate\r\n" +
  76                         "Accept-Language: en-us,en;q=0.5\r\n" +
  77                         "Keep-Alive: 300\r\n" +
  78                         "Proxy-Connection: keep-alive\r\n\r\n",
  79         },
  80         // HTTP/1.1 => chunked coding; body; empty trailer
  81         1: {
  82                 Req: Request{
  83                         Method: "GET",
  84                         URL: &url.URL{
  85                                 Scheme: "http",
  86                                 Host:   "www.google.com",
  87                                 Path:   "/search",
  88                         },
  89                         ProtoMajor:       1,
  90                         ProtoMinor:       1,
  91                         Header:           Header{},
  92                         TransferEncoding: []string{"chunked"},
  93                 },
  94
  95                 Body: []byte("abcdef"),
  96
  97                 WantWrite: "GET /search HTTP/1.1\r\n" +
  98                         "Host: www.google.com\r\n" +
  99                         "User-Agent: Go-http-client/1.1\r\n" +
 100                         "Transfer-Encoding: chunked\r\n\r\n" +
 101                         chunk("abcdef") + chunk(""),
 102
 103                 WantProxy: "GET http://www.google.com/search HTTP/1.1\r\n" +
 104                         "Host: www.google.com\r\n" +
 105                         "User-Agent: Go-http-client/1.1\r\n" +
 106                         "Transfer-Encoding: chunked\r\n\r\n" +
 107                         chunk("abcdef") + chunk(""),
 108         },
 109         // HTTP/1.1 POST => chunked coding; body; empty trailer
 110         2: {
 111                 Req: Request{
 112                         Method: "POST",
 113                         URL: &url.URL{
 114                                 Scheme: "http",
 115                                 Host:   "www.google.com",
 116                                 Path:   "/search",
 117                         },
 118                         ProtoMajor:       1,
 119                         ProtoMinor:       1,
 120                         Header:           Header{},
 121                         Close:            true,
 122                         TransferEncoding: []string{"chunked"},
 123                 },
 124
 125                 Body: []byte("abcdef"),
 126
 127                 WantWrite: "POST /search HTTP/1.1\r\n" +
 128                         "Host: www.google.com\r\n" +
 129                         "User-Agent: Go-http-client/1.1\r\n" +
 130                         "Connection: close\r\n" +
 131                         "Transfer-Encoding: chunked\r\n\r\n" +
 132                         chunk("abcdef") + chunk(""),
 133
 134                 WantProxy: "POST http://www.google.com/search HTTP/1.1\r\n" +
 135                         "Host: www.google.com\r\n" +
 136                         "User-Agent: Go-http-client/1.1\r\n" +
 137                         "Connection: close\r\n" +
 138                         "Transfer-Encoding: chunked\r\n\r\n" +
 139                         chunk("abcdef") + chunk(""),
 140         },
 141
 142         // HTTP/1.1 POST with Content-Length, no chunking
 143         3: {
 144                 Req: Request{
 145                         Method: "POST",
 146                         URL: &url.URL{
 147                                 Scheme: "http",
 148                                 Host:   "www.google.com",
 149                                 Path:   "/search",
 150                         },
 151                         ProtoMajor:    1,
 152                         ProtoMinor:    1,
 153                         Header:        Header{},
 154                         Close:         true,
 155                         ContentLength: 6,
 156                 },
 157
 158                 Body: []byte("abcdef"),
 159
 160                 WantWrite: "POST /search HTTP/1.1\r\n" +
 161                         "Host: www.google.com\r\n" +
 162                         "User-Agent: Go-http-client/1.1\r\n" +
 163                         "Connection: close\r\n" +
 164                         "Content-Length: 6\r\n" +
 165                         "\r\n" +
 166                         "abcdef",
 167
 168                 WantProxy: "POST http://www.google.com/search HTTP/1.1\r\n" +
 169                         "Host: www.google.com\r\n" +
 170                         "User-Agent: Go-http-client/1.1\r\n" +
 171                         "Connection: close\r\n" +
 172                         "Content-Length: 6\r\n" +
 173                         "\r\n" +
 174                         "abcdef",
 175         },
 176
 177         // HTTP/1.1 POST with Content-Length in headers
 178         4: {
 179                 Req: Request{
 180                         Method: "POST",
 181                         URL:    mustParseURL("http://example.com/"),
 182                         Host:   "example.com",
 183                         Header: Header{
 184                                 "Content-Length": []string{"10"}, // ignored
 185                         },
 186                         ContentLength: 6,
 187                 },
 188
 189                 Body: []byte("abcdef"),
 190
 191                 WantWrite: "POST / HTTP/1.1\r\n" +
 192                         "Host: example.com\r\n" +
 193                         "User-Agent: Go-http-client/1.1\r\n" +
 194                         "Content-Length: 6\r\n" +
 195                         "\r\n" +
 196                         "abcdef",
 197
 198                 WantProxy: "POST http://example.com/ HTTP/1.1\r\n" +
 199                         "Host: example.com\r\n" +
 200                         "User-Agent: Go-http-client/1.1\r\n" +
 201                         "Content-Length: 6\r\n" +
 202                         "\r\n" +
 203                         "abcdef",
 204         },
 205
 206         // default to HTTP/1.1
 207         5: {
 208                 Req: Request{
 209                         Method: "GET",
 210                         URL:    mustParseURL("/search"),
 211                         Host:   "www.google.com",
 212                 },
 213
 214                 WantWrite: "GET /search HTTP/1.1\r\n" +
 215                         "Host: www.google.com\r\n" +
 216                         "User-Agent: Go-http-client/1.1\r\n" +
 217                         "\r\n",
 218         },
 219
 220         // Request with a 0 ContentLength and a 0 byte body.
 221         6: {
 222                 Req: Request{
 223                         Method:        "POST",
 224                         URL:           mustParseURL("/"),
 225                         Host:          "example.com",
 226                         ProtoMajor:    1,
 227                         ProtoMinor:    1,
 228                         ContentLength: 0, // as if unset by user
 229                 },
 230
 231                 Body: func() io.ReadCloser { return ioutil.NopCloser(io.LimitReader(strings.NewReader("xx"), 0)) },
 232
 233                 WantWrite: "POST / HTTP/1.1\r\n" +
 234                         "Host: example.com\r\n" +
 235                         "User-Agent: Go-http-client/1.1\r\n" +
 236                         "Transfer-Encoding: chunked\r\n" +
 237                         "\r\n0\r\n\r\n",
 238
 239                 WantProxy: "POST / HTTP/1.1\r\n" +
 240                         "Host: example.com\r\n" +
 241                         "User-Agent: Go-http-client/1.1\r\n" +
 242                         "Transfer-Encoding: chunked\r\n" +
 243                         "\r\n0\r\n\r\n",
 244         },
 245
 246         // Request with a 0 ContentLength and a nil body.
 247         7: {
 248                 Req: Request{
 249                         Method:        "POST",
 250                         URL:           mustParseURL("/"),
 251                         Host:          "example.com",
 252                         ProtoMajor:    1,
 253                         ProtoMinor:    1,
 254                         ContentLength: 0, // as if unset by user
 255                 },
 256
 257                 Body: func() io.ReadCloser { return nil },
 258
 259                 WantWrite: "POST / HTTP/1.1\r\n" +
 260                         "Host: example.com\r\n" +
 261                         "User-Agent: Go-http-client/1.1\r\n" +
 262                         "Content-Length: 0\r\n" +
 263                         "\r\n",
 264
 265                 WantProxy: "POST / HTTP/1.1\r\n" +
 266                         "Host: example.com\r\n" +
 267                         "User-Agent: Go-http-client/1.1\r\n" +
 268                         "Content-Length: 0\r\n" +
 269                         "\r\n",
 270         },
 271
 272         // Request with a 0 ContentLength and a 1 byte body.
 273         8: {
 274                 Req: Request{
 275                         Method:        "POST",
 276                         URL:           mustParseURL("/"),
 277                         Host:          "example.com",
 278                         ProtoMajor:    1,
 279                         ProtoMinor:    1,
 280                         ContentLength: 0, // as if unset by user
 281                 },
 282
 283                 Body: func() io.ReadCloser { return ioutil.NopCloser(io.LimitReader(strings.NewReader("xx"), 1)) },
 284
 285                 WantWrite: "POST / HTTP/1.1\r\n" +
 286                         "Host: example.com\r\n" +
 287                         "User-Agent: Go-http-client/1.1\r\n" +
 288                         "Transfer-Encoding: chunked\r\n\r\n" +
 289                         chunk("x") + chunk(""),
 290
 291                 WantProxy: "POST / HTTP/1.1\r\n" +
 292                         "Host: example.com\r\n" +
 293                         "User-Agent: Go-http-client/1.1\r\n" +
 294                         "Transfer-Encoding: chunked\r\n\r\n" +
 295                         chunk("x") + chunk(""),
 296         },
 297
 298         // Request with a ContentLength of 10 but a 5 byte body.
 299         9: {
 300                 Req: Request{
 301                         Method:        "POST",
 302                         URL:           mustParseURL("/"),
 303                         Host:          "example.com",
 304                         ProtoMajor:    1,
 305                         ProtoMinor:    1,
 306                         ContentLength: 10, // but we're going to send only 5 bytes
 307                 },
 308                 Body:      []byte("12345"),
 309                 WantError: errors.New("http: ContentLength=10 with Body length 5"),
 310         },
 311
 312         // Request with a ContentLength of 4 but an 8 byte body.
 313         10: {
 314                 Req: Request{
 315                         Method:        "POST",
 316                         URL:           mustParseURL("/"),
 317                         Host:          "example.com",
 318                         ProtoMajor:    1,
 319                         ProtoMinor:    1,
 320                         ContentLength: 4, // but we're going to try to send 8 bytes
 321                 },
 322                 Body:      []byte("12345678"),
 323                 WantError: errors.New("http: ContentLength=4 with Body length 8"),
 324         },
 325
 326         // Request with a 5 ContentLength and nil body.
 327         11: {
 328                 Req: Request{
 329                         Method:        "POST",
 330                         URL:           mustParseURL("/"),
 331                         Host:          "example.com",
 332                         ProtoMajor:    1,
 333                         ProtoMinor:    1,
 334                         ContentLength: 5, // but we'll omit the body
 335                 },
 336                 WantError: errors.New("http: Request.ContentLength=5 with nil Body"),
 337         },
 338
 339         // Request with a 0 ContentLength and a body with 1 byte content and an error.
 340         12: {
 341                 Req: Request{
 342                         Method:        "POST",
 343                         URL:           mustParseURL("/"),
 344                         Host:          "example.com",
 345                         ProtoMajor:    1,
 346                         ProtoMinor:    1,
 347                         ContentLength: 0, // as if unset by user
 348                 },
 349
 350                 Body: func() io.ReadCloser {
 351                         err := errors.New("Custom reader error")
 352                         errReader := &errorReader{err}
 353                         return ioutil.NopCloser(io.MultiReader(strings.NewReader("x"), errReader))
 354                 },
 355
 356                 WantError: errors.New("Custom reader error"),
 357         },
 358
 359         // Request with a 0 ContentLength and a body without content and an error.
 360         13: {
 361                 Req: Request{
 362                         Method:        "POST",
 363                         URL:           mustParseURL("/"),
 364                         Host:          "example.com",
 365                         ProtoMajor:    1,
 366                         ProtoMinor:    1,
 367                         ContentLength: 0, // as if unset by user
 368                 },
 369
 370                 Body: func() io.ReadCloser {
 371                         err := errors.New("Custom reader error")
 372                         errReader := &errorReader{err}
 373                         return ioutil.NopCloser(errReader)
 374                 },
 375
 376                 WantError: errors.New("Custom reader error"),
 377         },
 378
 379         // Verify that DumpRequest preserves the HTTP version number, doesn't add a Host,
 380         // and doesn't add a User-Agent.
 381         14: {
 382                 Req: Request{
 383                         Method:     "GET",
 384                         URL:        mustParseURL("/foo"),
 385                         ProtoMajor: 1,
 386                         ProtoMinor: 0,
 387                         Header: Header{
 388                                 "X-Foo": []string{"X-Bar"},
 389                         },
 390                 },
 391
 392                 WantWrite: "GET /foo HTTP/1.1\r\n" +
 393                         "Host: \r\n" +
 394                         "User-Agent: Go-http-client/1.1\r\n" +
 395                         "X-Foo: X-Bar\r\n\r\n",
 396         },
 397
 398         // If no Request.Host and no Request.URL.Host, we send
 399         // an empty Host header, and don't use
 400         // Request.Header["Host"]. This is just testing that
 401         // we don't change Go 1.0 behavior.
 402         15: {
 403                 Req: Request{
 404                         Method: "GET",
 405                         Host:   "",
 406                         URL: &url.URL{
 407                                 Scheme: "http",
 408                                 Host:   "",
 409                                 Path:   "/search",
 410                         },
 411                         ProtoMajor: 1,
 412                         ProtoMinor: 1,
 413                         Header: Header{
 414                                 "Host": []string{"bad.example.com"},
 415                         },
 416                 },
 417
 418                 WantWrite: "GET /search HTTP/1.1\r\n" +
 419                         "Host: \r\n" +
 420                         "User-Agent: Go-http-client/1.1\r\n\r\n",
 421         },
 422
 423         // Opaque test #1 from golang.org/issue/4860
 424         16: {
 425                 Req: Request{
 426                         Method: "GET",
 427                         URL: &url.URL{
 428                                 Scheme: "http",
 429                                 Host:   "www.google.com",
 430                                 Opaque: "/%2F/%2F/",
 431                         },
 432                         ProtoMajor: 1,
 433                         ProtoMinor: 1,
 434                         Header:     Header{},
 435                 },
 436
 437                 WantWrite: "GET /%2F/%2F/ HTTP/1.1\r\n" +
 438                         "Host: www.google.com\r\n" +
 439                         "User-Agent: Go-http-client/1.1\r\n\r\n",
 440         },
 441
 442         // Opaque test #2 from golang.org/issue/4860
 443         17: {
 444                 Req: Request{
 445                         Method: "GET",
 446                         URL: &url.URL{
 447                                 Scheme: "http",
 448                                 Host:   "x.google.com",
 449                                 Opaque: "//y.google.com/%2F/%2F/",
 450                         },
 451                         ProtoMajor: 1,
 452                         ProtoMinor: 1,
 453                         Header:     Header{},
 454                 },
 455
 456                 WantWrite: "GET http://y.google.com/%2F/%2F/ HTTP/1.1\r\n" +
 457                         "Host: x.google.com\r\n" +
 458                         "User-Agent: Go-http-client/1.1\r\n\r\n",
 459         },
 460
 461         // Testing custom case in header keys. Issue 5022.
 462         18: {
 463                 Req: Request{
 464                         Method: "GET",
 465                         URL: &url.URL{
 466                                 Scheme: "http",
 467                                 Host:   "www.google.com",
 468                                 Path:   "/",
 469                         },
 470                         Proto:      "HTTP/1.1",
 471                         ProtoMajor: 1,
 472                         ProtoMinor: 1,
 473                         Header: Header{
 474                                 "ALL-CAPS": {"x"},
 475                         },
 476                 },
 477
 478                 WantWrite: "GET / HTTP/1.1\r\n" +
 479                         "Host: www.google.com\r\n" +
 480                         "User-Agent: Go-http-client/1.1\r\n" +
 481                         "ALL-CAPS: x\r\n" +
 482                         "\r\n",
 483         },
 484
 485         // Request with host header field; IPv6 address with zone identifier
 486         19: {
 487                 Req: Request{
 488                         Method: "GET",
 489                         URL: &url.URL{
 490                                 Host: "[fe80::1%en0]",
 491                         },
 492                 },
 493
 494                 WantWrite: "GET / HTTP/1.1\r\n" +
 495                         "Host: [fe80::1]\r\n" +
 496                         "User-Agent: Go-http-client/1.1\r\n" +
 497                         "\r\n",
 498         },
 499
 500         // Request with optional host header field; IPv6 address with zone identifier
 501         20: {
 502                 Req: Request{
 503                         Method: "GET",
 504                         URL: &url.URL{
 505                                 Host: "www.example.com",
 506                         },
 507                         Host: "[fe80::1%en0]:8080",
 508                 },
 509
 510                 WantWrite: "GET / HTTP/1.1\r\n" +
 511                         "Host: [fe80::1]:8080\r\n" +
 512                         "User-Agent: Go-http-client/1.1\r\n" +
 513                         "\r\n",
 514         },
 515 }
 516
 517 func TestRequestWrite(t *testing.T) {
 518         for i := range reqWriteTests {
 519                 tt := &reqWriteTests[i]
 520
 521                 setBody := func() {
 522                         if tt.Body == nil {
 523                                 return
 524                         }
 525                         switch b := tt.Body.(type) {
 526                         case []byte:
 527                                 tt.Req.Body = ioutil.NopCloser(bytes.NewReader(b))
 528                         case func() io.ReadCloser:
 529                                 tt.Req.Body = b()
 530                         }
 531                 }
 532                 setBody()
 533                 if tt.Req.Header == nil {
 534                         tt.Req.Header = make(Header)
 535                 }
 536
 537                 var braw bytes.Buffer
 538                 err := tt.Req.Write(&braw)
 539                 if g, e := fmt.Sprintf("%v", err), fmt.Sprintf("%v", tt.WantError); g != e {
 540                         t.Errorf("writing #%d, err = %q, want %q", i, g, e)
 541                         continue
 542                 }
 543                 if err != nil {
 544                         continue
 545                 }
 546
 547                 if tt.WantWrite != "" {
 548                         sraw := braw.String()
 549                         if sraw != tt.WantWrite {
 550                                 t.Errorf("Test %d, expecting:\n%s\nGot:\n%s\n", i, tt.WantWrite, sraw)
 551                                 continue
 552                         }
 553                 }
 554
 555                 if tt.WantProxy != "" {
 556                         setBody()
 557                         var praw bytes.Buffer
 558                         err = tt.Req.WriteProxy(&praw)
 559                         if err != nil {
 560                                 t.Errorf("WriteProxy #%d: %s", i, err)
 561                                 continue
 562                         }
 563                         sraw := praw.String()
 564                         if sraw != tt.WantProxy {
 565                                 t.Errorf("Test Proxy %d, expecting:\n%s\nGot:\n%s\n", i, tt.WantProxy, sraw)
 566                                 continue
 567                         }
 568                 }
 569         }
 570 }
 571
 572 func TestRequestWriteTransport(t *testing.T) {
 573         t.Parallel()
 574
 575         matchSubstr := func(substr string) func(string) error {
 576                 return func(written string) error {
 577                         if !strings.Contains(written, substr) {
 578                                 return fmt.Errorf("expected substring %q in request: %s", substr, written)
 579                         }
 580                         return nil
 581                 }
 582         }
 583
 584         noContentLengthOrTransferEncoding := func(req string) error {
 585                 if strings.Contains(req, "Content-Length: ") {
 586                         return fmt.Errorf("unexpected Content-Length in request: %s", req)
 587                 }
 588                 if strings.Contains(req, "Transfer-Encoding: ") {
 589                         return fmt.Errorf("unexpected Transfer-Encoding in request: %s", req)
 590                 }
 591                 return nil
 592         }
 593
 594         all := func(checks ...func(string) error) func(string) error {
 595                 return func(req string) error {
 596                         for _, c := range checks {
 597                                 if err := c(req); err != nil {
 598                                         return err
 599                                 }
 600                         }
 601                         return nil
 602                 }
 603         }
 604
 605         type testCase struct {
 606                 method string
 607                 clen   int64 // ContentLength
 608                 body   io.ReadCloser
 609                 want   func(string) error
 610
 611                 // optional:
 612                 init         func(*testCase)
 613                 afterReqRead func()
 614         }
 615
 616         tests := []testCase{
 617                 {
 618                         method: "GET",
 619                         want:   noContentLengthOrTransferEncoding,
 620                 },
 621                 {
 622                         method: "GET",
 623                         body:   ioutil.NopCloser(strings.NewReader("")),
 624                         want:   noContentLengthOrTransferEncoding,
 625                 },
 626                 {
 627                         method: "GET",
 628                         clen:   -1,
 629                         body:   ioutil.NopCloser(strings.NewReader("")),
 630                         want:   noContentLengthOrTransferEncoding,
 631                 },
 632                 // A GET with a body, with explicit content length:
 633                 {
 634                         method: "GET",
 635                         clen:   7,
 636                         body:   ioutil.NopCloser(strings.NewReader("foobody")),
 637                         want: all(matchSubstr("Content-Length: 7"),
 638                                 matchSubstr("foobody")),
 639                 },
 640                 // A GET with a body, sniffing the leading "f" from "foobody".
 641                 {
 642                         method: "GET",
 643                         clen:   -1,
 644                         body:   ioutil.NopCloser(strings.NewReader("foobody")),
 645                         want: all(matchSubstr("Transfer-Encoding: chunked"),
 646                                 matchSubstr("\r\n1\r\nf\r\n"),
 647                                 matchSubstr("oobody")),
 648                 },
 649                 // But a POST request is expected to have a body, so
 650                 // no sniffing happens:
 651                 {
 652                         method: "POST",
 653                         clen:   -1,
 654                         body:   ioutil.NopCloser(strings.NewReader("foobody")),
 655                         want: all(matchSubstr("Transfer-Encoding: chunked"),
 656                                 matchSubstr("foobody")),
 657                 },
 658                 {
 659                         method: "POST",
 660                         clen:   -1,
 661                         body:   ioutil.NopCloser(strings.NewReader("")),
 662                         want:   all(matchSubstr("Transfer-Encoding: chunked")),
 663                 },
 664                 // Verify that a blocking Request.Body doesn't block forever.
 665                 {
 666                         method: "GET",
 667                         clen:   -1,
 668                         init: func(tt *testCase) {
 669                                 pr, pw := io.Pipe()
 670                                 tt.afterReqRead = func() {
 671                                         pw.Close()
 672                                 }
 673                                 tt.body = ioutil.NopCloser(pr)
 674                         },
 675                         want: matchSubstr("Transfer-Encoding: chunked"),
 676                 },
 677         }
 678
 679         for i, tt := range tests {
 680                 if tt.init != nil {
 681                         tt.init(&tt)
 682                 }
 683                 req := &Request{
 684                         Method: tt.method,
 685                         URL: &url.URL{
 686                                 Scheme: "http",
 687                                 Host:   "example.com",
 688                         },
 689                         Header:        make(Header),
 690                         ContentLength: tt.clen,
 691                         Body:          tt.body,
 692                 }
 693                 got, err := dumpRequestOut(req, tt.afterReqRead)
 694                 if err != nil {
 695                         t.Errorf("test[%d]: %v", i, err)
 696                         continue
 697                 }
 698                 if err := tt.want(string(got)); err != nil {
 699                         t.Errorf("test[%d]: %v", i, err)
 700                 }
 701         }
 702 }
 703
 704 type closeChecker struct {
 705         io.Reader
 706         closed bool
 707 }
 708
 709 func (rc *closeChecker) Close() error {
 710         rc.closed = true
 711         return nil
 712 }
 713
 714 // TestRequestWriteClosesBody tests that Request.Write closes its request.Body.
 715 // It also indirectly tests NewRequest and that it doesn't wrap an existing Closer
 716 // inside a NopCloser, and that it serializes it correctly.
 717 func TestRequestWriteClosesBody(t *testing.T) {
 718         rc := &closeChecker{Reader: strings.NewReader("my body")}
 719         req, err := NewRequest("POST", "http://foo.com/", rc)
 720         if err != nil {
 721                 t.Fatal(err)
 722         }
 723         buf := new(bytes.Buffer)
 724         if err := req.Write(buf); err != nil {
 725                 t.Error(err)
 726         }
 727         if !rc.closed {
 728                 t.Error("body not closed after write")
 729         }
 730         expected := "POST / HTTP/1.1\r\n" +
 731                 "Host: foo.com\r\n" +
 732                 "User-Agent: Go-http-client/1.1\r\n" +
 733                 "Transfer-Encoding: chunked\r\n\r\n" +
 734                 chunk("my body") +
 735                 chunk("")
 736         if buf.String() != expected {
 737                 t.Errorf("write:\n got: %s\nwant: %s", buf.String(), expected)
 738         }
 739 }
 740
 741 func chunk(s string) string {
 742         return fmt.Sprintf("%x\r\n%s\r\n", len(s), s)
 743 }
 744
 745 func mustParseURL(s string) *url.URL {
 746         u, err := url.Parse(s)
 747         if err != nil {
 748                 panic(fmt.Sprintf("Error parsing URL %q: %v", s, err))
 749         }
 750         return u
 751 }
 752
 753 type writerFunc func([]byte) (int, error)
 754
 755 func (f writerFunc) Write(p []byte) (int, error) { return f(p) }
 756
 757 // TestRequestWriteError tests the Write err != nil checks in (*Request).write.
 758 func TestRequestWriteError(t *testing.T) {
 759         failAfter, writeCount := 0, 0
 760         errFail := errors.New("fake write failure")
 761
 762         // w is the buffered io.Writer to write the request to. It
 763         // fails exactly once on its Nth Write call, as controlled by
 764         // failAfter. It also tracks the number of calls in
 765         // writeCount.
 766         w := struct {
 767                 io.ByteWriter // to avoid being wrapped by a bufio.Writer
 768                 io.Writer
 769         }{
 770                 nil,
 771                 writerFunc(func(p []byte) (n int, err error) {
 772                         writeCount++
 773                         if failAfter == 0 {
 774                                 err = errFail
 775                         }
 776                         failAfter--
 777                         return len(p), err
 778                 }),
 779         }
 780
 781         req, _ := NewRequest("GET", "http://example.com/", nil)
 782         const writeCalls = 4 // number of Write calls in current implementation
 783         sawGood := false
 784         for n := 0; n <= writeCalls+2; n++ {
 785                 failAfter = n
 786                 writeCount = 0
 787                 err := req.Write(w)
 788                 var wantErr error
 789                 if n < writeCalls {
 790                         wantErr = errFail
 791                 }
 792                 if err != wantErr {
 793                         t.Errorf("for fail-after %d Writes, err = %v; want %v", n, err, wantErr)
 794                         continue
 795                 }
 796                 if err == nil {
 797                         sawGood = true
 798                         if writeCount != writeCalls {
 799                                 t.Fatalf("writeCalls constant is outdated in test")
 800                         }
 801                 }
 802                 if writeCount > writeCalls || writeCount > n+1 {
 803                         t.Errorf("for fail-after %d, saw unexpectedly high (%d) write calls", n, writeCount)
 804                 }
 805         }
 806         if !sawGood {
 807                 t.Fatalf("writeCalls constant is outdated in test")
 808         }
 809 }
 810
 811 // dumpRequestOut is a modified copy of net/http/httputil.DumpRequestOut.
 812 // Unlike the original, this version doesn't mutate the req.Body and
 813 // try to restore it. It always dumps the whole body.
 814 // And it doesn't support https.
 815 func dumpRequestOut(req *Request, onReadHeaders func()) ([]byte, error) {
 816
 817         // Use the actual Transport code to record what we would send
 818         // on the wire, but not using TCP.  Use a Transport with a
 819         // custom dialer that returns a fake net.Conn that waits
 820         // for the full input (and recording it), and then responds
 821         // with a dummy response.
 822         var buf bytes.Buffer // records the output
 823         pr, pw := io.Pipe()
 824         defer pr.Close()
 825         defer pw.Close()
 826         dr := &delegateReader{c: make(chan io.Reader)}
 827
 828         t := &Transport{
 829                 Dial: func(net, addr string) (net.Conn, error) {
 830                         return &dumpConn{io.MultiWriter(&buf, pw), dr}, nil
 831                 },
 832         }
 833         defer t.CloseIdleConnections()
 834
 835         // Wait for the request before replying with a dummy response:
 836         go func() {
 837                 req, err := ReadRequest(bufio.NewReader(pr))
 838                 if err == nil {
 839                         if onReadHeaders != nil {
 840                                 onReadHeaders()
 841                         }
 842                         // Ensure all the body is read; otherwise
 843                         // we'll get a partial dump.
 844                         io.Copy(ioutil.Discard, req.Body)
 845                         req.Body.Close()
 846                 }
 847                 dr.c <- strings.NewReader("HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n")
 848         }()
 849
 850         _, err := t.RoundTrip(req)
 851         if err != nil {
 852                 return nil, err
 853         }
 854         return buf.Bytes(), nil
 855 }
 856
 857 // delegateReader is a reader that delegates to another reader,
 858 // once it arrives on a channel.
 859 type delegateReader struct {
 860         c chan io.Reader
 861         r io.Reader // nil until received from c
 862 }
 863
 864 func (r *delegateReader) Read(p []byte) (int, error) {
 865         if r.r == nil {
 866                 r.r = <-r.c
 867         }
 868         return r.r.Read(p)
 869 }
 870
 871 // dumpConn is a net.Conn that writes to Writer and reads from Reader.
 872 type dumpConn struct {
 873         io.Writer
 874         io.Reader
 875 }
 876
 877 func (c *dumpConn) Close() error                       { return nil }
 878 func (c *dumpConn) LocalAddr() net.Addr                { return nil }
 879 func (c *dumpConn) RemoteAddr() net.Addr               { return nil }
 880 func (c *dumpConn) SetDeadline(t time.Time) error      { return nil }
 881 func (c *dumpConn) SetReadDeadline(t time.Time) error  { return nil }
 882 func (c *dumpConn) SetWriteDeadline(t time.Time) error { return nil }