Move Part and Envelope tests into enmime_test package

base64.go

@@ -56,7 +56,7 @@ func (bc *base64Cleaner) Read(p []byte) (n int, err error) {
 		case -1:
 			// Strip these, but warn the client
 			bc.Errors = append(bc.Errors, Error{
-				Name:   string(errorMalformedBase64),
+				Name:   ErrorMalformedBase64,
 				Detail: fmt.Sprintf("Unexpected %q in Base64 stream", buf[i]),
 				Severe: false,
 			})

base64_test.go

@@ -53,8 +53,8 @@ func TestBase64CleanerErrors(t *testing.T) {
 				t.Fatal(err)
 			}
 			if len(cleaner.Errors) == 1 {
-				if cleaner.Errors[0].Name != string(errorMalformedBase64) {
-					t.Errorf("got: %q, want: %q", cleaner.Errors[0].Name, errorMalformedBase64)
+				if cleaner.Errors[0].Name != ErrorMalformedBase64 {
+					t.Errorf("got: %q, want: %q", cleaner.Errors[0].Name, ErrorMalformedBase64)
 				}
 			} else {
 				t.Errorf("got %d Errors, wanted 1", len(cleaner.Errors))

detect_test.go

@@ -1,9 +1,14 @@
 package enmime
 
-import "testing"
+import (
+	"net/textproto"
+	"os"
+	"path/filepath"
+	"testing"
+)
 
 func TestDetectSinglePart(t *testing.T) {
-	r := openTestData("mail", "non-mime.raw")
+	r, _ := os.Open(filepath.Join("testdata", "mail", "non-mime.raw"))
 	msg, err := ReadParts(r)
 	if err != nil {
 		t.Fatal(err)
@@ -15,7 +20,7 @@ func TestDetectSinglePart(t *testing.T) {
 }
 
 func TestDetectMultiPart(t *testing.T) {
-	r := openTestData("mail", "html-mime-inline.raw")
+	r, _ := os.Open(filepath.Join("testdata", "mail", "html-mime-inline.raw"))
 	msg, err := ReadParts(r)
 	if err != nil {
 		t.Fatal(err)
@@ -27,7 +32,7 @@ func TestDetectMultiPart(t *testing.T) {
 }
 
 func TestDetectUnknownMultiPart(t *testing.T) {
-	r := openTestData("mail", "unknown-part-type.raw")
+	r, _ := os.Open(filepath.Join("testdata", "mail", "unknown-part-type.raw"))
 	msg, err := ReadParts(r)
 	if err != nil {
 		t.Fatal(err)
@@ -48,7 +53,7 @@ func TestDetectBinaryBody(t *testing.T) {
 		{filename: "attachment-only-no-disposition.raw", disposition: "none"},
 	}
 	for _, tt := range ttable {
-		r := openTestData("mail", tt.filename)
+		r, _ := os.Open(filepath.Join("testdata", "mail", tt.filename))
 		root, err := ReadParts(r)
 		if err != nil {
 			t.Fatal(err)
@@ -59,3 +64,106 @@ func TestDetectBinaryBody(t *testing.T) {
 		}
 	}
 }
+
+func TestDetectAttachmentHeader(t *testing.T) {
+	var htests = []struct {
+		want   bool
+		header textproto.MIMEHeader
+	}{
+		{
+			want: true,
+			header: textproto.MIMEHeader{
+				"Content-Disposition": []string{"attachment; filename=\"test.jpg\""}},
+		},
+		{
+			want: true,
+			header: textproto.MIMEHeader{
+				"Content-Disposition": []string{"ATTACHMENT; filename=\"test.jpg\""}},
+		},
+		{
+			want: true,
+			header: textproto.MIMEHeader{
+				"Content-Type":        []string{"image/jpg; name=\"test.jpg\""},
+				"Content-Disposition": []string{"attachment; filename=\"test.jpg\""},
+			},
+		},
+		{
+			want: true,
+			header: textproto.MIMEHeader{
+				"Content-Type": []string{"attachment; filename=\"test.jpg\""}},
+		},
+		{
+			want: true,
+			header: textproto.MIMEHeader{
+				"Content-Disposition": []string{"inline; filename=\"frog.jpg\""}},
+		},
+		{
+			want: false,
+			header: textproto.MIMEHeader{
+				"Content-Disposition": []string{"non-attachment; filename=\"frog.jpg\""}},
+		},
+		{
+			want:   false,
+			header: textproto.MIMEHeader{},
+		},
+	}
+
+	for _, s := range htests {
+		got := detectAttachmentHeader(s.header)
+		if got != s.want {
+			t.Errorf("detectAttachmentHeader(%v) == %v, want: %v", s.header, got, s.want)
+		}
+	}
+}
+
+func TestDetectTextHeader(t *testing.T) {
+	var htests = []struct {
+		want         bool
+		header       textproto.MIMEHeader
+		emptyIsPlain bool
+	}{
+		{
+			want:         true,
+			header:       textproto.MIMEHeader{"Content-Type": []string{"text/plain"}},
+			emptyIsPlain: true,
+		},
+		{
+			want:         true,
+			header:       textproto.MIMEHeader{"Content-Type": []string{"text/html"}},
+			emptyIsPlain: true,
+		},
+		{
+			want:         true,
+			header:       textproto.MIMEHeader{"Content-Type": []string{"text/html; charset=utf-8"}},
+			emptyIsPlain: true,
+		},
+		{
+			want:         true,
+			header:       textproto.MIMEHeader{},
+			emptyIsPlain: true,
+		},
+		{
+			want:         false,
+			header:       textproto.MIMEHeader{},
+			emptyIsPlain: false,
+		},
+		{
+			want:         false,
+			header:       textproto.MIMEHeader{"Content-Type": []string{"image/jpeg;"}},
+			emptyIsPlain: true,
+		},
+		{
+			want:         false,
+			header:       textproto.MIMEHeader{"Content-Type": []string{"application/octet-stream"}},
+			emptyIsPlain: true,
+		},
+	}
+
+	for _, s := range htests {
+		got := detectTextHeader(s.header, s.emptyIsPlain)
+		if got != s.want {
+			t.Errorf("detectTextHeader(%v, %v) == %v, want: %v",
+				s.header, s.emptyIsPlain, got, s.want)
+		}
+	}
+}

envelope.go

@@ -99,15 +99,15 @@ func EnvelopeFromPart(root *Part) (*Envelope, error) {
 	if e.Text == "" && e.HTML != "" {
 		// We always warn when this happens
 		e.Root.addWarning(
-			errorPlainTextFromHTML,
+			ErrorPlainTextFromHTML,
 			"Message did not contain a text/plain part")
 		var err error
 		if e.Text, err = html2text.FromString(e.HTML); err != nil {
 			// Downcoversion shouldn't fail
 			e.Text = ""
 			p := e.Root.BreadthMatchFirst(matchHTMLBodyPart)
 			p.addError(
-				errorPlainTextFromHTML,
+				ErrorPlainTextFromHTML,
 				"Failed to downconvert HTML: %v",
 				err)
 		}
@@ -158,7 +158,7 @@ func parseTextOnlyBody(root *Part, e *Envelope) error {
 					e.HTML = convHTML
 				} else {
 					// Conversion failed
-					root.addWarning(errorCharsetConversion, err.Error())
+					root.addWarning(ErrorCharsetConversion, err.Error())
 				}
 			}
 		}