This is the v1 version, had the v2 before.
This commit is contained in:
797
message_test.go
Normal file
797
message_test.go
Normal file
@@ -0,0 +1,797 @@
|
||||
package imap
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"reflect"
|
||||
"testing"
|
||||
"time"
|
||||
)
|
||||
|
||||
func TestCanonicalFlag(t *testing.T) {
|
||||
if got := CanonicalFlag("\\SEEN"); got != SeenFlag {
|
||||
t.Errorf("Invalid canonical flag: expected %q but got %q", SeenFlag, got)
|
||||
}
|
||||
|
||||
if got := CanonicalFlag("Junk"); got != "junk" {
|
||||
t.Errorf("Invalid canonical flag: expected %q but got %q", "junk", got)
|
||||
}
|
||||
}
|
||||
|
||||
func TestNewMessage(t *testing.T) {
|
||||
msg := NewMessage(42, []FetchItem{FetchBodyStructure, FetchFlags})
|
||||
|
||||
expected := &Message{
|
||||
SeqNum: 42,
|
||||
Items: map[FetchItem]interface{}{FetchBodyStructure: nil, FetchFlags: nil},
|
||||
Body: make(map[*BodySectionName]Literal),
|
||||
itemsOrder: []FetchItem{FetchBodyStructure, FetchFlags},
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(expected, msg) {
|
||||
t.Errorf("Invalid message: expected \n%+v\n but got \n%+v", expected, msg)
|
||||
}
|
||||
}
|
||||
|
||||
func formatFields(fields []interface{}) (string, error) {
|
||||
b := &bytes.Buffer{}
|
||||
w := NewWriter(b)
|
||||
|
||||
if err := w.writeList(fields); err != nil {
|
||||
return "", fmt.Errorf("Cannot format \n%+v\n got error: \n%v", fields, err)
|
||||
}
|
||||
|
||||
return b.String(), nil
|
||||
}
|
||||
|
||||
var messageTests = []struct {
|
||||
message *Message
|
||||
fields []interface{}
|
||||
}{
|
||||
{
|
||||
message: &Message{
|
||||
Items: map[FetchItem]interface{}{
|
||||
FetchEnvelope: nil,
|
||||
FetchBody: nil,
|
||||
FetchFlags: nil,
|
||||
FetchRFC822Size: nil,
|
||||
FetchUid: nil,
|
||||
},
|
||||
Body: map[*BodySectionName]Literal{},
|
||||
Envelope: envelopeTests[0].envelope,
|
||||
BodyStructure: bodyStructureTests[0].bodyStructure,
|
||||
Flags: []string{SeenFlag, AnsweredFlag},
|
||||
Size: 4242,
|
||||
Uid: 2424,
|
||||
itemsOrder: []FetchItem{FetchEnvelope, FetchBody, FetchFlags, FetchRFC822Size, FetchUid},
|
||||
},
|
||||
fields: []interface{}{
|
||||
RawString("ENVELOPE"), envelopeTests[0].fields,
|
||||
RawString("BODY"), bodyStructureTests[0].fields,
|
||||
RawString("FLAGS"), []interface{}{RawString(SeenFlag), RawString(AnsweredFlag)},
|
||||
RawString("RFC822.SIZE"), RawString("4242"),
|
||||
RawString("UID"), RawString("2424"),
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func TestMessage_Parse(t *testing.T) {
|
||||
for i, test := range messageTests {
|
||||
m := &Message{}
|
||||
if err := m.Parse(test.fields); err != nil {
|
||||
t.Errorf("Cannot parse message for #%v: %v", i, err)
|
||||
} else if !reflect.DeepEqual(m, test.message) {
|
||||
t.Errorf("Invalid parsed message for #%v: got \n%+v\n but expected \n%+v", i, m, test.message)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestMessage_Format(t *testing.T) {
|
||||
for i, test := range messageTests {
|
||||
fields := test.message.Format()
|
||||
|
||||
got, err := formatFields(fields)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
expected, _ := formatFields(test.fields)
|
||||
|
||||
if got != expected {
|
||||
t.Errorf("Invalid message fields for #%v: got \n%v\n but expected \n%v", i, got, expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var bodySectionNameTests = []struct {
|
||||
raw string
|
||||
parsed *BodySectionName
|
||||
formatted string
|
||||
}{
|
||||
{
|
||||
raw: "BODY[]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{}},
|
||||
},
|
||||
{
|
||||
raw: "RFC822",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{}},
|
||||
formatted: "BODY[]",
|
||||
},
|
||||
{
|
||||
raw: "BODY[HEADER]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Specifier: HeaderSpecifier}},
|
||||
},
|
||||
{
|
||||
raw: "BODY.PEEK[]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{}, Peek: true},
|
||||
},
|
||||
{
|
||||
raw: "BODY[TEXT]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Specifier: TextSpecifier}},
|
||||
},
|
||||
{
|
||||
raw: "RFC822.TEXT",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Specifier: TextSpecifier}},
|
||||
formatted: "BODY[TEXT]",
|
||||
},
|
||||
{
|
||||
raw: "RFC822.HEADER",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Specifier: HeaderSpecifier}, Peek: true},
|
||||
formatted: "BODY.PEEK[HEADER]",
|
||||
},
|
||||
{
|
||||
raw: "BODY[]<0.512>",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{}, Partial: []int{0, 512}},
|
||||
},
|
||||
{
|
||||
raw: "BODY[]<512>",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{}, Partial: []int{512}},
|
||||
},
|
||||
{
|
||||
raw: "BODY[1.2.3]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Path: []int{1, 2, 3}}},
|
||||
},
|
||||
{
|
||||
raw: "BODY[1.2.3.HEADER]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Specifier: HeaderSpecifier, Path: []int{1, 2, 3}}},
|
||||
},
|
||||
{
|
||||
raw: "BODY[5.MIME]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Specifier: MIMESpecifier, Path: []int{5}}},
|
||||
},
|
||||
{
|
||||
raw: "BODY[HEADER.FIELDS (From To)]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Specifier: HeaderSpecifier, Fields: []string{"From", "To"}}},
|
||||
},
|
||||
{
|
||||
raw: "BODY[HEADER.FIELDS.NOT (Content-Id)]",
|
||||
parsed: &BodySectionName{BodyPartName: BodyPartName{Specifier: HeaderSpecifier, Fields: []string{"Content-Id"}, NotFields: true}},
|
||||
},
|
||||
}
|
||||
|
||||
func TestNewBodySectionName(t *testing.T) {
|
||||
for i, test := range bodySectionNameTests {
|
||||
bsn, err := ParseBodySectionName(FetchItem(test.raw))
|
||||
if err != nil {
|
||||
t.Errorf("Cannot parse #%v: %v", i, err)
|
||||
continue
|
||||
}
|
||||
|
||||
if !reflect.DeepEqual(bsn.BodyPartName, test.parsed.BodyPartName) {
|
||||
t.Errorf("Invalid body part name for #%v: %#+v", i, bsn.BodyPartName)
|
||||
} else if bsn.Peek != test.parsed.Peek {
|
||||
t.Errorf("Invalid peek value for #%v: %#+v", i, bsn.Peek)
|
||||
} else if !reflect.DeepEqual(bsn.Partial, test.parsed.Partial) {
|
||||
t.Errorf("Invalid partial for #%v: %#+v", i, bsn.Partial)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBodySectionName_String(t *testing.T) {
|
||||
for i, test := range bodySectionNameTests {
|
||||
s := string(test.parsed.FetchItem())
|
||||
|
||||
expected := test.formatted
|
||||
if expected == "" {
|
||||
expected = test.raw
|
||||
}
|
||||
|
||||
if expected != s {
|
||||
t.Errorf("Invalid body section name for #%v: got %v but expected %v", i, s, expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBodySectionName_ExtractPartial(t *testing.T) {
|
||||
tests := []struct {
|
||||
bsn string
|
||||
whole string
|
||||
partial string
|
||||
}{
|
||||
{
|
||||
bsn: "BODY[]",
|
||||
whole: "Hello World!",
|
||||
partial: "Hello World!",
|
||||
},
|
||||
{
|
||||
bsn: "BODY[]<6.5>",
|
||||
whole: "Hello World!",
|
||||
partial: "World",
|
||||
},
|
||||
{
|
||||
bsn: "BODY[]<6.1000>",
|
||||
whole: "Hello World!",
|
||||
partial: "World!",
|
||||
},
|
||||
{
|
||||
bsn: "BODY[]<0.1>",
|
||||
whole: "Hello World!",
|
||||
partial: "H",
|
||||
},
|
||||
{
|
||||
bsn: "BODY[]<1000.2000>",
|
||||
whole: "Hello World!",
|
||||
partial: "",
|
||||
},
|
||||
}
|
||||
|
||||
for i, test := range tests {
|
||||
bsn, err := ParseBodySectionName(FetchItem(test.bsn))
|
||||
if err != nil {
|
||||
t.Errorf("Cannot parse body section name #%v: %v", i, err)
|
||||
continue
|
||||
}
|
||||
|
||||
partial := string(bsn.ExtractPartial([]byte(test.whole)))
|
||||
if partial != test.partial {
|
||||
t.Errorf("Invalid partial for #%v: got %v but expected %v", i, partial, test.partial)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var t = time.Date(2009, time.November, 10, 23, 0, 0, 0, time.FixedZone("", -6*60*60))
|
||||
|
||||
var envelopeTests = []struct {
|
||||
envelope *Envelope
|
||||
fields []interface{}
|
||||
}{
|
||||
{
|
||||
envelope: &Envelope{
|
||||
Date: t,
|
||||
Subject: "Hello World!",
|
||||
From: []*Address{addrTests[0].addr},
|
||||
Sender: nil,
|
||||
ReplyTo: nil,
|
||||
To: nil,
|
||||
Cc: nil,
|
||||
Bcc: nil,
|
||||
InReplyTo: "42@example.org",
|
||||
MessageId: "43@example.org",
|
||||
},
|
||||
fields: []interface{}{
|
||||
"Tue, 10 Nov 2009 23:00:00 -0600",
|
||||
"Hello World!",
|
||||
[]interface{}{addrTests[0].fields},
|
||||
nil,
|
||||
nil,
|
||||
nil,
|
||||
nil,
|
||||
nil,
|
||||
"42@example.org",
|
||||
"43@example.org",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func TestEnvelope_Parse(t *testing.T) {
|
||||
for i, test := range envelopeTests {
|
||||
e := &Envelope{}
|
||||
if err := e.Parse(test.fields); err != nil {
|
||||
t.Error("Error parsing envelope:", err)
|
||||
} else if !reflect.DeepEqual(e, test.envelope) {
|
||||
t.Errorf("Invalid envelope for #%v: got %v but expected %v", i, e, test.envelope)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnvelope_Parse_literal(t *testing.T) {
|
||||
subject := "Hello World!"
|
||||
l := bytes.NewBufferString(subject)
|
||||
fields := []interface{}{
|
||||
"Tue, 10 Nov 2009 23:00:00 -0600",
|
||||
l,
|
||||
nil,
|
||||
nil,
|
||||
nil,
|
||||
nil,
|
||||
nil,
|
||||
nil,
|
||||
"42@example.org",
|
||||
"43@example.org",
|
||||
}
|
||||
|
||||
e := &Envelope{}
|
||||
if err := e.Parse(fields); err != nil {
|
||||
t.Error("Error parsing envelope:", err)
|
||||
} else if e.Subject != subject {
|
||||
t.Errorf("Invalid envelope subject: got %v but expected %v", e.Subject, subject)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEnvelope_Format(t *testing.T) {
|
||||
for i, test := range envelopeTests {
|
||||
fields := test.envelope.Format()
|
||||
|
||||
got, err := formatFields(fields)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
expected, _ := formatFields(test.fields)
|
||||
|
||||
if got != expected {
|
||||
t.Errorf("Invalid envelope fields for #%v: got %v but expected %v", i, got, expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var addrTests = []struct {
|
||||
fields []interface{}
|
||||
addr *Address
|
||||
}{
|
||||
{
|
||||
fields: []interface{}{"The NSA", nil, "root", "nsa.gov"},
|
||||
addr: &Address{
|
||||
PersonalName: "The NSA",
|
||||
MailboxName: "root",
|
||||
HostName: "nsa.gov",
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func TestAddress_Parse(t *testing.T) {
|
||||
for i, test := range addrTests {
|
||||
addr := &Address{}
|
||||
|
||||
if err := addr.Parse(test.fields); err != nil {
|
||||
t.Error("Error parsing address:", err)
|
||||
} else if !reflect.DeepEqual(addr, test.addr) {
|
||||
t.Errorf("Invalid address for #%v: got %v but expected %v", i, addr, test.addr)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddress_Format(t *testing.T) {
|
||||
for i, test := range addrTests {
|
||||
fields := test.addr.Format()
|
||||
if !reflect.DeepEqual(fields, test.fields) {
|
||||
t.Errorf("Invalid address fields for #%v: got %v but expected %v", i, fields, test.fields)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmptyAddress(t *testing.T) {
|
||||
fields := []interface{}{nil, nil, nil, nil}
|
||||
addr := &Address{}
|
||||
err := addr.Parse(fields)
|
||||
if err == nil {
|
||||
t.Error("A nil address did not return an error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmptyGroupAddress(t *testing.T) {
|
||||
fields := []interface{}{nil, nil, "undisclosed-recipients", nil}
|
||||
addr := &Address{}
|
||||
err := addr.Parse(fields)
|
||||
if err == nil {
|
||||
t.Error("An empty group did not return an error when parsed as address")
|
||||
}
|
||||
}
|
||||
|
||||
func TestAddressList(t *testing.T) {
|
||||
fields := make([]interface{}, len(addrTests))
|
||||
addrs := make([]*Address, len(addrTests))
|
||||
for i, test := range addrTests {
|
||||
fields[i] = test.fields
|
||||
addrs[i] = test.addr
|
||||
}
|
||||
|
||||
gotAddrs := ParseAddressList(fields)
|
||||
if !reflect.DeepEqual(gotAddrs, addrs) {
|
||||
t.Error("Invalid address list: got", gotAddrs, "but expected", addrs)
|
||||
}
|
||||
|
||||
gotFields := FormatAddressList(addrs)
|
||||
if !reflect.DeepEqual(gotFields, fields) {
|
||||
t.Error("Invalid address list fields: got", gotFields, "but expected", fields)
|
||||
}
|
||||
}
|
||||
|
||||
func TestEmptyAddressList(t *testing.T) {
|
||||
addrs := make([]*Address, 0)
|
||||
|
||||
gotFields := FormatAddressList(addrs)
|
||||
if !reflect.DeepEqual(gotFields, nil) {
|
||||
t.Error("Invalid address list fields: got", gotFields, "but expected nil")
|
||||
}
|
||||
}
|
||||
|
||||
var paramsListTest = []struct {
|
||||
fields []interface{}
|
||||
params map[string]string
|
||||
}{
|
||||
{
|
||||
fields: nil,
|
||||
params: map[string]string{},
|
||||
},
|
||||
{
|
||||
fields: []interface{}{"a", "b"},
|
||||
params: map[string]string{"a": "b"},
|
||||
},
|
||||
}
|
||||
|
||||
func TestParseParamList(t *testing.T) {
|
||||
for i, test := range paramsListTest {
|
||||
if params, err := ParseParamList(test.fields); err != nil {
|
||||
t.Errorf("Cannot parse params fields for #%v: %v", i, err)
|
||||
} else if !reflect.DeepEqual(params, test.params) {
|
||||
t.Errorf("Invalid params for #%v: got %v but expected %v", i, params, test.params)
|
||||
}
|
||||
}
|
||||
|
||||
// Malformed params lists
|
||||
|
||||
fields := []interface{}{"cc", []interface{}{"dille"}}
|
||||
if params, err := ParseParamList(fields); err == nil {
|
||||
t.Error("Parsed invalid params list:", params)
|
||||
}
|
||||
|
||||
fields = []interface{}{"cc"}
|
||||
if params, err := ParseParamList(fields); err == nil {
|
||||
t.Error("Parsed invalid params list:", params)
|
||||
}
|
||||
}
|
||||
|
||||
func TestFormatParamList(t *testing.T) {
|
||||
for i, test := range paramsListTest {
|
||||
fields := FormatParamList(test.params)
|
||||
|
||||
if !reflect.DeepEqual(fields, test.fields) {
|
||||
t.Errorf("Invalid params fields for #%v: got %v but expected %v", i, fields, test.fields)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
var bodyStructureTests = []struct {
|
||||
fields []interface{}
|
||||
bodyStructure *BodyStructure
|
||||
}{
|
||||
{
|
||||
fields: []interface{}{"image", "jpeg", []interface{}{}, "<foo4%25foo1@bar.net>", "A picture of cat", "base64", RawString("4242")},
|
||||
bodyStructure: &BodyStructure{
|
||||
MIMEType: "image",
|
||||
MIMESubType: "jpeg",
|
||||
Params: map[string]string{},
|
||||
Id: "<foo4%25foo1@bar.net>",
|
||||
Description: "A picture of cat",
|
||||
Encoding: "base64",
|
||||
Size: 4242,
|
||||
},
|
||||
},
|
||||
{
|
||||
fields: []interface{}{"text", "plain", []interface{}{"charset", "utf-8"}, nil, nil, "us-ascii", RawString("42"), RawString("2")},
|
||||
bodyStructure: &BodyStructure{
|
||||
MIMEType: "text",
|
||||
MIMESubType: "plain",
|
||||
Params: map[string]string{"charset": "utf-8"},
|
||||
Encoding: "us-ascii",
|
||||
Size: 42,
|
||||
Lines: 2,
|
||||
},
|
||||
},
|
||||
{
|
||||
fields: []interface{}{
|
||||
"message", "rfc822", []interface{}{}, nil, nil, "us-ascii", RawString("42"),
|
||||
(&Envelope{}).Format(),
|
||||
(&BodyStructure{}).Format(),
|
||||
RawString("67"),
|
||||
},
|
||||
bodyStructure: &BodyStructure{
|
||||
MIMEType: "message",
|
||||
MIMESubType: "rfc822",
|
||||
Params: map[string]string{},
|
||||
Encoding: "us-ascii",
|
||||
Size: 42,
|
||||
Lines: 67,
|
||||
Envelope: &Envelope{
|
||||
From: nil,
|
||||
Sender: nil,
|
||||
ReplyTo: nil,
|
||||
To: nil,
|
||||
Cc: nil,
|
||||
Bcc: nil,
|
||||
},
|
||||
BodyStructure: &BodyStructure{
|
||||
Params: map[string]string{},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
fields: []interface{}{
|
||||
"application", "pdf", []interface{}{}, nil, nil, "base64", RawString("4242"),
|
||||
"e0323a9039add2978bf5b49550572c7c",
|
||||
[]interface{}{"attachment", []interface{}{"filename", "document.pdf"}},
|
||||
[]interface{}{"en-US"}, []interface{}{},
|
||||
},
|
||||
bodyStructure: &BodyStructure{
|
||||
MIMEType: "application",
|
||||
MIMESubType: "pdf",
|
||||
Params: map[string]string{},
|
||||
Encoding: "base64",
|
||||
Size: 4242,
|
||||
Extended: true,
|
||||
MD5: "e0323a9039add2978bf5b49550572c7c",
|
||||
Disposition: "attachment",
|
||||
DispositionParams: map[string]string{"filename": "document.pdf"},
|
||||
Language: []string{"en-US"},
|
||||
Location: []string{},
|
||||
},
|
||||
},
|
||||
{
|
||||
fields: []interface{}{
|
||||
[]interface{}{"text", "plain", []interface{}{}, nil, nil, "us-ascii", RawString("87"), RawString("22")},
|
||||
[]interface{}{"text", "html", []interface{}{}, nil, nil, "us-ascii", RawString("106"), RawString("36")},
|
||||
"alternative",
|
||||
},
|
||||
bodyStructure: &BodyStructure{
|
||||
MIMEType: "multipart",
|
||||
MIMESubType: "alternative",
|
||||
Params: map[string]string{},
|
||||
Parts: []*BodyStructure{
|
||||
{
|
||||
MIMEType: "text",
|
||||
MIMESubType: "plain",
|
||||
Params: map[string]string{},
|
||||
Encoding: "us-ascii",
|
||||
Size: 87,
|
||||
Lines: 22,
|
||||
},
|
||||
{
|
||||
MIMEType: "text",
|
||||
MIMESubType: "html",
|
||||
Params: map[string]string{},
|
||||
Encoding: "us-ascii",
|
||||
Size: 106,
|
||||
Lines: 36,
|
||||
},
|
||||
},
|
||||
},
|
||||
},
|
||||
{
|
||||
fields: []interface{}{
|
||||
[]interface{}{"text", "plain", []interface{}{}, nil, nil, "us-ascii", RawString("87"), RawString("22")},
|
||||
"alternative", []interface{}{"hello", "world"},
|
||||
[]interface{}{"inline", []interface{}{}},
|
||||
[]interface{}{"en-US"}, []interface{}{},
|
||||
},
|
||||
bodyStructure: &BodyStructure{
|
||||
MIMEType: "multipart",
|
||||
MIMESubType: "alternative",
|
||||
Params: map[string]string{"hello": "world"},
|
||||
Parts: []*BodyStructure{
|
||||
{
|
||||
MIMEType: "text",
|
||||
MIMESubType: "plain",
|
||||
Params: map[string]string{},
|
||||
Encoding: "us-ascii",
|
||||
Size: 87,
|
||||
Lines: 22,
|
||||
},
|
||||
},
|
||||
Extended: true,
|
||||
Disposition: "inline",
|
||||
DispositionParams: map[string]string{},
|
||||
Language: []string{"en-US"},
|
||||
Location: []string{},
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
func TestBodyStructure_Parse(t *testing.T) {
|
||||
for i, test := range bodyStructureTests {
|
||||
bs := &BodyStructure{}
|
||||
|
||||
if err := bs.Parse(test.fields); err != nil {
|
||||
t.Errorf("Cannot parse #%v: %v", i, err)
|
||||
} else if !reflect.DeepEqual(bs, test.bodyStructure) {
|
||||
t.Errorf("Invalid body structure for #%v: got \n%+v\n but expected \n%+v", i, bs, test.bodyStructure)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBodyStructure_Parse_uppercase(t *testing.T) {
|
||||
fields := []interface{}{
|
||||
"APPLICATION", "PDF", []interface{}{"NAME", "Document.pdf"}, nil, nil,
|
||||
"BASE64", RawString("4242"), nil,
|
||||
[]interface{}{"ATTACHMENT", []interface{}{"FILENAME", "Document.pdf"}},
|
||||
nil, nil,
|
||||
}
|
||||
|
||||
expected := &BodyStructure{
|
||||
MIMEType: "application",
|
||||
MIMESubType: "pdf",
|
||||
Params: map[string]string{"name": "Document.pdf"},
|
||||
Encoding: "base64",
|
||||
Size: 4242,
|
||||
Extended: true,
|
||||
MD5: "",
|
||||
Disposition: "attachment",
|
||||
DispositionParams: map[string]string{"filename": "Document.pdf"},
|
||||
Language: nil,
|
||||
Location: []string{},
|
||||
}
|
||||
|
||||
bs := &BodyStructure{}
|
||||
if err := bs.Parse(fields); err != nil {
|
||||
t.Errorf("Cannot parse: %v", err)
|
||||
} else if !reflect.DeepEqual(bs, expected) {
|
||||
t.Errorf("Invalid body structure: got \n%+v\n but expected \n%+v", bs, expected)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBodyStructure_Format(t *testing.T) {
|
||||
for i, test := range bodyStructureTests {
|
||||
fields := test.bodyStructure.Format()
|
||||
got, err := formatFields(fields)
|
||||
if err != nil {
|
||||
t.Error(err)
|
||||
continue
|
||||
}
|
||||
|
||||
expected, _ := formatFields(test.fields)
|
||||
|
||||
if got != expected {
|
||||
t.Errorf("Invalid body structure fields for #%v: has \n%v\n but expected \n%v", i, got, expected)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBodyStructureFilename(t *testing.T) {
|
||||
tests := []struct {
|
||||
bs BodyStructure
|
||||
filename string
|
||||
}{
|
||||
{
|
||||
bs: BodyStructure{
|
||||
DispositionParams: map[string]string{"filename": "cat.png"},
|
||||
},
|
||||
filename: "cat.png",
|
||||
},
|
||||
{
|
||||
bs: BodyStructure{
|
||||
Params: map[string]string{"name": "cat.png"},
|
||||
},
|
||||
filename: "cat.png",
|
||||
},
|
||||
{
|
||||
bs: BodyStructure{},
|
||||
filename: "",
|
||||
},
|
||||
{
|
||||
bs: BodyStructure{
|
||||
DispositionParams: map[string]string{"filename": "=?UTF-8?Q?Opis_przedmiotu_zam=c3=b3wienia_-_za=c5=82=c4=85cznik_nr_1?= =?UTF-8?Q?=2epdf?="},
|
||||
},
|
||||
filename: "Opis przedmiotu zamówienia - załącznik nr 1.pdf",
|
||||
},
|
||||
}
|
||||
|
||||
for i, test := range tests {
|
||||
got, err := test.bs.Filename()
|
||||
if err != nil {
|
||||
t.Errorf("Invalid body structure filename for #%v: error: %v", i, err)
|
||||
continue
|
||||
}
|
||||
|
||||
if got != test.filename {
|
||||
t.Errorf("Invalid body structure filename for #%v: got '%v', want '%v'", i, got, test.filename)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestBodyStructureWalk(t *testing.T) {
|
||||
textPlain := &BodyStructure{
|
||||
MIMEType: "text",
|
||||
MIMESubType: "plain",
|
||||
}
|
||||
|
||||
textHTML := &BodyStructure{
|
||||
MIMEType: "text",
|
||||
MIMESubType: "plain",
|
||||
}
|
||||
|
||||
multipartAlternative := &BodyStructure{
|
||||
MIMEType: "multipart",
|
||||
MIMESubType: "alternative",
|
||||
Parts: []*BodyStructure{textPlain, textHTML},
|
||||
}
|
||||
|
||||
imagePNG := &BodyStructure{
|
||||
MIMEType: "image",
|
||||
MIMESubType: "png",
|
||||
}
|
||||
|
||||
multipartMixed := &BodyStructure{
|
||||
MIMEType: "multipart",
|
||||
MIMESubType: "mixed",
|
||||
Parts: []*BodyStructure{multipartAlternative, imagePNG},
|
||||
}
|
||||
|
||||
type testNode struct {
|
||||
path []int
|
||||
part *BodyStructure
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
bs *BodyStructure
|
||||
nodes []testNode
|
||||
walkChildren bool
|
||||
}{
|
||||
{
|
||||
bs: textPlain,
|
||||
nodes: []testNode{
|
||||
{path: []int{1}, part: textPlain},
|
||||
},
|
||||
},
|
||||
{
|
||||
bs: multipartAlternative,
|
||||
nodes: []testNode{
|
||||
{path: nil, part: multipartAlternative},
|
||||
{path: []int{1}, part: textPlain},
|
||||
{path: []int{2}, part: textHTML},
|
||||
},
|
||||
walkChildren: true,
|
||||
},
|
||||
{
|
||||
bs: multipartMixed,
|
||||
nodes: []testNode{
|
||||
{path: nil, part: multipartMixed},
|
||||
{path: []int{1}, part: multipartAlternative},
|
||||
{path: []int{1, 1}, part: textPlain},
|
||||
{path: []int{1, 2}, part: textHTML},
|
||||
{path: []int{2}, part: imagePNG},
|
||||
},
|
||||
walkChildren: true,
|
||||
},
|
||||
{
|
||||
bs: multipartMixed,
|
||||
nodes: []testNode{
|
||||
{path: nil, part: multipartMixed},
|
||||
},
|
||||
walkChildren: false,
|
||||
},
|
||||
}
|
||||
|
||||
for i, test := range tests {
|
||||
j := 0
|
||||
test.bs.Walk(func(path []int, part *BodyStructure) bool {
|
||||
if j >= len(test.nodes) {
|
||||
t.Errorf("Test #%v: invalid node count: got > %v, want %v", i, j, len(test.nodes))
|
||||
return false
|
||||
}
|
||||
n := &test.nodes[j]
|
||||
if !reflect.DeepEqual(path, n.path) {
|
||||
t.Errorf("Test #%v: node #%v: invalid path: got %v, want %v", i, j, path, n.path)
|
||||
}
|
||||
if part != n.part {
|
||||
t.Errorf("Test #%v: node #%v: invalid part: got %v, want %v", i, j, part, n.part)
|
||||
}
|
||||
j++
|
||||
return test.walkChildren
|
||||
})
|
||||
if j != len(test.nodes) {
|
||||
t.Errorf("Test #%v: invalid node count: got %v, want %v", i, j, len(test.nodes))
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user