1 /* 2 * Copyright (C) 2009 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.email.provider; 18 19 import com.android.emailcommon.internet.Rfc822Output; 20 import com.android.emailcommon.provider.Account; 21 import com.android.emailcommon.provider.EmailContent; 22 import com.android.emailcommon.provider.EmailContent.Attachment; 23 import com.android.emailcommon.provider.EmailContent.Body; 24 import com.android.emailcommon.provider.EmailContent.Message; 25 import com.android.emailcommon.provider.HostAuth; 26 import com.android.emailcommon.provider.Mailbox; 27 import com.android.emailcommon.utility.Utility; 28 29 import android.content.ContentUris; 30 import android.content.Context; 31 import android.net.Uri; 32 import android.test.MoreAsserts; 33 34 import java.io.File; 35 import java.io.FileOutputStream; 36 37 import junit.framework.Assert; 38 39 public class ProviderTestUtils extends Assert { 40 41 /** 42 * No constructor - statics only 43 */ ProviderTestUtils()44 private ProviderTestUtils() { 45 } 46 47 /** 48 * Create an account for test purposes 49 */ setupAccount(String name, boolean saveIt, Context context)50 public static Account setupAccount(String name, boolean saveIt, Context context) { 51 Account account = new Account(); 52 53 account.mDisplayName = name; 54 account.mEmailAddress = name + "@android.com"; 55 account.mSyncKey = "sync-key-" + name; 56 account.mSyncLookback = 1; 57 account.mSyncInterval = Account.CHECK_INTERVAL_NEVER; 58 account.mHostAuthKeyRecv = 0; 59 account.mHostAuthKeySend = 0; 60 account.mFlags = 4; 61 account.mIsDefault = true; 62 account.mCompatibilityUuid = "test-uid-" + name; 63 account.mSenderName = name; 64 account.mRingtoneUri = "content://ringtone-" + name; 65 account.mProtocolVersion = "2.5" + name; 66 account.mNewMessageCount = 5 + name.length(); 67 account.mPolicyKey = 0; 68 account.mSecuritySyncKey = "sec-sync-key-" + name; 69 account.mSignature = "signature-" + name; 70 if (saveIt) { 71 account.save(context); 72 } 73 return account; 74 } 75 76 /** 77 * Lightweight way of deleting an account for testing. 78 */ deleteAccount(Context context, long accountId)79 public static void deleteAccount(Context context, long accountId) { 80 context.getContentResolver().delete(ContentUris.withAppendedId( 81 Account.CONTENT_URI, accountId), null, null); 82 } 83 84 /** 85 * Create a hostauth record for test purposes 86 */ setupHostAuth(String name, long accountId, boolean saveIt, Context context)87 public static HostAuth setupHostAuth(String name, long accountId, boolean saveIt, 88 Context context) { 89 return setupHostAuth("protocol", name, saveIt, context); 90 } 91 92 /** 93 * Create a hostauth record for test purposes 94 */ setupHostAuth(String protocol, String name, boolean saveIt, Context context)95 public static HostAuth setupHostAuth(String protocol, String name, boolean saveIt, 96 Context context) { 97 HostAuth hostAuth = new HostAuth(); 98 99 hostAuth.mProtocol = protocol; 100 hostAuth.mAddress = "address-" + name; 101 hostAuth.mPort = 100; 102 hostAuth.mFlags = 200; 103 hostAuth.mLogin = "login-" + name; 104 hostAuth.mPassword = "password-" + name; 105 hostAuth.mDomain = "domain-" + name; 106 107 if (saveIt) { 108 hostAuth.save(context); 109 } 110 return hostAuth; 111 } 112 113 /** 114 * Create a mailbox for test purposes 115 */ setupMailbox(String name, long accountId, boolean saveIt, Context context)116 public static Mailbox setupMailbox(String name, long accountId, boolean saveIt, 117 Context context) { 118 return setupMailbox(name, accountId, saveIt, context, Mailbox.TYPE_MAIL); 119 } setupMailbox(String name, long accountId, boolean saveIt, Context context, int type)120 public static Mailbox setupMailbox(String name, long accountId, boolean saveIt, 121 Context context, int type) { 122 return setupMailbox(name, accountId, saveIt, context, type, '/'); 123 } setupMailbox(String name, long accountId, boolean saveIt, Context context, int type, char delimiter)124 public static Mailbox setupMailbox(String name, long accountId, boolean saveIt, 125 Context context, int type, char delimiter) { 126 Mailbox box = new Mailbox(); 127 128 int delimiterIndex = name.lastIndexOf(delimiter); 129 String displayName = name; 130 if (delimiterIndex > 0) { 131 displayName = name.substring(delimiterIndex + 1); 132 } 133 box.mDisplayName = displayName; 134 box.mServerId = name; 135 box.mParentServerId = "parent-serverid-" + name; 136 box.mParentKey = 4; 137 box.mAccountKey = accountId; 138 box.mType = type; 139 box.mDelimiter = delimiter; 140 box.mSyncKey = "sync-key-" + name; 141 box.mSyncLookback = 2; 142 box.mSyncInterval = Account.CHECK_INTERVAL_NEVER; 143 box.mSyncTime = 3; 144 box.mFlagVisible = true; 145 box.mFlags = 5; 146 box.mVisibleLimit = 6; 147 148 if (saveIt) { 149 box.save(context); 150 } 151 return box; 152 } 153 154 /** 155 * Create a message for test purposes 156 */ setupMessage(String name, long accountId, long mailboxId, boolean addBody, boolean saveIt, Context context)157 public static Message setupMessage(String name, long accountId, long mailboxId, 158 boolean addBody, boolean saveIt, Context context) { 159 // Default starred, read, (backword compatibility) 160 return setupMessage(name, accountId, mailboxId, addBody, saveIt, context, true, true); 161 } 162 163 /** 164 * Create a message for test purposes 165 */ setupMessage(String name, long accountId, long mailboxId, boolean addBody, boolean saveIt, Context context, boolean starred, boolean read)166 public static Message setupMessage(String name, long accountId, long mailboxId, 167 boolean addBody, boolean saveIt, Context context, boolean starred, boolean read) { 168 Message message = new Message(); 169 170 message.mDisplayName = name; 171 message.mTimeStamp = 100 + name.length(); 172 message.mSubject = "subject " + name; 173 message.mFlagRead = read; 174 message.mFlagLoaded = Message.FLAG_LOADED_UNLOADED; 175 message.mFlagFavorite = starred; 176 message.mFlagAttachment = true; 177 message.mFlags = 0; 178 179 message.mServerId = "serverid " + name; 180 message.mServerTimeStamp = 300 + name.length(); 181 message.mClientId = "clientid " + name; 182 message.mMessageId = "messageid " + name; 183 184 message.mMailboxKey = mailboxId; 185 message.mAccountKey = accountId; 186 187 message.mFrom = "from " + name; 188 message.mTo = "to " + name; 189 message.mCc = "cc " + name; 190 message.mBcc = "bcc " + name; 191 message.mReplyTo = "replyto " + name; 192 193 message.mMeetingInfo = "123" + accountId + mailboxId + name.length(); 194 195 if (addBody) { 196 message.mText = "body text " + name; 197 message.mHtml = "body html " + name; 198 message.mTextReply = "reply text " + name; 199 message.mHtmlReply = "reply html " + name; 200 message.mSourceKey = 400 + name.length(); 201 message.mIntroText = "intro text " + name; 202 } 203 204 if (saveIt) { 205 message.save(context); 206 } 207 return message; 208 } 209 210 /** 211 * Create a test body 212 * 213 * @param messageId the message this body belongs to 214 * @param textContent the plain text for the body 215 * @param htmlContent the html text for the body 216 * @param saveIt if true, write the new attachment directly to the DB 217 * @param context use this context 218 */ setupBody(long messageId, String textContent, String htmlContent, boolean saveIt, Context context)219 public static Body setupBody(long messageId, String textContent, String htmlContent, 220 boolean saveIt, Context context) { 221 Body body = new Body(); 222 body.mMessageKey = messageId; 223 body.mTextContent = textContent; 224 body.mHtmlContent = htmlContent; 225 body.mTextReply = "text reply " + messageId; 226 body.mHtmlReply = "html reply " + messageId; 227 body.mSourceKey = messageId + 0x1000; 228 body.mIntroText = "intro text " + messageId; 229 if (saveIt) { 230 body.save(context); 231 } 232 return body; 233 } 234 235 /** 236 * Create a test attachment. A few fields are specified by params, and all other fields 237 * are generated using pseudo-unique values. 238 * 239 * @param messageId the message to attach to 240 * @param fileName the "file" to indicate in the attachment 241 * @param length the "length" of the attachment 242 * @param flags the flags to set in the attachment 243 * @param saveIt if true, write the new attachment directly to the DB 244 * @param context use this context 245 */ setupAttachment(long messageId, String fileName, long length, int flags, boolean saveIt, Context context)246 public static Attachment setupAttachment(long messageId, String fileName, long length, 247 int flags, boolean saveIt, Context context) { 248 Attachment att = new Attachment(); 249 att.mSize = length; 250 att.mFileName = fileName; 251 att.mContentId = "contentId " + fileName; 252 att.mContentUri = "contentUri " + fileName; 253 att.mMessageKey = messageId; 254 att.mMimeType = "mimeType " + fileName; 255 att.mLocation = "location " + fileName; 256 att.mEncoding = "encoding " + fileName; 257 att.mContent = "content " + fileName; 258 att.mFlags = flags; 259 att.mContentBytes = Utility.toUtf8("content " + fileName); 260 att.mAccountKey = messageId + 0x1000; 261 if (saveIt) { 262 att.save(context); 263 } 264 return att; 265 } 266 267 /** 268 * Create a test attachment with flags = 0 (see above) 269 * 270 * @param messageId the message to attach to 271 * @param fileName the "file" to indicate in the attachment 272 * @param length the "length" of the attachment 273 * @param saveIt if true, write the new attachment directly to the DB 274 * @param context use this context 275 */ setupAttachment(long messageId, String fileName, long length, boolean saveIt, Context context)276 public static Attachment setupAttachment(long messageId, String fileName, long length, 277 boolean saveIt, Context context) { 278 return setupAttachment(messageId, fileName, length, 0, saveIt, context); 279 } 280 assertEmailContentEqual(String caller, EmailContent expect, EmailContent actual)281 private static void assertEmailContentEqual(String caller, EmailContent expect, 282 EmailContent actual) { 283 if (expect == actual) { 284 return; 285 } 286 287 assertEquals(caller + " mId", expect.mId, actual.mId); 288 assertEquals(caller + " mBaseUri", expect.mBaseUri, actual.mBaseUri); 289 } 290 291 /** 292 * Compare two accounts for equality 293 * 294 * TODO: check host auth? 295 */ assertAccountEqual(String caller, Account expect, Account actual)296 public static void assertAccountEqual(String caller, Account expect, Account actual) { 297 if (expect == actual) { 298 return; 299 } 300 301 assertEmailContentEqual(caller, expect, actual); 302 assertEquals(caller + " mDisplayName", expect.mDisplayName, actual.mDisplayName); 303 assertEquals(caller + " mEmailAddress", expect.mEmailAddress, actual.mEmailAddress); 304 assertEquals(caller + " mSyncKey", expect.mSyncKey, actual.mSyncKey); 305 306 assertEquals(caller + " mSyncLookback", expect.mSyncLookback, actual.mSyncLookback); 307 assertEquals(caller + " mSyncInterval", expect.mSyncInterval, actual.mSyncInterval); 308 assertEquals(caller + " mHostAuthKeyRecv", expect.mHostAuthKeyRecv, 309 actual.mHostAuthKeyRecv); 310 assertEquals(caller + " mHostAuthKeySend", expect.mHostAuthKeySend, 311 actual.mHostAuthKeySend); 312 assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags); 313 assertEquals(caller + " mIsDefault", expect.mIsDefault, actual.mIsDefault); 314 assertEquals(caller + " mCompatibilityUuid", expect.mCompatibilityUuid, 315 actual.mCompatibilityUuid); 316 assertEquals(caller + " mSenderName", expect.mSenderName, actual.mSenderName); 317 assertEquals(caller + " mRingtoneUri", expect.mRingtoneUri, actual.mRingtoneUri); 318 assertEquals(caller + " mProtocolVersion", expect.mProtocolVersion, 319 actual.mProtocolVersion); 320 assertEquals(caller + " mNewMessageCount", expect.mNewMessageCount, 321 actual.mNewMessageCount); 322 assertEquals(caller + " mPolicyKey", expect.mPolicyKey, actual.mPolicyKey); 323 assertEquals(caller + " mSecuritySyncKey", expect.mSecuritySyncKey, 324 actual.mSecuritySyncKey); 325 assertEquals(caller + " mSignature", expect.mSignature, actual.mSignature); 326 } 327 328 /** 329 * Compare two hostauth records for equality 330 */ assertHostAuthEqual(String caller, HostAuth expect, HostAuth actual)331 public static void assertHostAuthEqual(String caller, HostAuth expect, HostAuth actual) { 332 assertHostAuthEqual(caller, expect, actual, true); 333 } 334 assertHostAuthEqual(String caller, HostAuth expect, HostAuth actual, boolean testEmailContent)335 public static void assertHostAuthEqual(String caller, HostAuth expect, HostAuth actual, 336 boolean testEmailContent) { 337 if (expect == actual) { 338 return; 339 } 340 341 if (testEmailContent) { 342 assertEmailContentEqual(caller, expect, actual); 343 } 344 assertEquals(caller + " mProtocol", expect.mProtocol, actual.mProtocol); 345 assertEquals(caller + " mAddress", expect.mAddress, actual.mAddress); 346 assertEquals(caller + " mPort", expect.mPort, actual.mPort); 347 assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags); 348 assertEquals(caller + " mLogin", expect.mLogin, actual.mLogin); 349 assertEquals(caller + " mPassword", expect.mPassword, actual.mPassword); 350 assertEquals(caller + " mDomain", expect.mDomain, actual.mDomain); 351 // This field is dead and is not checked 352 // assertEquals(caller + " mAccountKey", expect.mAccountKey, actual.mAccountKey); 353 } 354 355 /** 356 * Compare two mailboxes for equality 357 */ assertMailboxEqual(String caller, Mailbox expect, Mailbox actual)358 public static void assertMailboxEqual(String caller, Mailbox expect, Mailbox actual) { 359 if (expect == actual) { 360 return; 361 } 362 363 assertEmailContentEqual(caller, expect, actual); 364 assertEquals(caller + " mDisplayName", expect.mDisplayName, actual.mDisplayName); 365 assertEquals(caller + " mServerId", expect.mServerId, actual.mServerId); 366 assertEquals(caller + " mParentServerId", expect.mParentServerId, actual.mParentServerId); 367 assertEquals(caller + " mParentKey", expect.mParentKey, actual.mParentKey); 368 assertEquals(caller + " mAccountKey", expect.mAccountKey, actual.mAccountKey); 369 assertEquals(caller + " mType", expect.mType, actual.mType); 370 assertEquals(caller + " mDelimiter", expect.mDelimiter, actual.mDelimiter); 371 assertEquals(caller + " mSyncKey", expect.mSyncKey, actual.mSyncKey); 372 assertEquals(caller + " mSyncLookback", expect.mSyncLookback, actual.mSyncLookback); 373 assertEquals(caller + " mSyncInterval", expect.mSyncInterval, actual.mSyncInterval); 374 assertEquals(caller + " mSyncTime", expect.mSyncTime, actual.mSyncTime); 375 assertEquals(caller + " mFlagVisible", expect.mFlagVisible, actual.mFlagVisible); 376 assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags); 377 assertEquals(caller + " mVisibleLimit", expect.mVisibleLimit, actual.mVisibleLimit); 378 } 379 380 /** 381 * Compare two messages for equality 382 * 383 * TODO: body? 384 * TODO: attachments? 385 */ assertMessageEqual(String caller, Message expect, Message actual)386 public static void assertMessageEqual(String caller, Message expect, Message actual) { 387 if (expect == actual) { 388 return; 389 } 390 391 assertEmailContentEqual(caller, expect, actual); 392 assertEquals(caller + " mDisplayName", expect.mDisplayName, actual.mDisplayName); 393 assertEquals(caller + " mTimeStamp", expect.mTimeStamp, actual.mTimeStamp); 394 assertEquals(caller + " mSubject", expect.mSubject, actual.mSubject); 395 assertEquals(caller + " mFlagRead = false", expect.mFlagRead, actual.mFlagRead); 396 assertEquals(caller + " mFlagLoaded", expect.mFlagLoaded, actual.mFlagLoaded); 397 assertEquals(caller + " mFlagFavorite", expect.mFlagFavorite, actual.mFlagFavorite); 398 assertEquals(caller + " mFlagAttachment", expect.mFlagAttachment, actual.mFlagAttachment); 399 assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags); 400 401 assertEquals(caller + " mServerId", expect.mServerId, actual.mServerId); 402 assertEquals(caller + " mServerTimeStamp", expect.mServerTimeStamp,actual.mServerTimeStamp); 403 assertEquals(caller + " mClientId", expect.mClientId, actual.mClientId); 404 assertEquals(caller + " mMessageId", expect.mMessageId, actual.mMessageId); 405 406 assertEquals(caller + " mMailboxKey", expect.mMailboxKey, actual.mMailboxKey); 407 assertEquals(caller + " mAccountKey", expect.mAccountKey, actual.mAccountKey); 408 409 assertEquals(caller + " mFrom", expect.mFrom, actual.mFrom); 410 assertEquals(caller + " mTo", expect.mTo, actual.mTo); 411 assertEquals(caller + " mCc", expect.mCc, actual.mCc); 412 assertEquals(caller + " mBcc", expect.mBcc, actual.mBcc); 413 assertEquals(caller + " mReplyTo", expect.mReplyTo, actual.mReplyTo); 414 415 assertEquals(caller + " mMeetingInfo", expect.mMeetingInfo, actual.mMeetingInfo); 416 417 assertEquals(caller + " mSnippet", expect.mSnippet, actual.mSnippet); 418 419 assertEquals(caller + " mText", expect.mText, actual.mText); 420 assertEquals(caller + " mHtml", expect.mHtml, actual.mHtml); 421 assertEquals(caller + " mTextReply", expect.mTextReply, actual.mTextReply); 422 assertEquals(caller + " mHtmlReply", expect.mHtmlReply, actual.mHtmlReply); 423 assertEquals(caller + " mSourceKey", expect.mSourceKey, actual.mSourceKey); 424 assertEquals(caller + " mIntroText", expect.mIntroText, actual.mIntroText); 425 } 426 427 /** 428 * Compare to attachments for equality 429 * 430 * TODO: file / content URI mapping? Compare the actual files? 431 */ assertAttachmentEqual(String caller, Attachment expect, Attachment actual)432 public static void assertAttachmentEqual(String caller, Attachment expect, Attachment actual) { 433 if (expect == actual) { 434 return; 435 } 436 437 assertEmailContentEqual(caller, expect, actual); 438 assertEquals(caller + " mSize", expect.mSize, actual.mSize); 439 assertEquals(caller + " mFileName", expect.mFileName, actual.mFileName); 440 assertEquals(caller + " mContentId", expect.mContentId, actual.mContentId); 441 assertEquals(caller + " mContentUri", expect.mContentUri, actual.mContentUri); 442 assertEquals(caller + " mMessageKey", expect.mMessageKey, actual.mMessageKey); 443 assertEquals(caller + " mMimeType", expect.mMimeType, actual.mMimeType); 444 assertEquals(caller + " mLocation", expect.mLocation, actual.mLocation); 445 assertEquals(caller + " mEncoding", expect.mEncoding, actual.mEncoding); 446 assertEquals(caller + " mContent", expect.mContent, actual.mContent); 447 assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags); 448 MoreAsserts.assertEquals(caller + " mContentBytes", 449 expect.mContentBytes, actual.mContentBytes); 450 assertEquals(caller + " mAccountKey", expect.mAccountKey, actual.mAccountKey); 451 } 452 453 /** 454 * Create a temporary EML file based on {@code msg} in the directory {@code directory}. 455 */ createTempEmlFile(Context context, Message msg, File directory)456 public static Uri createTempEmlFile(Context context, Message msg, File directory) 457 throws Exception { 458 // Write out the message in rfc822 format 459 File outputFile = File.createTempFile("message", "tmp", directory); 460 assertNotNull(outputFile); 461 FileOutputStream outputStream = new FileOutputStream(outputFile); 462 Rfc822Output.writeTo(context, msg.mId, outputStream, true, false); 463 outputStream.close(); 464 465 return Uri.fromFile(outputFile); 466 } 467 } 468