libgo/go/net/http/response_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         "compress/gzip"
  11         "crypto/rand"
  12         "fmt"
  13         "io"
  14         "io/ioutil"
  15         "net/url"
  16         "reflect"
  17         "strings"
  18         "testing"
  19 )
  20
  21 type respTest struct {
  22         Raw  string
  23         Resp Response
  24         Body string
  25 }
  26
  27 func dummyReq(method string) *Request {
  28         return &Request{Method: method}
  29 }
  30
  31 var respTests = []respTest{
  32         // Unchunked response without Content-Length.
  33         {
  34                 "HTTP/1.0 200 OK\r\n" +
  35                         "Connection: close\r\n" +
  36                         "\r\n" +
  37                         "Body here\n",
  38
  39                 Response{
  40                         Status:     "200 OK",
  41                         StatusCode: 200,
  42                         Proto:      "HTTP/1.0",
  43                         ProtoMajor: 1,
  44                         ProtoMinor: 0,
  45                         Request:    dummyReq("GET"),
  46                         Header: Header{
  47                                 "Connection": {"close"}, // TODO(rsc): Delete?
  48                         },
  49                         Close:         true,
  50                         ContentLength: -1,
  51                 },
  52
  53                 "Body here\n",
  54         },
  55
  56         // Unchunked HTTP/1.1 response without Content-Length or
  57         // Connection headers.
  58         {
  59                 "HTTP/1.1 200 OK\r\n" +
  60                         "\r\n" +
  61                         "Body here\n",
  62
  63                 Response{
  64                         Status:        "200 OK",
  65                         StatusCode:    200,
  66                         Proto:         "HTTP/1.1",
  67                         ProtoMajor:    1,
  68                         ProtoMinor:    1,
  69                         Header:        Header{},
  70                         Request:       dummyReq("GET"),
  71                         Close:         true,
  72                         ContentLength: -1,
  73                 },
  74
  75                 "Body here\n",
  76         },
  77
  78         // Unchunked HTTP/1.1 204 response without Content-Length.
  79         {
  80                 "HTTP/1.1 204 No Content\r\n" +
  81                         "\r\n" +
  82                         "Body should not be read!\n",
  83
  84                 Response{
  85                         Status:        "204 No Content",
  86                         StatusCode:    204,
  87                         Proto:         "HTTP/1.1",
  88                         ProtoMajor:    1,
  89                         ProtoMinor:    1,
  90                         Header:        Header{},
  91                         Request:       dummyReq("GET"),
  92                         Close:         false,
  93                         ContentLength: 0,
  94                 },
  95
  96                 "",
  97         },
  98
  99         // Unchunked response with Content-Length.
 100         {
 101                 "HTTP/1.0 200 OK\r\n" +
 102                         "Content-Length: 10\r\n" +
 103                         "Connection: close\r\n" +
 104                         "\r\n" +
 105                         "Body here\n",
 106
 107                 Response{
 108                         Status:     "200 OK",
 109                         StatusCode: 200,
 110                         Proto:      "HTTP/1.0",
 111                         ProtoMajor: 1,
 112                         ProtoMinor: 0,
 113                         Request:    dummyReq("GET"),
 114                         Header: Header{
 115                                 "Connection":     {"close"},
 116                                 "Content-Length": {"10"},
 117                         },
 118                         Close:         true,
 119                         ContentLength: 10,
 120                 },
 121
 122                 "Body here\n",
 123         },
 124
 125         // Chunked response without Content-Length.
 126         {
 127                 "HTTP/1.1 200 OK\r\n" +
 128                         "Transfer-Encoding: chunked\r\n" +
 129                         "\r\n" +
 130                         "0a\r\n" +
 131                         "Body here\n\r\n" +
 132                         "09\r\n" +
 133                         "continued\r\n" +
 134                         "0\r\n" +
 135                         "\r\n",
 136
 137                 Response{
 138                         Status:           "200 OK",
 139                         StatusCode:       200,
 140                         Proto:            "HTTP/1.1",
 141                         ProtoMajor:       1,
 142                         ProtoMinor:       1,
 143                         Request:          dummyReq("GET"),
 144                         Header:           Header{},
 145                         Close:            false,
 146                         ContentLength:    -1,
 147                         TransferEncoding: []string{"chunked"},
 148                 },
 149
 150                 "Body here\ncontinued",
 151         },
 152
 153         // Chunked response with Content-Length.
 154         {
 155                 "HTTP/1.1 200 OK\r\n" +
 156                         "Transfer-Encoding: chunked\r\n" +
 157                         "Content-Length: 10\r\n" +
 158                         "\r\n" +
 159                         "0a\r\n" +
 160                         "Body here\n\r\n" +
 161                         "0\r\n" +
 162                         "\r\n",
 163
 164                 Response{
 165                         Status:           "200 OK",
 166                         StatusCode:       200,
 167                         Proto:            "HTTP/1.1",
 168                         ProtoMajor:       1,
 169                         ProtoMinor:       1,
 170                         Request:          dummyReq("GET"),
 171                         Header:           Header{},
 172                         Close:            false,
 173                         ContentLength:    -1,
 174                         TransferEncoding: []string{"chunked"},
 175                 },
 176
 177                 "Body here\n",
 178         },
 179
 180         // Chunked response in response to a HEAD request
 181         {
 182                 "HTTP/1.1 200 OK\r\n" +
 183                         "Transfer-Encoding: chunked\r\n" +
 184                         "\r\n",
 185
 186                 Response{
 187                         Status:           "200 OK",
 188                         StatusCode:       200,
 189                         Proto:            "HTTP/1.1",
 190                         ProtoMajor:       1,
 191                         ProtoMinor:       1,
 192                         Request:          dummyReq("HEAD"),
 193                         Header:           Header{},
 194                         TransferEncoding: []string{"chunked"},
 195                         Close:            false,
 196                         ContentLength:    -1,
 197                 },
 198
 199                 "",
 200         },
 201
 202         // Content-Length in response to a HEAD request
 203         {
 204                 "HTTP/1.0 200 OK\r\n" +
 205                         "Content-Length: 256\r\n" +
 206                         "\r\n",
 207
 208                 Response{
 209                         Status:           "200 OK",
 210                         StatusCode:       200,
 211                         Proto:            "HTTP/1.0",
 212                         ProtoMajor:       1,
 213                         ProtoMinor:       0,
 214                         Request:          dummyReq("HEAD"),
 215                         Header:           Header{"Content-Length": {"256"}},
 216                         TransferEncoding: nil,
 217                         Close:            true,
 218                         ContentLength:    256,
 219                 },
 220
 221                 "",
 222         },
 223
 224         // Content-Length in response to a HEAD request with HTTP/1.1
 225         {
 226                 "HTTP/1.1 200 OK\r\n" +
 227                         "Content-Length: 256\r\n" +
 228                         "\r\n",
 229
 230                 Response{
 231                         Status:           "200 OK",
 232                         StatusCode:       200,
 233                         Proto:            "HTTP/1.1",
 234                         ProtoMajor:       1,
 235                         ProtoMinor:       1,
 236                         Request:          dummyReq("HEAD"),
 237                         Header:           Header{"Content-Length": {"256"}},
 238                         TransferEncoding: nil,
 239                         Close:            false,
 240                         ContentLength:    256,
 241                 },
 242
 243                 "",
 244         },
 245
 246         // No Content-Length or Chunked in response to a HEAD request
 247         {
 248                 "HTTP/1.0 200 OK\r\n" +
 249                         "\r\n",
 250
 251                 Response{
 252                         Status:           "200 OK",
 253                         StatusCode:       200,
 254                         Proto:            "HTTP/1.0",
 255                         ProtoMajor:       1,
 256                         ProtoMinor:       0,
 257                         Request:          dummyReq("HEAD"),
 258                         Header:           Header{},
 259                         TransferEncoding: nil,
 260                         Close:            true,
 261                         ContentLength:    -1,
 262                 },
 263
 264                 "",
 265         },
 266
 267         // explicit Content-Length of 0.
 268         {
 269                 "HTTP/1.1 200 OK\r\n" +
 270                         "Content-Length: 0\r\n" +
 271                         "\r\n",
 272
 273                 Response{
 274                         Status:     "200 OK",
 275                         StatusCode: 200,
 276                         Proto:      "HTTP/1.1",
 277                         ProtoMajor: 1,
 278                         ProtoMinor: 1,
 279                         Request:    dummyReq("GET"),
 280                         Header: Header{
 281                                 "Content-Length": {"0"},
 282                         },
 283                         Close:         false,
 284                         ContentLength: 0,
 285                 },
 286
 287                 "",
 288         },
 289
 290         // Status line without a Reason-Phrase, but trailing space.
 291         // (permitted by RFC 2616)
 292         {
 293                 "HTTP/1.0 303 \r\n\r\n",
 294                 Response{
 295                         Status:        "303 ",
 296                         StatusCode:    303,
 297                         Proto:         "HTTP/1.0",
 298                         ProtoMajor:    1,
 299                         ProtoMinor:    0,
 300                         Request:       dummyReq("GET"),
 301                         Header:        Header{},
 302                         Close:         true,
 303                         ContentLength: -1,
 304                 },
 305
 306                 "",
 307         },
 308
 309         // Status line without a Reason-Phrase, and no trailing space.
 310         // (not permitted by RFC 2616, but we'll accept it anyway)
 311         {
 312                 "HTTP/1.0 303\r\n\r\n",
 313                 Response{
 314                         Status:        "303 ",
 315                         StatusCode:    303,
 316                         Proto:         "HTTP/1.0",
 317                         ProtoMajor:    1,
 318                         ProtoMinor:    0,
 319                         Request:       dummyReq("GET"),
 320                         Header:        Header{},
 321                         Close:         true,
 322                         ContentLength: -1,
 323                 },
 324
 325                 "",
 326         },
 327
 328         // golang.org/issue/4767: don't special-case multipart/byteranges responses
 329         {
 330                 `HTTP/1.1 206 Partial Content
 331 Connection: close
 332 Content-Type: multipart/byteranges; boundary=18a75608c8f47cef
 333
 334 some body`,
 335                 Response{
 336                         Status:     "206 Partial Content",
 337                         StatusCode: 206,
 338                         Proto:      "HTTP/1.1",
 339                         ProtoMajor: 1,
 340                         ProtoMinor: 1,
 341                         Request:    dummyReq("GET"),
 342                         Header: Header{
 343                                 "Content-Type": []string{"multipart/byteranges; boundary=18a75608c8f47cef"},
 344                         },
 345                         Close:         true,
 346                         ContentLength: -1,
 347                 },
 348
 349                 "some body",
 350         },
 351 }
 352
 353 func TestReadResponse(t *testing.T) {
 354         for i, tt := range respTests {
 355                 resp, err := ReadResponse(bufio.NewReader(strings.NewReader(tt.Raw)), tt.Resp.Request)
 356                 if err != nil {
 357                         t.Errorf("#%d: %v", i, err)
 358                         continue
 359                 }
 360                 rbody := resp.Body
 361                 resp.Body = nil
 362                 diff(t, fmt.Sprintf("#%d Response", i), resp, &tt.Resp)
 363                 var bout bytes.Buffer
 364                 if rbody != nil {
 365                         _, err = io.Copy(&bout, rbody)
 366                         if err != nil {
 367                                 t.Errorf("#%d: %v", i, err)
 368                                 continue
 369                         }
 370                         rbody.Close()
 371                 }
 372                 body := bout.String()
 373                 if body != tt.Body {
 374                         t.Errorf("#%d: Body = %q want %q", i, body, tt.Body)
 375                 }
 376         }
 377 }
 378
 379 func TestWriteResponse(t *testing.T) {
 380         for i, tt := range respTests {
 381                 resp, err := ReadResponse(bufio.NewReader(strings.NewReader(tt.Raw)), tt.Resp.Request)
 382                 if err != nil {
 383                         t.Errorf("#%d: %v", i, err)
 384                         continue
 385                 }
 386                 bout := bytes.NewBuffer(nil)
 387                 err = resp.Write(bout)
 388                 if err != nil {
 389                         t.Errorf("#%d: %v", i, err)
 390                         continue
 391                 }
 392         }
 393 }
 394
 395 var readResponseCloseInMiddleTests = []struct {
 396         chunked, compressed bool
 397 }{
 398         {false, false},
 399         {true, false},
 400         {true, true},
 401 }
 402
 403 // TestReadResponseCloseInMiddle tests that closing a body after
 404 // reading only part of its contents advances the read to the end of
 405 // the request, right up until the next request.
 406 func TestReadResponseCloseInMiddle(t *testing.T) {
 407         for _, test := range readResponseCloseInMiddleTests {
 408                 fatalf := func(format string, args ...interface{}) {
 409                         args = append([]interface{}{test.chunked, test.compressed}, args...)
 410                         t.Fatalf("on test chunked=%v, compressed=%v: "+format, args...)
 411                 }
 412                 checkErr := func(err error, msg string) {
 413                         if err == nil {
 414                                 return
 415                         }
 416                         fatalf(msg+": %v", err)
 417                 }
 418                 var buf bytes.Buffer
 419                 buf.WriteString("HTTP/1.1 200 OK\r\n")
 420                 if test.chunked {
 421                         buf.WriteString("Transfer-Encoding: chunked\r\n")
 422                 } else {
 423                         buf.WriteString("Content-Length: 1000000\r\n")
 424                 }
 425                 var wr io.Writer = &buf
 426                 if test.chunked {
 427                         wr = newChunkedWriter(wr)
 428                 }
 429                 if test.compressed {
 430                         buf.WriteString("Content-Encoding: gzip\r\n")
 431                         wr = gzip.NewWriter(wr)
 432                 }
 433                 buf.WriteString("\r\n")
 434
 435                 chunk := bytes.Repeat([]byte{'x'}, 1000)
 436                 for i := 0; i < 1000; i++ {
 437                         if test.compressed {
 438                                 // Otherwise this compresses too well.
 439                                 _, err := io.ReadFull(rand.Reader, chunk)
 440                                 checkErr(err, "rand.Reader ReadFull")
 441                         }
 442                         wr.Write(chunk)
 443                 }
 444                 if test.compressed {
 445                         err := wr.(*gzip.Writer).Close()
 446                         checkErr(err, "compressor close")
 447                 }
 448                 if test.chunked {
 449                         buf.WriteString("0\r\n\r\n")
 450                 }
 451                 buf.WriteString("Next Request Here")
 452
 453                 bufr := bufio.NewReader(&buf)
 454                 resp, err := ReadResponse(bufr, dummyReq("GET"))
 455                 checkErr(err, "ReadResponse")
 456                 expectedLength := int64(-1)
 457                 if !test.chunked {
 458                         expectedLength = 1000000
 459                 }
 460                 if resp.ContentLength != expectedLength {
 461                         fatalf("expected response length %d, got %d", expectedLength, resp.ContentLength)
 462                 }
 463                 if resp.Body == nil {
 464                         fatalf("nil body")
 465                 }
 466                 if test.compressed {
 467                         gzReader, err := gzip.NewReader(resp.Body)
 468                         checkErr(err, "gzip.NewReader")
 469                         resp.Body = &readerAndCloser{gzReader, resp.Body}
 470                 }
 471
 472                 rbuf := make([]byte, 2500)
 473                 n, err := io.ReadFull(resp.Body, rbuf)
 474                 checkErr(err, "2500 byte ReadFull")
 475                 if n != 2500 {
 476                         fatalf("ReadFull only read %d bytes", n)
 477                 }
 478                 if test.compressed == false && !bytes.Equal(bytes.Repeat([]byte{'x'}, 2500), rbuf) {
 479                         fatalf("ReadFull didn't read 2500 'x'; got %q", string(rbuf))
 480                 }
 481                 resp.Body.Close()
 482
 483                 rest, err := ioutil.ReadAll(bufr)
 484                 checkErr(err, "ReadAll on remainder")
 485                 if e, g := "Next Request Here", string(rest); e != g {
 486                         fatalf("remainder = %q, expected %q", g, e)
 487                 }
 488         }
 489 }
 490
 491 func diff(t *testing.T, prefix string, have, want interface{}) {
 492         hv := reflect.ValueOf(have).Elem()
 493         wv := reflect.ValueOf(want).Elem()
 494         if hv.Type() != wv.Type() {
 495                 t.Errorf("%s: type mismatch %v want %v", prefix, hv.Type(), wv.Type())
 496         }
 497         for i := 0; i < hv.NumField(); i++ {
 498                 hf := hv.Field(i).Interface()
 499                 wf := wv.Field(i).Interface()
 500                 if !reflect.DeepEqual(hf, wf) {
 501                         t.Errorf("%s: %s = %v want %v", prefix, hv.Type().Field(i).Name, hf, wf)
 502                 }
 503         }
 504 }
 505
 506 type responseLocationTest struct {
 507         location string // Response's Location header or ""
 508         requrl   string // Response.Request.URL or ""
 509         want     string
 510         wantErr  error
 511 }
 512
 513 var responseLocationTests = []responseLocationTest{
 514         {"/foo", "http://bar.com/baz", "http://bar.com/foo", nil},
 515         {"http://foo.com/", "http://bar.com/baz", "http://foo.com/", nil},
 516         {"", "http://bar.com/baz", "", ErrNoLocation},
 517 }
 518
 519 func TestLocationResponse(t *testing.T) {
 520         for i, tt := range responseLocationTests {
 521                 res := new(Response)
 522                 res.Header = make(Header)
 523                 res.Header.Set("Location", tt.location)
 524                 if tt.requrl != "" {
 525                         res.Request = &Request{}
 526                         var err error
 527                         res.Request.URL, err = url.Parse(tt.requrl)
 528                         if err != nil {
 529                                 t.Fatalf("bad test URL %q: %v", tt.requrl, err)
 530                         }
 531                 }
 532
 533                 got, err := res.Location()
 534                 if tt.wantErr != nil {
 535                         if err == nil {
 536                                 t.Errorf("%d. err=nil; want %q", i, tt.wantErr)
 537                                 continue
 538                         }
 539                         if g, e := err.Error(), tt.wantErr.Error(); g != e {
 540                                 t.Errorf("%d. err=%q; want %q", i, g, e)
 541                                 continue
 542                         }
 543                         continue
 544                 }
 545                 if err != nil {
 546                         t.Errorf("%d. err=%q", i, err)
 547                         continue
 548                 }
 549                 if g, e := got.String(), tt.want; g != e {
 550                         t.Errorf("%d. Location=%q; want %q", i, g, e)
 551                 }
 552         }
 553 }
 554
 555 func TestResponseStatusStutter(t *testing.T) {
 556         r := &Response{
 557                 Status:     "123 some status",
 558                 StatusCode: 123,
 559                 ProtoMajor: 1,
 560                 ProtoMinor: 3,
 561         }
 562         var buf bytes.Buffer
 563         r.Write(&buf)
 564         if strings.Contains(buf.String(), "123 123") {
 565                 t.Errorf("stutter in status: %s", buf.String())
 566         }
 567 }