// 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))
}
}
})
}
}