264 lines
11 KiB
Java
264 lines
11 KiB
Java
/*
|
|
* Copyright (C) 2014 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.email;
|
|
|
|
import android.content.Context;
|
|
import android.test.AndroidTestCase;
|
|
import android.test.suitebuilder.annotation.SmallTest;
|
|
|
|
import com.android.emailcommon.TempDirectory;
|
|
import com.android.emailcommon.internet.MimeBodyPart;
|
|
import com.android.emailcommon.internet.MimeMessage;
|
|
import com.android.emailcommon.internet.MimeMultipart;
|
|
import com.android.emailcommon.mail.Address;
|
|
import com.android.emailcommon.mail.Message.RecipientType;
|
|
import com.android.emailcommon.mail.MessagingException;
|
|
import com.android.emailcommon.mail.Multipart;
|
|
import com.android.emailcommon.mail.Part;
|
|
import com.android.emailcommon.provider.EmailContent;
|
|
import com.android.emailcommon.provider.EmailContent.Attachment;
|
|
import com.android.emailcommon.utility.ConversionUtilities;
|
|
import com.android.emailcommon.utility.ConversionUtilities.BodyFieldData;
|
|
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.FileOutputStream;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Date;
|
|
|
|
@SmallTest
|
|
public class LegacyConversionsTest extends AndroidTestCase {
|
|
|
|
@Override
|
|
protected void setUp() throws Exception {
|
|
super.setUp();
|
|
TempDirectory.setTempDirectory(getContext());
|
|
}
|
|
|
|
/**
|
|
* Test basic fields conversion from Store message to Provider message.
|
|
*/
|
|
public void testUpdateMessageFields_Basic() throws MessagingException {
|
|
final MimeMessage message = new MimeMessage();
|
|
message.setUid("UID.12345678");
|
|
message.setSentDate(new Date(1));
|
|
message.setMessageId("Test-Message-ID");
|
|
message.setSubject("This is the subject");
|
|
|
|
final EmailContent.Message localMessage = new EmailContent.Message();
|
|
final boolean result = LegacyConversions.updateMessageFields(localMessage, message, 1, 1);
|
|
assertTrue(result);
|
|
|
|
assertEquals(message.getUid(), localMessage.mServerId);
|
|
assertEquals(message.getSubject(), localMessage.mSubject);
|
|
assertEquals(message.getMessageId(), localMessage.mMessageId);
|
|
assertEquals(message.getSentDate().getTime(), localMessage.mTimeStamp);
|
|
}
|
|
|
|
/**
|
|
* Test the conversion of plain ASCII (not MIME-encoded) email addresses.
|
|
*/
|
|
public void testUpdateMessageFields_PlainAddresses() throws MessagingException {
|
|
// create plain ASCII email addresses
|
|
final String fromList = "Sender <sender@droid.com>";
|
|
final String replyToList = "Reply1 <reply1@droid.com>,Reply2 <reply2@droid.com>";
|
|
final String toList = "ToA <toA@droid.com>,ToB <toB@droid.com>";
|
|
final String ccList = "CcA <ccA@droid.com>,CcB <ccB@droid.com>";
|
|
final String bccList = "BccA <bccA@droid.com>,Bcc2 <bccB@droid.com>";
|
|
|
|
// parse the addresses
|
|
final Address from = Address.fromHeader(fromList)[0];
|
|
final Address[] replies = Address.fromHeader(replyToList);
|
|
final Address[] tos = Address.fromHeader(toList);
|
|
final Address[] ccs = Address.fromHeader(ccList);
|
|
final Address[] bccs = Address.fromHeader(bccList);
|
|
|
|
// make a message with the email addresses
|
|
final MimeMessage message = new MimeMessage();
|
|
message.setFrom(from);
|
|
message.setReplyTo(replies);
|
|
message.setRecipients(RecipientType.TO, tos);
|
|
message.setRecipients(RecipientType.CC, ccs);
|
|
message.setRecipients(RecipientType.BCC, bccs);
|
|
|
|
// convert the message to a local message using the conversation method
|
|
final EmailContent.Message localMessage = new EmailContent.Message();
|
|
final boolean result = LegacyConversions.updateMessageFields(localMessage, message, 1, 1);
|
|
assertTrue(result);
|
|
|
|
// verify that we will store the email addresses in decoded form
|
|
assertEquals(fromList, localMessage.mFrom);
|
|
assertEquals(replyToList, localMessage.mReplyTo);
|
|
assertEquals(toList, localMessage.mTo);
|
|
assertEquals(ccList, localMessage.mCc);
|
|
assertEquals(bccList, localMessage.mBcc);
|
|
}
|
|
|
|
/**
|
|
* Test the conversion of MIME-encoded non-ASCII email addresses.
|
|
*/
|
|
public void testUpdateMessageFields_EncodedAddresses() throws MessagingException {
|
|
final String e = "=?EUC-KR?B?uvG50Ln4yKO4pg==?="; // Mime Encoded value of 비밀번호를
|
|
final String d = "\uBE44\uBC00\uBC88\uD638\uB97C"; // Mime Decoded value of e
|
|
|
|
// create the email address in encoded form
|
|
String fromList = String.format("%s <sender@droid.com>", e);
|
|
String replyToList = String.format("%s <reply1@droid.com>,%s <reply2@droid.com>", e, e);
|
|
String toList = String.format("%s <toA@droid.com>,%s <toB@droid.com>", e, e);
|
|
String ccList = String.format("%s <ccA@droid.com>,%s <ccB@droid.com>", e, e);
|
|
String bccList = String.format("%s <bccA@droid.com>,%s <bccB@droid.com>", e, e);
|
|
|
|
// parse the encoded addresses
|
|
final Address from = Address.fromHeader(fromList)[0];
|
|
final Address[] replies = Address.fromHeader(replyToList);
|
|
final Address[] tos = Address.fromHeader(toList);
|
|
final Address[] ccs = Address.fromHeader(ccList);
|
|
final Address[] bccs = Address.fromHeader(bccList);
|
|
|
|
// make a message with the email addresses
|
|
final MimeMessage message = new MimeMessage();
|
|
message.setFrom(from);
|
|
message.setReplyTo(replies);
|
|
message.setRecipients(RecipientType.TO, tos);
|
|
message.setRecipients(RecipientType.CC, ccs);
|
|
message.setRecipients(RecipientType.BCC, bccs);
|
|
|
|
// convert the message to a local message using the conversion method
|
|
final EmailContent.Message localMessage = new EmailContent.Message();
|
|
final boolean result = LegacyConversions.updateMessageFields(localMessage, message, 1, 1);
|
|
assertTrue(result);
|
|
|
|
// verify that we will store the email addresses in decoded form
|
|
String decodedFrom = String.format("%s <sender@droid.com>", d);
|
|
String decodedReply = String.format("%s <reply1@droid.com>,%s <reply2@droid.com>", d, d);
|
|
String decodedTo = String.format("%s <toA@droid.com>,%s <toB@droid.com>", d, d);
|
|
String decodedCc = String.format("%s <ccA@droid.com>,%s <ccB@droid.com>", d, d);
|
|
String decodedBcc = String.format("%s <bccA@droid.com>,%s <bccB@droid.com>", d, d);
|
|
|
|
assertEquals(decodedFrom, localMessage.mFrom);
|
|
assertEquals(decodedReply, localMessage.mReplyTo);
|
|
assertEquals(decodedTo, localMessage.mTo);
|
|
assertEquals(decodedCc, localMessage.mCc);
|
|
assertEquals(decodedBcc, localMessage.mBcc);
|
|
}
|
|
|
|
/**
|
|
* Test basic conversion from Store message to Provider message, when the provider message
|
|
* does not have a proper message-id.
|
|
*/
|
|
public void testUpdateMessageFields_NoMessageId() throws MessagingException {
|
|
final MimeMessage message = new MimeMessage();
|
|
// set, then remove the message id
|
|
message.setMessageId("Test-Message-ID");
|
|
message.removeHeader("Message-ID");
|
|
|
|
// create a local message with an ID
|
|
final EmailContent.Message localMessage = new EmailContent.Message();
|
|
localMessage.mMessageId = "Test-Message-ID-Second";
|
|
|
|
final boolean result = LegacyConversions.updateMessageFields(localMessage, message, 1, 1);
|
|
assertTrue(result);
|
|
assertEquals("Test-Message-ID-Second", localMessage.mMessageId);
|
|
}
|
|
|
|
/**
|
|
* Basic test of body parts conversion from Store message to Provider message.
|
|
* This tests that a null body part simply results in null text, and does not crash
|
|
* or return "null".
|
|
*/
|
|
public void testUpdateBodyFieldsNullText() throws MessagingException {
|
|
ArrayList<Part> viewables = new ArrayList<Part>();
|
|
viewables.add(new MimeBodyPart(null, "text/plain"));
|
|
|
|
// a "null" body part of type text/plain should result in a null mTextContent
|
|
final BodyFieldData data = ConversionUtilities.parseBodyFields(viewables);
|
|
assertNull(data.textContent);
|
|
}
|
|
|
|
/**
|
|
* Test adding an attachment to a message, and then parsing it back out.
|
|
* @throws MessagingException
|
|
*/
|
|
public void testAttachmentRoundTrip() throws Exception {
|
|
final Context context = getContext();
|
|
final MimeMultipart mp = new MimeMultipart();
|
|
mp.setSubType("mixed");
|
|
|
|
final long size;
|
|
|
|
final File tempDir = context.getCacheDir();
|
|
if (!tempDir.isDirectory() && !tempDir.mkdirs()) {
|
|
fail("Could not create temporary directory");
|
|
}
|
|
|
|
final File tempAttachmentFile = File.createTempFile("testAttachmentRoundTrip", ".txt",
|
|
tempDir);
|
|
|
|
try {
|
|
final OutputStream attOut = new FileOutputStream(tempAttachmentFile);
|
|
try {
|
|
attOut.write("TestData".getBytes());
|
|
} finally {
|
|
attOut.close();
|
|
}
|
|
size = tempAttachmentFile.length();
|
|
final InputStream attIn = new FileInputStream(tempAttachmentFile);
|
|
LegacyConversions.addAttachmentPart(mp, "text/plain", size, "test.txt",
|
|
"testContentId", attIn);
|
|
} finally {
|
|
if (!tempAttachmentFile.delete()) {
|
|
fail("Setup failure: Could not clean up temp file");
|
|
}
|
|
}
|
|
|
|
final MimeMessage outMessage = new MimeMessage();
|
|
outMessage.setBody(mp);
|
|
|
|
final MimeMessage inMessage;
|
|
|
|
final File tempBodyFile = File.createTempFile("testAttachmentRoundTrip", ".eml",
|
|
context.getCacheDir());
|
|
try {
|
|
final OutputStream bodyOut = new FileOutputStream(tempBodyFile);
|
|
try {
|
|
outMessage.writeTo(bodyOut);
|
|
} finally {
|
|
bodyOut.close();
|
|
}
|
|
final InputStream bodyIn = new FileInputStream(tempBodyFile);
|
|
try {
|
|
inMessage = new MimeMessage(bodyIn);
|
|
} finally {
|
|
bodyIn.close();
|
|
}
|
|
} finally {
|
|
if (!tempBodyFile.delete()) {
|
|
fail("Setup failure: Could not clean up temp file");
|
|
}
|
|
}
|
|
final Multipart inBody = (Multipart) inMessage.getBody();
|
|
final Part attPart = inBody.getBodyPart(0);
|
|
final Attachment att = LegacyConversions.mimePartToAttachment(attPart);
|
|
assertEquals(att.mFileName, "test.txt");
|
|
assertEquals(att.mMimeType, "text/plain");
|
|
assertEquals(att.mSize, size);
|
|
assertEquals(att.mContentId, "testContentId");
|
|
}
|
|
}
|