ProviderTestUtils.java revision 9e2c6bd5f21f2d19eef7ebfe30e6fdf94ede0857 
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.provider.EmailContent.Account;
20import com.android.email.provider.EmailContent.Attachment;
21import com.android.email.provider.EmailContent.Mailbox;
22import com.android.email.provider.EmailContent.Message;
23
24import android.content.Context;
25
26import junit.framework.Assert;
27
28public class ProviderTestUtils extends Assert {
29
30    /**
31     * No constructor - statics only
32     */
33    private ProviderTestUtils() {
34    }
35
36    /**
37     * Create an account for test purposes
38     */
39    public static Account setupAccount(String name, boolean saveIt, Context context) {
40        Account account = new Account();
41
42        account.mDisplayName = name;
43        account.mEmailAddress = name + "@android.com";
44        account.mSyncKey = "sync-key-" + name;
45        account.mSyncLookback = 1;
46        account.mSyncInterval = EmailContent.Account.CHECK_INTERVAL_NEVER;
47        account.mHostAuthKeyRecv = 2;
48        account.mHostAuthKeySend = 3;
49        account.mFlags = 4;
50        account.mIsDefault = true;
51        account.mCompatibilityUuid = "test-uid-" + name;
52        account.mSenderName = name;
53        account.mRingtoneUri = "content://ringtone-" + name;
54        account.mProtocolVersion = "2.5" + name;
55
56        if (saveIt) {
57            account.save(context);
58        }
59        return account;
60    }
61
62    /**
63     * Create a mailbox for test purposes
64     */
65    public static Mailbox setupMailbox(String name, long accountId, boolean saveIt,
66            Context context) {
67        Mailbox box = new Mailbox();
68
69        box.mDisplayName = name;
70        box.mServerId = "serverid-" + name;
71        box.mParentServerId = "parent-serverid-" + name;
72        box.mAccountKey = accountId;
73        box.mType = Mailbox.TYPE_MAIL;
74        box.mDelimiter = 1;
75        box.mSyncKey = "sync-key-" + name;
76        box.mSyncLookback = 2;
77        box.mSyncInterval = EmailContent.Account.CHECK_INTERVAL_NEVER;
78        box.mSyncTime = 3;
79        box.mUnreadCount = 4;
80        box.mFlagVisible = true;
81        box.mFlags = 5;
82        box.mVisibleLimit = 6;
83
84        if (saveIt) {
85            box.save(context);
86        }
87        return box;
88    }
89
90    /**
91     * Create a message for test purposes
92     *
93     * TODO: body
94     * TODO: attachments
95     */
96    public static Message setupMessage(String name, long accountId, long mailboxId,
97            boolean addBody, boolean saveIt, Context context) {
98        Message message = new Message();
99
100        message.mDisplayName = name;
101        message.mTimeStamp = 1;
102        message.mSubject = "subject " + name;
103        message.mPreview = "preview " + name;
104        message.mFlagRead = true;
105        message.mFlagLoaded = Message.NOT_LOADED;
106        message.mFlagFavorite = true;
107        message.mFlagAttachment = true;
108        message.mFlags = 2;
109
110        message.mTextInfo = "textinfo " + name;
111        message.mHtmlInfo = "htmlinfo " + name;
112
113        message.mServerId = "serverid " + name;
114        message.mServerIntId = 0;
115        message.mClientId = "clientid " + name;
116        message.mMessageId = "messageid " + name;
117        message.mThreadId = "threadid " + name;
118
119        message.mMailboxKey = mailboxId;
120        message.mAccountKey = accountId;
121        message.mReferenceKey = 4;
122
123        message.mSender = "sender " + name;
124        message.mFrom = "from " + name;
125        message.mTo = "to " + name;
126        message.mCc = "cc " + name;
127        message.mBcc = "bcc " + name;
128        message.mReplyTo = "replyto " + name;
129
130        message.mServerVersion = "serverversion " + name;
131
132        if (addBody) {
133            message.mText = "body text " + name;
134            message.mHtml = "body html " + name;
135        }
136
137        if (saveIt) {
138            message.save(context);
139        }
140        return message;
141    }
142
143    /**
144     * Create a test attachment.  A few fields are specified by params, and all other fields
145     * are generated using pseudo-unique values.
146     *
147     * @param messageId the message to attach to
148     * @param fileName the "file" to indicate in the attachment
149     * @param length the "length" of the attachment
150     * @param saveIt if true, write the new attachment directly to the DB
151     * @param context use this context
152     */
153    public static Attachment setupAttachment(long messageId, String fileName, long length,
154            boolean saveIt, Context context) {
155        Attachment att = new Attachment();
156        att.mSize = length;
157        att.mFileName = fileName;
158        att.mContentId = "contentId " + fileName;
159        att.mContentUri = "contentUri " + fileName;
160        att.mMessageKey = messageId;
161        att.mMimeType = "mimeType " + fileName;
162        att.mLocation = "location " + fileName;
163        att.mEncoding = "encoding " + fileName;
164        if (saveIt) {
165            att.save(context);
166        }
167        return att;
168    }
169
170    private static void assertEmailContentEqual(String caller, EmailContent expect,
171            EmailContent actual) {
172        if (expect == actual) {
173            return;
174        }
175
176        assertEquals(caller + " mId", expect.mId, actual.mId);
177        assertEquals(caller + " mBaseUri", expect.mBaseUri, actual.mBaseUri);
178    }
179
180    /**
181     * Compare two accounts for equality
182     *
183     * TODO: check host auth?
184     */
185    public static void assertAccountEqual(String caller, Account expect, Account actual) {
186        if (expect == actual) {
187            return;
188        }
189
190        assertEmailContentEqual(caller, expect, actual);
191        assertEquals(caller + " mDisplayName", expect.mDisplayName, actual.mDisplayName);
192        assertEquals(caller + " mEmailAddress", expect.mEmailAddress, actual.mEmailAddress);
193        assertEquals(caller + " mSyncKey", expect.mSyncKey, actual.mSyncKey);
194
195        assertEquals(caller + " mSyncLookback", expect.mSyncLookback, actual.mSyncLookback);
196        assertEquals(caller + " mSyncInterval", expect.mSyncInterval, actual.mSyncInterval);
197        assertEquals(caller + " mHostAuthKeyRecv", expect.mHostAuthKeyRecv,
198                actual.mHostAuthKeyRecv);
199        assertEquals(caller + " mHostAuthKeySend", expect.mHostAuthKeySend,
200                actual.mHostAuthKeySend);
201        assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags);
202        assertEquals(caller + " mIsDefault", expect.mIsDefault, actual.mIsDefault);
203        assertEquals(caller + " mCompatibilityUuid", expect.mCompatibilityUuid,
204                actual.mCompatibilityUuid);
205        assertEquals(caller + " mSenderName", expect.mSenderName, actual.mSenderName);
206        assertEquals(caller + " mRingtoneUri", expect.mRingtoneUri, actual.mRingtoneUri);
207        assertEquals(caller + " mProtocolVersion", expect.mProtocolVersion,
208                actual.mProtocolVersion);
209    }
210
211    /**
212     * Compare two mailboxes for equality
213     */
214    public static void assertMailboxEqual(String caller, Mailbox expect, Mailbox actual) {
215        if (expect == actual) {
216            return;
217        }
218
219        assertEmailContentEqual(caller, expect, actual);
220        assertEquals(caller + " mDisplayName", expect.mDisplayName, actual.mDisplayName);
221        assertEquals(caller + " mServerId", expect.mServerId, actual.mServerId);
222        assertEquals(caller + " mParentServerId", expect.mParentServerId, actual.mParentServerId);
223        assertEquals(caller + " mAccountKey", expect.mAccountKey, actual.mAccountKey);
224        assertEquals(caller + " mType", expect.mType, actual.mType);
225        assertEquals(caller + " mDelimiter", expect.mDelimiter, actual.mDelimiter);
226        assertEquals(caller + " mSyncKey", expect.mSyncKey, actual.mSyncKey);
227        assertEquals(caller + " mSyncLookback", expect.mSyncLookback, actual.mSyncLookback);
228        assertEquals(caller + " mSyncInterval", expect.mSyncInterval, actual.mSyncInterval);
229        assertEquals(caller + " mSyncTime", expect.mSyncTime, actual.mSyncTime);
230        assertEquals(caller + " mUnreadCount", expect.mUnreadCount, actual.mUnreadCount);
231        assertEquals(caller + " mFlagVisible", expect.mFlagVisible, actual.mFlagVisible);
232        assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags);
233        assertEquals(caller + " mVisibleLimit", expect.mVisibleLimit, actual.mVisibleLimit);
234    }
235
236    /**
237     * Compare two messages for equality
238     *
239     * TODO: body?
240     * TODO: attachments?
241     */
242    public static void assertMessageEqual(String caller, Message expect, Message actual) {
243        if (expect == actual) {
244            return;
245        }
246
247        assertEmailContentEqual(caller, expect, actual);
248        assertEquals(caller + " mDisplayName", expect.mDisplayName, actual.mDisplayName);
249        assertEquals(caller + " mTimeStamp", expect.mTimeStamp, actual.mTimeStamp);
250        assertEquals(caller + " mSubject", expect.mSubject, actual.mSubject);
251        assertEquals(caller + " mPreview", expect.mPreview, actual.mPreview);
252        assertEquals(caller + " mFlagRead = false", expect.mFlagRead, actual.mFlagRead);
253        assertEquals(caller + " mFlagLoaded", expect.mFlagLoaded, actual.mFlagLoaded);
254        assertEquals(caller + " mFlagFavorite", expect.mFlagFavorite, actual.mFlagFavorite);
255        assertEquals(caller + " mFlagAttachment", expect.mFlagAttachment, actual.mFlagAttachment);
256        assertEquals(caller + " mFlags", expect.mFlags, actual.mFlags);
257
258        assertEquals(caller + " mTextInfo", expect.mTextInfo, actual.mTextInfo);
259        assertEquals(caller + " mHtmlInfo", expect.mHtmlInfo, actual.mHtmlInfo);
260
261        assertEquals(caller + " mServerId", expect.mServerId, actual.mServerId);
262        assertEquals(caller + " mServerIntId", expect.mServerIntId, actual.mServerIntId);
263        assertEquals(caller + " mClientId", expect.mClientId, actual.mClientId);
264        assertEquals(caller + " mMessageId", expect.mMessageId, actual.mMessageId);
265        assertEquals(caller + " mThreadId", expect.mThreadId, actual.mThreadId);
266
267        assertEquals(caller + " mMailboxKey", expect.mMailboxKey, actual.mMailboxKey);
268        assertEquals(caller + " mAccountKey", expect.mAccountKey, actual.mAccountKey);
269        assertEquals(caller + " mReferenceKey", expect.mReferenceKey, actual.mReferenceKey);
270
271        assertEquals(caller + " mSender", expect.mSender, actual.mSender);
272        assertEquals(caller + " mFrom", expect.mFrom, actual.mFrom);
273        assertEquals(caller + " mTo", expect.mTo, actual.mTo);
274        assertEquals(caller + " mCc", expect.mCc, actual.mCc);
275        assertEquals(caller + " mBcc", expect.mBcc, actual.mBcc);
276        assertEquals(caller + " mReplyTo", expect.mReplyTo, actual.mReplyTo);
277
278        assertEquals(caller + " mServerVersion", expect.mServerVersion, actual.mServerVersion);
279
280        assertEquals(caller + " mText", expect.mText, actual.mText);
281        assertEquals(caller + " mHtml", expect.mHtml, actual.mHtml);
282    }
283
284    /**
285     * Compare to attachments for equality
286     *
287     * TODO: file / content URI mapping?  Compare the actual files?
288     */
289    public static void assertAttachmentEqual(String caller, Attachment expect, Attachment actual) {
290        if (expect == actual) {
291            return;
292        }
293
294        assertEmailContentEqual(caller, expect, actual);
295        assertEquals(caller + " mSize", expect.mSize, actual.mSize);
296        assertEquals(caller + " mFileName", expect.mFileName, actual.mFileName);
297        assertEquals(caller + " mContentId", expect.mContentId, actual.mContentId);
298        assertEquals(caller + " mContentUri", expect.mContentUri, actual.mContentUri);
299        assertEquals(caller + " mMessageKey", expect.mMessageKey, actual.mMessageKey);
300        assertEquals(caller + " mMimeType", expect.mMimeType, actual.mMimeType);
301        assertEquals(caller + " mLocation", expect.mLocation, actual.mLocation);
302        assertEquals(caller + " mEncoding", expect.mEncoding, actual.mEncoding);
303    }
304}
305