/http/serve_test.go

http://github.com/petar/GoHTTP · Go · 1082 lines · 872 code · 118 blank · 92 comment · 264 complexity · 6186ebc0852a3a6dfaf4d39058267825 MD5 · raw file

  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. // End-to-end serving tests
  5. package http_test
  6. import (
  7. "bufio"
  8. "bytes"
  9. "fmt"
  10. . "http"
  11. "http/httptest"
  12. "io"
  13. "io/ioutil"
  14. "log"
  15. "os"
  16. "net"
  17. "reflect"
  18. "strings"
  19. "syscall"
  20. "testing"
  21. "time"
  22. "url"
  23. )
  24. type dummyAddr string
  25. type oneConnListener struct {
  26. conn net.Conn
  27. }
  28. func (l *oneConnListener) Accept() (c net.Conn, err os.Error) {
  29. c = l.conn
  30. if c == nil {
  31. err = os.EOF
  32. return
  33. }
  34. err = nil
  35. l.conn = nil
  36. return
  37. }
  38. func (l *oneConnListener) Close() os.Error {
  39. return nil
  40. }
  41. func (l *oneConnListener) Addr() net.Addr {
  42. return dummyAddr("test-address")
  43. }
  44. func (a dummyAddr) Network() string {
  45. return string(a)
  46. }
  47. func (a dummyAddr) String() string {
  48. return string(a)
  49. }
  50. type testConn struct {
  51. readBuf bytes.Buffer
  52. writeBuf bytes.Buffer
  53. }
  54. func (c *testConn) Read(b []byte) (int, os.Error) {
  55. return c.readBuf.Read(b)
  56. }
  57. func (c *testConn) Write(b []byte) (int, os.Error) {
  58. return c.writeBuf.Write(b)
  59. }
  60. func (c *testConn) Close() os.Error {
  61. return nil
  62. }
  63. func (c *testConn) LocalAddr() net.Addr {
  64. return dummyAddr("local-addr")
  65. }
  66. func (c *testConn) RemoteAddr() net.Addr {
  67. return dummyAddr("remote-addr")
  68. }
  69. func (c *testConn) SetTimeout(nsec int64) os.Error {
  70. return nil
  71. }
  72. func (c *testConn) SetReadTimeout(nsec int64) os.Error {
  73. return nil
  74. }
  75. func (c *testConn) SetWriteTimeout(nsec int64) os.Error {
  76. return nil
  77. }
  78. func TestConsumingBodyOnNextConn(t *testing.T) {
  79. conn := new(testConn)
  80. for i := 0; i < 2; i++ {
  81. conn.readBuf.Write([]byte(
  82. "POST / HTTP/1.1\r\n" +
  83. "Host: test\r\n" +
  84. "Content-Length: 11\r\n" +
  85. "\r\n" +
  86. "foo=1&bar=1"))
  87. }
  88. reqNum := 0
  89. ch := make(chan *Request)
  90. servech := make(chan os.Error)
  91. listener := &oneConnListener{conn}
  92. handler := func(res ResponseWriter, req *Request) {
  93. reqNum++
  94. ch <- req
  95. }
  96. go func() {
  97. servech <- Serve(listener, HandlerFunc(handler))
  98. }()
  99. var req *Request
  100. req = <-ch
  101. if req == nil {
  102. t.Fatal("Got nil first request.")
  103. }
  104. if req.Method != "POST" {
  105. t.Errorf("For request #1's method, got %q; expected %q",
  106. req.Method, "POST")
  107. }
  108. req = <-ch
  109. if req == nil {
  110. t.Fatal("Got nil first request.")
  111. }
  112. if req.Method != "POST" {
  113. t.Errorf("For request #2's method, got %q; expected %q",
  114. req.Method, "POST")
  115. }
  116. if serveerr := <-servech; serveerr != os.EOF {
  117. t.Errorf("Serve returned %q; expected EOF", serveerr)
  118. }
  119. }
  120. type stringHandler string
  121. func (s stringHandler) ServeHTTP(w ResponseWriter, r *Request) {
  122. w.Header().Set("Result", string(s))
  123. }
  124. var handlers = []struct {
  125. pattern string
  126. msg string
  127. }{
  128. {"/", "Default"},
  129. {"/someDir/", "someDir"},
  130. {"someHost.com/someDir/", "someHost.com/someDir"},
  131. }
  132. var vtests = []struct {
  133. url string
  134. expected string
  135. }{
  136. {"http://localhost/someDir/apage", "someDir"},
  137. {"http://localhost/otherDir/apage", "Default"},
  138. {"http://someHost.com/someDir/apage", "someHost.com/someDir"},
  139. {"http://otherHost.com/someDir/apage", "someDir"},
  140. {"http://otherHost.com/aDir/apage", "Default"},
  141. }
  142. func TestHostHandlers(t *testing.T) {
  143. for _, h := range handlers {
  144. Handle(h.pattern, stringHandler(h.msg))
  145. }
  146. ts := httptest.NewServer(nil)
  147. defer ts.Close()
  148. conn, err := net.Dial("tcp", ts.Listener.Addr().String())
  149. if err != nil {
  150. t.Fatal(err)
  151. }
  152. defer conn.Close()
  153. cc := NewClientConn(conn, nil)
  154. for _, vt := range vtests {
  155. var r *Response
  156. var req Request
  157. if req.URL, err = url.Parse(vt.url); err != nil {
  158. t.Errorf("cannot parse url: %v", err)
  159. continue
  160. }
  161. if err := cc.Write(&req); err != nil {
  162. t.Errorf("writing request: %v", err)
  163. continue
  164. }
  165. r, err := cc.Read(&req)
  166. if err != nil {
  167. t.Errorf("reading response: %v", err)
  168. continue
  169. }
  170. s := r.Header.Get("Result")
  171. if s != vt.expected {
  172. t.Errorf("Get(%q) = %q, want %q", vt.url, s, vt.expected)
  173. }
  174. }
  175. }
  176. // Tests for http://code.google.com/p/go/issues/detail?id=900
  177. func TestMuxRedirectLeadingSlashes(t *testing.T) {
  178. paths := []string{"//foo.txt", "///foo.txt", "/../../foo.txt"}
  179. for _, path := range paths {
  180. req, err := ReadRequest(bufio.NewReader(bytes.NewBufferString("GET " + path + " HTTP/1.1\r\nHost: test\r\n\r\n")))
  181. if err != nil {
  182. t.Errorf("%s", err)
  183. }
  184. mux := NewServeMux()
  185. resp := httptest.NewRecorder()
  186. mux.ServeHTTP(resp, req)
  187. if loc, expected := resp.Header().Get("Location"), "/foo.txt"; loc != expected {
  188. t.Errorf("Expected Location header set to %q; got %q", expected, loc)
  189. return
  190. }
  191. if code, expected := resp.Code, StatusMovedPermanently; code != expected {
  192. t.Errorf("Expected response code of StatusMovedPermanently; got %d", code)
  193. return
  194. }
  195. }
  196. }
  197. func TestServerTimeouts(t *testing.T) {
  198. // TODO(bradfitz): convert this to use httptest.Server
  199. l, err := net.Listen("tcp", "127.0.0.1:0")
  200. if err != nil {
  201. t.Fatalf("listen error: %v", err)
  202. }
  203. addr, _ := l.Addr().(*net.TCPAddr)
  204. reqNum := 0
  205. handler := HandlerFunc(func(res ResponseWriter, req *Request) {
  206. reqNum++
  207. fmt.Fprintf(res, "req=%d", reqNum)
  208. })
  209. const second = 1000000000 /* nanos */
  210. server := &Server{Handler: handler, ReadTimeout: 0.25 * second, WriteTimeout: 0.25 * second}
  211. go server.Serve(l)
  212. url := fmt.Sprintf("http://%s/", addr)
  213. // Hit the HTTP server successfully.
  214. tr := &Transport{DisableKeepAlives: true} // they interfere with this test
  215. c := &Client{Transport: tr}
  216. r, err := c.Get(url)
  217. if err != nil {
  218. t.Fatalf("http Get #1: %v", err)
  219. }
  220. got, _ := ioutil.ReadAll(r.Body)
  221. expected := "req=1"
  222. if string(got) != expected {
  223. t.Errorf("Unexpected response for request #1; got %q; expected %q",
  224. string(got), expected)
  225. }
  226. // Slow client that should timeout.
  227. t1 := time.Nanoseconds()
  228. conn, err := net.Dial("tcp", addr.String())
  229. if err != nil {
  230. t.Fatalf("Dial: %v", err)
  231. }
  232. buf := make([]byte, 1)
  233. n, err := conn.Read(buf)
  234. latency := time.Nanoseconds() - t1
  235. if n != 0 || err != os.EOF {
  236. t.Errorf("Read = %v, %v, wanted %v, %v", n, err, 0, os.EOF)
  237. }
  238. if latency < second*0.20 /* fudge from 0.25 above */ {
  239. t.Errorf("got EOF after %d ns, want >= %d", latency, second*0.20)
  240. }
  241. // Hit the HTTP server successfully again, verifying that the
  242. // previous slow connection didn't run our handler. (that we
  243. // get "req=2", not "req=3")
  244. r, err = Get(url)
  245. if err != nil {
  246. t.Fatalf("http Get #2: %v", err)
  247. }
  248. got, _ = ioutil.ReadAll(r.Body)
  249. expected = "req=2"
  250. if string(got) != expected {
  251. t.Errorf("Get #2 got %q, want %q", string(got), expected)
  252. }
  253. l.Close()
  254. }
  255. // TestIdentityResponse verifies that a handler can unset
  256. func TestIdentityResponse(t *testing.T) {
  257. handler := HandlerFunc(func(rw ResponseWriter, req *Request) {
  258. rw.Header().Set("Content-Length", "3")
  259. rw.Header().Set("Transfer-Encoding", req.FormValue("te"))
  260. switch {
  261. case req.FormValue("overwrite") == "1":
  262. _, err := rw.Write([]byte("foo TOO LONG"))
  263. if err != ErrContentLength {
  264. t.Errorf("expected ErrContentLength; got %v", err)
  265. }
  266. case req.FormValue("underwrite") == "1":
  267. rw.Header().Set("Content-Length", "500")
  268. rw.Write([]byte("too short"))
  269. default:
  270. rw.Write([]byte("foo"))
  271. }
  272. })
  273. ts := httptest.NewServer(handler)
  274. defer ts.Close()
  275. // Note: this relies on the assumption (which is true) that
  276. // Get sends HTTP/1.1 or greater requests. Otherwise the
  277. // server wouldn't have the choice to send back chunked
  278. // responses.
  279. for _, te := range []string{"", "identity"} {
  280. url := ts.URL + "/?te=" + te
  281. res, err := Get(url)
  282. if err != nil {
  283. t.Fatalf("error with Get of %s: %v", url, err)
  284. }
  285. if cl, expected := res.ContentLength, int64(3); cl != expected {
  286. t.Errorf("for %s expected res.ContentLength of %d; got %d", url, expected, cl)
  287. }
  288. if cl, expected := res.Header.Get("Content-Length"), "3"; cl != expected {
  289. t.Errorf("for %s expected Content-Length header of %q; got %q", url, expected, cl)
  290. }
  291. if tl, expected := len(res.TransferEncoding), 0; tl != expected {
  292. t.Errorf("for %s expected len(res.TransferEncoding) of %d; got %d (%v)",
  293. url, expected, tl, res.TransferEncoding)
  294. }
  295. res.Body.Close()
  296. }
  297. // Verify that ErrContentLength is returned
  298. url := ts.URL + "/?overwrite=1"
  299. _, err := Get(url)
  300. if err != nil {
  301. t.Fatalf("error with Get of %s: %v", url, err)
  302. }
  303. // Verify that the connection is closed when the declared Content-Length
  304. // is larger than what the handler wrote.
  305. conn, err := net.Dial("tcp", ts.Listener.Addr().String())
  306. if err != nil {
  307. t.Fatalf("error dialing: %v", err)
  308. }
  309. _, err = conn.Write([]byte("GET /?underwrite=1 HTTP/1.1\r\nHost: foo\r\n\r\n"))
  310. if err != nil {
  311. t.Fatalf("error writing: %v", err)
  312. }
  313. // The next ReadAll will hang for a failing test, so use a Timer instead
  314. // to fail more traditionally
  315. timer := time.AfterFunc(2e9, func() {
  316. t.Fatalf("Timeout expired in ReadAll.")
  317. })
  318. defer timer.Stop()
  319. got, _ := ioutil.ReadAll(conn)
  320. expectedSuffix := "\r\n\r\ntoo short"
  321. if !strings.HasSuffix(string(got), expectedSuffix) {
  322. t.Fatalf("Expected output to end with %q; got response body %q",
  323. expectedSuffix, string(got))
  324. }
  325. }
  326. func testTcpConnectionCloses(t *testing.T, req string, h Handler) {
  327. s := httptest.NewServer(h)
  328. defer s.Close()
  329. conn, err := net.Dial("tcp", s.Listener.Addr().String())
  330. if err != nil {
  331. t.Fatal("dial error:", err)
  332. }
  333. defer conn.Close()
  334. _, err = fmt.Fprint(conn, req)
  335. if err != nil {
  336. t.Fatal("print error:", err)
  337. }
  338. r := bufio.NewReader(conn)
  339. _, err = ReadResponse(r, &Request{Method: "GET"})
  340. if err != nil {
  341. t.Fatal("ReadResponse error:", err)
  342. }
  343. success := make(chan bool)
  344. go func() {
  345. select {
  346. case <-time.After(5e9):
  347. t.Fatal("body not closed after 5s")
  348. case <-success:
  349. }
  350. }()
  351. _, err = ioutil.ReadAll(r)
  352. if err != nil {
  353. t.Fatal("read error:", err)
  354. }
  355. success <- true
  356. }
  357. // TestServeHTTP10Close verifies that HTTP/1.0 requests won't be kept alive.
  358. func TestServeHTTP10Close(t *testing.T) {
  359. testTcpConnectionCloses(t, "GET / HTTP/1.0\r\n\r\n", HandlerFunc(func(w ResponseWriter, r *Request) {
  360. ServeFile(w, r, "testdata/file")
  361. }))
  362. }
  363. // TestHandlersCanSetConnectionClose verifies that handlers can force a connection to close,
  364. // even for HTTP/1.1 requests.
  365. func TestHandlersCanSetConnectionClose11(t *testing.T) {
  366. testTcpConnectionCloses(t, "GET / HTTP/1.1\r\n\r\n", HandlerFunc(func(w ResponseWriter, r *Request) {
  367. w.Header().Set("Connection", "close")
  368. }))
  369. }
  370. func TestHandlersCanSetConnectionClose10(t *testing.T) {
  371. testTcpConnectionCloses(t, "GET / HTTP/1.0\r\nConnection: keep-alive\r\n\r\n", HandlerFunc(func(w ResponseWriter, r *Request) {
  372. w.Header().Set("Connection", "close")
  373. }))
  374. }
  375. func TestSetsRemoteAddr(t *testing.T) {
  376. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  377. fmt.Fprintf(w, "%s", r.RemoteAddr)
  378. }))
  379. defer ts.Close()
  380. res, err := Get(ts.URL)
  381. if err != nil {
  382. t.Fatalf("Get error: %v", err)
  383. }
  384. body, err := ioutil.ReadAll(res.Body)
  385. if err != nil {
  386. t.Fatalf("ReadAll error: %v", err)
  387. }
  388. ip := string(body)
  389. if !strings.HasPrefix(ip, "127.0.0.1:") && !strings.HasPrefix(ip, "[::1]:") {
  390. t.Fatalf("Expected local addr; got %q", ip)
  391. }
  392. }
  393. func TestChunkedResponseHeaders(t *testing.T) {
  394. log.SetOutput(ioutil.Discard) // is noisy otherwise
  395. defer log.SetOutput(os.Stderr)
  396. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  397. w.Header().Set("Content-Length", "intentional gibberish") // we check that this is deleted
  398. fmt.Fprintf(w, "I am a chunked response.")
  399. }))
  400. defer ts.Close()
  401. res, err := Get(ts.URL)
  402. if err != nil {
  403. t.Fatalf("Get error: %v", err)
  404. }
  405. if g, e := res.ContentLength, int64(-1); g != e {
  406. t.Errorf("expected ContentLength of %d; got %d", e, g)
  407. }
  408. if g, e := res.TransferEncoding, []string{"chunked"}; !reflect.DeepEqual(g, e) {
  409. t.Errorf("expected TransferEncoding of %v; got %v", e, g)
  410. }
  411. if _, haveCL := res.Header["Content-Length"]; haveCL {
  412. t.Errorf("Unexpected Content-Length")
  413. }
  414. }
  415. // Test304Responses verifies that 304s don't declare that they're
  416. // chunking in their response headers and aren't allowed to produce
  417. // output.
  418. func Test304Responses(t *testing.T) {
  419. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  420. w.WriteHeader(StatusNotModified)
  421. _, err := w.Write([]byte("illegal body"))
  422. if err != ErrBodyNotAllowed {
  423. t.Errorf("on Write, expected ErrBodyNotAllowed, got %v", err)
  424. }
  425. }))
  426. defer ts.Close()
  427. res, err := Get(ts.URL)
  428. if err != nil {
  429. t.Error(err)
  430. }
  431. if len(res.TransferEncoding) > 0 {
  432. t.Errorf("expected no TransferEncoding; got %v", res.TransferEncoding)
  433. }
  434. body, err := ioutil.ReadAll(res.Body)
  435. if err != nil {
  436. t.Error(err)
  437. }
  438. if len(body) > 0 {
  439. t.Errorf("got unexpected body %q", string(body))
  440. }
  441. }
  442. // TestHeadResponses verifies that responses to HEAD requests don't
  443. // declare that they're chunking in their response headers and aren't
  444. // allowed to produce output.
  445. func TestHeadResponses(t *testing.T) {
  446. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  447. _, err := w.Write([]byte("Ignored body"))
  448. if err != ErrBodyNotAllowed {
  449. t.Errorf("on Write, expected ErrBodyNotAllowed, got %v", err)
  450. }
  451. // Also exercise the ReaderFrom path
  452. _, err = io.Copy(w, strings.NewReader("Ignored body"))
  453. if err != ErrBodyNotAllowed {
  454. t.Errorf("on Copy, expected ErrBodyNotAllowed, got %v", err)
  455. }
  456. }))
  457. defer ts.Close()
  458. res, err := Head(ts.URL)
  459. if err != nil {
  460. t.Error(err)
  461. }
  462. if len(res.TransferEncoding) > 0 {
  463. t.Errorf("expected no TransferEncoding; got %v", res.TransferEncoding)
  464. }
  465. body, err := ioutil.ReadAll(res.Body)
  466. if err != nil {
  467. t.Error(err)
  468. }
  469. if len(body) > 0 {
  470. t.Errorf("got unexpected body %q", string(body))
  471. }
  472. }
  473. func TestTLSHandshakeTimeout(t *testing.T) {
  474. if true {
  475. t.Logf("Skipping broken test; issue 2281")
  476. return
  477. }
  478. ts := httptest.NewUnstartedServer(HandlerFunc(func(w ResponseWriter, r *Request) {}))
  479. ts.Config.ReadTimeout = 250e6
  480. ts.StartTLS()
  481. defer ts.Close()
  482. conn, err := net.Dial("tcp", ts.Listener.Addr().String())
  483. if err != nil {
  484. t.Fatalf("Dial: %v", err)
  485. }
  486. defer conn.Close()
  487. timer := time.AfterFunc(10e9, func() { t.Fatalf("Timeout") })
  488. defer timer.Stop()
  489. var buf [1]byte
  490. n, err := conn.Read(buf[:])
  491. if err == nil || n != 0 {
  492. t.Errorf("Read = %d, %v; want an error and no bytes", n, err)
  493. }
  494. }
  495. func TestTLSServer(t *testing.T) {
  496. ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  497. if r.TLS != nil {
  498. w.Header().Set("X-TLS-Set", "true")
  499. if r.TLS.HandshakeComplete {
  500. w.Header().Set("X-TLS-HandshakeComplete", "true")
  501. }
  502. }
  503. }))
  504. defer ts.Close()
  505. // Connect an idle TCP connection to this server before we run
  506. // our real tests. This idle connection used to block forever
  507. // in the TLS handshake, preventing future connections from
  508. // being accepted. It may prevent future accidental blocking
  509. // in newConn.
  510. idleConn, err := net.Dial("tcp", ts.Listener.Addr().String())
  511. if err != nil {
  512. t.Fatalf("Dial: %v", err)
  513. }
  514. defer idleConn.Close()
  515. time.AfterFunc(10e9, func() { t.Fatalf("Timeout") })
  516. if !strings.HasPrefix(ts.URL, "https://") {
  517. t.Fatalf("expected test TLS server to start with https://, got %q", ts.URL)
  518. }
  519. res, err := Get(ts.URL)
  520. if err != nil {
  521. t.Fatal(err)
  522. }
  523. if res == nil {
  524. t.Fatalf("got nil Response")
  525. }
  526. defer res.Body.Close()
  527. if res.Header.Get("X-TLS-Set") != "true" {
  528. t.Errorf("expected X-TLS-Set response header")
  529. }
  530. if res.Header.Get("X-TLS-HandshakeComplete") != "true" {
  531. t.Errorf("expected X-TLS-HandshakeComplete header")
  532. }
  533. }
  534. type serverExpectTest struct {
  535. contentLength int // of request body
  536. expectation string // e.g. "100-continue"
  537. readBody bool // whether handler should read the body (if false, sends StatusUnauthorized)
  538. expectedResponse string // expected substring in first line of http response
  539. }
  540. var serverExpectTests = []serverExpectTest{
  541. // Normal 100-continues, case-insensitive.
  542. {100, "100-continue", true, "100 Continue"},
  543. {100, "100-cOntInUE", true, "100 Continue"},
  544. // No 100-continue.
  545. {100, "", true, "200 OK"},
  546. // 100-continue but requesting client to deny us,
  547. // so it never reads the body.
  548. {100, "100-continue", false, "401 Unauthorized"},
  549. // Likewise without 100-continue:
  550. {100, "", false, "401 Unauthorized"},
  551. // Non-standard expectations are failures
  552. {0, "a-pony", false, "417 Expectation Failed"},
  553. // Expect-100 requested but no body
  554. {0, "100-continue", true, "400 Bad Request"},
  555. }
  556. // Tests that the server responds to the "Expect" request header
  557. // correctly.
  558. func TestServerExpect(t *testing.T) {
  559. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  560. // Note using r.FormValue("readbody") because for POST
  561. // requests that would read from r.Body, which we only
  562. // conditionally want to do.
  563. if strings.Contains(r.URL.RawPath, "readbody=true") {
  564. ioutil.ReadAll(r.Body)
  565. w.Write([]byte("Hi"))
  566. } else {
  567. w.WriteHeader(StatusUnauthorized)
  568. }
  569. }))
  570. defer ts.Close()
  571. runTest := func(test serverExpectTest) {
  572. conn, err := net.Dial("tcp", ts.Listener.Addr().String())
  573. if err != nil {
  574. t.Fatalf("Dial: %v", err)
  575. }
  576. defer conn.Close()
  577. sendf := func(format string, args ...interface{}) {
  578. _, err := fmt.Fprintf(conn, format, args...)
  579. if err != nil {
  580. t.Fatalf("On test %#v, error writing %q: %v", test, format, err)
  581. }
  582. }
  583. go func() {
  584. sendf("POST /?readbody=%v HTTP/1.1\r\n"+
  585. "Connection: close\r\n"+
  586. "Content-Length: %d\r\n"+
  587. "Expect: %s\r\nHost: foo\r\n\r\n",
  588. test.readBody, test.contentLength, test.expectation)
  589. if test.contentLength > 0 && strings.ToLower(test.expectation) != "100-continue" {
  590. body := strings.Repeat("A", test.contentLength)
  591. sendf(body)
  592. }
  593. }()
  594. bufr := bufio.NewReader(conn)
  595. line, err := bufr.ReadString('\n')
  596. if err != nil {
  597. t.Fatalf("ReadString: %v", err)
  598. }
  599. if !strings.Contains(line, test.expectedResponse) {
  600. t.Errorf("for test %#v got first line=%q", test, line)
  601. }
  602. }
  603. for _, test := range serverExpectTests {
  604. runTest(test)
  605. }
  606. }
  607. func TestServerConsumesRequestBody(t *testing.T) {
  608. conn := new(testConn)
  609. body := strings.Repeat("x", 1<<20)
  610. conn.readBuf.Write([]byte(fmt.Sprintf(
  611. "POST / HTTP/1.1\r\n"+
  612. "Host: test\r\n"+
  613. "Content-Length: %d\r\n"+
  614. "\r\n", len(body))))
  615. conn.readBuf.Write([]byte(body))
  616. done := make(chan bool)
  617. ls := &oneConnListener{conn}
  618. go Serve(ls, HandlerFunc(func(rw ResponseWriter, req *Request) {
  619. if conn.readBuf.Len() < len(body)/2 {
  620. t.Errorf("on request, read buffer length is %d; expected about 1MB", conn.readBuf.Len())
  621. }
  622. rw.WriteHeader(200)
  623. if g, e := conn.readBuf.Len(), 0; g != e {
  624. t.Errorf("after WriteHeader, read buffer length is %d; want %d", g, e)
  625. }
  626. done <- true
  627. }))
  628. <-done
  629. }
  630. func TestTimeoutHandler(t *testing.T) {
  631. sendHi := make(chan bool, 1)
  632. writeErrors := make(chan os.Error, 1)
  633. sayHi := HandlerFunc(func(w ResponseWriter, r *Request) {
  634. <-sendHi
  635. _, werr := w.Write([]byte("hi"))
  636. writeErrors <- werr
  637. })
  638. timeout := make(chan int64, 1) // write to this to force timeouts
  639. ts := httptest.NewServer(NewTestTimeoutHandler(sayHi, timeout))
  640. defer ts.Close()
  641. // Succeed without timing out:
  642. sendHi <- true
  643. res, err := Get(ts.URL)
  644. if err != nil {
  645. t.Error(err)
  646. }
  647. if g, e := res.StatusCode, StatusOK; g != e {
  648. t.Errorf("got res.StatusCode %d; expected %d", g, e)
  649. }
  650. body, _ := ioutil.ReadAll(res.Body)
  651. if g, e := string(body), "hi"; g != e {
  652. t.Errorf("got body %q; expected %q", g, e)
  653. }
  654. if g := <-writeErrors; g != nil {
  655. t.Errorf("got unexpected Write error on first request: %v", g)
  656. }
  657. // Times out:
  658. timeout <- 1
  659. res, err = Get(ts.URL)
  660. if err != nil {
  661. t.Error(err)
  662. }
  663. if g, e := res.StatusCode, StatusServiceUnavailable; g != e {
  664. t.Errorf("got res.StatusCode %d; expected %d", g, e)
  665. }
  666. body, _ = ioutil.ReadAll(res.Body)
  667. if !strings.Contains(string(body), "<title>Timeout</title>") {
  668. t.Errorf("expected timeout body; got %q", string(body))
  669. }
  670. // Now make the previously-timed out handler speak again,
  671. // which verifies the panic is handled:
  672. sendHi <- true
  673. if g, e := <-writeErrors, ErrHandlerTimeout; g != e {
  674. t.Errorf("expected Write error of %v; got %v", e, g)
  675. }
  676. }
  677. // Verifies we don't path.Clean() on the wrong parts in redirects.
  678. func TestRedirectMunging(t *testing.T) {
  679. req, _ := NewRequest("GET", "http://example.com/", nil)
  680. resp := httptest.NewRecorder()
  681. Redirect(resp, req, "/foo?next=http://bar.com/", 302)
  682. if g, e := resp.Header().Get("Location"), "/foo?next=http://bar.com/"; g != e {
  683. t.Errorf("Location header was %q; want %q", g, e)
  684. }
  685. resp = httptest.NewRecorder()
  686. Redirect(resp, req, "http://localhost:8080/_ah/login?continue=http://localhost:8080/", 302)
  687. if g, e := resp.Header().Get("Location"), "http://localhost:8080/_ah/login?continue=http://localhost:8080/"; g != e {
  688. t.Errorf("Location header was %q; want %q", g, e)
  689. }
  690. }
  691. // TestZeroLengthPostAndResponse exercises an optimization done by the Transport:
  692. // when there is no body (either because the method doesn't permit a body, or an
  693. // explicit Content-Length of zero is present), then the transport can re-use the
  694. // connection immediately. But when it re-uses the connection, it typically closes
  695. // the previous request's body, which is not optimal for zero-lengthed bodies,
  696. // as the client would then see http.ErrBodyReadAfterClose and not 0, os.EOF.
  697. func TestZeroLengthPostAndResponse(t *testing.T) {
  698. ts := httptest.NewServer(HandlerFunc(func(rw ResponseWriter, r *Request) {
  699. all, err := ioutil.ReadAll(r.Body)
  700. if err != nil {
  701. t.Fatalf("handler ReadAll: %v", err)
  702. }
  703. if len(all) != 0 {
  704. t.Errorf("handler got %d bytes; expected 0", len(all))
  705. }
  706. rw.Header().Set("Content-Length", "0")
  707. }))
  708. defer ts.Close()
  709. req, err := NewRequest("POST", ts.URL, strings.NewReader(""))
  710. if err != nil {
  711. t.Fatal(err)
  712. }
  713. req.ContentLength = 0
  714. var resp [5]*Response
  715. for i := range resp {
  716. resp[i], err = DefaultClient.Do(req)
  717. if err != nil {
  718. t.Fatalf("client post #%d: %v", i, err)
  719. }
  720. }
  721. for i := range resp {
  722. all, err := ioutil.ReadAll(resp[i].Body)
  723. if err != nil {
  724. t.Fatalf("req #%d: client ReadAll: %v", i, err)
  725. }
  726. if len(all) != 0 {
  727. t.Errorf("req #%d: client got %d bytes; expected 0", i, len(all))
  728. }
  729. }
  730. }
  731. func TestHandlerPanic(t *testing.T) {
  732. // Unlike the other tests that set the log output to ioutil.Discard
  733. // to quiet the output, this test uses a pipe. The pipe serves three
  734. // purposes:
  735. //
  736. // 1) The log.Print from the http server (generated by the caught
  737. // panic) will go to the pipe instead of stderr, making the
  738. // output quiet.
  739. //
  740. // 2) We read from the pipe to verify that the handler
  741. // actually caught the panic and logged something.
  742. //
  743. // 3) The blocking Read call prevents this TestHandlerPanic
  744. // function from exiting before the HTTP server handler
  745. // finishes crashing. If this text function exited too
  746. // early (and its defer log.SetOutput(os.Stderr) ran),
  747. // then the crash output could spill into the next test.
  748. pr, pw := io.Pipe()
  749. log.SetOutput(pw)
  750. defer log.SetOutput(os.Stderr)
  751. ts := httptest.NewServer(HandlerFunc(func(ResponseWriter, *Request) {
  752. panic("intentional death for testing")
  753. }))
  754. defer ts.Close()
  755. _, err := Get(ts.URL)
  756. if err == nil {
  757. t.Logf("expected an error")
  758. }
  759. // Do a blocking read on the log output pipe so its logging
  760. // doesn't bleed into the next test. But wait only 5 seconds
  761. // for it.
  762. done := make(chan bool)
  763. go func() {
  764. buf := make([]byte, 1024)
  765. _, err := pr.Read(buf)
  766. pr.Close()
  767. if err != nil {
  768. t.Fatal(err)
  769. }
  770. done <- true
  771. }()
  772. select {
  773. case <-done:
  774. return
  775. case <-time.After(5e9):
  776. t.Fatal("expected server handler to log an error")
  777. }
  778. }
  779. func TestNoDate(t *testing.T) {
  780. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  781. w.Header()["Date"] = nil
  782. }))
  783. defer ts.Close()
  784. res, err := Get(ts.URL)
  785. if err != nil {
  786. t.Fatal(err)
  787. }
  788. _, present := res.Header["Date"]
  789. if present {
  790. t.Fatalf("Expected no Date header; got %v", res.Header["Date"])
  791. }
  792. }
  793. func TestStripPrefix(t *testing.T) {
  794. h := HandlerFunc(func(w ResponseWriter, r *Request) {
  795. w.Header().Set("X-Path", r.URL.Path)
  796. })
  797. ts := httptest.NewServer(StripPrefix("/foo", h))
  798. defer ts.Close()
  799. res, err := Get(ts.URL + "/foo/bar")
  800. if err != nil {
  801. t.Fatal(err)
  802. }
  803. if g, e := res.Header.Get("X-Path"), "/bar"; g != e {
  804. t.Errorf("test 1: got %s, want %s", g, e)
  805. }
  806. res, err = Get(ts.URL + "/bar")
  807. if err != nil {
  808. t.Fatal(err)
  809. }
  810. if g, e := res.StatusCode, 404; g != e {
  811. t.Errorf("test 2: got status %v, want %v", g, e)
  812. }
  813. }
  814. func TestRequestLimit(t *testing.T) {
  815. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  816. t.Fatalf("didn't expect to get request in Handler")
  817. }))
  818. defer ts.Close()
  819. req, _ := NewRequest("GET", ts.URL, nil)
  820. var bytesPerHeader = len("header12345: val12345\r\n")
  821. for i := 0; i < ((DefaultMaxHeaderBytes+4096)/bytesPerHeader)+1; i++ {
  822. req.Header.Set(fmt.Sprintf("header%05d", i), fmt.Sprintf("val%05d", i))
  823. }
  824. res, err := DefaultClient.Do(req)
  825. if err != nil {
  826. // Some HTTP clients may fail on this undefined behavior (server replying and
  827. // closing the connection while the request is still being written), but
  828. // we do support it (at least currently), so we expect a response below.
  829. t.Fatalf("Do: %v", err)
  830. }
  831. if res.StatusCode != 413 {
  832. t.Fatalf("expected 413 response status; got: %d %s", res.StatusCode, res.Status)
  833. }
  834. }
  835. type neverEnding byte
  836. func (b neverEnding) Read(p []byte) (n int, err os.Error) {
  837. for i := range p {
  838. p[i] = byte(b)
  839. }
  840. return len(p), nil
  841. }
  842. type countReader struct {
  843. r io.Reader
  844. n *int64
  845. }
  846. func (cr countReader) Read(p []byte) (n int, err os.Error) {
  847. n, err = cr.r.Read(p)
  848. *cr.n += int64(n)
  849. return
  850. }
  851. func TestRequestBodyLimit(t *testing.T) {
  852. const limit = 1 << 20
  853. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {
  854. r.Body = MaxBytesReader(w, r.Body, limit)
  855. n, err := io.Copy(ioutil.Discard, r.Body)
  856. if err == nil {
  857. t.Errorf("expected error from io.Copy")
  858. }
  859. if n != limit {
  860. t.Errorf("io.Copy = %d, want %d", n, limit)
  861. }
  862. }))
  863. defer ts.Close()
  864. nWritten := int64(0)
  865. req, _ := NewRequest("POST", ts.URL, io.LimitReader(countReader{neverEnding('a'), &nWritten}, limit*200))
  866. // Send the POST, but don't care it succeeds or not. The
  867. // remote side is going to reply and then close the TCP
  868. // connection, and HTTP doesn't really define if that's
  869. // allowed or not. Some HTTP clients will get the response
  870. // and some (like ours, currently) will complain that the
  871. // request write failed, without reading the response.
  872. //
  873. // But that's okay, since what we're really testing is that
  874. // the remote side hung up on us before we wrote too much.
  875. _, _ = DefaultClient.Do(req)
  876. if nWritten > limit*100 {
  877. t.Errorf("handler restricted the request body to %d bytes, but client managed to write %d",
  878. limit, nWritten)
  879. }
  880. }
  881. // TestClientWriteShutdown tests that if the client shuts down the write
  882. // side of their TCP connection, the server doesn't send a 400 Bad Request.
  883. func TestClientWriteShutdown(t *testing.T) {
  884. ts := httptest.NewServer(HandlerFunc(func(w ResponseWriter, r *Request) {}))
  885. defer ts.Close()
  886. conn, err := net.Dial("tcp", ts.Listener.Addr().String())
  887. if err != nil {
  888. t.Fatalf("Dial: %v", err)
  889. }
  890. err = conn.(*net.TCPConn).CloseWrite()
  891. if err != nil {
  892. t.Fatalf("Dial: %v", err)
  893. }
  894. donec := make(chan bool)
  895. go func() {
  896. defer close(donec)
  897. bs, err := ioutil.ReadAll(conn)
  898. if err != nil {
  899. t.Fatalf("ReadAll: %v", err)
  900. }
  901. got := string(bs)
  902. if got != "" {
  903. t.Errorf("read %q from server; want nothing", got)
  904. }
  905. }()
  906. select {
  907. case <-donec:
  908. case <-time.After(10e9):
  909. t.Fatalf("timeout")
  910. }
  911. }
  912. type errorListener struct {
  913. errs []os.Error
  914. }
  915. func (l *errorListener) Accept() (c net.Conn, err os.Error) {
  916. if len(l.errs) == 0 {
  917. return nil, os.EOF
  918. }
  919. err = l.errs[0]
  920. l.errs = l.errs[1:]
  921. return
  922. }
  923. func (l *errorListener) Close() os.Error {
  924. return nil
  925. }
  926. func (l *errorListener) Addr() net.Addr {
  927. return dummyAddr("test-address")
  928. }
  929. func TestAcceptMaxFds(t *testing.T) {
  930. log.SetOutput(ioutil.Discard) // is noisy otherwise
  931. defer log.SetOutput(os.Stderr)
  932. ln := &errorListener{[]os.Error{
  933. &net.OpError{
  934. Op: "accept",
  935. Error: os.Errno(syscall.EMFILE),
  936. }}}
  937. err := Serve(ln, HandlerFunc(HandlerFunc(func(ResponseWriter, *Request) {})))
  938. if err != os.EOF {
  939. t.Errorf("got error %v, want EOF", err)
  940. }
  941. }
  942. func BenchmarkClientServer(b *testing.B) {
  943. b.StopTimer()
  944. ts := httptest.NewServer(HandlerFunc(func(rw ResponseWriter, r *Request) {
  945. fmt.Fprintf(rw, "Hello world.\n")
  946. }))
  947. defer ts.Close()
  948. b.StartTimer()
  949. for i := 0; i < b.N; i++ {
  950. res, err := Get(ts.URL)
  951. if err != nil {
  952. panic("Get: " + err.String())
  953. }
  954. all, err := ioutil.ReadAll(res.Body)
  955. if err != nil {
  956. panic("ReadAll: " + err.String())
  957. }
  958. body := string(all)
  959. if body != "Hello world.\n" {
  960. panic("Got body: " + body)
  961. }
  962. }
  963. b.StopTimer()
  964. }