don't enforce deadlines

Author: dunglas

src/net/http/httptest/example_test.go

@@ -46,7 +46,7 @@ func ExampleResponseRecorder_requestController() {
 	}
 
 	req := httptest.NewRequest("GET", "http://example.com/bar", strings.NewReader("bar"))
-	w, req := httptest.NewRecorderWithDeadlineAwareRequest(req)
+	w := httptest.NewRecorder()
 	handler(w, req)
 
 	resp := w.Result()

src/net/http/httptest/recorder.go

@@ -6,12 +6,10 @@ package httptest
 
 import (
 	"bytes"
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"net/textproto"
-	"os"
 	"strconv"
 	"strings"
 	"time"
@@ -45,18 +43,17 @@ type ResponseRecorder struct {
 	// Flushed is whether the Handler called Flush.
 	Flushed bool
 
-	// ReadDeadline is the read deadline that has been set using
+	// ReadDeadline is the last read deadline that has been set using
 	// "net/http".ResponseController
 	ReadDeadline time.Time
 
-	// WriteDeadline is the write deadline that has been set using
+	// WriteDeadline is the last write deadline that has been set using
 	// "net/http".ResponseController
 	WriteDeadline time.Time
 
 	result      *http.Response // cache of Result's return value
 	snapHeader  http.Header    // snapshot of HeaderMap at first Write
 	wroteHeader bool
-	requestBody *deadlineBodyReader
 }
 
 // NewRecorder returns an initialized ResponseRecorder.
@@ -68,21 +65,6 @@ func NewRecorder() *ResponseRecorder {
 	}
 }
 
-// NewRecorderWithDeadlineAwareRequest returns an initialized ResponseRecorder
-// and wraps the body of the HTTP request passed as parameter in a special "io".ReadCloser
-// that supports read deadlines.
-// The request read deadline can be set using ResponseRecorder.SetReadDeadline
-// and "http".ResponseController.
-// The body of returned the HTTP request returns an error when the read deadline is reached.
-// The read deadline can be inspected by reading ResponseRecorder.ReadDeadline.
-func NewRecorderWithDeadlineAwareRequest(r *http.Request) (*ResponseRecorder, *http.Request) {
-	rw := NewRecorder()
-	rw.requestBody = &deadlineBodyReader{r.Body, time.Time{}}
-	r.Body = rw.requestBody
-
-	return rw, r
-}
-
 // DefaultRemoteAddr is the default remote address to return in RemoteAddr if
 // an explicit DefaultRemoteAddr isn't set on ResponseRecorder.
 const DefaultRemoteAddr = "1.2.3.4"
@@ -132,10 +114,6 @@ func (rw *ResponseRecorder) writeHeader(b []byte, str string) {
 // Write implements http.ResponseWriter. The data in buf is written to
 // rw.Body, if not nil.
 func (rw *ResponseRecorder) Write(buf []byte) (int, error) {
-	if !rw.WriteDeadline.IsZero() && time.Now().After(rw.WriteDeadline) {
-		return 0, os.ErrDeadlineExceeded
-	}
-
 	rw.writeHeader(buf, "")
 	if rw.Body != nil {
 		rw.Body.Write(buf)
@@ -146,10 +124,6 @@ func (rw *ResponseRecorder) Write(buf []byte) (int, error) {
 // WriteString implements io.StringWriter. The data in str is written
 // to rw.Body, if not nil.
 func (rw *ResponseRecorder) WriteString(str string) (int, error) {
-	if !rw.WriteDeadline.IsZero() && time.Now().After(rw.WriteDeadline) {
-		return 0, os.ErrDeadlineExceeded
-	}
-
 	rw.writeHeader(nil, str)
 	if rw.Body != nil {
 		rw.Body.WriteString(str)
@@ -193,10 +167,6 @@ func (rw *ResponseRecorder) WriteHeader(code int) {
 // with the recorder. To test whether Flush was
 // called, see rw.Flushed.
 func (rw *ResponseRecorder) FlushError() error {
-	if !rw.WriteDeadline.IsZero() && time.Now().After(rw.WriteDeadline) {
-		return os.ErrDeadlineExceeded
-	}
-
 	if !rw.wroteHeader {
 		rw.WriteHeader(200)
 	}
@@ -213,28 +183,28 @@ func (rw *ResponseRecorder) Flush() {
 
 // SetReadDeadline allows using "net/http".ResponseController.SetReadDeadline()
 // with the recorder.
+//
+// The deadline is recorded but is not enforced.
+// To prevent flaky tests reads made after the deadline will work
+// as if no deadline was set.
+//
 // To retrieve the deadline, use rw.ReadDeadline.
-// To use this method, be sure NewRecorderWithDeadlineAwareRequest
 func (rw *ResponseRecorder) SetReadDeadline(deadline time.Time) error {
-	if rw.requestBody == nil {
-		return errors.New("The request has not been created using NewRecorderWithDeadlineAwareRequest()")
-	}
-
-	if deadline.After(rw.ReadDeadline) {
-		rw.ReadDeadline = deadline
-		rw.requestBody.deadline = deadline
-	}
+	rw.ReadDeadline = deadline
 
 	return nil
 }
 
 // SetWriteDeadline allows using "net/http".ResponseController.SetWriteDeadline()
 // with the recorder.
+//
+// The deadline is recorded but is not enforced.
+// To prevent flaky tests writes made after the deadline will work
+// as if no deadline was set.
+//
 // To retrieve the deadline, use rw.WriteDeadline.
 func (rw *ResponseRecorder) SetWriteDeadline(deadline time.Time) error {
-	if deadline.After(rw.WriteDeadline) {
-		rw.WriteDeadline = deadline
-	}
+	rw.WriteDeadline = deadline
 
 	return nil
 }
@@ -329,16 +299,3 @@ func parseContentLength(cl string) int64 {
 	}
 	return int64(n)
 }
-
-type deadlineBodyReader struct {
-	io.ReadCloser
-	deadline time.Time
-}
-
-func (r *deadlineBodyReader) Read(p []byte) (n int, err error) {
-	if time.Now().After(r.deadline) {
-		return 0, os.ErrDeadlineExceeded
-	}
-
-	return r.ReadCloser.Read(p)
-}

src/net/http/httptest/recorder_test.go

@@ -5,11 +5,9 @@
 package httptest
 
 import (
-	"errors"
 	"fmt"
 	"io"
 	"net/http"
-	"os"
 	"testing"
 	"time"
 )
@@ -373,65 +371,29 @@ func TestRecorderPanicsOnNonXXXStatusCode(t *testing.T) {
 	}
 }
 
-type neverEnding byte
-
-func (b neverEnding) Read(p []byte) (n int, err error) {
-	for i := range p {
-		p[i] = byte(b)
-	}
-	return len(p), nil
-}
-
-func TestSetWriteDeadline(t *testing.T) {
+func TestRecorderSetWriteDeadline(t *testing.T) {
 	rw := NewRecorder()
 	rc := http.NewResponseController(rw)
 
-	expected := time.Now().Add(1 * time.Millisecond)
+	expected := time.Now().Add(1 * time.Second)
 	if err := rc.SetWriteDeadline(expected); err != nil {
 		t.Errorf(`"ResponseController.WriteDeadline(): got unexpected error %q`, err)
 	}
 
 	if rw.WriteDeadline != expected {
 		t.Errorf(`"ResponseRecorder.WriteDeadline: got %q want %q`, rw.WriteDeadline, expected)
 	}
-
-	if _, err := io.Copy(rw, neverEnding('a')); !errors.Is(err, os.ErrDeadlineExceeded) {
-		t.Errorf(`"ResponseRecorder.Write(): got %q want %q`, err, os.ErrDeadlineExceeded)
-	}
-
-	if _, err := rw.WriteString("a"); !errors.Is(err, os.ErrDeadlineExceeded) {
-		t.Errorf(`"ResponseRecorder.WriteString(): got %q want %q`, err, os.ErrDeadlineExceeded)
-	}
-
-	if err := rw.FlushError(); !errors.Is(err, os.ErrDeadlineExceeded) {
-		t.Errorf(`"ResponseRecorder.FlushError(): got %q want %q`, err, os.ErrDeadlineExceeded)
-	}
-
-	if b, _ := rw.Body.ReadByte(); b != 'a' {
-		t.Errorf(`"ResponseRecorder.Body starts with %q ; want "a"`, b)
-	}
 }
 
-func TestSetReadDeadline(t *testing.T) {
-	req, _ := http.NewRequest("GET", "https://example.com", neverEnding('a'))
-	rw, req := NewRecorderWithDeadlineAwareRequest(req)
-	rc := http.NewResponseController(rw)
+func TestRecorderSetReadDeadline(t *testing.T) {
+	rw := NewRecorder()
 
-	expected := time.Now().Add(1 * time.Millisecond)
-	if err := rc.SetReadDeadline(expected); err != nil {
-		t.Errorf(`"ResponseController.SetReadDeadline(): got unexpected error %q`, err)
+	expected := time.Now().Add(1 * time.Second)
+	if err := rw.SetReadDeadline(expected); err != nil {
+		t.Errorf(`"ResponseRecorder.SetReadDeadline(): got unexpected error %q`, err)
 	}
 
 	if rw.ReadDeadline != expected {
 		t.Errorf(`"ResponseRecorder.ReadDeadline: got %q want %q`, rw.ReadDeadline, expected)
 	}
-
-	data, err := io.ReadAll(req.Body)
-	if !errors.Is(err, os.ErrDeadlineExceeded) {
-		t.Errorf(`"ResponseRecorder.GetDeadlineRequestBody(): got %q want %q`, err, os.ErrDeadlineExceeded)
-	}
-
-	if b := data[0]; b != 'a' {
-		t.Errorf(`Request Body starts with %q ; want "a"`, b)
-	}
 }