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