src/net/http/client_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 // Tests for client.go
   6
   7 package http_test
   8
   9 import (
  10         "bytes"
  11         "context"
  12         "crypto/tls"
  13         "crypto/x509"
  14         "encoding/base64"
  15         "errors"
  16         "fmt"
  17         "io"
  18         "io/ioutil"
  19         "log"
  20         "net"
  21         . "net/http"
  22         "net/http/httptest"
  23         "net/url"
  24         "reflect"
  25         "strconv"
  26         "strings"
  27         "sync"
  28         "testing"
  29         "time"
  30 )
  31
  32 var robotsTxtHandler = HandlerFunc(func(w ResponseWriter, r *Request) {
  33         w.Header().Set("Last-Modified", "sometime")
  34         fmt.Fprintf(w, "User-agent: go\nDisallow: /something/")
  35 })
  36
  37 // pedanticReadAll works like ioutil.ReadAll but additionally
  38 // verifies that r obeys the documented io.Reader contract.
  39 func pedanticReadAll(r io.Reader) (b []byte, err error) {
  40         var bufa [64]byte
  41         buf := bufa[:]
  42         for {
  43                 n, err := r.Read(buf)
  44                 if n == 0 && err == nil {
  45                         return nil, fmt.Errorf("Read: n=0 with err=nil")
  46                 }
  47                 b = append(b, buf[:n]...)
  48                 if err == io.EOF {
  49                         n, err := r.Read(buf)
  50                         if n != 0 || err != io.EOF {
  51                                 return nil, fmt.Errorf("Read: n=%d err=%#v after EOF", n, err)
  52                         }
  53                         return b, nil
  54                 }
  55                 if err != nil {
  56                         return b, err
  57                 }
  58         }
  59 }
  60
  61 type chanWriter chan string
  62
  63 func (w chanWriter) Write(p []byte) (n int, err error) {
  64         w <- string(p)
  65         return len(p), nil
  66 }
  67
  68 func TestClient(t *testing.T) {
  69         defer afterTest(t)
  70         ts := httptest.NewServer(robotsTxtHandler)
  71         defer ts.Close()
  72
  73         r, err := Get(ts.URL)
  74         var b []byte
  75         if err == nil {
  76                 b, err = pedanticReadAll(r.Body)
  77                 r.Body.Close()
  78         }
  79         if err != nil {
  80                 t.Error(err)
  81         } else if s := string(b); !strings.HasPrefix(s, "User-agent:") {
  82                 t.Errorf("Incorrect page body (did not begin with User-agent): %q", s)
  83         }
  84 }
  85
  86 func TestClientHead_h1(t *testing.T) { testClientHead(t, h1Mode) }
  87 func TestClientHead_h2(t *testing.T) { testClientHead(t, h2Mode) }
  88
  89 func testClientHead(t *testing.T, h2 bool) {
  90         defer afterTest(t)
  91         cst := newClientServerTest(t, h2, robotsTxtHandler)
  92         defer cst.close()
  93
  94         r, err := cst.c.Head(cst.ts.URL)
  95         if err != nil {
  96                 t.Fatal(err)
  97         }
  98         if _, ok := r.Header["Last-Modified"]; !ok {
  99                 t.Error("Last-Modified header not found.")
 100         }
 101 }
 102
 103 type recordingTransport struct {
 104         req *Request
 105 }
 106
 107 func (t *recordingTransport) RoundTrip(req *Request) (resp *Response, err error) {
 108         t.req = req
 109         return nil, errors.New("dummy impl")
 110 }
 111
 112 func TestGetRequestFormat(t *testing.T) {
 113         defer afterTest(t)
 114         tr := &recordingTransport{}
 115         client := &Client{Transport: tr}
 116         url := "http://dummy.faketld/"
 117         client.Get(url) // Note: doesn't hit network
 118         if tr.req.Method != "GET" {
 119                 t.Errorf("expected method %q; got %q", "GET", tr.req.Method)
 120         }
 121         if tr.req.URL.String() != url {
 122                 t.Errorf("expected URL %q; got %q", url, tr.req.URL.String())
 123         }
 124         if tr.req.Header == nil {
 125                 t.Errorf("expected non-nil request Header")
 126         }
 127 }
 128
 129 func TestPostRequestFormat(t *testing.T) {
 130         defer afterTest(t)
 131         tr := &recordingTransport{}
 132         client := &Client{Transport: tr}
 133
 134         url := "http://dummy.faketld/"
 135         json := `{"key":"value"}`
 136         b := strings.NewReader(json)
 137         client.Post(url, "application/json", b) // Note: doesn't hit network
 138
 139         if tr.req.Method != "POST" {
 140                 t.Errorf("got method %q, want %q", tr.req.Method, "POST")
 141         }
 142         if tr.req.URL.String() != url {
 143                 t.Errorf("got URL %q, want %q", tr.req.URL.String(), url)
 144         }
 145         if tr.req.Header == nil {
 146                 t.Fatalf("expected non-nil request Header")
 147         }
 148         if tr.req.Close {
 149                 t.Error("got Close true, want false")
 150         }
 151         if g, e := tr.req.ContentLength, int64(len(json)); g != e {
 152                 t.Errorf("got ContentLength %d, want %d", g, e)
 153         }
 154 }
 155
 156 func TestPostFormRequestFormat(t *testing.T) {
 157         defer afterTest(t)
 158         tr := &recordingTransport{}
 159         client := &Client{Transport: tr}
 160
 161         urlStr := "http://dummy.faketld/"
 162         form := make(url.Values)
 163         form.Set("foo", "bar")
 164         form.Add("foo", "bar2")
 165         form.Set("bar", "baz")
 166         client.PostForm(urlStr, form) // Note: doesn't hit network
 167
 168         if tr.req.Method != "POST" {
 169                 t.Errorf("got method %q, want %q", tr.req.Method, "POST")
 170         }
 171         if tr.req.URL.String() != urlStr {
 172                 t.Errorf("got URL %q, want %q", tr.req.URL.String(), urlStr)
 173         }
 174         if tr.req.Header == nil {
 175                 t.Fatalf("expected non-nil request Header")
 176         }
 177         if g, e := tr.req.Header.Get("Content-Type"), "application/x-www-form-urlencoded"; g != e {
 178                 t.Errorf("got Content-Type %q, want %q", g, e)
 179         }
 180         if tr.req.Close {
 181                 t.Error("got Close true, want false")
 182         }
 183         // Depending on map iteration, body can be either of these.
 184         expectedBody := "foo=bar&foo=bar2&bar=baz"
 185         expectedBody1 := "bar=baz&foo=bar&foo=bar2"
 186         if g, e := tr.req.ContentLength, int64(len(expectedBody)); g != e {
 187                 t.Errorf("got ContentLength %d, want %d", g, e)
 188         }
 189         bodyb, err := ioutil.ReadAll(tr.req.Body)
 190         if err != nil {
 191                 t.Fatalf("ReadAll on req.Body: %v", err)
 192         }
 193         if g := string(bodyb); g != expectedBody && g != expectedBody1 {
 194                 t.Errorf("got body %q, want %q or %q", g, expectedBody, expectedBody1)
 195         }
 196 }
 197
 198 func TestClientRedirects(t *testing.T) {
 199         defer afterTest(t)
 200         var ts *httptest.Server
 201         ts = httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 202                 n, _ := strconv.Atoi(r.FormValue("n"))
 203                 // Test Referer header. (7 is arbitrary position to test at)
 204                 if n == 7 {
 205                         if g, e := r.Referer(), ts.URL+"/?n=6"; e != g {
 206                                 t.Errorf("on request ?n=7, expected referer of %q; got %q", e, g)
 207                         }
 208                 }
 209                 if n < 15 {
 210                         Redirect(w, r, fmt.Sprintf("/?n=%d", n+1), StatusFound)
 211                         return
 212                 }
 213                 fmt.Fprintf(w, "n=%d", n)
 214         }))
 215         defer ts.Close()
 216
 217         c := &Client{}
 218         _, err := c.Get(ts.URL)
 219         if e, g := "Get /?n=10: stopped after 10 redirects", fmt.Sprintf("%v", err); e != g {
 220                 t.Errorf("with default client Get, expected error %q, got %q", e, g)
 221         }
 222
 223         // HEAD request should also have the ability to follow redirects.
 224         _, err = c.Head(ts.URL)
 225         if e, g := "Head /?n=10: stopped after 10 redirects", fmt.Sprintf("%v", err); e != g {
 226                 t.Errorf("with default client Head, expected error %q, got %q", e, g)
 227         }
 228
 229         // Do should also follow redirects.
 230         greq, _ := NewRequest("GET", ts.URL, nil)
 231         _, err = c.Do(greq)
 232         if e, g := "Get /?n=10: stopped after 10 redirects", fmt.Sprintf("%v", err); e != g {
 233                 t.Errorf("with default client Do, expected error %q, got %q", e, g)
 234         }
 235
 236         // Requests with an empty Method should also redirect (Issue 12705)
 237         greq.Method = ""
 238         _, err = c.Do(greq)
 239         if e, g := "Get /?n=10: stopped after 10 redirects", fmt.Sprintf("%v", err); e != g {
 240                 t.Errorf("with default client Do and empty Method, expected error %q, got %q", e, g)
 241         }
 242
 243         var checkErr error
 244         var lastVia []*Request
 245         var lastReq *Request
 246         c = &Client{CheckRedirect: func(req *Request, via []*Request) error {
 247                 lastReq = req
 248                 lastVia = via
 249                 return checkErr
 250         }}
 251         res, err := c.Get(ts.URL)
 252         if err != nil {
 253                 t.Fatalf("Get error: %v", err)
 254         }
 255         res.Body.Close()
 256         finalUrl := res.Request.URL.String()
 257         if e, g := "<nil>", fmt.Sprintf("%v", err); e != g {
 258                 t.Errorf("with custom client, expected error %q, got %q", e, g)
 259         }
 260         if !strings.HasSuffix(finalUrl, "/?n=15") {
 261                 t.Errorf("expected final url to end in /?n=15; got url %q", finalUrl)
 262         }
 263         if e, g := 15, len(lastVia); e != g {
 264                 t.Errorf("expected lastVia to have contained %d elements; got %d", e, g)
 265         }
 266
 267         // Test that Request.Cancel is propagated between requests (Issue 14053)
 268         creq, _ := NewRequest("HEAD", ts.URL, nil)
 269         cancel := make(chan struct{})
 270         creq.Cancel = cancel
 271         if _, err := c.Do(creq); err != nil {
 272                 t.Fatal(err)
 273         }
 274         if lastReq == nil {
 275                 t.Fatal("didn't see redirect")
 276         }
 277         if lastReq.Cancel != cancel {
 278                 t.Errorf("expected lastReq to have the cancel channel set on the initial req")
 279         }
 280
 281         checkErr = errors.New("no redirects allowed")
 282         res, err = c.Get(ts.URL)
 283         if urlError, ok := err.(*url.Error); !ok || urlError.Err != checkErr {
 284                 t.Errorf("with redirects forbidden, expected a *url.Error with our 'no redirects allowed' error inside; got %#v (%q)", err, err)
 285         }
 286         if res == nil {
 287                 t.Fatalf("Expected a non-nil Response on CheckRedirect failure (https://golang.org/issue/3795)")
 288         }
 289         res.Body.Close()
 290         if res.Header.Get("Location") == "" {
 291                 t.Errorf("no Location header in Response")
 292         }
 293 }
 294
 295 func TestClientRedirectContext(t *testing.T) {
 296         defer afterTest(t)
 297         ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 298                 Redirect(w, r, "/", StatusFound)
 299         }))
 300         defer ts.Close()
 301
 302         ctx, cancel := context.WithCancel(context.Background())
 303         c := &Client{CheckRedirect: func(req *Request, via []*Request) error {
 304                 cancel()
 305                 if len(via) > 2 {
 306                         return errors.New("too many redirects")
 307                 }
 308                 return nil
 309         }}
 310         req, _ := NewRequest("GET", ts.URL, nil)
 311         req = req.WithContext(ctx)
 312         _, err := c.Do(req)
 313         ue, ok := err.(*url.Error)
 314         if !ok {
 315                 t.Fatalf("got error %T; want *url.Error", err)
 316         }
 317         if ue.Err != context.Canceled {
 318                 t.Errorf("url.Error.Err = %v; want %v", ue.Err, context.Canceled)
 319         }
 320 }
 321
 322 func TestPostRedirects(t *testing.T) {
 323         defer afterTest(t)
 324         var log struct {
 325                 sync.Mutex
 326                 bytes.Buffer
 327         }
 328         var ts *httptest.Server
 329         ts = httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 330                 log.Lock()
 331                 fmt.Fprintf(&log.Buffer, "%s %s ", r.Method, r.RequestURI)
 332                 log.Unlock()
 333                 if v := r.URL.Query().Get("code"); v != "" {
 334                         code, _ := strconv.Atoi(v)
 335                         if code/100 == 3 {
 336                                 w.Header().Set("Location", ts.URL)
 337                         }
 338                         w.WriteHeader(code)
 339                 }
 340         }))
 341         defer ts.Close()
 342         tests := []struct {
 343                 suffix string
 344                 want   int // response code
 345         }{
 346                 {"/", 200},
 347                 {"/?code=301", 301},
 348                 {"/?code=302", 200},
 349                 {"/?code=303", 200},
 350                 {"/?code=404", 404},
 351         }
 352         for _, tt := range tests {
 353                 res, err := Post(ts.URL+tt.suffix, "text/plain", strings.NewReader("Some content"))
 354                 if err != nil {
 355                         t.Fatal(err)
 356                 }
 357                 if res.StatusCode != tt.want {
 358                         t.Errorf("POST %s: status code = %d; want %d", tt.suffix, res.StatusCode, tt.want)
 359                 }
 360         }
 361         log.Lock()
 362         got := log.String()
 363         log.Unlock()
 364         want := "POST / POST /?code=301 POST /?code=302 GET / POST /?code=303 GET / POST /?code=404 "
 365         if got != want {
 366                 t.Errorf("Log differs.\n Got: %q\nWant: %q", got, want)
 367         }
 368 }
 369
 370 func TestClientRedirectUseResponse(t *testing.T) {
 371         defer afterTest(t)
 372         const body = "Hello, world."
 373         var ts *httptest.Server
 374         ts = httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 375                 if strings.Contains(r.URL.Path, "/other") {
 376                         io.WriteString(w, "wrong body")
 377                 } else {
 378                         w.Header().Set("Location", ts.URL+"/other")
 379                         w.WriteHeader(StatusFound)
 380                         io.WriteString(w, body)
 381                 }
 382         }))
 383         defer ts.Close()
 384
 385         c := &Client{CheckRedirect: func(req *Request, via []*Request) error {
 386                 if req.Response == nil {
 387                         t.Error("expected non-nil Request.Response")
 388                 }
 389                 return ErrUseLastResponse
 390         }}
 391         res, err := c.Get(ts.URL)
 392         if err != nil {
 393                 t.Fatal(err)
 394         }
 395         if res.StatusCode != StatusFound {
 396                 t.Errorf("status = %d; want %d", res.StatusCode, StatusFound)
 397         }
 398         defer res.Body.Close()
 399         slurp, err := ioutil.ReadAll(res.Body)
 400         if err != nil {
 401                 t.Fatal(err)
 402         }
 403         if string(slurp) != body {
 404                 t.Errorf("body = %q; want %q", slurp, body)
 405         }
 406 }
 407
 408 var expectedCookies = []*Cookie{
 409         {Name: "ChocolateChip", Value: "tasty"},
 410         {Name: "First", Value: "Hit"},
 411         {Name: "Second", Value: "Hit"},
 412 }
 413
 414 var echoCookiesRedirectHandler = HandlerFunc(func(w ResponseWriter, r *Request) {
 415         for _, cookie := range r.Cookies() {
 416                 SetCookie(w, cookie)
 417         }
 418         if r.URL.Path == "/" {
 419                 SetCookie(w, expectedCookies[1])
 420                 Redirect(w, r, "/second", StatusMovedPermanently)
 421         } else {
 422                 SetCookie(w, expectedCookies[2])
 423                 w.Write([]byte("hello"))
 424         }
 425 })
 426
 427 func TestClientSendsCookieFromJar(t *testing.T) {
 428         defer afterTest(t)
 429         tr := &recordingTransport{}
 430         client := &Client{Transport: tr}
 431         client.Jar = &TestJar{perURL: make(map[string][]*Cookie)}
 432         us := "http://dummy.faketld/"
 433         u, _ := url.Parse(us)
 434         client.Jar.SetCookies(u, expectedCookies)
 435
 436         client.Get(us) // Note: doesn't hit network
 437         matchReturnedCookies(t, expectedCookies, tr.req.Cookies())
 438
 439         client.Head(us) // Note: doesn't hit network
 440         matchReturnedCookies(t, expectedCookies, tr.req.Cookies())
 441
 442         client.Post(us, "text/plain", strings.NewReader("body")) // Note: doesn't hit network
 443         matchReturnedCookies(t, expectedCookies, tr.req.Cookies())
 444
 445         client.PostForm(us, url.Values{}) // Note: doesn't hit network
 446         matchReturnedCookies(t, expectedCookies, tr.req.Cookies())
 447
 448         req, _ := NewRequest("GET", us, nil)
 449         client.Do(req) // Note: doesn't hit network
 450         matchReturnedCookies(t, expectedCookies, tr.req.Cookies())
 451
 452         req, _ = NewRequest("POST", us, nil)
 453         client.Do(req) // Note: doesn't hit network
 454         matchReturnedCookies(t, expectedCookies, tr.req.Cookies())
 455 }
 456
 457 // Just enough correctness for our redirect tests. Uses the URL.Host as the
 458 // scope of all cookies.
 459 type TestJar struct {
 460         m      sync.Mutex
 461         perURL map[string][]*Cookie
 462 }
 463
 464 func (j *TestJar) SetCookies(u *url.URL, cookies []*Cookie) {
 465         j.m.Lock()
 466         defer j.m.Unlock()
 467         if j.perURL == nil {
 468                 j.perURL = make(map[string][]*Cookie)
 469         }
 470         j.perURL[u.Host] = cookies
 471 }
 472
 473 func (j *TestJar) Cookies(u *url.URL) []*Cookie {
 474         j.m.Lock()
 475         defer j.m.Unlock()
 476         return j.perURL[u.Host]
 477 }
 478
 479 func TestRedirectCookiesJar(t *testing.T) {
 480         defer afterTest(t)
 481         var ts *httptest.Server
 482         ts = httptest.NewServer(echoCookiesRedirectHandler)
 483         defer ts.Close()
 484         c := &Client{
 485                 Jar: new(TestJar),
 486         }
 487         u, _ := url.Parse(ts.URL)
 488         c.Jar.SetCookies(u, []*Cookie{expectedCookies[0]})
 489         resp, err := c.Get(ts.URL)
 490         if err != nil {
 491                 t.Fatalf("Get: %v", err)
 492         }
 493         resp.Body.Close()
 494         matchReturnedCookies(t, expectedCookies, resp.Cookies())
 495 }
 496
 497 func matchReturnedCookies(t *testing.T, expected, given []*Cookie) {
 498         if len(given) != len(expected) {
 499                 t.Logf("Received cookies: %v", given)
 500                 t.Errorf("Expected %d cookies, got %d", len(expected), len(given))
 501         }
 502         for _, ec := range expected {
 503                 foundC := false
 504                 for _, c := range given {
 505                         if ec.Name == c.Name && ec.Value == c.Value {
 506                                 foundC = true
 507                                 break
 508                         }
 509                 }
 510                 if !foundC {
 511                         t.Errorf("Missing cookie %v", ec)
 512                 }
 513         }
 514 }
 515
 516 func TestJarCalls(t *testing.T) {
 517         defer afterTest(t)
 518         ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 519                 pathSuffix := r.RequestURI[1:]
 520                 if r.RequestURI == "/nosetcookie" {
 521                         return // don't set cookies for this path
 522                 }
 523                 SetCookie(w, &Cookie{Name: "name" + pathSuffix, Value: "val" + pathSuffix})
 524                 if r.RequestURI == "/" {
 525                         Redirect(w, r, "http://secondhost.fake/secondpath", 302)
 526                 }
 527         }))
 528         defer ts.Close()
 529         jar := new(RecordingJar)
 530         c := &Client{
 531                 Jar: jar,
 532                 Transport: &Transport{
 533                         Dial: func(_ string, _ string) (net.Conn, error) {
 534                                 return net.Dial("tcp", ts.Listener.Addr().String())
 535                         },
 536                 },
 537         }
 538         _, err := c.Get("http://firsthost.fake/")
 539         if err != nil {
 540                 t.Fatal(err)
 541         }
 542         _, err = c.Get("http://firsthost.fake/nosetcookie")
 543         if err != nil {
 544                 t.Fatal(err)
 545         }
 546         got := jar.log.String()
 547         want := `Cookies("http://firsthost.fake/")
 548 SetCookie("http://firsthost.fake/", [name=val])
 549 Cookies("http://secondhost.fake/secondpath")
 550 SetCookie("http://secondhost.fake/secondpath", [namesecondpath=valsecondpath])
 551 Cookies("http://firsthost.fake/nosetcookie")
 552 `
 553         if got != want {
 554                 t.Errorf("Got Jar calls:\n%s\nWant:\n%s", got, want)
 555         }
 556 }
 557
 558 // RecordingJar keeps a log of calls made to it, without
 559 // tracking any cookies.
 560 type RecordingJar struct {
 561         mu  sync.Mutex
 562         log bytes.Buffer
 563 }
 564
 565 func (j *RecordingJar) SetCookies(u *url.URL, cookies []*Cookie) {
 566         j.logf("SetCookie(%q, %v)\n", u, cookies)
 567 }
 568
 569 func (j *RecordingJar) Cookies(u *url.URL) []*Cookie {
 570         j.logf("Cookies(%q)\n", u)
 571         return nil
 572 }
 573
 574 func (j *RecordingJar) logf(format string, args ...interface{}) {
 575         j.mu.Lock()
 576         defer j.mu.Unlock()
 577         fmt.Fprintf(&j.log, format, args...)
 578 }
 579
 580 func TestStreamingGet_h1(t *testing.T) { testStreamingGet(t, h1Mode) }
 581 func TestStreamingGet_h2(t *testing.T) { testStreamingGet(t, h2Mode) }
 582
 583 func testStreamingGet(t *testing.T, h2 bool) {
 584         defer afterTest(t)
 585         say := make(chan string)
 586         cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
 587                 w.(Flusher).Flush()
 588                 for str := range say {
 589                         w.Write([]byte(str))
 590                         w.(Flusher).Flush()
 591                 }
 592         }))
 593         defer cst.close()
 594
 595         c := cst.c
 596         res, err := c.Get(cst.ts.URL)
 597         if err != nil {
 598                 t.Fatal(err)
 599         }
 600         var buf [10]byte
 601         for _, str := range []string{"i", "am", "also", "known", "as", "comet"} {
 602                 say <- str
 603                 n, err := io.ReadFull(res.Body, buf[0:len(str)])
 604                 if err != nil {
 605                         t.Fatalf("ReadFull on %q: %v", str, err)
 606                 }
 607                 if n != len(str) {
 608                         t.Fatalf("Receiving %q, only read %d bytes", str, n)
 609                 }
 610                 got := string(buf[0:n])
 611                 if got != str {
 612                         t.Fatalf("Expected %q, got %q", str, got)
 613                 }
 614         }
 615         close(say)
 616         _, err = io.ReadFull(res.Body, buf[0:1])
 617         if err != io.EOF {
 618                 t.Fatalf("at end expected EOF, got %v", err)
 619         }
 620 }
 621
 622 type writeCountingConn struct {
 623         net.Conn
 624         count *int
 625 }
 626
 627 func (c *writeCountingConn) Write(p []byte) (int, error) {
 628         *c.count++
 629         return c.Conn.Write(p)
 630 }
 631
 632 // TestClientWrites verifies that client requests are buffered and we
 633 // don't send a TCP packet per line of the http request + body.
 634 func TestClientWrites(t *testing.T) {
 635         defer afterTest(t)
 636         ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 637         }))
 638         defer ts.Close()
 639
 640         writes := 0
 641         dialer := func(netz string, addr string) (net.Conn, error) {
 642                 c, err := net.Dial(netz, addr)
 643                 if err == nil {
 644                         c = &writeCountingConn{c, &writes}
 645                 }
 646                 return c, err
 647         }
 648         c := &Client{Transport: &Transport{Dial: dialer}}
 649
 650         _, err := c.Get(ts.URL)
 651         if err != nil {
 652                 t.Fatal(err)
 653         }
 654         if writes != 1 {
 655                 t.Errorf("Get request did %d Write calls, want 1", writes)
 656         }
 657
 658         writes = 0
 659         _, err = c.PostForm(ts.URL, url.Values{"foo": {"bar"}})
 660         if err != nil {
 661                 t.Fatal(err)
 662         }
 663         if writes != 1 {
 664                 t.Errorf("Post request did %d Write calls, want 1", writes)
 665         }
 666 }
 667
 668 func TestClientInsecureTransport(t *testing.T) {
 669         defer afterTest(t)
 670         ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 671                 w.Write([]byte("Hello"))
 672         }))
 673         errc := make(chanWriter, 10) // but only expecting 1
 674         ts.Config.ErrorLog = log.New(errc, "", 0)
 675         defer ts.Close()
 676
 677         // TODO(bradfitz): add tests for skipping hostname checks too?
 678         // would require a new cert for testing, and probably
 679         // redundant with these tests.
 680         for _, insecure := range []bool{true, false} {
 681                 tr := &Transport{
 682                         TLSClientConfig: &tls.Config{
 683                                 InsecureSkipVerify: insecure,
 684                         },
 685                 }
 686                 defer tr.CloseIdleConnections()
 687                 c := &Client{Transport: tr}
 688                 res, err := c.Get(ts.URL)
 689                 if (err == nil) != insecure {
 690                         t.Errorf("insecure=%v: got unexpected err=%v", insecure, err)
 691                 }
 692                 if res != nil {
 693                         res.Body.Close()
 694                 }
 695         }
 696
 697         select {
 698         case v := <-errc:
 699                 if !strings.Contains(v, "TLS handshake error") {
 700                         t.Errorf("expected an error log message containing 'TLS handshake error'; got %q", v)
 701                 }
 702         case <-time.After(5 * time.Second):
 703                 t.Errorf("timeout waiting for logged error")
 704         }
 705
 706 }
 707
 708 func TestClientErrorWithRequestURI(t *testing.T) {
 709         defer afterTest(t)
 710         req, _ := NewRequest("GET", "http://localhost:1234/", nil)
 711         req.RequestURI = "/this/field/is/illegal/and/should/error/"
 712         _, err := DefaultClient.Do(req)
 713         if err == nil {
 714                 t.Fatalf("expected an error")
 715         }
 716         if !strings.Contains(err.Error(), "RequestURI") {
 717                 t.Errorf("wanted error mentioning RequestURI; got error: %v", err)
 718         }
 719 }
 720
 721 func newTLSTransport(t *testing.T, ts *httptest.Server) *Transport {
 722         certs := x509.NewCertPool()
 723         for _, c := range ts.TLS.Certificates {
 724                 roots, err := x509.ParseCertificates(c.Certificate[len(c.Certificate)-1])
 725                 if err != nil {
 726                         t.Fatalf("error parsing server's root cert: %v", err)
 727                 }
 728                 for _, root := range roots {
 729                         certs.AddCert(root)
 730                 }
 731         }
 732         return &Transport{
 733                 TLSClientConfig: &tls.Config{RootCAs: certs},
 734         }
 735 }
 736
 737 func TestClientWithCorrectTLSServerName(t *testing.T) {
 738         defer afterTest(t)
 739
 740         const serverName = "example.com"
 741         ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 742                 if r.TLS.ServerName != serverName {
 743                         t.Errorf("expected client to set ServerName %q, got: %q", serverName, r.TLS.ServerName)
 744                 }
 745         }))
 746         defer ts.Close()
 747
 748         trans := newTLSTransport(t, ts)
 749         trans.TLSClientConfig.ServerName = serverName
 750         c := &Client{Transport: trans}
 751         if _, err := c.Get(ts.URL); err != nil {
 752                 t.Fatalf("expected successful TLS connection, got error: %v", err)
 753         }
 754 }
 755
 756 func TestClientWithIncorrectTLSServerName(t *testing.T) {
 757         defer afterTest(t)
 758         ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {}))
 759         defer ts.Close()
 760         errc := make(chanWriter, 10) // but only expecting 1
 761         ts.Config.ErrorLog = log.New(errc, "", 0)
 762
 763         trans := newTLSTransport(t, ts)
 764         trans.TLSClientConfig.ServerName = "badserver"
 765         c := &Client{Transport: trans}
 766         _, err := c.Get(ts.URL)
 767         if err == nil {
 768                 t.Fatalf("expected an error")
 769         }
 770         if !strings.Contains(err.Error(), "127.0.0.1") || !strings.Contains(err.Error(), "badserver") {
 771                 t.Errorf("wanted error mentioning 127.0.0.1 and badserver; got error: %v", err)
 772         }
 773         select {
 774         case v := <-errc:
 775                 if !strings.Contains(v, "TLS handshake error") {
 776                         t.Errorf("expected an error log message containing 'TLS handshake error'; got %q", v)
 777                 }
 778         case <-time.After(5 * time.Second):
 779                 t.Errorf("timeout waiting for logged error")
 780         }
 781 }
 782
 783 // Test for golang.org/issue/5829; the Transport should respect TLSClientConfig.ServerName
 784 // when not empty.
 785 //
 786 // tls.Config.ServerName (non-empty, set to "example.com") takes
 787 // precedence over "some-other-host.tld" which previously incorrectly
 788 // took precedence. We don't actually connect to (or even resolve)
 789 // "some-other-host.tld", though, because of the Transport.Dial hook.
 790 //
 791 // The httptest.Server has a cert with "example.com" as its name.
 792 func TestTransportUsesTLSConfigServerName(t *testing.T) {
 793         defer afterTest(t)
 794         ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 795                 w.Write([]byte("Hello"))
 796         }))
 797         defer ts.Close()
 798
 799         tr := newTLSTransport(t, ts)
 800         tr.TLSClientConfig.ServerName = "example.com" // one of httptest's Server cert names
 801         tr.Dial = func(netw, addr string) (net.Conn, error) {
 802                 return net.Dial(netw, ts.Listener.Addr().String())
 803         }
 804         defer tr.CloseIdleConnections()
 805         c := &Client{Transport: tr}
 806         res, err := c.Get("https://some-other-host.tld/")
 807         if err != nil {
 808                 t.Fatal(err)
 809         }
 810         res.Body.Close()
 811 }
 812
 813 func TestResponseSetsTLSConnectionState(t *testing.T) {
 814         defer afterTest(t)
 815         ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 816                 w.Write([]byte("Hello"))
 817         }))
 818         defer ts.Close()
 819
 820         tr := newTLSTransport(t, ts)
 821         tr.TLSClientConfig.CipherSuites = []uint16{tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA}
 822         tr.Dial = func(netw, addr string) (net.Conn, error) {
 823                 return net.Dial(netw, ts.Listener.Addr().String())
 824         }
 825         defer tr.CloseIdleConnections()
 826         c := &Client{Transport: tr}
 827         res, err := c.Get("https://example.com/")
 828         if err != nil {
 829                 t.Fatal(err)
 830         }
 831         defer res.Body.Close()
 832         if res.TLS == nil {
 833                 t.Fatal("Response didn't set TLS Connection State.")
 834         }
 835         if got, want := res.TLS.CipherSuite, tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA; got != want {
 836                 t.Errorf("TLS Cipher Suite = %d; want %d", got, want)
 837         }
 838 }
 839
 840 // Check that an HTTPS client can interpret a particular TLS error
 841 // to determine that the server is speaking HTTP.
 842 // See golang.org/issue/11111.
 843 func TestHTTPSClientDetectsHTTPServer(t *testing.T) {
 844         defer afterTest(t)
 845         ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {}))
 846         defer ts.Close()
 847
 848         _, err := Get(strings.Replace(ts.URL, "http", "https", 1))
 849         if got := err.Error(); !strings.Contains(got, "HTTP response to HTTPS client") {
 850                 t.Fatalf("error = %q; want error indicating HTTP response to HTTPS request", got)
 851         }
 852 }
 853
 854 // Verify Response.ContentLength is populated. https://golang.org/issue/4126
 855 func TestClientHeadContentLength_h1(t *testing.T) {
 856         testClientHeadContentLength(t, h1Mode)
 857 }
 858
 859 func TestClientHeadContentLength_h2(t *testing.T) {
 860         testClientHeadContentLength(t, h2Mode)
 861 }
 862
 863 func testClientHeadContentLength(t *testing.T, h2 bool) {
 864         defer afterTest(t)
 865         cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
 866                 if v := r.FormValue("cl"); v != "" {
 867                         w.Header().Set("Content-Length", v)
 868                 }
 869         }))
 870         defer cst.close()
 871         tests := []struct {
 872                 suffix string
 873                 want   int64
 874         }{
 875                 {"/?cl=1234", 1234},
 876                 {"/?cl=0", 0},
 877                 {"", -1},
 878         }
 879         for _, tt := range tests {
 880                 req, _ := NewRequest("HEAD", cst.ts.URL+tt.suffix, nil)
 881                 res, err := cst.c.Do(req)
 882                 if err != nil {
 883                         t.Fatal(err)
 884                 }
 885                 if res.ContentLength != tt.want {
 886                         t.Errorf("Content-Length = %d; want %d", res.ContentLength, tt.want)
 887                 }
 888                 bs, err := ioutil.ReadAll(res.Body)
 889                 if err != nil {
 890                         t.Fatal(err)
 891                 }
 892                 if len(bs) != 0 {
 893                         t.Errorf("Unexpected content: %q", bs)
 894                 }
 895         }
 896 }
 897
 898 func TestEmptyPasswordAuth(t *testing.T) {
 899         defer afterTest(t)
 900         gopher := "gopher"
 901         ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 902                 auth := r.Header.Get("Authorization")
 903                 if strings.HasPrefix(auth, "Basic ") {
 904                         encoded := auth[6:]
 905                         decoded, err := base64.StdEncoding.DecodeString(encoded)
 906                         if err != nil {
 907                                 t.Fatal(err)
 908                         }
 909                         expected := gopher + ":"
 910                         s := string(decoded)
 911                         if expected != s {
 912                                 t.Errorf("Invalid Authorization header. Got %q, wanted %q", s, expected)
 913                         }
 914                 } else {
 915                         t.Errorf("Invalid auth %q", auth)
 916                 }
 917         }))
 918         defer ts.Close()
 919         c := &Client{}
 920         req, err := NewRequest("GET", ts.URL, nil)
 921         if err != nil {
 922                 t.Fatal(err)
 923         }
 924         req.URL.User = url.User(gopher)
 925         resp, err := c.Do(req)
 926         if err != nil {
 927                 t.Fatal(err)
 928         }
 929         defer resp.Body.Close()
 930 }
 931
 932 func TestBasicAuth(t *testing.T) {
 933         defer afterTest(t)
 934         tr := &recordingTransport{}
 935         client := &Client{Transport: tr}
 936
 937         url := "http://My%20User:My%20Pass@dummy.faketld/"
 938         expected := "My User:My Pass"
 939         client.Get(url)
 940
 941         if tr.req.Method != "GET" {
 942                 t.Errorf("got method %q, want %q", tr.req.Method, "GET")
 943         }
 944         if tr.req.URL.String() != url {
 945                 t.Errorf("got URL %q, want %q", tr.req.URL.String(), url)
 946         }
 947         if tr.req.Header == nil {
 948                 t.Fatalf("expected non-nil request Header")
 949         }
 950         auth := tr.req.Header.Get("Authorization")
 951         if strings.HasPrefix(auth, "Basic ") {
 952                 encoded := auth[6:]
 953                 decoded, err := base64.StdEncoding.DecodeString(encoded)
 954                 if err != nil {
 955                         t.Fatal(err)
 956                 }
 957                 s := string(decoded)
 958                 if expected != s {
 959                         t.Errorf("Invalid Authorization header. Got %q, wanted %q", s, expected)
 960                 }
 961         } else {
 962                 t.Errorf("Invalid auth %q", auth)
 963         }
 964 }
 965
 966 func TestBasicAuthHeadersPreserved(t *testing.T) {
 967         defer afterTest(t)
 968         tr := &recordingTransport{}
 969         client := &Client{Transport: tr}
 970
 971         // If Authorization header is provided, username in URL should not override it
 972         url := "http://My%20User@dummy.faketld/"
 973         req, err := NewRequest("GET", url, nil)
 974         if err != nil {
 975                 t.Fatal(err)
 976         }
 977         req.SetBasicAuth("My User", "My Pass")
 978         expected := "My User:My Pass"
 979         client.Do(req)
 980
 981         if tr.req.Method != "GET" {
 982                 t.Errorf("got method %q, want %q", tr.req.Method, "GET")
 983         }
 984         if tr.req.URL.String() != url {
 985                 t.Errorf("got URL %q, want %q", tr.req.URL.String(), url)
 986         }
 987         if tr.req.Header == nil {
 988                 t.Fatalf("expected non-nil request Header")
 989         }
 990         auth := tr.req.Header.Get("Authorization")
 991         if strings.HasPrefix(auth, "Basic ") {
 992                 encoded := auth[6:]
 993                 decoded, err := base64.StdEncoding.DecodeString(encoded)
 994                 if err != nil {
 995                         t.Fatal(err)
 996                 }
 997                 s := string(decoded)
 998                 if expected != s {
 999                         t.Errorf("Invalid Authorization header. Got %q, wanted %q", s, expected)
1000                 }
1001         } else {
1002                 t.Errorf("Invalid auth %q", auth)
1003         }
1004
1005 }
1006
1007 func TestClientTimeout_h1(t *testing.T) { testClientTimeout(t, h1Mode) }
1008 func TestClientTimeout_h2(t *testing.T) { testClientTimeout(t, h2Mode) }
1009
1010 func testClientTimeout(t *testing.T, h2 bool) {
1011         if testing.Short() {
1012                 t.Skip("skipping in short mode")
1013         }
1014         defer afterTest(t)
1015         sawRoot := make(chan bool, 1)
1016         sawSlow := make(chan bool, 1)
1017         cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1018                 if r.URL.Path == "/" {
1019                         sawRoot <- true
1020                         Redirect(w, r, "/slow", StatusFound)
1021                         return
1022                 }
1023                 if r.URL.Path == "/slow" {
1024                         w.Write([]byte("Hello"))
1025                         w.(Flusher).Flush()
1026                         sawSlow <- true
1027                         time.Sleep(2 * time.Second)
1028                         return
1029                 }
1030         }))
1031         defer cst.close()
1032         const timeout = 500 * time.Millisecond
1033         cst.c.Timeout = timeout
1034
1035         res, err := cst.c.Get(cst.ts.URL)
1036         if err != nil {
1037                 t.Fatal(err)
1038         }
1039
1040         select {
1041         case <-sawRoot:
1042                 // good.
1043         default:
1044                 t.Fatal("handler never got / request")
1045         }
1046
1047         select {
1048         case <-sawSlow:
1049                 // good.
1050         default:
1051                 t.Fatal("handler never got /slow request")
1052         }
1053
1054         errc := make(chan error, 1)
1055         go func() {
1056                 _, err := ioutil.ReadAll(res.Body)
1057                 errc <- err
1058                 res.Body.Close()
1059         }()
1060
1061         const failTime = timeout * 2
1062         select {
1063         case err := <-errc:
1064                 if err == nil {
1065                         t.Fatal("expected error from ReadAll")
1066                 }
1067                 ne, ok := err.(net.Error)
1068                 if !ok {
1069                         t.Errorf("error value from ReadAll was %T; expected some net.Error", err)
1070                 } else if !ne.Timeout() {
1071                         t.Errorf("net.Error.Timeout = false; want true")
1072                 }
1073                 if got := ne.Error(); !strings.Contains(got, "Client.Timeout exceeded") {
1074                         t.Errorf("error string = %q; missing timeout substring", got)
1075                 }
1076         case <-time.After(failTime):
1077                 t.Errorf("timeout after %v waiting for timeout of %v", failTime, timeout)
1078         }
1079 }
1080
1081 func TestClientTimeout_Headers_h1(t *testing.T) { testClientTimeout_Headers(t, h1Mode) }
1082 func TestClientTimeout_Headers_h2(t *testing.T) { testClientTimeout_Headers(t, h2Mode) }
1083
1084 // Client.Timeout firing before getting to the body
1085 func testClientTimeout_Headers(t *testing.T, h2 bool) {
1086         if testing.Short() {
1087                 t.Skip("skipping in short mode")
1088         }
1089         defer afterTest(t)
1090         donec := make(chan bool)
1091         cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1092                 <-donec
1093         }))
1094         defer cst.close()
1095         // Note that we use a channel send here and not a close.
1096         // The race detector doesn't know that we're waiting for a timeout
1097         // and thinks that the waitgroup inside httptest.Server is added to concurrently
1098         // with us closing it. If we timed out immediately, we could close the testserver
1099         // before we entered the handler. We're not timing out immediately and there's
1100         // no way we would be done before we entered the handler, but the race detector
1101         // doesn't know this, so synchronize explicitly.
1102         defer func() { donec <- true }()
1103
1104         cst.c.Timeout = 500 * time.Millisecond
1105         _, err := cst.c.Get(cst.ts.URL)
1106         if err == nil {
1107                 t.Fatal("got response from Get; expected error")
1108         }
1109         if _, ok := err.(*url.Error); !ok {
1110                 t.Fatalf("Got error of type %T; want *url.Error", err)
1111         }
1112         ne, ok := err.(net.Error)
1113         if !ok {
1114                 t.Fatalf("Got error of type %T; want some net.Error", err)
1115         }
1116         if !ne.Timeout() {
1117                 t.Error("net.Error.Timeout = false; want true")
1118         }
1119         if got := ne.Error(); !strings.Contains(got, "Client.Timeout exceeded") {
1120                 t.Errorf("error string = %q; missing timeout substring", got)
1121         }
1122 }
1123
1124 func TestClientRedirectEatsBody_h1(t *testing.T) { testClientRedirectEatsBody(t, h1Mode) }
1125 func TestClientRedirectEatsBody_h2(t *testing.T) { testClientRedirectEatsBody(t, h2Mode) }
1126 func testClientRedirectEatsBody(t *testing.T, h2 bool) {
1127         defer afterTest(t)
1128         saw := make(chan string, 2)
1129         cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
1130                 saw <- r.RemoteAddr
1131                 if r.URL.Path == "/" {
1132                         Redirect(w, r, "/foo", StatusFound) // which includes a body
1133                 }
1134         }))
1135         defer cst.close()
1136
1137         res, err := cst.c.Get(cst.ts.URL)
1138         if err != nil {
1139                 t.Fatal(err)
1140         }
1141         _, err = ioutil.ReadAll(res.Body)
1142         if err != nil {
1143                 t.Fatal(err)
1144         }
1145         res.Body.Close()
1146
1147         var first string
1148         select {
1149         case first = <-saw:
1150         default:
1151                 t.Fatal("server didn't see a request")
1152         }
1153
1154         var second string
1155         select {
1156         case second = <-saw:
1157         default:
1158                 t.Fatal("server didn't see a second request")
1159         }
1160
1161         if first != second {
1162                 t.Fatal("server saw different client ports before & after the redirect")
1163         }
1164 }
1165
1166 // eofReaderFunc is an io.Reader that runs itself, and then returns io.EOF.
1167 type eofReaderFunc func()
1168
1169 func (f eofReaderFunc) Read(p []byte) (n int, err error) {
1170         f()
1171         return 0, io.EOF
1172 }
1173
1174 func TestReferer(t *testing.T) {
1175         tests := []struct {
1176                 lastReq, newReq string // from -> to URLs
1177                 want            string
1178         }{
1179                 // don't send user:
1180                 {"http://gopher@test.com", "http://link.com", "http://test.com"},
1181                 {"https://gopher@test.com", "https://link.com", "https://test.com"},
1182
1183                 // don't send a user and password:
1184                 {"http://gopher:go@test.com", "http://link.com", "http://test.com"},
1185                 {"https://gopher:go@test.com", "https://link.com", "https://test.com"},
1186
1187                 // nothing to do:
1188                 {"http://test.com", "http://link.com", "http://test.com"},
1189                 {"https://test.com", "https://link.com", "https://test.com"},
1190
1191                 // https to http doesn't send a referer:
1192                 {"https://test.com", "http://link.com", ""},
1193                 {"https://gopher:go@test.com", "http://link.com", ""},
1194         }
1195         for _, tt := range tests {
1196                 l, err := url.Parse(tt.lastReq)
1197                 if err != nil {
1198                         t.Fatal(err)
1199                 }
1200                 n, err := url.Parse(tt.newReq)
1201                 if err != nil {
1202                         t.Fatal(err)
1203                 }
1204                 r := ExportRefererForURL(l, n)
1205                 if r != tt.want {
1206                         t.Errorf("refererForURL(%q, %q) = %q; want %q", tt.lastReq, tt.newReq, r, tt.want)
1207                 }
1208         }
1209 }
1210
1211 // issue15577Tripper returns a Response with a redirect response
1212 // header and doesn't populate its Response.Request field.
1213 type issue15577Tripper struct{}
1214
1215 func (issue15577Tripper) RoundTrip(*Request) (*Response, error) {
1216         resp := &Response{
1217                 StatusCode: 303,
1218                 Header:     map[string][]string{"Location": {"http://www.example.com/"}},
1219                 Body:       ioutil.NopCloser(strings.NewReader("")),
1220         }
1221         return resp, nil
1222 }
1223
1224 // Issue 15577: don't assume the roundtripper's response populates its Request field.
1225 func TestClientRedirectResponseWithoutRequest(t *testing.T) {
1226         c := &Client{
1227                 CheckRedirect: func(*Request, []*Request) error { return fmt.Errorf("no redirects!") },
1228                 Transport:     issue15577Tripper{},
1229         }
1230         // Check that this doesn't crash:
1231         c.Get("http://dummy.tld")
1232 }
1233
1234 // Issue 4800: copy (some) headers when Client follows a redirect
1235 func TestClientCopyHeadersOnRedirect(t *testing.T) {
1236         const (
1237                 ua   = "some-agent/1.2"
1238                 xfoo = "foo-val"
1239         )
1240         var ts2URL string
1241         ts1 := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
1242                 want := Header{
1243                         "User-Agent":      []string{ua},
1244                         "X-Foo":           []string{xfoo},
1245                         "Referer":         []string{ts2URL},
1246                         "Accept-Encoding": []string{"gzip"},
1247                 }
1248                 if !reflect.DeepEqual(r.Header, want) {
1249                         t.Errorf("Request.Header = %#v; want %#v", r.Header, want)
1250                 }
1251                 if t.Failed() {
1252                         w.Header().Set("Result", "got errors")
1253                 } else {
1254                         w.Header().Set("Result", "ok")
1255                 }
1256         }))
1257         defer ts1.Close()
1258         ts2 := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
1259                 Redirect(w, r, ts1.URL, StatusFound)
1260         }))
1261         defer ts2.Close()
1262         ts2URL = ts2.URL
1263
1264         tr := &Transport{}
1265         defer tr.CloseIdleConnections()
1266         c := &Client{
1267                 Transport: tr,
1268                 CheckRedirect: func(r *Request, via []*Request) error {
1269                         want := Header{
1270                                 "User-Agent": []string{ua},
1271                                 "X-Foo":      []string{xfoo},
1272                                 "Referer":    []string{ts2URL},
1273                         }
1274                         if !reflect.DeepEqual(r.Header, want) {
1275                                 t.Errorf("CheckRedirect Request.Header = %#v; want %#v", r.Header, want)
1276                         }
1277                         return nil
1278                 },
1279         }
1280
1281         req, _ := NewRequest("GET", ts2.URL, nil)
1282         req.Header.Add("User-Agent", ua)
1283         req.Header.Add("X-Foo", xfoo)
1284         req.Header.Add("Cookie", "foo=bar")
1285         req.Header.Add("Authorization", "secretpassword")
1286         res, err := c.Do(req)
1287         if err != nil {
1288                 t.Fatal(err)
1289         }
1290         defer res.Body.Close()
1291         if res.StatusCode != 200 {
1292                 t.Fatal(res.Status)
1293         }
1294         if got := res.Header.Get("Result"); got != "ok" {
1295                 t.Errorf("result = %q; want ok", got)
1296         }
1297 }
1298
1299 // Part of Issue 4800
1300 func TestShouldCopyHeaderOnRedirect(t *testing.T) {
1301         tests := []struct {
1302                 header     string
1303                 initialURL string
1304                 destURL    string
1305                 want       bool
1306         }{
1307                 {"User-Agent", "http://foo.com/", "http://bar.com/", true},
1308                 {"X-Foo", "http://foo.com/", "http://bar.com/", true},
1309
1310                 // Sensitive headers:
1311                 {"cookie", "http://foo.com/", "http://bar.com/", false},
1312                 {"cookie2", "http://foo.com/", "http://bar.com/", false},
1313                 {"authorization", "http://foo.com/", "http://bar.com/", false},
1314                 {"www-authenticate", "http://foo.com/", "http://bar.com/", false},
1315
1316                 // But subdomains should work:
1317                 {"www-authenticate", "http://foo.com/", "http://foo.com/", true},
1318                 {"www-authenticate", "http://foo.com/", "http://sub.foo.com/", true},
1319                 {"www-authenticate", "http://foo.com/", "http://notfoo.com/", false},
1320                 // TODO(bradfitz): make this test work, once issue 16142 is fixed:
1321                 // {"www-authenticate", "http://foo.com:80/", "http://foo.com/", true},
1322         }
1323         for i, tt := range tests {
1324                 u0, err := url.Parse(tt.initialURL)
1325                 if err != nil {
1326                         t.Errorf("%d. initial URL %q parse error: %v", i, tt.initialURL, err)
1327                         continue
1328                 }
1329                 u1, err := url.Parse(tt.destURL)
1330                 if err != nil {
1331                         t.Errorf("%d. dest URL %q parse error: %v", i, tt.destURL, err)
1332                         continue
1333                 }
1334                 got := Export_shouldCopyHeaderOnRedirect(tt.header, u0, u1)
1335                 if got != tt.want {
1336                         t.Errorf("%d. shouldCopyHeaderOnRedirect(%q, %q => %q) = %v; want %v",
1337                                 i, tt.header, tt.initialURL, tt.destURL, got, tt.want)
1338                 }
1339         }
1340 }
1341
1342 func TestClientRedirectTypes(t *testing.T) {
1343         defer afterTest(t)
1344
1345         tests := [...]struct {
1346                 broken       int // broken is bug number
1347                 method       string
1348                 serverStatus int
1349                 wantMethod   string // desired subsequent client method
1350         }{
1351                 0: {method: "POST", serverStatus: 301, wantMethod: "GET"},
1352                 1: {method: "POST", serverStatus: 302, wantMethod: "GET"},
1353                 2: {method: "POST", serverStatus: 307, wantMethod: "POST", broken: 16840},
1354
1355                 5: {method: "GET", serverStatus: 301, wantMethod: "GET"},
1356                 6: {method: "GET", serverStatus: 302, wantMethod: "GET"},
1357                 7: {method: "GET", serverStatus: 303, wantMethod: "GET"},
1358                 8: {method: "GET", serverStatus: 307, wantMethod: "GET"},
1359                 9: {method: "GET", serverStatus: 308, wantMethod: "GET"},
1360
1361                 10: {method: "DELETE", serverStatus: 308, wantMethod: "DELETE", broken: 13994},
1362         }
1363
1364         handlerc := make(chan HandlerFunc, 1)
1365
1366         ts := httptest.NewServer(HandlerFunc(func(rw ResponseWriter, req *Request) {
1367                 h := <-handlerc
1368                 h(rw, req)
1369         }))
1370         defer ts.Close()
1371
1372         for i, tt := range tests {
1373                 if tt.broken != 0 {
1374                         t.Logf("#%d: skipping known broken test case. See Issue #%d", i, tt.broken)
1375                         continue
1376                 }
1377
1378                 handlerc <- func(w ResponseWriter, r *Request) {
1379                         w.Header().Set("Location", ts.URL)
1380                         w.WriteHeader(tt.serverStatus)
1381                 }
1382
1383                 req, err := NewRequest(tt.method, ts.URL, nil)
1384                 if err != nil {
1385                         t.Errorf("#%d: NewRequest: %v", i, err)
1386                         continue
1387                 }
1388
1389                 c := &Client{}
1390                 c.CheckRedirect = func(req *Request, via []*Request) error {
1391                         if got, want := req.Method, tt.wantMethod; got != want {
1392                                 return fmt.Errorf("#%d: got next method %q; want %q", i, got, want)
1393                         }
1394                         handlerc <- func(rw ResponseWriter, req *Request) {
1395                                 // TODO: Check that the body is valid when we do 307 and 308 support
1396                         }
1397                         return nil
1398                 }
1399
1400                 res, err := c.Do(req)
1401                 if err != nil {
1402                         t.Errorf("#%d: Response: %v", i, err)
1403                         continue
1404                 }
1405
1406                 res.Body.Close()
1407         }
1408 }