netramesh

1
// Copyright 2009 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_test
6

7
import (
8
	"bufio"
9
	"bytes"
10
	"context"
11
	"encoding/base64"
12
	"fmt"
13
	"io"
14
	"io/ioutil"
15
	"mime/multipart"
16
	. "net/http"
17
	"net/url"
18
	"os"
19
	"reflect"
20
	"regexp"
21
	"strings"
22
	"testing"
23
)
24

25
func TestQuery(t *testing.T) {
26
	req := &Request{Method: "GET"}
27
	req.URL, _ = url.Parse("http://www.google.com/search?q=foo&q=bar")
28
	if q := req.FormValue("q"); q != "foo" {
29
		t.Errorf(`req.FormValue("q") = %q, want "foo"`, q)
30
	}
31
}
32

33
func TestParseFormQuery(t *testing.T) {
34
	req, _ := NewRequest("POST", "http://www.google.com/search?q=foo&q=bar&both=x&prio=1&orphan=nope&empty=not",
35
		strings.NewReader("z=post&both=y&prio=2&=nokey&orphan;empty=&"))
36
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
37

38
	if q := req.FormValue("q"); q != "foo" {
39
		t.Errorf(`req.FormValue("q") = %q, want "foo"`, q)
40
	}
41
	if z := req.FormValue("z"); z != "post" {
42
		t.Errorf(`req.FormValue("z") = %q, want "post"`, z)
43
	}
44
	if bq, found := req.PostForm["q"]; found {
45
		t.Errorf(`req.PostForm["q"] = %q, want no entry in map`, bq)
46
	}
47
	if bz := req.PostFormValue("z"); bz != "post" {
48
		t.Errorf(`req.PostFormValue("z") = %q, want "post"`, bz)
49
	}
50
	if qs := req.Form["q"]; !reflect.DeepEqual(qs, []string{"foo", "bar"}) {
51
		t.Errorf(`req.Form["q"] = %q, want ["foo", "bar"]`, qs)
52
	}
53
	if both := req.Form["both"]; !reflect.DeepEqual(both, []string{"y", "x"}) {
54
		t.Errorf(`req.Form["both"] = %q, want ["y", "x"]`, both)
55
	}
56
	if prio := req.FormValue("prio"); prio != "2" {
57
		t.Errorf(`req.FormValue("prio") = %q, want "2" (from body)`, prio)
58
	}
59
	if orphan := req.Form["orphan"]; !reflect.DeepEqual(orphan, []string{"", "nope"}) {
60
		t.Errorf(`req.FormValue("orphan") = %q, want "" (from body)`, orphan)
61
	}
62
	if empty := req.Form["empty"]; !reflect.DeepEqual(empty, []string{"", "not"}) {
63
		t.Errorf(`req.FormValue("empty") = %q, want "" (from body)`, empty)
64
	}
65
	if nokey := req.Form[""]; !reflect.DeepEqual(nokey, []string{"nokey"}) {
66
		t.Errorf(`req.FormValue("nokey") = %q, want "nokey" (from body)`, nokey)
67
	}
68
}
69

70
// Tests that we only parse the form automatically for certain methods.
71
func TestParseFormQueryMethods(t *testing.T) {
72
	for _, method := range []string{"POST", "PATCH", "PUT", "FOO"} {
73
		req, _ := NewRequest(method, "http://www.google.com/search",
74
			strings.NewReader("foo=bar"))
75
		req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
76
		want := "bar"
77
		if method == "FOO" {
78
			want = ""
79
		}
80
		if got := req.FormValue("foo"); got != want {
81
			t.Errorf(`for method %s, FormValue("foo") = %q; want %q`, method, got, want)
82
		}
83
	}
84
}
85

86
type stringMap map[string][]string
87
type parseContentTypeTest struct {
88
	shouldError bool
89
	contentType stringMap
90
}
91

92
var parseContentTypeTests = []parseContentTypeTest{
93
	{false, stringMap{"Content-Type": {"text/plain"}}},
94
	// Empty content type is legal - may be treated as
95
	// application/octet-stream (RFC 7231, section 3.1.1.5)
96
	{false, stringMap{}},
97
	{true, stringMap{"Content-Type": {"text/plain; boundary="}}},
98
	{false, stringMap{"Content-Type": {"application/unknown"}}},
99
}
100

101
func TestParseFormUnknownContentType(t *testing.T) {
102
	for i, test := range parseContentTypeTests {
103
		req := &Request{
104
			Method: "POST",
105
			Header: Header(test.contentType),
106
			Body:   ioutil.NopCloser(strings.NewReader("body")),
107
		}
108
		err := req.ParseForm()
109
		switch {
110
		case err == nil && test.shouldError:
111
			t.Errorf("test %d should have returned error", i)
112
		case err != nil && !test.shouldError:
113
			t.Errorf("test %d should not have returned error, got %v", i, err)
114
		}
115
	}
116
}
117

118
func TestParseFormInitializeOnError(t *testing.T) {
119
	nilBody, _ := NewRequest("POST", "http://www.google.com/search?q=foo", nil)
120
	tests := []*Request{
121
		nilBody,
122
		{Method: "GET", URL: nil},
123
	}
124
	for i, req := range tests {
125
		err := req.ParseForm()
126
		if req.Form == nil {
127
			t.Errorf("%d. Form not initialized, error %v", i, err)
128
		}
129
		if req.PostForm == nil {
130
			t.Errorf("%d. PostForm not initialized, error %v", i, err)
131
		}
132
	}
133
}
134

135
func TestMultipartReader(t *testing.T) {
136
	req := &Request{
137
		Method: "POST",
138
		Header: Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
139
		Body:   ioutil.NopCloser(new(bytes.Buffer)),
140
	}
141
	multipart, err := req.MultipartReader()
142
	if multipart == nil {
143
		t.Errorf("expected multipart; error: %v", err)
144
	}
145

146
	req = &Request{
147
		Method: "POST",
148
		Header: Header{"Content-Type": {`multipart/mixed; boundary="foo123"`}},
149
		Body:   ioutil.NopCloser(new(bytes.Buffer)),
150
	}
151
	multipart, err = req.MultipartReader()
152
	if multipart == nil {
153
		t.Errorf("expected multipart; error: %v", err)
154
	}
155

156
	req.Header = Header{"Content-Type": {"text/plain"}}
157
	multipart, err = req.MultipartReader()
158
	if multipart != nil {
159
		t.Error("unexpected multipart for text/plain")
160
	}
161
}
162

163
// Issue 9305: ParseMultipartForm should populate PostForm too
164
func TestParseMultipartFormPopulatesPostForm(t *testing.T) {
165
	postData :=
166
		`--xxx
167
Content-Disposition: form-data; name="field1"
168

169
value1
170
--xxx
171
Content-Disposition: form-data; name="field2"
172

173
value2
174
--xxx
175
Content-Disposition: form-data; name="file"; filename="file"
176
Content-Type: application/octet-stream
177
Content-Transfer-Encoding: binary
178

179
binary data
180
--xxx--
181
`
182
	req := &Request{
183
		Method: "POST",
184
		Header: Header{"Content-Type": {`multipart/form-data; boundary=xxx`}},
185
		Body:   ioutil.NopCloser(strings.NewReader(postData)),
186
	}
187

188
	initialFormItems := map[string]string{
189
		"language": "Go",
190
		"name":     "gopher",
191
		"skill":    "go-ing",
192
		"field2":   "initial-value2",
193
	}
194

195
	req.Form = make(url.Values)
196
	for k, v := range initialFormItems {
197
		req.Form.Add(k, v)
198
	}
199

200
	err := req.ParseMultipartForm(10000)
201
	if err != nil {
202
		t.Fatalf("unexpected multipart error %v", err)
203
	}
204

205
	wantForm := url.Values{
206
		"language": []string{"Go"},
207
		"name":     []string{"gopher"},
208
		"skill":    []string{"go-ing"},
209
		"field1":   []string{"value1"},
210
		"field2":   []string{"initial-value2", "value2"},
211
	}
212
	if !reflect.DeepEqual(req.Form, wantForm) {
213
		t.Fatalf("req.Form = %v, want %v", req.Form, wantForm)
214
	}
215

216
	wantPostForm := url.Values{
217
		"field1": []string{"value1"},
218
		"field2": []string{"value2"},
219
	}
220
	if !reflect.DeepEqual(req.PostForm, wantPostForm) {
221
		t.Fatalf("req.PostForm = %v, want %v", req.PostForm, wantPostForm)
222
	}
223
}
224

225
func TestParseMultipartForm(t *testing.T) {
226
	req := &Request{
227
		Method: "POST",
228
		Header: Header{"Content-Type": {`multipart/form-data; boundary="foo123"`}},
229
		Body:   ioutil.NopCloser(new(bytes.Buffer)),
230
	}
231
	err := req.ParseMultipartForm(25)
232
	if err == nil {
233
		t.Error("expected multipart EOF, got nil")
234
	}
235

236
	req.Header = Header{"Content-Type": {"text/plain"}}
237
	err = req.ParseMultipartForm(25)
238
	if err != ErrNotMultipart {
239
		t.Error("expected ErrNotMultipart for text/plain")
240
	}
241
}
242

243
func TestRedirect_h1(t *testing.T) { testRedirect(t, h1Mode) }
244
func TestRedirect_h2(t *testing.T) { testRedirect(t, h2Mode) }
245
func testRedirect(t *testing.T, h2 bool) {
246
	defer afterTest(t)
247
	cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
248
		switch r.URL.Path {
249
		case "/":
250
			w.Header().Set("Location", "/foo/")
251
			w.WriteHeader(StatusSeeOther)
252
		case "/foo/":
253
			fmt.Fprintf(w, "foo")
254
		default:
255
			w.WriteHeader(StatusBadRequest)
256
		}
257
	}))
258
	defer cst.close()
259

260
	var end = regexp.MustCompile("/foo/$")
261
	r, err := cst.c.Get(cst.ts.URL)
262
	if err != nil {
263
		t.Fatal(err)
264
	}
265
	r.Body.Close()
266
	url := r.Request.URL.String()
267
	if r.StatusCode != 200 || !end.MatchString(url) {
268
		t.Fatalf("Get got status %d at %q, want 200 matching /foo/$", r.StatusCode, url)
269
	}
270
}
271

272
func TestSetBasicAuth(t *testing.T) {
273
	r, _ := NewRequest("GET", "http://example.com/", nil)
274
	r.SetBasicAuth("Aladdin", "open sesame")
275
	if g, e := r.Header.Get("Authorization"), "Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ=="; g != e {
276
		t.Errorf("got header %q, want %q", g, e)
277
	}
278
}
279

280
func TestMultipartRequest(t *testing.T) {
281
	// Test that we can read the values and files of a
282
	// multipart request with FormValue and FormFile,
283
	// and that ParseMultipartForm can be called multiple times.
284
	req := newTestMultipartRequest(t)
285
	if err := req.ParseMultipartForm(25); err != nil {
286
		t.Fatal("ParseMultipartForm first call:", err)
287
	}
288
	defer req.MultipartForm.RemoveAll()
289
	validateTestMultipartContents(t, req, false)
290
	if err := req.ParseMultipartForm(25); err != nil {
291
		t.Fatal("ParseMultipartForm second call:", err)
292
	}
293
	validateTestMultipartContents(t, req, false)
294
}
295

296
func TestMultipartRequestAuto(t *testing.T) {
297
	// Test that FormValue and FormFile automatically invoke
298
	// ParseMultipartForm and return the right values.
299
	req := newTestMultipartRequest(t)
300
	defer func() {
301
		if req.MultipartForm != nil {
302
			req.MultipartForm.RemoveAll()
303
		}
304
	}()
305
	validateTestMultipartContents(t, req, true)
306
}
307

308
func TestMissingFileMultipartRequest(t *testing.T) {
309
	// Test that FormFile returns an error if
310
	// the named file is missing.
311
	req := newTestMultipartRequest(t)
312
	testMissingFile(t, req)
313
}
314

315
// Test that FormValue invokes ParseMultipartForm.
316
func TestFormValueCallsParseMultipartForm(t *testing.T) {
317
	req, _ := NewRequest("POST", "http://www.google.com/", strings.NewReader("z=post"))
318
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded; param=value")
319
	if req.Form != nil {
320
		t.Fatal("Unexpected request Form, want nil")
321
	}
322
	req.FormValue("z")
323
	if req.Form == nil {
324
		t.Fatal("ParseMultipartForm not called by FormValue")
325
	}
326
}
327

328
// Test that FormFile invokes ParseMultipartForm.
329
func TestFormFileCallsParseMultipartForm(t *testing.T) {
330
	req := newTestMultipartRequest(t)
331
	if req.Form != nil {
332
		t.Fatal("Unexpected request Form, want nil")
333
	}
334
	req.FormFile("")
335
	if req.Form == nil {
336
		t.Fatal("ParseMultipartForm not called by FormFile")
337
	}
338
}
339

340
// Test that ParseMultipartForm errors if called
341
// after MultipartReader on the same request.
342
func TestParseMultipartFormOrder(t *testing.T) {
343
	req := newTestMultipartRequest(t)
344
	if _, err := req.MultipartReader(); err != nil {
345
		t.Fatalf("MultipartReader: %v", err)
346
	}
347
	if err := req.ParseMultipartForm(1024); err == nil {
348
		t.Fatal("expected an error from ParseMultipartForm after call to MultipartReader")
349
	}
350
}
351

352
// Test that MultipartReader errors if called
353
// after ParseMultipartForm on the same request.
354
func TestMultipartReaderOrder(t *testing.T) {
355
	req := newTestMultipartRequest(t)
356
	if err := req.ParseMultipartForm(25); err != nil {
357
		t.Fatalf("ParseMultipartForm: %v", err)
358
	}
359
	defer req.MultipartForm.RemoveAll()
360
	if _, err := req.MultipartReader(); err == nil {
361
		t.Fatal("expected an error from MultipartReader after call to ParseMultipartForm")
362
	}
363
}
364

365
// Test that FormFile errors if called after
366
// MultipartReader on the same request.
367
func TestFormFileOrder(t *testing.T) {
368
	req := newTestMultipartRequest(t)
369
	if _, err := req.MultipartReader(); err != nil {
370
		t.Fatalf("MultipartReader: %v", err)
371
	}
372
	if _, _, err := req.FormFile(""); err == nil {
373
		t.Fatal("expected an error from FormFile after call to MultipartReader")
374
	}
375
}
376

377
var readRequestErrorTests = []struct {
378
	in  string
379
	err string
380

381
	header Header
382
}{
383
	0: {"GET / HTTP/1.1\r\nheader:foo\r\n\r\n", "", Header{"Header": {"foo"}}},
384
	1: {"GET / HTTP/1.1\r\nheader:foo\r\n", io.ErrUnexpectedEOF.Error(), nil},
385
	2: {"", io.EOF.Error(), nil},
386
	3: {
387
		in:  "HEAD / HTTP/1.1\r\nContent-Length:4\r\n\r\n",
388
		err: "http: method cannot contain a Content-Length",
389
	},
390
	4: {
391
		in:     "HEAD / HTTP/1.1\r\n\r\n",
392
		header: Header{},
393
	},
394

395
	// Multiple Content-Length values should either be
396
	// deduplicated if same or reject otherwise
397
	// See Issue 16490.
398
	5: {
399
		in:  "POST / HTTP/1.1\r\nContent-Length: 10\r\nContent-Length: 0\r\n\r\nGopher hey\r\n",
400
		err: "cannot contain multiple Content-Length headers",
401
	},
402
	6: {
403
		in:  "POST / HTTP/1.1\r\nContent-Length: 10\r\nContent-Length: 6\r\n\r\nGopher\r\n",
404
		err: "cannot contain multiple Content-Length headers",
405
	},
406
	7: {
407
		in:     "PUT / HTTP/1.1\r\nContent-Length: 6 \r\nContent-Length: 6\r\nContent-Length:6\r\n\r\nGopher\r\n",
408
		err:    "",
409
		header: Header{"Content-Length": {"6"}},
410
	},
411
	8: {
412
		in:  "PUT / HTTP/1.1\r\nContent-Length: 1\r\nContent-Length: 6 \r\n\r\n",
413
		err: "cannot contain multiple Content-Length headers",
414
	},
415
	9: {
416
		in:  "POST / HTTP/1.1\r\nContent-Length:\r\nContent-Length: 3\r\n\r\n",
417
		err: "cannot contain multiple Content-Length headers",
418
	},
419
	10: {
420
		in:     "HEAD / HTTP/1.1\r\nContent-Length:0\r\nContent-Length: 0\r\n\r\n",
421
		header: Header{"Content-Length": {"0"}},
422
	},
423
}
424

425
func TestReadRequestErrors(t *testing.T) {
426
	for i, tt := range readRequestErrorTests {
427
		req, err := ReadRequest(bufio.NewReader(strings.NewReader(tt.in)))
428
		if err == nil {
429
			if tt.err != "" {
430
				t.Errorf("#%d: got nil err; want %q", i, tt.err)
431
			}
432

433
			if !reflect.DeepEqual(tt.header, req.Header) {
434
				t.Errorf("#%d: gotHeader: %q wantHeader: %q", i, req.Header, tt.header)
435
			}
436
			continue
437
		}
438

439
		if tt.err == "" || !strings.Contains(err.Error(), tt.err) {
440
			t.Errorf("%d: got error = %v; want %v", i, err, tt.err)
441
		}
442
	}
443
}
444

445
var newRequestHostTests = []struct {
446
	in, out string
447
}{
448
	{"http://www.example.com/", "www.example.com"},
449
	{"http://www.example.com:8080/", "www.example.com:8080"},
450

451
	{"http://192.168.0.1/", "192.168.0.1"},
452
	{"http://192.168.0.1:8080/", "192.168.0.1:8080"},
453
	{"http://192.168.0.1:/", "192.168.0.1"},
454

455
	{"http://[fe80::1]/", "[fe80::1]"},
456
	{"http://[fe80::1]:8080/", "[fe80::1]:8080"},
457
	{"http://[fe80::1%25en0]/", "[fe80::1%en0]"},
458
	{"http://[fe80::1%25en0]:8080/", "[fe80::1%en0]:8080"},
459
	{"http://[fe80::1%25en0]:/", "[fe80::1%en0]"},
460
}
461

462
func TestNewRequestHost(t *testing.T) {
463
	for i, tt := range newRequestHostTests {
464
		req, err := NewRequest("GET", tt.in, nil)
465
		if err != nil {
466
			t.Errorf("#%v: %v", i, err)
467
			continue
468
		}
469
		if req.Host != tt.out {
470
			t.Errorf("got %q; want %q", req.Host, tt.out)
471
		}
472
	}
473
}
474

475
func TestRequestInvalidMethod(t *testing.T) {
476
	_, err := NewRequest("bad method", "http://foo.com/", nil)
477
	if err == nil {
478
		t.Error("expected error from NewRequest with invalid method")
479
	}
480
	req, err := NewRequest("GET", "http://foo.example/", nil)
481
	if err != nil {
482
		t.Fatal(err)
483
	}
484
	req.Method = "bad method"
485
	_, err = DefaultClient.Do(req)
486
	if err == nil || !strings.Contains(err.Error(), "invalid method") {
487
		t.Errorf("Transport error = %v; want invalid method", err)
488
	}
489

490
	req, err = NewRequest("", "http://foo.com/", nil)
491
	if err != nil {
492
		t.Errorf("NewRequest(empty method) = %v; want nil", err)
493
	} else if req.Method != "GET" {
494
		t.Errorf("NewRequest(empty method) has method %q; want GET", req.Method)
495
	}
496
}
497

498
func TestNewRequestContentLength(t *testing.T) {
499
	readByte := func(r io.Reader) io.Reader {
500
		var b [1]byte
501
		r.Read(b[:])
502
		return r
503
	}
504
	tests := []struct {
505
		r    io.Reader
506
		want int64
507
	}{
508
		{bytes.NewReader([]byte("123")), 3},
509
		{bytes.NewBuffer([]byte("1234")), 4},
510
		{strings.NewReader("12345"), 5},
511
		{strings.NewReader(""), 0},
512
		{NoBody, 0},
513

514
		// Not detected. During Go 1.8 we tried to make these set to -1, but
515
		// due to Issue 18117, we keep these returning 0, even though they're
516
		// unknown.
517
		{struct{ io.Reader }{strings.NewReader("xyz")}, 0},
518
		{io.NewSectionReader(strings.NewReader("x"), 0, 6), 0},
519
		{readByte(io.NewSectionReader(strings.NewReader("xy"), 0, 6)), 0},
520
	}
521
	for i, tt := range tests {
522
		req, err := NewRequest("POST", "http://localhost/", tt.r)
523
		if err != nil {
524
			t.Fatal(err)
525
		}
526
		if req.ContentLength != tt.want {
527
			t.Errorf("test[%d]: ContentLength(%T) = %d; want %d", i, tt.r, req.ContentLength, tt.want)
528
		}
529
	}
530
}
531

532
var parseHTTPVersionTests = []struct {
533
	vers         string
534
	major, minor int
535
	ok           bool
536
}{
537
	{"HTTP/0.9", 0, 9, true},
538
	{"HTTP/1.0", 1, 0, true},
539
	{"HTTP/1.1", 1, 1, true},
540
	{"HTTP/3.14", 3, 14, true},
541

542
	{"HTTP", 0, 0, false},
543
	{"HTTP/one.one", 0, 0, false},
544
	{"HTTP/1.1/", 0, 0, false},
545
	{"HTTP/-1,0", 0, 0, false},
546
	{"HTTP/0,-1", 0, 0, false},
547
	{"HTTP/", 0, 0, false},
548
	{"HTTP/1,1", 0, 0, false},
549
}
550

551
func TestParseHTTPVersion(t *testing.T) {
552
	for _, tt := range parseHTTPVersionTests {
553
		major, minor, ok := ParseHTTPVersion(tt.vers)
554
		if ok != tt.ok || major != tt.major || minor != tt.minor {
555
			type version struct {
556
				major, minor int
557
				ok           bool
558
			}
559
			t.Errorf("failed to parse %q, expected: %#v, got %#v", tt.vers, version{tt.major, tt.minor, tt.ok}, version{major, minor, ok})
560
		}
561
	}
562
}
563

564
type getBasicAuthTest struct {
565
	username, password string
566
	ok                 bool
567
}
568

569
type basicAuthCredentialsTest struct {
570
	username, password string
571
}
572

573
var getBasicAuthTests = []struct {
574
	username, password string
575
	ok                 bool
576
}{
577
	{"Aladdin", "open sesame", true},
578
	{"Aladdin", "open:sesame", true},
579
	{"", "", true},
580
}
581

582
func TestGetBasicAuth(t *testing.T) {
583
	for _, tt := range getBasicAuthTests {
584
		r, _ := NewRequest("GET", "http://example.com/", nil)
585
		r.SetBasicAuth(tt.username, tt.password)
586
		username, password, ok := r.BasicAuth()
587
		if ok != tt.ok || username != tt.username || password != tt.password {
588
			t.Errorf("BasicAuth() = %#v, want %#v", getBasicAuthTest{username, password, ok},
589
				getBasicAuthTest{tt.username, tt.password, tt.ok})
590
		}
591
	}
592
	// Unauthenticated request.
593
	r, _ := NewRequest("GET", "http://example.com/", nil)
594
	username, password, ok := r.BasicAuth()
595
	if ok {
596
		t.Errorf("expected false from BasicAuth when the request is unauthenticated")
597
	}
598
	want := basicAuthCredentialsTest{"", ""}
599
	if username != want.username || password != want.password {
600
		t.Errorf("expected credentials: %#v when the request is unauthenticated, got %#v",
601
			want, basicAuthCredentialsTest{username, password})
602
	}
603
}
604

605
var parseBasicAuthTests = []struct {
606
	header, username, password string
607
	ok                         bool
608
}{
609
	{"Basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true},
610

611
	// Case doesn't matter:
612
	{"BASIC " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true},
613
	{"basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "Aladdin", "open sesame", true},
614

615
	{"Basic " + base64.StdEncoding.EncodeToString([]byte("Aladdin:open:sesame")), "Aladdin", "open:sesame", true},
616
	{"Basic " + base64.StdEncoding.EncodeToString([]byte(":")), "", "", true},
617
	{"Basic" + base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "", "", false},
618
	{base64.StdEncoding.EncodeToString([]byte("Aladdin:open sesame")), "", "", false},
619
	{"Basic ", "", "", false},
620
	{"Basic Aladdin:open sesame", "", "", false},
621
	{`Digest username="Aladdin"`, "", "", false},
622
}
623

624
func TestParseBasicAuth(t *testing.T) {
625
	for _, tt := range parseBasicAuthTests {
626
		r, _ := NewRequest("GET", "http://example.com/", nil)
627
		r.Header.Set("Authorization", tt.header)
628
		username, password, ok := r.BasicAuth()
629
		if ok != tt.ok || username != tt.username || password != tt.password {
630
			t.Errorf("BasicAuth() = %#v, want %#v", getBasicAuthTest{username, password, ok},
631
				getBasicAuthTest{tt.username, tt.password, tt.ok})
632
		}
633
	}
634
}
635

636
type logWrites struct {
637
	t   *testing.T
638
	dst *[]string
639
}
640

641
func (l logWrites) WriteByte(c byte) error {
642
	l.t.Fatalf("unexpected WriteByte call")
643
	return nil
644
}
645

646
func (l logWrites) Write(p []byte) (n int, err error) {
647
	*l.dst = append(*l.dst, string(p))
648
	return len(p), nil
649
}
650

651
func TestRequestWriteBufferedWriter(t *testing.T) {
652
	got := []string{}
653
	req, _ := NewRequest("GET", "http://foo.com/", nil)
654
	req.Write(logWrites{t, &got})
655
	want := []string{
656
		"GET / HTTP/1.1\r\n",
657
		"Host: foo.com\r\n",
658
		"User-Agent: " + DefaultUserAgent + "\r\n",
659
		"\r\n",
660
	}
661
	if !reflect.DeepEqual(got, want) {
662
		t.Errorf("Writes = %q\n  Want = %q", got, want)
663
	}
664
}
665

666
func TestRequestBadHost(t *testing.T) {
667
	got := []string{}
668
	req, err := NewRequest("GET", "http://foo/after", nil)
669
	if err != nil {
670
		t.Fatal(err)
671
	}
672
	req.Host = "foo.com with spaces"
673
	req.URL.Host = "foo.com with spaces"
674
	req.Write(logWrites{t, &got})
675
	want := []string{
676
		"GET /after HTTP/1.1\r\n",
677
		"Host: foo.com\r\n",
678
		"User-Agent: " + DefaultUserAgent + "\r\n",
679
		"\r\n",
680
	}
681
	if !reflect.DeepEqual(got, want) {
682
		t.Errorf("Writes = %q\n  Want = %q", got, want)
683
	}
684
}
685

686
func TestStarRequest(t *testing.T) {
687
	req, err := ReadRequest(bufio.NewReader(strings.NewReader("M-SEARCH * HTTP/1.1\r\n\r\n")))
688
	if err != nil {
689
		return
690
	}
691
	if req.ContentLength != 0 {
692
		t.Errorf("ContentLength = %d; want 0", req.ContentLength)
693
	}
694
	if req.Body == nil {
695
		t.Errorf("Body = nil; want non-nil")
696
	}
697

698
	// Request.Write has Client semantics for Body/ContentLength,
699
	// where ContentLength 0 means unknown if Body is non-nil, and
700
	// thus chunking will happen unless we change semantics and
701
	// signal that we want to serialize it as exactly zero.  The
702
	// only way to do that for outbound requests is with a nil
703
	// Body:
704
	clientReq := *req
705
	clientReq.Body = nil
706

707
	var out bytes.Buffer
708
	if err := clientReq.Write(&out); err != nil {
709
		t.Fatal(err)
710
	}
711

712
	if strings.Contains(out.String(), "chunked") {
713
		t.Error("wrote chunked request; want no body")
714
	}
715
	back, err := ReadRequest(bufio.NewReader(bytes.NewReader(out.Bytes())))
716
	if err != nil {
717
		t.Fatal(err)
718
	}
719
	// Ignore the Headers (the User-Agent breaks the deep equal,
720
	// but we don't care about it)
721
	req.Header = nil
722
	back.Header = nil
723
	if !reflect.DeepEqual(req, back) {
724
		t.Errorf("Original request doesn't match Request read back.")
725
		t.Logf("Original: %#v", req)
726
		t.Logf("Original.URL: %#v", req.URL)
727
		t.Logf("Wrote: %s", out.Bytes())
728
		t.Logf("Read back (doesn't match Original): %#v", back)
729
	}
730
}
731

732
type responseWriterJustWriter struct {
733
	io.Writer
734
}
735

736
func (responseWriterJustWriter) Header() Header  { panic("should not be called") }
737
func (responseWriterJustWriter) WriteHeader(int) { panic("should not be called") }
738

739
// delayedEOFReader never returns (n > 0, io.EOF), instead putting
740
// off the io.EOF until a subsequent Read call.
741
type delayedEOFReader struct {
742
	r io.Reader
743
}
744

745
func (dr delayedEOFReader) Read(p []byte) (n int, err error) {
746
	n, err = dr.r.Read(p)
747
	if n > 0 && err == io.EOF {
748
		err = nil
749
	}
750
	return
751
}
752

753
func TestIssue10884_MaxBytesEOF(t *testing.T) {
754
	dst := ioutil.Discard
755
	_, err := io.Copy(dst, MaxBytesReader(
756
		responseWriterJustWriter{dst},
757
		ioutil.NopCloser(delayedEOFReader{strings.NewReader("12345")}),
758
		5))
759
	if err != nil {
760
		t.Fatal(err)
761
	}
762
}
763

764
// Issue 14981: MaxBytesReader's return error wasn't sticky. It
765
// doesn't technically need to be, but people expected it to be.
766
func TestMaxBytesReaderStickyError(t *testing.T) {
767
	isSticky := func(r io.Reader) error {
768
		var log bytes.Buffer
769
		buf := make([]byte, 1000)
770
		var firstErr error
771
		for {
772
			n, err := r.Read(buf)
773
			fmt.Fprintf(&log, "Read(%d) = %d, %v\n", len(buf), n, err)
774
			if err == nil {
775
				continue
776
			}
777
			if firstErr == nil {
778
				firstErr = err
779
				continue
780
			}
781
			if !reflect.DeepEqual(err, firstErr) {
782
				return fmt.Errorf("non-sticky error. got log:\n%s", log.Bytes())
783
			}
784
			t.Logf("Got log: %s", log.Bytes())
785
			return nil
786
		}
787
	}
788
	tests := [...]struct {
789
		readable int
790
		limit    int64
791
	}{
792
		0: {99, 100},
793
		1: {100, 100},
794
		2: {101, 100},
795
	}
796
	for i, tt := range tests {
797
		rc := MaxBytesReader(nil, ioutil.NopCloser(bytes.NewReader(make([]byte, tt.readable))), tt.limit)
798
		if err := isSticky(rc); err != nil {
799
			t.Errorf("%d. error: %v", i, err)
800
		}
801
	}
802
}
803

804
func TestWithContextDeepCopiesURL(t *testing.T) {
805
	req, err := NewRequest("POST", "https://golang.org/", nil)
806
	if err != nil {
807
		t.Fatal(err)
808
	}
809

810
	reqCopy := req.WithContext(context.Background())
811
	reqCopy.URL.Scheme = "http"
812

813
	firstURL, secondURL := req.URL.String(), reqCopy.URL.String()
814
	if firstURL == secondURL {
815
		t.Errorf("unexpected change to original request's URL")
816
	}
817

818
	// And also check we don't crash on nil (Issue 20601)
819
	req.URL = nil
820
	reqCopy = req.WithContext(context.Background())
821
	if reqCopy.URL != nil {
822
		t.Error("expected nil URL in cloned request")
823
	}
824
}
825

826
// verify that NewRequest sets Request.GetBody and that it works
827
func TestNewRequestGetBody(t *testing.T) {
828
	tests := []struct {
829
		r io.Reader
830
	}{
831
		{r: strings.NewReader("hello")},
832
		{r: bytes.NewReader([]byte("hello"))},
833
		{r: bytes.NewBuffer([]byte("hello"))},
834
	}
835
	for i, tt := range tests {
836
		req, err := NewRequest("POST", "http://foo.tld/", tt.r)
837
		if err != nil {
838
			t.Errorf("test[%d]: %v", i, err)
839
			continue
840
		}
841
		if req.Body == nil {
842
			t.Errorf("test[%d]: Body = nil", i)
843
			continue
844
		}
845
		if req.GetBody == nil {
846
			t.Errorf("test[%d]: GetBody = nil", i)
847
			continue
848
		}
849
		slurp1, err := ioutil.ReadAll(req.Body)
850
		if err != nil {
851
			t.Errorf("test[%d]: ReadAll(Body) = %v", i, err)
852
		}
853
		newBody, err := req.GetBody()
854
		if err != nil {
855
			t.Errorf("test[%d]: GetBody = %v", i, err)
856
		}
857
		slurp2, err := ioutil.ReadAll(newBody)
858
		if err != nil {
859
			t.Errorf("test[%d]: ReadAll(GetBody()) = %v", i, err)
860
		}
861
		if string(slurp1) != string(slurp2) {
862
			t.Errorf("test[%d]: Body %q != GetBody %q", i, slurp1, slurp2)
863
		}
864
	}
865
}
866

867
func testMissingFile(t *testing.T, req *Request) {
868
	f, fh, err := req.FormFile("missing")
869
	if f != nil {
870
		t.Errorf("FormFile file = %v, want nil", f)
871
	}
872
	if fh != nil {
873
		t.Errorf("FormFile file header = %q, want nil", fh)
874
	}
875
	if err != ErrMissingFile {
876
		t.Errorf("FormFile err = %q, want ErrMissingFile", err)
877
	}
878
}
879

880
func newTestMultipartRequest(t *testing.T) *Request {
881
	b := strings.NewReader(strings.Replace(message, "\n", "\r\n", -1))
882
	req, err := NewRequest("POST", "/", b)
883
	if err != nil {
884
		t.Fatal("NewRequest:", err)
885
	}
886
	ctype := fmt.Sprintf(`multipart/form-data; boundary="%s"`, boundary)
887
	req.Header.Set("Content-type", ctype)
888
	return req
889
}
890

891
func validateTestMultipartContents(t *testing.T, req *Request, allMem bool) {
892
	if g, e := req.FormValue("texta"), textaValue; g != e {
893
		t.Errorf("texta value = %q, want %q", g, e)
894
	}
895
	if g, e := req.FormValue("textb"), textbValue; g != e {
896
		t.Errorf("textb value = %q, want %q", g, e)
897
	}
898
	if g := req.FormValue("missing"); g != "" {
899
		t.Errorf("missing value = %q, want empty string", g)
900
	}
901

902
	assertMem := func(n string, fd multipart.File) {
903
		if _, ok := fd.(*os.File); ok {
904
			t.Error(n, " is *os.File, should not be")
905
		}
906
	}
907
	fda := testMultipartFile(t, req, "filea", "filea.txt", fileaContents)
908
	defer fda.Close()
909
	assertMem("filea", fda)
910
	fdb := testMultipartFile(t, req, "fileb", "fileb.txt", filebContents)
911
	defer fdb.Close()
912
	if allMem {
913
		assertMem("fileb", fdb)
914
	} else {
915
		if _, ok := fdb.(*os.File); !ok {
916
			t.Errorf("fileb has unexpected underlying type %T", fdb)
917
		}
918
	}
919

920
	testMissingFile(t, req)
921
}
922

923
func testMultipartFile(t *testing.T, req *Request, key, expectFilename, expectContent string) multipart.File {
924
	f, fh, err := req.FormFile(key)
925
	if err != nil {
926
		t.Fatalf("FormFile(%q): %q", key, err)
927
	}
928
	if fh.Filename != expectFilename {
929
		t.Errorf("filename = %q, want %q", fh.Filename, expectFilename)
930
	}
931
	var b bytes.Buffer
932
	_, err = io.Copy(&b, f)
933
	if err != nil {
934
		t.Fatal("copying contents:", err)
935
	}
936
	if g := b.String(); g != expectContent {
937
		t.Errorf("contents = %q, want %q", g, expectContent)
938
	}
939
	return f
940
}
941

942
const (
943
	fileaContents = "This is a test file."
944
	filebContents = "Another test file."
945
	textaValue    = "foo"
946
	textbValue    = "bar"
947
	boundary      = `MyBoundary`
948
)
949

950
const message = `
951
--MyBoundary
952
Content-Disposition: form-data; name="filea"; filename="filea.txt"
953
Content-Type: text/plain
954

955
` + fileaContents + `
956
--MyBoundary
957
Content-Disposition: form-data; name="fileb"; filename="fileb.txt"
958
Content-Type: text/plain
959

960
` + filebContents + `
961
--MyBoundary
962
Content-Disposition: form-data; name="texta"
963

964
` + textaValue + `
965
--MyBoundary
966
Content-Disposition: form-data; name="textb"
967

968
` + textbValue + `
969
--MyBoundary--
970
`
971

972
func benchmarkReadRequest(b *testing.B, request string) {
973
	request = request + "\n"                             // final \n
974
	request = strings.Replace(request, "\n", "\r\n", -1) // expand \n to \r\n
975
	b.SetBytes(int64(len(request)))
976
	r := bufio.NewReader(&infiniteReader{buf: []byte(request)})
977
	b.ReportAllocs()
978
	b.ResetTimer()
979
	for i := 0; i < b.N; i++ {
980
		_, err := ReadRequest(r)
981
		if err != nil {
982
			b.Fatalf("failed to read request: %v", err)
983
		}
984
	}
985
}
986

987
// infiniteReader satisfies Read requests as if the contents of buf
988
// loop indefinitely.
989
type infiniteReader struct {
990
	buf    []byte
991
	offset int
992
}
993

994
func (r *infiniteReader) Read(b []byte) (int, error) {
995
	n := copy(b, r.buf[r.offset:])
996
	r.offset = (r.offset + n) % len(r.buf)
997
	return n, nil
998
}
999

1000
func BenchmarkReadRequestChrome(b *testing.B) {
1001
	// https://github.com/felixge/node-http-perf/blob/master/fixtures/get.http
1002
	benchmarkReadRequest(b, `GET / HTTP/1.1
1003
Host: localhost:8080
1004
Connection: keep-alive
1005
Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8
1006
User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_2) AppleWebKit/537.17 (KHTML, like Gecko) Chrome/24.0.1312.52 Safari/537.17
1007
Accept-Encoding: gzip,deflate,sdch
1008
Accept-Language: en-US,en;q=0.8
1009
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.3
1010
Cookie: __utma=1.1978842379.1323102373.1323102373.1323102373.1; EPi:NumberOfVisits=1,2012-02-28T13:42:18; CrmSession=5b707226b9563e1bc69084d07a107c98; plushContainerWidth=100%25; plushNoTopMenu=0; hudson_auto_refresh=false
1011
`)
1012
}
1013

1014
func BenchmarkReadRequestCurl(b *testing.B) {
1015
	// curl http://localhost:8080/
1016
	benchmarkReadRequest(b, `GET / HTTP/1.1
1017
User-Agent: curl/7.27.0
1018
Host: localhost:8080
1019
Accept: */*
1020
`)
1021
}
1022

1023
func BenchmarkReadRequestApachebench(b *testing.B) {
1024
	// ab -n 1 -c 1 http://localhost:8080/
1025
	benchmarkReadRequest(b, `GET / HTTP/1.0
1026
Host: localhost:8080
1027
User-Agent: ApacheBench/2.3
1028
Accept: */*
1029
`)
1030
}
1031

1032
func BenchmarkReadRequestSiege(b *testing.B) {
1033
	// siege -r 1 -c 1 http://localhost:8080/
1034
	benchmarkReadRequest(b, `GET / HTTP/1.1
1035
Host: localhost:8080
1036
Accept: */*
1037
Accept-Encoding: gzip
1038
User-Agent: JoeDog/1.00 [en] (X11; I; Siege 2.70)
1039
Connection: keep-alive
1040
`)
1041
}
1042

1043
func BenchmarkReadRequestWrk(b *testing.B) {
1044
	// wrk -t 1 -r 1 -c 1 http://localhost:8080/
1045
	benchmarkReadRequest(b, `GET / HTTP/1.1
1046
Host: localhost:8080
1047
`)
1048
}
1049