code review 8101043: net/http: more tests, better comments, remove an allocation

src/pkg/net/http/serve_test.go

 // Copyright 2010 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 // End-to-end serving tests
 
 package http_test
 
 import (
         "bufio"
         "bytes"
         "crypto/tls"
+        "errors"
         "fmt"
         "io"
         "io/ioutil"
         "log"
         "net"
         . "net/http"
         "net/http/httptest"
         "net/http/httputil"
         "net/url"
         "os"
@@ skipping 1421 matching lines @@
         res, err = Get(ts.URL + "/second")
         if err != nil {
                 t.Fatal(err)
         }
         res.Body.Close()
         if got := <-uric; got != "/second" {
                 t.Errorf("Handler saw request for %q; want /second", got)
         }
 }
 
+// Tests regarding the ordering of Write, WriteHeader, Header, and
+// Flush calls.  In Go 1.0, rw.WriteHeader immediately flushed the
+// (*response).header to the wire. In Go 1.1, the actual wire flush is
+// delayed, so we could maybe tack on a Content-Length and better
+// Content-Type after we see more (or all) of the output. To preserve
+// compatibility with Go 1, we need to be careful to track which
+// headers were live at the time of WriteHeader, so we write the same
+// ones, even if the handler modifies them (~erroneously) after the
+// first Write.
+func TestHeaderToWire(t *testing.T) {
+        req := []byte(strings.Replace(`GET / HTTP/1.1
+Host: golang.org
+
+`, "\n", "\r\n", -1))
+
+        tests := []struct {
+                name    string
+                handler func(ResponseWriter, *Request)
+                check   func(output string) error
+        }{
+                {
+                        name: "write without Header",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                rw.Write([]byte("hello world"))
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "Content-Length:") {
+                                        return errors.New("no content-length")
+                                }
+                                if !strings.Contains(got, "Content-Type: text/plain") {
+                                        return errors.New("no content-length")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "Header mutation before write",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                h := rw.Header()
+                                h.Set("Content-Type", "some/type")
+                                rw.Write([]byte("hello world"))
+                                h.Set("Too-Late", "bogus")
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "Content-Length:") {
+                                        return errors.New("no content-length")
+                                }
+                                if !strings.Contains(got, "Content-Type: some/type") {
+                                        return errors.New("wrong content-type")
+                                }
+                                if strings.Contains(got, "Too-Late") {
+                                        return errors.New("don't want too-late header")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "write then useless Header mutation",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                rw.Write([]byte("hello world"))
+                                rw.Header().Set("Too-Late", "Write already wrote headers")
+                        },
+                        check: func(got string) error {
+                                if strings.Contains(got, "Too-Late") {
+                                        return errors.New("header appeared from after WriteHeader")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "flush then write",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                rw.(Flusher).Flush()
+                                rw.Write([]byte("post-flush"))
+                                rw.Header().Set("Too-Late", "Write already wrote headers")
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "Transfer-Encoding: chunked") {
+                                        return errors.New("not chunked")
+                                }
+                                if strings.Contains(got, "Too-Late") {
+                                        return errors.New("header appeared from after WriteHeader")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "header then flush",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                rw.Header().Set("Content-Type", "some/type")
+                                rw.(Flusher).Flush()
+                                rw.Write([]byte("post-flush"))
+                                rw.Header().Set("Too-Late", "Write already wrote headers")
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "Transfer-Encoding: chunked") {
+                                        return errors.New("not chunked")
+                                }
+                                if strings.Contains(got, "Too-Late") {
+                                        return errors.New("header appeared from after WriteHeader")
+                                }
+                                if !strings.Contains(got, "Content-Type: some/type") {
+                                        return errors.New("wrong content-length")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "sniff-on-first-write content-type",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                rw.Write([]byte("<html><head></head><body>some html</body></html>"))
+                                rw.Header().Set("Content-Type", "x/wrong")
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "Content-Type: text/html") {
+                                        return errors.New("wrong content-length; want html")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "explicit content-type wins",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                rw.Header().Set("Content-Type", "some/type")
+                                rw.Write([]byte("<html><head></head><body>some html</body></html>"))
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "Content-Type: some/type") {
+                                        return errors.New("wrong content-length; want html")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "empty handler",
+                        handler: func(rw ResponseWriter, r *Request) {
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "Content-Type: text/plain") {
+                                        return errors.New("wrong content-length; want text/plain")
+                                }
+                                if !strings.Contains(got, "Content-Length: 0") {
+                                        return errors.New("want 0 content-length")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "only Header, no write",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                rw.Header().Set("Some-Header", "some-value")
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "Some-Header") {
+                                        return errors.New("didn't get header")
+                                }
+                                return nil
+                        },
+                },
+                {
+                        name: "WriteHeader call",
+                        handler: func(rw ResponseWriter, r *Request) {
+                                rw.WriteHeader(404)
+                                rw.Header().Set("Too-Late", "some-value")
+                        },
+                        check: func(got string) error {
+                                if !strings.Contains(got, "404") {
+                                        return errors.New("wrong status")
+                                }
+                                if strings.Contains(got, "Some-Header") {
+                                        return errors.New("shouldn't have seen Too-Late")
+                                }
+                                return nil
+                        },
+                },
+        }
+        for _, tc := range tests {
+                var output bytes.Buffer
+                conn := &rwTestConn{
+                        Reader: bytes.NewReader(req),
+                        Writer: &output,
+                        closec: make(chan bool, 1),
+                }
+                ln := &oneConnListener{conn: conn}
+                go Serve(ln, HandlerFunc(tc.handler))
+                <-conn.closec
+                if err := tc.check(output.String()); err != nil {
+                        t.Errorf("%s: %v\nGot response:\n%s", tc.name, err, output.Bytes())
+                }
+        }
+}
+
 // goTimeout runs f, failing t if f takes more than ns to complete.
 func goTimeout(t *testing.T, d time.Duration, f func()) {
         ch := make(chan bool, 2)
         timer := time.AfterFunc(d, func() {
                 t.Errorf("Timeout expired after %v", d)
                 ch <- true
         })
         defer timer.Stop()
         go func() {
                 defer func() { ch <- true }()
@@ skipping 239 matching lines @@
                 rw.Header().Set("Content-Type", "text/html; charset=utf-8")
                 rw.Write(res)
         })
         ln := &oneConnListener{conn: conn}
         go Serve(ln, handler)
         <-conn.closec
         if b.N != handled {
                 b.Errorf("b.N=%d but handled %d", b.N, handled)
         }
 }
+
+// same as above, but representing the most simple possible request
+// and handler. Notably: the handler does not call rw.Header().
+func BenchmarkServerFakeConnWithKeepAliveLite(b *testing.B) {
+        b.ReportAllocs()
+
+        req := []byte(strings.Replace(`GET / HTTP/1.1
+Host: golang.org
+
+`, "\n", "\r\n", -1))
+        res := []byte("Hello world!\n")
+
+        conn := &rwTestConn{
+                Reader: &repeatReader{content: req, count: b.N},
+                Writer: ioutil.Discard,
+                closec: make(chan bool, 1),
+        }
+        handled := 0
+        handler := HandlerFunc(func(rw ResponseWriter, r *Request) {
+                handled++
+                rw.Write(res)
+        })
+        ln := &oneConnListener{conn: conn}
+        go Serve(ln, handler)
+        <-conn.closec
+        if b.N != handled {
+                b.Errorf("b.N=%d but handled %d", b.N, handled)
+        }
+}