| // Copyright 2011 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. |
| |
| package multipart |
| |
| import ( |
| "bytes" |
| "io" |
| "os" |
| "strings" |
| "testing" |
| ) |
| |
| func TestReadForm(t *testing.T) { |
| b := strings.NewReader(strings.Replace(message, "\n", "\r\n", -1)) |
| r := NewReader(b, boundary) |
| f, err := r.ReadForm(25) |
| if err != nil { |
| t.Fatal("ReadForm:", err) |
| } |
| defer f.RemoveAll() |
| if g, e := f.Value["texta"][0], textaValue; g != e { |
| t.Errorf("texta value = %q, want %q", g, e) |
| } |
| if g, e := f.Value["textb"][0], textbValue; g != e { |
| t.Errorf("texta value = %q, want %q", g, e) |
| } |
| fd := testFile(t, f.File["filea"][0], "filea.txt", fileaContents) |
| if _, ok := fd.(*os.File); ok { |
| t.Error("file is *os.File, should not be") |
| } |
| fd.Close() |
| fd = testFile(t, f.File["fileb"][0], "fileb.txt", filebContents) |
| if _, ok := fd.(*os.File); !ok { |
| t.Errorf("file has unexpected underlying type %T", fd) |
| } |
| fd.Close() |
| } |
| |
| func TestReadFormWithNamelessFile(t *testing.T) { |
| b := strings.NewReader(strings.Replace(messageWithFileWithoutName, "\n", "\r\n", -1)) |
| r := NewReader(b, boundary) |
| f, err := r.ReadForm(25) |
| if err != nil { |
| t.Fatal("ReadForm:", err) |
| } |
| defer f.RemoveAll() |
| |
| fd := testFile(t, f.File["hiddenfile"][0], "", filebContents) |
| if _, ok := fd.(sectionReadCloser); !ok { |
| t.Errorf("file has unexpected underlying type %T", fd) |
| } |
| fd.Close() |
| |
| } |
| |
| func testFile(t *testing.T, fh *FileHeader, efn, econtent string) File { |
| if fh.Filename != efn { |
| t.Errorf("filename = %q, want %q", fh.Filename, efn) |
| } |
| if fh.Size != int64(len(econtent)) { |
| t.Errorf("size = %d, want %d", fh.Size, len(econtent)) |
| } |
| f, err := fh.Open() |
| if err != nil { |
| t.Fatal("opening file:", err) |
| } |
| b := new(bytes.Buffer) |
| _, err = io.Copy(b, f) |
| if err != nil { |
| t.Fatal("copying contents:", err) |
| } |
| if g := b.String(); g != econtent { |
| t.Errorf("contents = %q, want %q", g, econtent) |
| } |
| return f |
| } |
| |
| const ( |
| fileaContents = "This is a test file." |
| filebContents = "Another test file." |
| textaValue = "foo" |
| textbValue = "bar" |
| boundary = `MyBoundary` |
| ) |
| |
| const messageWithFileWithoutName = ` |
| --MyBoundary |
| Content-Disposition: form-data; name="hiddenfile"; filename="" |
| Content-Type: text/plain |
| |
| ` + filebContents + ` |
| --MyBoundary-- |
| ` |
| |
| const message = ` |
| --MyBoundary |
| Content-Disposition: form-data; name="filea"; filename="filea.txt" |
| Content-Type: text/plain |
| |
| ` + fileaContents + ` |
| --MyBoundary |
| Content-Disposition: form-data; name="fileb"; filename="fileb.txt" |
| Content-Type: text/plain |
| |
| ` + filebContents + ` |
| --MyBoundary |
| Content-Disposition: form-data; name="texta" |
| |
| ` + textaValue + ` |
| --MyBoundary |
| Content-Disposition: form-data; name="textb" |
| |
| ` + textbValue + ` |
| --MyBoundary-- |
| ` |
| |
| func TestReadForm_NoReadAfterEOF(t *testing.T) { |
| maxMemory := int64(32) << 20 |
| boundary := `---------------------------8d345eef0d38dc9` |
| body := ` |
| -----------------------------8d345eef0d38dc9 |
| Content-Disposition: form-data; name="version" |
| |
| 171 |
| -----------------------------8d345eef0d38dc9--` |
| |
| mr := NewReader(&failOnReadAfterErrorReader{t: t, r: strings.NewReader(body)}, boundary) |
| |
| f, err := mr.ReadForm(maxMemory) |
| if err != nil { |
| t.Fatal(err) |
| } |
| t.Logf("Got: %#v", f) |
| } |
| |
| // failOnReadAfterErrorReader is an io.Reader wrapping r. |
| // It fails t if any Read is called after a failing Read. |
| type failOnReadAfterErrorReader struct { |
| t *testing.T |
| r io.Reader |
| sawErr error |
| } |
| |
| func (r *failOnReadAfterErrorReader) Read(p []byte) (n int, err error) { |
| if r.sawErr != nil { |
| r.t.Fatalf("unexpected Read on Reader after previous read saw error %v", r.sawErr) |
| } |
| n, err = r.r.Read(p) |
| r.sawErr = err |
| return |
| } |
| |
| // TestReadForm_NonFileMaxMemory asserts that the ReadForm maxMemory limit is applied |
| // while processing non-file form data as well as file form data. |
| func TestReadForm_NonFileMaxMemory(t *testing.T) { |
| largeTextValue := strings.Repeat("1", (10<<20)+25) |
| message := `--MyBoundary |
| Content-Disposition: form-data; name="largetext" |
| |
| ` + largeTextValue + ` |
| --MyBoundary-- |
| ` |
| |
| testBody := strings.Replace(message, "\n", "\r\n", -1) |
| testCases := []struct { |
| name string |
| maxMemory int64 |
| err error |
| }{ |
| {"smaller", 50, nil}, |
| {"exact-fit", 25, nil}, |
| {"too-large", 0, ErrMessageTooLarge}, |
| } |
| for _, tc := range testCases { |
| t.Run(tc.name, func(t *testing.T) { |
| b := strings.NewReader(testBody) |
| r := NewReader(b, boundary) |
| f, err := r.ReadForm(tc.maxMemory) |
| if err == nil { |
| defer f.RemoveAll() |
| } |
| if tc.err != err { |
| t.Fatalf("ReadForm error - got: %v; expected: %v", tc.err, err) |
| } |
| if err == nil { |
| if g := f.Value["largetext"][0]; g != largeTextValue { |
| t.Errorf("largetext mismatch: got size: %v, expected size: %v", len(g), len(largeTextValue)) |
| } |
| } |
| }) |
| } |
| } |