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         "net"
  14         "net/url"
  15         "strings"
  16         "testing"
  17         "testing/iotest"
  18         "time"
  19 )
  20
  21 type reqWriteTest struct {
  22         Req  Request
  23         Body any // 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 io.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 io.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 := iotest.ErrReader(err)
 353                         return io.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 := iotest.ErrReader(err)
 373                         return io.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         // CONNECT without Opaque
 517         21: {
 518                 Req: Request{
 519                         Method: "CONNECT",
 520                         URL: &url.URL{
 521                                 Scheme: "https", // of proxy.com
 522                                 Host:   "proxy.com",
 523                         },
 524                 },
 525                 // What we used to do, locking that behavior in:
 526                 WantWrite: "CONNECT proxy.com HTTP/1.1\r\n" +
 527                         "Host: proxy.com\r\n" +
 528                         "User-Agent: Go-http-client/1.1\r\n" +
 529                         "\r\n",
 530         },
 531
 532         // CONNECT with Opaque
 533         22: {
 534                 Req: Request{
 535                         Method: "CONNECT",
 536                         URL: &url.URL{
 537                                 Scheme: "https", // of proxy.com
 538                                 Host:   "proxy.com",
 539                                 Opaque: "backend:443",
 540                         },
 541                 },
 542                 WantWrite: "CONNECT backend:443 HTTP/1.1\r\n" +
 543                         "Host: proxy.com\r\n" +
 544                         "User-Agent: Go-http-client/1.1\r\n" +
 545                         "\r\n",
 546         },
 547
 548         // Verify that a nil header value doesn't get written.
 549         23: {
 550                 Req: Request{
 551                         Method: "GET",
 552                         URL:    mustParseURL("/foo"),
 553                         Header: Header{
 554                                 "X-Foo":             []string{"X-Bar"},
 555                                 "X-Idempotency-Key": nil,
 556                         },
 557                 },
 558
 559                 WantWrite: "GET /foo HTTP/1.1\r\n" +
 560                         "Host: \r\n" +
 561                         "User-Agent: Go-http-client/1.1\r\n" +
 562                         "X-Foo: X-Bar\r\n\r\n",
 563         },
 564         24: {
 565                 Req: Request{
 566                         Method: "GET",
 567                         URL:    mustParseURL("/foo"),
 568                         Header: Header{
 569                                 "X-Foo":             []string{"X-Bar"},
 570                                 "X-Idempotency-Key": []string{},
 571                         },
 572                 },
 573
 574                 WantWrite: "GET /foo HTTP/1.1\r\n" +
 575                         "Host: \r\n" +
 576                         "User-Agent: Go-http-client/1.1\r\n" +
 577                         "X-Foo: X-Bar\r\n\r\n",
 578         },
 579
 580         25: {
 581                 Req: Request{
 582                         Method: "GET",
 583                         URL: &url.URL{
 584                                 Host:     "www.example.com",
 585                                 RawQuery: "new\nline", // or any CTL
 586                         },
 587                 },
 588                 WantError: errors.New("net/http: can't write control character in Request.URL"),
 589         },
 590
 591         26: { // Request with nil body and PATCH method. Issue #40978
 592                 Req: Request{
 593                         Method:        "PATCH",
 594                         URL:           mustParseURL("/"),
 595                         Host:          "example.com",
 596                         ProtoMajor:    1,
 597                         ProtoMinor:    1,
 598                         ContentLength: 0, // as if unset by user
 599                 },
 600                 Body: nil,
 601                 WantWrite: "PATCH / HTTP/1.1\r\n" +
 602                         "Host: example.com\r\n" +
 603                         "User-Agent: Go-http-client/1.1\r\n" +
 604                         "Content-Length: 0\r\n\r\n",
 605                 WantProxy: "PATCH / HTTP/1.1\r\n" +
 606                         "Host: example.com\r\n" +
 607                         "User-Agent: Go-http-client/1.1\r\n" +
 608                         "Content-Length: 0\r\n\r\n",
 609         },
 610 }
 611
 612 func TestRequestWrite(t *testing.T) {
 613         for i := range reqWriteTests {
 614                 tt := &reqWriteTests[i]
 615
 616                 setBody := func() {
 617                         if tt.Body == nil {
 618                                 return
 619                         }
 620                         switch b := tt.Body.(type) {
 621                         case []byte:
 622                                 tt.Req.Body = io.NopCloser(bytes.NewReader(b))
 623                         case func() io.ReadCloser:
 624                                 tt.Req.Body = b()
 625                         }
 626                 }
 627                 setBody()
 628                 if tt.Req.Header == nil {
 629                         tt.Req.Header = make(Header)
 630                 }
 631
 632                 var braw bytes.Buffer
 633                 err := tt.Req.Write(&braw)
 634                 if g, e := fmt.Sprintf("%v", err), fmt.Sprintf("%v", tt.WantError); g != e {
 635                         t.Errorf("writing #%d, err = %q, want %q", i, g, e)
 636                         continue
 637                 }
 638                 if err != nil {
 639                         continue
 640                 }
 641
 642                 if tt.WantWrite != "" {
 643                         sraw := braw.String()
 644                         if sraw != tt.WantWrite {
 645                                 t.Errorf("Test %d, expecting:\n%s\nGot:\n%s\n", i, tt.WantWrite, sraw)
 646                                 continue
 647                         }
 648                 }
 649
 650                 if tt.WantProxy != "" {
 651                         setBody()
 652                         var praw bytes.Buffer
 653                         err = tt.Req.WriteProxy(&praw)
 654                         if err != nil {
 655                                 t.Errorf("WriteProxy #%d: %s", i, err)
 656                                 continue
 657                         }
 658                         sraw := praw.String()
 659                         if sraw != tt.WantProxy {
 660                                 t.Errorf("Test Proxy %d, expecting:\n%s\nGot:\n%s\n", i, tt.WantProxy, sraw)
 661                                 continue
 662                         }
 663                 }
 664         }
 665 }
 666
 667 func TestRequestWriteTransport(t *testing.T) {
 668         t.Parallel()
 669
 670         matchSubstr := func(substr string) func(string) error {
 671                 return func(written string) error {
 672                         if !strings.Contains(written, substr) {
 673                                 return fmt.Errorf("expected substring %q in request: %s", substr, written)
 674                         }
 675                         return nil
 676                 }
 677         }
 678
 679         noContentLengthOrTransferEncoding := func(req string) error {
 680                 if strings.Contains(req, "Content-Length: ") {
 681                         return fmt.Errorf("unexpected Content-Length in request: %s", req)
 682                 }
 683                 if strings.Contains(req, "Transfer-Encoding: ") {
 684                         return fmt.Errorf("unexpected Transfer-Encoding in request: %s", req)
 685                 }
 686                 return nil
 687         }
 688
 689         all := func(checks ...func(string) error) func(string) error {
 690                 return func(req string) error {
 691                         for _, c := range checks {
 692                                 if err := c(req); err != nil {
 693                                         return err
 694                                 }
 695                         }
 696                         return nil
 697                 }
 698         }
 699
 700         type testCase struct {
 701                 method string
 702                 clen   int64 // ContentLength
 703                 body   io.ReadCloser
 704                 want   func(string) error
 705
 706                 // optional:
 707                 init         func(*testCase)
 708                 afterReqRead func()
 709         }
 710
 711         tests := []testCase{
 712                 {
 713                         method: "GET",
 714                         want:   noContentLengthOrTransferEncoding,
 715                 },
 716                 {
 717                         method: "GET",
 718                         body:   io.NopCloser(strings.NewReader("")),
 719                         want:   noContentLengthOrTransferEncoding,
 720                 },
 721                 {
 722                         method: "GET",
 723                         clen:   -1,
 724                         body:   io.NopCloser(strings.NewReader("")),
 725                         want:   noContentLengthOrTransferEncoding,
 726                 },
 727                 // A GET with a body, with explicit content length:
 728                 {
 729                         method: "GET",
 730                         clen:   7,
 731                         body:   io.NopCloser(strings.NewReader("foobody")),
 732                         want: all(matchSubstr("Content-Length: 7"),
 733                                 matchSubstr("foobody")),
 734                 },
 735                 // A GET with a body, sniffing the leading "f" from "foobody".
 736                 {
 737                         method: "GET",
 738                         clen:   -1,
 739                         body:   io.NopCloser(strings.NewReader("foobody")),
 740                         want: all(matchSubstr("Transfer-Encoding: chunked"),
 741                                 matchSubstr("\r\n1\r\nf\r\n"),
 742                                 matchSubstr("oobody")),
 743                 },
 744                 // But a POST request is expected to have a body, so
 745                 // no sniffing happens:
 746                 {
 747                         method: "POST",
 748                         clen:   -1,
 749                         body:   io.NopCloser(strings.NewReader("foobody")),
 750                         want: all(matchSubstr("Transfer-Encoding: chunked"),
 751                                 matchSubstr("foobody")),
 752                 },
 753                 {
 754                         method: "POST",
 755                         clen:   -1,
 756                         body:   io.NopCloser(strings.NewReader("")),
 757                         want:   all(matchSubstr("Transfer-Encoding: chunked")),
 758                 },
 759                 // Verify that a blocking Request.Body doesn't block forever.
 760                 {
 761                         method: "GET",
 762                         clen:   -1,
 763                         init: func(tt *testCase) {
 764                                 pr, pw := io.Pipe()
 765                                 tt.afterReqRead = func() {
 766                                         pw.Close()
 767                                 }
 768                                 tt.body = io.NopCloser(pr)
 769                         },
 770                         want: matchSubstr("Transfer-Encoding: chunked"),
 771                 },
 772         }
 773
 774         for i, tt := range tests {
 775                 if tt.init != nil {
 776                         tt.init(&tt)
 777                 }
 778                 req := &Request{
 779                         Method: tt.method,
 780                         URL: &url.URL{
 781                                 Scheme: "http",
 782                                 Host:   "example.com",
 783                         },
 784                         Header:        make(Header),
 785                         ContentLength: tt.clen,
 786                         Body:          tt.body,
 787                 }
 788                 got, err := dumpRequestOut(req, tt.afterReqRead)
 789                 if err != nil {
 790                         t.Errorf("test[%d]: %v", i, err)
 791                         continue
 792                 }
 793                 if err := tt.want(string(got)); err != nil {
 794                         t.Errorf("test[%d]: %v", i, err)
 795                 }
 796         }
 797 }
 798
 799 type closeChecker struct {
 800         io.Reader
 801         closed bool
 802 }
 803
 804 func (rc *closeChecker) Close() error {
 805         rc.closed = true
 806         return nil
 807 }
 808
 809 // TestRequestWriteClosesBody tests that Request.Write closes its request.Body.
 810 // It also indirectly tests NewRequest and that it doesn't wrap an existing Closer
 811 // inside a NopCloser, and that it serializes it correctly.
 812 func TestRequestWriteClosesBody(t *testing.T) {
 813         rc := &closeChecker{Reader: strings.NewReader("my body")}
 814         req, err := NewRequest("POST", "http://foo.com/", rc)
 815         if err != nil {
 816                 t.Fatal(err)
 817         }
 818         buf := new(bytes.Buffer)
 819         if err := req.Write(buf); err != nil {
 820                 t.Error(err)
 821         }
 822         if !rc.closed {
 823                 t.Error("body not closed after write")
 824         }
 825         expected := "POST / HTTP/1.1\r\n" +
 826                 "Host: foo.com\r\n" +
 827                 "User-Agent: Go-http-client/1.1\r\n" +
 828                 "Transfer-Encoding: chunked\r\n\r\n" +
 829                 chunk("my body") +
 830                 chunk("")
 831         if buf.String() != expected {
 832                 t.Errorf("write:\n got: %s\nwant: %s", buf.String(), expected)
 833         }
 834 }
 835
 836 func chunk(s string) string {
 837         return fmt.Sprintf("%x\r\n%s\r\n", len(s), s)
 838 }
 839
 840 func mustParseURL(s string) *url.URL {
 841         u, err := url.Parse(s)
 842         if err != nil {
 843                 panic(fmt.Sprintf("Error parsing URL %q: %v", s, err))
 844         }
 845         return u
 846 }
 847
 848 type writerFunc func([]byte) (int, error)
 849
 850 func (f writerFunc) Write(p []byte) (int, error) { return f(p) }
 851
 852 // TestRequestWriteError tests the Write err != nil checks in (*Request).write.
 853 func TestRequestWriteError(t *testing.T) {
 854         failAfter, writeCount := 0, 0
 855         errFail := errors.New("fake write failure")
 856
 857         // w is the buffered io.Writer to write the request to. It
 858         // fails exactly once on its Nth Write call, as controlled by
 859         // failAfter. It also tracks the number of calls in
 860         // writeCount.
 861         w := struct {
 862                 io.ByteWriter // to avoid being wrapped by a bufio.Writer
 863                 io.Writer
 864         }{
 865                 nil,
 866                 writerFunc(func(p []byte) (n int, err error) {
 867                         writeCount++
 868                         if failAfter == 0 {
 869                                 err = errFail
 870                         }
 871                         failAfter--
 872                         return len(p), err
 873                 }),
 874         }
 875
 876         req, _ := NewRequest("GET", "http://example.com/", nil)
 877         const writeCalls = 4 // number of Write calls in current implementation
 878         sawGood := false
 879         for n := 0; n <= writeCalls+2; n++ {
 880                 failAfter = n
 881                 writeCount = 0
 882                 err := req.Write(w)
 883                 var wantErr error
 884                 if n < writeCalls {
 885                         wantErr = errFail
 886                 }
 887                 if err != wantErr {
 888                         t.Errorf("for fail-after %d Writes, err = %v; want %v", n, err, wantErr)
 889                         continue
 890                 }
 891                 if err == nil {
 892                         sawGood = true
 893                         if writeCount != writeCalls {
 894                                 t.Fatalf("writeCalls constant is outdated in test")
 895                         }
 896                 }
 897                 if writeCount > writeCalls || writeCount > n+1 {
 898                         t.Errorf("for fail-after %d, saw unexpectedly high (%d) write calls", n, writeCount)
 899                 }
 900         }
 901         if !sawGood {
 902                 t.Fatalf("writeCalls constant is outdated in test")
 903         }
 904 }
 905
 906 // dumpRequestOut is a modified copy of net/http/httputil.DumpRequestOut.
 907 // Unlike the original, this version doesn't mutate the req.Body and
 908 // try to restore it. It always dumps the whole body.
 909 // And it doesn't support https.
 910 func dumpRequestOut(req *Request, onReadHeaders func()) ([]byte, error) {
 911
 912         // Use the actual Transport code to record what we would send
 913         // on the wire, but not using TCP.  Use a Transport with a
 914         // custom dialer that returns a fake net.Conn that waits
 915         // for the full input (and recording it), and then responds
 916         // with a dummy response.
 917         var buf bytes.Buffer // records the output
 918         pr, pw := io.Pipe()
 919         defer pr.Close()
 920         defer pw.Close()
 921         dr := &delegateReader{c: make(chan io.Reader)}
 922
 923         t := &Transport{
 924                 Dial: func(net, addr string) (net.Conn, error) {
 925                         return &dumpConn{io.MultiWriter(&buf, pw), dr}, nil
 926                 },
 927         }
 928         defer t.CloseIdleConnections()
 929
 930         // Wait for the request before replying with a dummy response:
 931         go func() {
 932                 req, err := ReadRequest(bufio.NewReader(pr))
 933                 if err == nil {
 934                         if onReadHeaders != nil {
 935                                 onReadHeaders()
 936                         }
 937                         // Ensure all the body is read; otherwise
 938                         // we'll get a partial dump.
 939                         io.Copy(io.Discard, req.Body)
 940                         req.Body.Close()
 941                 }
 942                 dr.c <- strings.NewReader("HTTP/1.1 204 No Content\r\nConnection: close\r\n\r\n")
 943         }()
 944
 945         _, err := t.RoundTrip(req)
 946         if err != nil {
 947                 return nil, err
 948         }
 949         return buf.Bytes(), nil
 950 }
 951
 952 // delegateReader is a reader that delegates to another reader,
 953 // once it arrives on a channel.
 954 type delegateReader struct {
 955         c chan io.Reader
 956         r io.Reader // nil until received from c
 957 }
 958
 959 func (r *delegateReader) Read(p []byte) (int, error) {
 960         if r.r == nil {
 961                 r.r = <-r.c
 962         }
 963         return r.r.Read(p)
 964 }
 965
 966 // dumpConn is a net.Conn that writes to Writer and reads from Reader.
 967 type dumpConn struct {
 968         io.Writer
 969         io.Reader
 970 }
 971
 972 func (c *dumpConn) Close() error                       { return nil }
 973 func (c *dumpConn) LocalAddr() net.Addr                { return nil }
 974 func (c *dumpConn) RemoteAddr() net.Addr               { return nil }
 975 func (c *dumpConn) SetDeadline(t time.Time) error      { return nil }
 976 func (c *dumpConn) SetReadDeadline(t time.Time) error  { return nil }
 977 func (c *dumpConn) SetWriteDeadline(t time.Time) error { return nil }