libgo/go/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         "crypto/tls"
  11         "fmt"
  12         . "http"
  13         "http/httptest"
  14         "io"
  15         "io/ioutil"
  16         "net"
  17         "os"
  18         "strconv"
  19         "strings"
  20         "testing"
  21         "url"
  22 )
  23
  24 var robotsTxtHandler = HandlerFunc(func(w ResponseWriter, r *Request) {
  25         w.Header().Set("Last-Modified", "sometime")
  26         fmt.Fprintf(w, "User-agent: go\nDisallow: /something/")
  27 })
  28
  29 func TestClient(t *testing.T) {
  30         ts := httptest.NewServer(robotsTxtHandler)
  31         defer ts.Close()
  32
  33         r, err := Get(ts.URL)
  34         var b []byte
  35         if err == nil {
  36                 b, err = ioutil.ReadAll(r.Body)
  37                 r.Body.Close()
  38         }
  39         if err != nil {
  40                 t.Error(err)
  41         } else if s := string(b); !strings.HasPrefix(s, "User-agent:") {
  42                 t.Errorf("Incorrect page body (did not begin with User-agent): %q", s)
  43         }
  44 }
  45
  46 func TestClientHead(t *testing.T) {
  47         ts := httptest.NewServer(robotsTxtHandler)
  48         defer ts.Close()
  49
  50         r, err := Head(ts.URL)
  51         if err != nil {
  52                 t.Fatal(err)
  53         }
  54         if _, ok := r.Header["Last-Modified"]; !ok {
  55                 t.Error("Last-Modified header not found.")
  56         }
  57 }
  58
  59 type recordingTransport struct {
  60         req *Request
  61 }
  62
  63 func (t *recordingTransport) RoundTrip(req *Request) (resp *Response, err os.Error) {
  64         t.req = req
  65         return nil, os.NewError("dummy impl")
  66 }
  67
  68 func TestGetRequestFormat(t *testing.T) {
  69         tr := &recordingTransport{}
  70         client := &Client{Transport: tr}
  71         url := "http://dummy.faketld/"
  72         client.Get(url) // Note: doesn't hit network
  73         if tr.req.Method != "GET" {
  74                 t.Errorf("expected method %q; got %q", "GET", tr.req.Method)
  75         }
  76         if tr.req.URL.String() != url {
  77                 t.Errorf("expected URL %q; got %q", url, tr.req.URL.String())
  78         }
  79         if tr.req.Header == nil {
  80                 t.Errorf("expected non-nil request Header")
  81         }
  82 }
  83
  84 func TestPostRequestFormat(t *testing.T) {
  85         tr := &recordingTransport{}
  86         client := &Client{Transport: tr}
  87
  88         url := "http://dummy.faketld/"
  89         json := `{"key":"value"}`
  90         b := strings.NewReader(json)
  91         client.Post(url, "application/json", b) // Note: doesn't hit network
  92
  93         if tr.req.Method != "POST" {
  94                 t.Errorf("got method %q, want %q", tr.req.Method, "POST")
  95         }
  96         if tr.req.URL.String() != url {
  97                 t.Errorf("got URL %q, want %q", tr.req.URL.String(), url)
  98         }
  99         if tr.req.Header == nil {
 100                 t.Fatalf("expected non-nil request Header")
 101         }
 102         if tr.req.Close {
 103                 t.Error("got Close true, want false")
 104         }
 105         if g, e := tr.req.ContentLength, int64(len(json)); g != e {
 106                 t.Errorf("got ContentLength %d, want %d", g, e)
 107         }
 108 }
 109
 110 func TestPostFormRequestFormat(t *testing.T) {
 111         tr := &recordingTransport{}
 112         client := &Client{Transport: tr}
 113
 114         urlStr := "http://dummy.faketld/"
 115         form := make(url.Values)
 116         form.Set("foo", "bar")
 117         form.Add("foo", "bar2")
 118         form.Set("bar", "baz")
 119         client.PostForm(urlStr, form) // Note: doesn't hit network
 120
 121         if tr.req.Method != "POST" {
 122                 t.Errorf("got method %q, want %q", tr.req.Method, "POST")
 123         }
 124         if tr.req.URL.String() != urlStr {
 125                 t.Errorf("got URL %q, want %q", tr.req.URL.String(), urlStr)
 126         }
 127         if tr.req.Header == nil {
 128                 t.Fatalf("expected non-nil request Header")
 129         }
 130         if g, e := tr.req.Header.Get("Content-Type"), "application/x-www-form-urlencoded"; g != e {
 131                 t.Errorf("got Content-Type %q, want %q", g, e)
 132         }
 133         if tr.req.Close {
 134                 t.Error("got Close true, want false")
 135         }
 136         // Depending on map iteration, body can be either of these.
 137         expectedBody := "foo=bar&foo=bar2&bar=baz"
 138         expectedBody1 := "bar=baz&foo=bar&foo=bar2"
 139         if g, e := tr.req.ContentLength, int64(len(expectedBody)); g != e {
 140                 t.Errorf("got ContentLength %d, want %d", g, e)
 141         }
 142         bodyb, err := ioutil.ReadAll(tr.req.Body)
 143         if err != nil {
 144                 t.Fatalf("ReadAll on req.Body: %v", err)
 145         }
 146         if g := string(bodyb); g != expectedBody && g != expectedBody1 {
 147                 t.Errorf("got body %q, want %q or %q", g, expectedBody, expectedBody1)
 148         }
 149 }
 150
 151 func TestRedirects(t *testing.T) {
 152         var ts *httptest.Server
 153         ts = httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 154                 n, _ := strconv.Atoi(r.FormValue("n"))
 155                 // Test Referer header. (7 is arbitrary position to test at)
 156                 if n == 7 {
 157                         if g, e := r.Referer(), ts.URL+"/?n=6"; e != g {
 158                                 t.Errorf("on request ?n=7, expected referer of %q; got %q", e, g)
 159                         }
 160                 }
 161                 if n < 15 {
 162                         Redirect(w, r, fmt.Sprintf("/?n=%d", n+1), StatusFound)
 163                         return
 164                 }
 165                 fmt.Fprintf(w, "n=%d", n)
 166         }))
 167         defer ts.Close()
 168
 169         c := &Client{}
 170         _, err := c.Get(ts.URL)
 171         if e, g := "Get /?n=10: stopped after 10 redirects", fmt.Sprintf("%v", err); e != g {
 172                 t.Errorf("with default client Get, expected error %q, got %q", e, g)
 173         }
 174
 175         // HEAD request should also have the ability to follow redirects.
 176         _, err = c.Head(ts.URL)
 177         if e, g := "Head /?n=10: stopped after 10 redirects", fmt.Sprintf("%v", err); e != g {
 178                 t.Errorf("with default client Head, expected error %q, got %q", e, g)
 179         }
 180
 181         // Do should also follow redirects.
 182         greq, _ := NewRequest("GET", ts.URL, nil)
 183         _, err = c.Do(greq)
 184         if e, g := "Get /?n=10: stopped after 10 redirects", fmt.Sprintf("%v", err); e != g {
 185                 t.Errorf("with default client Do, expected error %q, got %q", e, g)
 186         }
 187
 188         var checkErr os.Error
 189         var lastVia []*Request
 190         c = &Client{CheckRedirect: func(_ *Request, via []*Request) os.Error {
 191                 lastVia = via
 192                 return checkErr
 193         }}
 194         res, err := c.Get(ts.URL)
 195         finalUrl := res.Request.URL.String()
 196         if e, g := "<nil>", fmt.Sprintf("%v", err); e != g {
 197                 t.Errorf("with custom client, expected error %q, got %q", e, g)
 198         }
 199         if !strings.HasSuffix(finalUrl, "/?n=15") {
 200                 t.Errorf("expected final url to end in /?n=15; got url %q", finalUrl)
 201         }
 202         if e, g := 15, len(lastVia); e != g {
 203                 t.Errorf("expected lastVia to have contained %d elements; got %d", e, g)
 204         }
 205
 206         checkErr = os.NewError("no redirects allowed")
 207         res, err = c.Get(ts.URL)
 208         finalUrl = res.Request.URL.String()
 209         if e, g := "Get /?n=1: no redirects allowed", fmt.Sprintf("%v", err); e != g {
 210                 t.Errorf("with redirects forbidden, expected error %q, got %q", e, g)
 211         }
 212 }
 213
 214 func TestStreamingGet(t *testing.T) {
 215         say := make(chan string)
 216         ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 217                 w.(Flusher).Flush()
 218                 for str := range say {
 219                         w.Write([]byte(str))
 220                         w.(Flusher).Flush()
 221                 }
 222         }))
 223         defer ts.Close()
 224
 225         c := &Client{}
 226         res, err := c.Get(ts.URL)
 227         if err != nil {
 228                 t.Fatal(err)
 229         }
 230         var buf [10]byte
 231         for _, str := range []string{"i", "am", "also", "known", "as", "comet"} {
 232                 say <- str
 233                 n, err := io.ReadFull(res.Body, buf[0:len(str)])
 234                 if err != nil {
 235                         t.Fatalf("ReadFull on %q: %v", str, err)
 236                 }
 237                 if n != len(str) {
 238                         t.Fatalf("Receiving %q, only read %d bytes", str, n)
 239                 }
 240                 got := string(buf[0:n])
 241                 if got != str {
 242                         t.Fatalf("Expected %q, got %q", str, got)
 243                 }
 244         }
 245         close(say)
 246         _, err = io.ReadFull(res.Body, buf[0:1])
 247         if err != os.EOF {
 248                 t.Fatalf("at end expected EOF, got %v", err)
 249         }
 250 }
 251
 252 type writeCountingConn struct {
 253         net.Conn
 254         count *int
 255 }
 256
 257 func (c *writeCountingConn) Write(p []byte) (int, os.Error) {
 258         *c.count++
 259         return c.Conn.Write(p)
 260 }
 261
 262 // TestClientWrites verifies that client requests are buffered and we
 263 // don't send a TCP packet per line of the http request + body.
 264 func TestClientWrites(t *testing.T) {
 265         ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 266         }))
 267         defer ts.Close()
 268
 269         writes := 0
 270         dialer := func(netz string, addr string) (net.Conn, os.Error) {
 271                 c, err := net.Dial(netz, addr)
 272                 if err == nil {
 273                         c = &writeCountingConn{c, &writes}
 274                 }
 275                 return c, err
 276         }
 277         c := &Client{Transport: &Transport{Dial: dialer}}
 278
 279         _, err := c.Get(ts.URL)
 280         if err != nil {
 281                 t.Fatal(err)
 282         }
 283         if writes != 1 {
 284                 t.Errorf("Get request did %d Write calls, want 1", writes)
 285         }
 286
 287         writes = 0
 288         _, err = c.PostForm(ts.URL, url.Values{"foo": {"bar"}})
 289         if err != nil {
 290                 t.Fatal(err)
 291         }
 292         if writes != 1 {
 293                 t.Errorf("Post request did %d Write calls, want 1", writes)
 294         }
 295 }
 296
 297 func TestClientInsecureTransport(t *testing.T) {
 298         ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
 299                 w.Write([]byte("Hello"))
 300         }))
 301         defer ts.Close()
 302
 303         // TODO(bradfitz): add tests for skipping hostname checks too?
 304         // would require a new cert for testing, and probably
 305         // redundant with these tests.
 306         for _, insecure := range []bool{true, false} {
 307                 tr := &Transport{
 308                         TLSClientConfig: &tls.Config{
 309                                 InsecureSkipVerify: insecure,
 310                         },
 311                 }
 312                 c := &Client{Transport: tr}
 313                 _, err := c.Get(ts.URL)
 314                 if (err == nil) != insecure {
 315                         t.Errorf("insecure=%v: got unexpected err=%v", insecure, err)
 316                 }
 317         }
 318 }