Source file src/net/http/httputil/dump_test.go

Documentation: net/http/httputil

     1  // Copyright 2011 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 httputil
     6  
     7  import (
     8  	"bufio"
     9  	"bytes"
    10  	"context"
    11  	"fmt"
    12  	"io"
    13  	"math/rand"
    14  	"net/http"
    15  	"net/url"
    16  	"runtime"
    17  	"runtime/pprof"
    18  	"strings"
    19  	"testing"
    20  	"time"
    21  )
    22  
    23  type eofReader struct{}
    24  
    25  func (n eofReader) Close() error { return nil }
    26  
    27  func (n eofReader) Read([]byte) (int, error) { return 0, io.EOF }
    28  
    29  type dumpTest struct {
    30  	// Either Req or GetReq can be set/nil but not both.
    31  	Req    *http.Request
    32  	GetReq func() *http.Request
    33  
    34  	Body interface{} // optional []byte or func() io.ReadCloser to populate Req.Body
    35  
    36  	WantDump    string
    37  	WantDumpOut string
    38  	MustError   bool // if true, the test is expected to throw an error
    39  	NoBody      bool // if true, set DumpRequest{,Out} body to false
    40  }
    41  
    42  var dumpTests = []dumpTest{
    43  	// HTTP/1.1 => chunked coding; body; empty trailer
    44  	{
    45  		Req: &http.Request{
    46  			Method: "GET",
    47  			URL: &url.URL{
    48  				Scheme: "http",
    49  				Host:   "www.google.com",
    50  				Path:   "/search",
    51  			},
    52  			ProtoMajor:       1,
    53  			ProtoMinor:       1,
    54  			TransferEncoding: []string{"chunked"},
    55  		},
    56  
    57  		Body: []byte("abcdef"),
    58  
    59  		WantDump: "GET /search HTTP/1.1\r\n" +
    60  			"Host: www.google.com\r\n" +
    61  			"Transfer-Encoding: chunked\r\n\r\n" +
    62  			chunk("abcdef") + chunk(""),
    63  	},
    64  
    65  	// Verify that DumpRequest preserves the HTTP version number, doesn't add a Host,
    66  	// and doesn't add a User-Agent.
    67  	{
    68  		Req: &http.Request{
    69  			Method:     "GET",
    70  			URL:        mustParseURL("/foo"),
    71  			ProtoMajor: 1,
    72  			ProtoMinor: 0,
    73  			Header: http.Header{
    74  				"X-Foo": []string{"X-Bar"},
    75  			},
    76  		},
    77  
    78  		WantDump: "GET /foo HTTP/1.0\r\n" +
    79  			"X-Foo: X-Bar\r\n\r\n",
    80  	},
    81  
    82  	{
    83  		Req: mustNewRequest("GET", "http://example.com/foo", nil),
    84  
    85  		WantDumpOut: "GET /foo HTTP/1.1\r\n" +
    86  			"Host: example.com\r\n" +
    87  			"User-Agent: Go-http-client/1.1\r\n" +
    88  			"Accept-Encoding: gzip\r\n\r\n",
    89  	},
    90  
    91  	// Test that an https URL doesn't try to do an SSL negotiation
    92  	// with a bytes.Buffer and hang with all goroutines not
    93  	// runnable.
    94  	{
    95  		Req: mustNewRequest("GET", "https://example.com/foo", nil),
    96  		WantDumpOut: "GET /foo HTTP/1.1\r\n" +
    97  			"Host: example.com\r\n" +
    98  			"User-Agent: Go-http-client/1.1\r\n" +
    99  			"Accept-Encoding: gzip\r\n\r\n",
   100  	},
   101  
   102  	// Request with Body, but Dump requested without it.
   103  	{
   104  		Req: &http.Request{
   105  			Method: "POST",
   106  			URL: &url.URL{
   107  				Scheme: "http",
   108  				Host:   "post.tld",
   109  				Path:   "/",
   110  			},
   111  			ContentLength: 6,
   112  			ProtoMajor:    1,
   113  			ProtoMinor:    1,
   114  		},
   115  
   116  		Body: []byte("abcdef"),
   117  
   118  		WantDumpOut: "POST / HTTP/1.1\r\n" +
   119  			"Host: post.tld\r\n" +
   120  			"User-Agent: Go-http-client/1.1\r\n" +
   121  			"Content-Length: 6\r\n" +
   122  			"Accept-Encoding: gzip\r\n\r\n",
   123  
   124  		NoBody: true,
   125  	},
   126  
   127  	// Request with Body > 8196 (default buffer size)
   128  	{
   129  		Req: &http.Request{
   130  			Method: "POST",
   131  			URL: &url.URL{
   132  				Scheme: "http",
   133  				Host:   "post.tld",
   134  				Path:   "/",
   135  			},
   136  			Header: http.Header{
   137  				"Content-Length": []string{"8193"},
   138  			},
   139  
   140  			ContentLength: 8193,
   141  			ProtoMajor:    1,
   142  			ProtoMinor:    1,
   143  		},
   144  
   145  		Body: bytes.Repeat([]byte("a"), 8193),
   146  
   147  		WantDumpOut: "POST / HTTP/1.1\r\n" +
   148  			"Host: post.tld\r\n" +
   149  			"User-Agent: Go-http-client/1.1\r\n" +
   150  			"Content-Length: 8193\r\n" +
   151  			"Accept-Encoding: gzip\r\n\r\n" +
   152  			strings.Repeat("a", 8193),
   153  		WantDump: "POST / HTTP/1.1\r\n" +
   154  			"Host: post.tld\r\n" +
   155  			"Content-Length: 8193\r\n\r\n" +
   156  			strings.Repeat("a", 8193),
   157  	},
   158  
   159  	{
   160  		GetReq: func() *http.Request {
   161  			return mustReadRequest("GET http://foo.com/ HTTP/1.1\r\n" +
   162  				"User-Agent: blah\r\n\r\n")
   163  		},
   164  		NoBody: true,
   165  		WantDump: "GET http://foo.com/ HTTP/1.1\r\n" +
   166  			"User-Agent: blah\r\n\r\n",
   167  	},
   168  
   169  	// Issue #7215. DumpRequest should return the "Content-Length" when set
   170  	{
   171  		GetReq: func() *http.Request {
   172  			return mustReadRequest("POST /v2/api/?login HTTP/1.1\r\n" +
   173  				"Host: passport.myhost.com\r\n" +
   174  				"Content-Length: 3\r\n" +
   175  				"\r\nkey1=name1&key2=name2")
   176  		},
   177  		WantDump: "POST /v2/api/?login HTTP/1.1\r\n" +
   178  			"Host: passport.myhost.com\r\n" +
   179  			"Content-Length: 3\r\n" +
   180  			"\r\nkey",
   181  	},
   182  	// Issue #7215. DumpRequest should return the "Content-Length" in ReadRequest
   183  	{
   184  		GetReq: func() *http.Request {
   185  			return mustReadRequest("POST /v2/api/?login HTTP/1.1\r\n" +
   186  				"Host: passport.myhost.com\r\n" +
   187  				"Content-Length: 0\r\n" +
   188  				"\r\nkey1=name1&key2=name2")
   189  		},
   190  		WantDump: "POST /v2/api/?login HTTP/1.1\r\n" +
   191  			"Host: passport.myhost.com\r\n" +
   192  			"Content-Length: 0\r\n\r\n",
   193  	},
   194  
   195  	// Issue #7215. DumpRequest should not return the "Content-Length" if unset
   196  	{
   197  		GetReq: func() *http.Request {
   198  			return mustReadRequest("POST /v2/api/?login HTTP/1.1\r\n" +
   199  				"Host: passport.myhost.com\r\n" +
   200  				"\r\nkey1=name1&key2=name2")
   201  		},
   202  		WantDump: "POST /v2/api/?login HTTP/1.1\r\n" +
   203  			"Host: passport.myhost.com\r\n\r\n",
   204  	},
   205  
   206  	// Issue 18506: make drainBody recognize NoBody. Otherwise
   207  	// this was turning into a chunked request.
   208  	{
   209  		Req: mustNewRequest("POST", "http://example.com/foo", http.NoBody),
   210  		WantDumpOut: "POST /foo HTTP/1.1\r\n" +
   211  			"Host: example.com\r\n" +
   212  			"User-Agent: Go-http-client/1.1\r\n" +
   213  			"Content-Length: 0\r\n" +
   214  			"Accept-Encoding: gzip\r\n\r\n",
   215  	},
   216  
   217  	// Issue 34504: a non-nil Body without ContentLength set should be chunked
   218  	{
   219  		Req: &http.Request{
   220  			Method: "PUT",
   221  			URL: &url.URL{
   222  				Scheme: "http",
   223  				Host:   "post.tld",
   224  				Path:   "/test",
   225  			},
   226  			ContentLength: 0,
   227  			Proto:         "HTTP/1.1",
   228  			ProtoMajor:    1,
   229  			ProtoMinor:    1,
   230  			Body:          &eofReader{},
   231  		},
   232  		NoBody: true,
   233  		WantDumpOut: "PUT /test HTTP/1.1\r\n" +
   234  			"Host: post.tld\r\n" +
   235  			"User-Agent: Go-http-client/1.1\r\n" +
   236  			"Transfer-Encoding: chunked\r\n" +
   237  			"Accept-Encoding: gzip\r\n\r\n",
   238  	},
   239  }
   240  
   241  func TestDumpRequest(t *testing.T) {
   242  	// Make a copy of dumpTests and add 10 new cases with an empty URL
   243  	// to test that no goroutines are leaked. See golang.org/issue/32571.
   244  	// 10 seems to be a decent number which always triggers the failure.
   245  	dumpTests := dumpTests[:]
   246  	for i := 0; i < 10; i++ {
   247  		dumpTests = append(dumpTests, dumpTest{
   248  			Req:       mustNewRequest("GET", "", nil),
   249  			MustError: true,
   250  		})
   251  	}
   252  	numg0 := runtime.NumGoroutine()
   253  	for i, tt := range dumpTests {
   254  		if tt.Req != nil && tt.GetReq != nil || tt.Req == nil && tt.GetReq == nil {
   255  			t.Errorf("#%d: either .Req(%p) or .GetReq(%p) can be set/nil but not both", i, tt.Req, tt.GetReq)
   256  			continue
   257  		}
   258  
   259  		freshReq := func(ti dumpTest) *http.Request {
   260  			req := ti.Req
   261  			if req == nil {
   262  				req = ti.GetReq()
   263  			}
   264  
   265  			if req.Header == nil {
   266  				req.Header = make(http.Header)
   267  			}
   268  
   269  			if ti.Body == nil {
   270  				return req
   271  			}
   272  			switch b := ti.Body.(type) {
   273  			case []byte:
   274  				req.Body = io.NopCloser(bytes.NewReader(b))
   275  			case func() io.ReadCloser:
   276  				req.Body = b()
   277  			default:
   278  				t.Fatalf("Test %d: unsupported Body of %T", i, ti.Body)
   279  			}
   280  			return req
   281  		}
   282  
   283  		if tt.WantDump != "" {
   284  			req := freshReq(tt)
   285  			dump, err := DumpRequest(req, !tt.NoBody)
   286  			if err != nil {
   287  				t.Errorf("DumpRequest #%d: %s\nWantDump:\n%s", i, err, tt.WantDump)
   288  				continue
   289  			}
   290  			if string(dump) != tt.WantDump {
   291  				t.Errorf("DumpRequest %d, expecting:\n%s\nGot:\n%s\n", i, tt.WantDump, string(dump))
   292  				continue
   293  			}
   294  		}
   295  
   296  		if tt.MustError {
   297  			req := freshReq(tt)
   298  			_, err := DumpRequestOut(req, !tt.NoBody)
   299  			if err == nil {
   300  				t.Errorf("DumpRequestOut #%d: expected an error, got nil", i)
   301  			}
   302  			continue
   303  		}
   304  
   305  		if tt.WantDumpOut != "" {
   306  			req := freshReq(tt)
   307  			dump, err := DumpRequestOut(req, !tt.NoBody)
   308  			if err != nil {
   309  				t.Errorf("DumpRequestOut #%d: %s", i, err)
   310  				continue
   311  			}
   312  			if string(dump) != tt.WantDumpOut {
   313  				t.Errorf("DumpRequestOut %d, expecting:\n%s\nGot:\n%s\n", i, tt.WantDumpOut, string(dump))
   314  				continue
   315  			}
   316  		}
   317  	}
   318  
   319  	// Validate we haven't leaked any goroutines.
   320  	var dg int
   321  	dl := deadline(t, 5*time.Second, time.Second)
   322  	for time.Now().Before(dl) {
   323  		if dg = runtime.NumGoroutine() - numg0; dg <= 4 {
   324  			// No unexpected goroutines.
   325  			return
   326  		}
   327  
   328  		// Allow goroutines to schedule and die off.
   329  		runtime.Gosched()
   330  	}
   331  
   332  	buf := make([]byte, 4096)
   333  	buf = buf[:runtime.Stack(buf, true)]
   334  	t.Errorf("Unexpectedly large number of new goroutines: %d new: %s", dg, buf)
   335  }
   336  
   337  // deadline returns the time which is needed before t.Deadline()
   338  // if one is configured and it is s greater than needed in the future,
   339  // otherwise defaultDelay from the current time.
   340  func deadline(t *testing.T, defaultDelay, needed time.Duration) time.Time {
   341  	if dl, ok := t.Deadline(); ok {
   342  		if dl = dl.Add(-needed); dl.After(time.Now()) {
   343  			// Allow an arbitrarily long delay.
   344  			return dl
   345  		}
   346  	}
   347  
   348  	// No deadline configured or its closer than needed from now
   349  	// so just use the default.
   350  	return time.Now().Add(defaultDelay)
   351  }
   352  
   353  func chunk(s string) string {
   354  	return fmt.Sprintf("%x\r\n%s\r\n", len(s), s)
   355  }
   356  
   357  func mustParseURL(s string) *url.URL {
   358  	u, err := url.Parse(s)
   359  	if err != nil {
   360  		panic(fmt.Sprintf("Error parsing URL %q: %v", s, err))
   361  	}
   362  	return u
   363  }
   364  
   365  func mustNewRequest(method, url string, body io.Reader) *http.Request {
   366  	req, err := http.NewRequest(method, url, body)
   367  	if err != nil {
   368  		panic(fmt.Sprintf("NewRequest(%q, %q, %p) err = %v", method, url, body, err))
   369  	}
   370  	return req
   371  }
   372  
   373  func mustReadRequest(s string) *http.Request {
   374  	req, err := http.ReadRequest(bufio.NewReader(strings.NewReader(s)))
   375  	if err != nil {
   376  		panic(err)
   377  	}
   378  	return req
   379  }
   380  
   381  var dumpResTests = []struct {
   382  	res  *http.Response
   383  	body bool
   384  	want string
   385  }{
   386  	{
   387  		res: &http.Response{
   388  			Status:        "200 OK",
   389  			StatusCode:    200,
   390  			Proto:         "HTTP/1.1",
   391  			ProtoMajor:    1,
   392  			ProtoMinor:    1,
   393  			ContentLength: 50,
   394  			Header: http.Header{
   395  				"Foo": []string{"Bar"},
   396  			},
   397  			Body: io.NopCloser(strings.NewReader("foo")), // shouldn't be used
   398  		},
   399  		body: false, // to verify we see 50, not empty or 3.
   400  		want: `HTTP/1.1 200 OK
   401  Content-Length: 50
   402  Foo: Bar`,
   403  	},
   404  
   405  	{
   406  		res: &http.Response{
   407  			Status:        "200 OK",
   408  			StatusCode:    200,
   409  			Proto:         "HTTP/1.1",
   410  			ProtoMajor:    1,
   411  			ProtoMinor:    1,
   412  			ContentLength: 3,
   413  			Body:          io.NopCloser(strings.NewReader("foo")),
   414  		},
   415  		body: true,
   416  		want: `HTTP/1.1 200 OK
   417  Content-Length: 3
   418  
   419  foo`,
   420  	},
   421  
   422  	{
   423  		res: &http.Response{
   424  			Status:           "200 OK",
   425  			StatusCode:       200,
   426  			Proto:            "HTTP/1.1",
   427  			ProtoMajor:       1,
   428  			ProtoMinor:       1,
   429  			ContentLength:    -1,
   430  			Body:             io.NopCloser(strings.NewReader("foo")),
   431  			TransferEncoding: []string{"chunked"},
   432  		},
   433  		body: true,
   434  		want: `HTTP/1.1 200 OK
   435  Transfer-Encoding: chunked
   436  
   437  3
   438  foo
   439  0`,
   440  	},
   441  	{
   442  		res: &http.Response{
   443  			Status:        "200 OK",
   444  			StatusCode:    200,
   445  			Proto:         "HTTP/1.1",
   446  			ProtoMajor:    1,
   447  			ProtoMinor:    1,
   448  			ContentLength: 0,
   449  			Header: http.Header{
   450  				// To verify if headers are not filtered out.
   451  				"Foo1": []string{"Bar1"},
   452  				"Foo2": []string{"Bar2"},
   453  			},
   454  			Body: nil,
   455  		},
   456  		body: false, // to verify we see 0, not empty.
   457  		want: `HTTP/1.1 200 OK
   458  Foo1: Bar1
   459  Foo2: Bar2
   460  Content-Length: 0`,
   461  	},
   462  }
   463  
   464  func TestDumpResponse(t *testing.T) {
   465  	for i, tt := range dumpResTests {
   466  		gotb, err := DumpResponse(tt.res, tt.body)
   467  		if err != nil {
   468  			t.Errorf("%d. DumpResponse = %v", i, err)
   469  			continue
   470  		}
   471  		got := string(gotb)
   472  		got = strings.TrimSpace(got)
   473  		got = strings.ReplaceAll(got, "\r", "")
   474  
   475  		if got != tt.want {
   476  			t.Errorf("%d.\nDumpResponse got:\n%s\n\nWant:\n%s\n", i, got, tt.want)
   477  		}
   478  	}
   479  }
   480  
   481  // Issue 38352: Check for deadlock on canceled requests.
   482  func TestDumpRequestOutIssue38352(t *testing.T) {
   483  	if testing.Short() {
   484  		return
   485  	}
   486  	t.Parallel()
   487  
   488  	timeout := 10 * time.Second
   489  	if deadline, ok := t.Deadline(); ok {
   490  		timeout = time.Until(deadline)
   491  		timeout -= time.Second * 2 // Leave 2 seconds to report failures.
   492  	}
   493  	for i := 0; i < 1000; i++ {
   494  		delay := time.Duration(rand.Intn(5)) * time.Millisecond
   495  		ctx, cancel := context.WithTimeout(context.Background(), delay)
   496  		defer cancel()
   497  
   498  		r := bytes.NewBuffer(make([]byte, 10000))
   499  		req, err := http.NewRequestWithContext(ctx, http.MethodPost, "http://example.com", r)
   500  		if err != nil {
   501  			t.Fatal(err)
   502  		}
   503  
   504  		out := make(chan error)
   505  		go func() {
   506  			_, err = DumpRequestOut(req, true)
   507  			out <- err
   508  		}()
   509  
   510  		select {
   511  		case <-out:
   512  		case <-time.After(timeout):
   513  			b := &bytes.Buffer{}
   514  			fmt.Fprintf(b, "deadlock detected on iteration %d after %s with delay: %v\n", i, timeout, delay)
   515  			pprof.Lookup("goroutine").WriteTo(b, 1)
   516  			t.Fatal(b.String())
   517  		}
   518  	}
   519  }
   520  

View as plain text