← Back to branch summary

~chris.gagnon/+junk/qtpim-coverage

« back to all changes in this revision

Viewing changes to tests/auto/organizer/qorganizere2e/tst_qorganizere2e.cpp

  • Committer: chris.gagnon
  • Date: 2013-12-10 23:09:37 UTC
  • Revision ID: chris.gagnon@canonical.com-20131210230937-2akf1ft1edcttk87
first post

Show diffs side-by-side

added added

removed removed

Lines of Context:
tests/auto/organizer/qorganizere2e/tst_qorganizere2e.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2012 Digia Plc and/or its subsidiary(-ies).
 
4
** Contact: http://www.qt-project.org/legal
 
5
**
 
6
** This file is part of the test suite of the Qt Toolkit.
 
7
**
 
8
** $QT_BEGIN_LICENSE:LGPL$
 
9
** Commercial License Usage
 
10
** Licensees holding valid commercial Qt licenses may use this file in
 
11
** accordance with the commercial license agreement provided with the
 
12
** Software or, alternatively, in accordance with the terms contained in
 
13
** a written agreement between you and Digia.  For licensing terms and
 
14
** conditions see http://qt.digia.com/licensing.  For further information
 
15
** use the contact form at http://qt.digia.com/contact-us.
 
16
**
 
17
** GNU Lesser General Public License Usage
 
18
** Alternatively, this file may be used under the terms of the GNU Lesser
 
19
** General Public License version 2.1 as published by the Free Software
 
20
** Foundation and appearing in the file LICENSE.LGPL included in the
 
21
** packaging of this file.  Please review the following information to
 
22
** ensure the GNU Lesser General Public License version 2.1 requirements
 
23
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
24
**
 
25
** In addition, as a special exception, Digia gives you certain additional
 
26
** rights.  These rights are described in the Digia Qt LGPL Exception
 
27
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
28
**
 
29
** GNU General Public License Usage
 
30
** Alternatively, this file may be used under the terms of the GNU
 
31
** General Public License version 3.0 as published by the Free Software
 
32
** Foundation and appearing in the file LICENSE.GPL included in the
 
33
** packaging of this file.  Please review the following information to
 
34
** ensure the GNU General Public License version 3.0 requirements will be
 
35
** met: http://www.gnu.org/copyleft/gpl.html.
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
 
 
42
#include <QtTest/QtTest>
 
43
 
 
44
#include <qorganizeritemdetails.h>
 
45
#include <qorganizeritems.h>
 
46
#include <qorganizermanager.h>
 
47
#include "../../jsondbprocess.h"
 
48
 
 
49
QTORGANIZER_USE_NAMESPACE
 
50
 
 
51
class tst_QOrganizerE2E : public QObject
 
52
{
 
53
    Q_OBJECT
 
54
 
 
55
private slots:
 
56
    void initTestCase();
 
57
    void cleanupTestCase();
 
58
 
 
59
    void testMegaItem_data() { addManager(); }
 
60
    void testMegaItem();
 
61
 
 
62
    void testUnsupportedItemType_data() { addManager(); }
 
63
    void testUnsupportedItemType();
 
64
 
 
65
    void testInvalidParentId_data() { addManager(); }
 
66
    void testInvalidParentId();
 
67
 
 
68
private:
 
69
    void addManager();
 
70
 
 
71
    QOrganizerItem createItem(QOrganizerItemType::ItemType itemType);
 
72
    QOrganizerItemDetail createDetail(QOrganizerItemDetail::DetailType detailType);
 
73
 
 
74
    // <manager, items> pair for existing items
 
75
    QMap<QString, QList<QOrganizerItem> > existingItems;
 
76
 
 
77
    JsonDbProcess jsondbProcess;
 
78
};
 
79
 
 
80
void tst_QOrganizerE2E::initTestCase()
 
81
{
 
82
    // Start JsonDb daemon if needed
 
83
    if (QOrganizerManager::availableManagers().contains("jsondb")) {
 
84
        QString partitions_json = QFINDTESTDATA("partitions.json");
 
85
        QVERIFY2(!partitions_json.isEmpty(), "partitions.json file is missing");
 
86
        QVERIFY2(jsondbProcess.start(partitions_json), "Failed to start JsonDb process");
 
87
    }
 
88
 
 
89
    // back-up all existing items
 
90
    QStringList availableManagers(QOrganizerManager::availableManagers());
 
91
    foreach (const QString &manager, availableManagers) {
 
92
        QOrganizerManager organizerManager(manager);
 
93
        QList<QOrganizerItem> items(organizerManager.items());
 
94
        if (items.size() > 0) {
 
95
            existingItems.insert(manager, items);
 
96
            QList<QOrganizerItemId> itemIds(organizerManager.itemIds());
 
97
            organizerManager.removeItems(itemIds);
 
98
        }
 
99
    }
 
100
}
 
101
 
 
102
void tst_QOrganizerE2E::cleanupTestCase()
 
103
{
 
104
    // remove all items generated when running tests
 
105
    QStringList availableManagers(QOrganizerManager::availableManagers());
 
106
    foreach (const QString &manager, availableManagers) {
 
107
        QOrganizerManager organizerManager(manager);
 
108
        organizerManager.removeItems(organizerManager.itemIds());
 
109
    }
 
110
 
 
111
    // restore all existing items
 
112
    QMap<QString, QList<QOrganizerItem> >::iterator i = existingItems.begin();
 
113
    while (i != existingItems.end()) {
 
114
        QOrganizerManager organizerManager(i.key());
 
115
        organizerManager.saveItems(&(i.value()));
 
116
        ++i;
 
117
    }
 
118
 
 
119
    if (QOrganizerManager::availableManagers().contains("jsondb"))
 
120
        jsondbProcess.terminate();
 
121
}
 
122
 
 
123
void tst_QOrganizerE2E::testMegaItem()
 
124
{
 
125
    QFETCH(QString, managerName);
 
126
    QOrganizerManager organizerManager(managerName);
 
127
 
 
128
    QList<QOrganizerItemType::ItemType> supportedItemTypes(organizerManager.supportedItemTypes());
 
129
    foreach (QOrganizerItemType::ItemType itemType, supportedItemTypes) {
 
130
        QOrganizerItem referenceItem = createItem(itemType);
 
131
        QCOMPARE(referenceItem.type(), itemType);
 
132
 
 
133
        QList<QOrganizerItemDetail::DetailType> supportedDetails(organizerManager.supportedItemDetails(itemType));
 
134
        foreach (QOrganizerItemDetail::DetailType supportedDetail, supportedDetails) {
 
135
            QOrganizerItemDetail detail = createDetail(supportedDetail);
 
136
            if (detail.type() != supportedDetail)
 
137
                continue;
 
138
 
 
139
            QVERIFY(referenceItem.saveDetail(&detail));
 
140
        }
 
141
 
 
142
        // set parent for occurrence
 
143
        if (itemType == QOrganizerItemType::TypeEventOccurrence || itemType == QOrganizerItemType::TypeTodoOccurrence) {
 
144
            bool parentItemAvailable(false);
 
145
            QList<QOrganizerItem> items(organizerManager.items());
 
146
            foreach (const QOrganizerItem &item, items) {
 
147
                if ((itemType == QOrganizerItemType::TypeEventOccurrence && item.type() == QOrganizerItemType::TypeEvent)
 
148
                    || (itemType == QOrganizerItemType::TypeTodoOccurrence && item.type() == QOrganizerItemType::TypeTodo)) {
 
149
                    QOrganizerItemParent parent;
 
150
                    parent.setOriginalDate(QDate(1996, 9, 24));
 
151
                    parent.setParentId(item.id());
 
152
                    QVERIFY(referenceItem.saveDetail(&parent));
 
153
                    parentItemAvailable = true;
 
154
                    break;
 
155
                }
 
156
            }
 
157
            if (!parentItemAvailable)
 
158
                continue;
 
159
        }
 
160
 
 
161
        // so that the referenceItem stays the same
 
162
        QOrganizerItem itemToSave(referenceItem);
 
163
        QVERIFY(organizerManager.saveItem(&itemToSave));
 
164
 
 
165
        QOrganizerItem itemRead = organizerManager.item(itemToSave.id());
 
166
 
 
167
        // special details
 
168
        QCOMPARE(itemRead.type(), referenceItem.type());
 
169
 
 
170
        if (organizerManager.supportedItemDetails(itemType).contains(QOrganizerItemDetail::TypeGuid))
 
171
            QCOMPARE(itemRead.details(QOrganizerItemDetail::TypeGuid).size(), 1);
 
172
 
 
173
        if (organizerManager.supportedItemDetails(itemType).contains(QOrganizerItemDetail::TypeTimestamp))
 
174
            QCOMPARE(itemRead.details(QOrganizerItemDetail::TypeTimestamp).size(), 1);
 
175
 
 
176
        QCOMPARE(itemRead.details(QOrganizerItemDetail::TypeReminder).size(), 0);
 
177
 
 
178
        // all details should saved and loaded correctly
 
179
        foreach (const QOrganizerItemDetail &detail, referenceItem.details())
 
180
            QCOMPARE(itemRead.detail(detail.type()), detail);
 
181
    }
 
182
}
 
183
 
 
184
void tst_QOrganizerE2E::testUnsupportedItemType()
 
185
{
 
186
    QFETCH(QString, managerName);
 
187
    QOrganizerManager organizerManager(managerName);
 
188
 
 
189
    QList<QOrganizerItemType::ItemType> supportedItemTypes(organizerManager.supportedItemTypes());
 
190
    if (!supportedItemTypes.contains(QOrganizerItemType::TypeEvent)) {
 
191
        QOrganizerItem event = createItem(QOrganizerItemType::TypeEvent);
 
192
        QVERIFY(!organizerManager.saveItem(&event));
 
193
    }
 
194
    if (!supportedItemTypes.contains(QOrganizerItemType::TypeEventOccurrence)) {
 
195
        QOrganizerItem eventOccurence = createItem(QOrganizerItemType::TypeEventOccurrence);
 
196
        QVERIFY(!organizerManager.saveItem(&eventOccurence));
 
197
    }
 
198
    if (!supportedItemTypes.contains(QOrganizerItemType::TypeTodo)) {
 
199
        QOrganizerItem todo = createItem(QOrganizerItemType::TypeTodo);
 
200
        QVERIFY(!organizerManager.saveItem(&todo));
 
201
    }
 
202
    if (!supportedItemTypes.contains(QOrganizerItemType::TypeTodoOccurrence)) {
 
203
        QOrganizerItem todoOccurence = createItem(QOrganizerItemType::TypeTodoOccurrence);
 
204
        QVERIFY(!organizerManager.saveItem(&todoOccurence));
 
205
    }
 
206
    if (!supportedItemTypes.contains(QOrganizerItemType::TypeJournal)) {
 
207
        QOrganizerItem journal = createItem(QOrganizerItemType::TypeJournal);
 
208
        QVERIFY(!organizerManager.saveItem(&journal));
 
209
    }
 
210
    if (!supportedItemTypes.contains(QOrganizerItemType::TypeNote)) {
 
211
        QOrganizerItem note = createItem(QOrganizerItemType::TypeNote);
 
212
        QVERIFY(!organizerManager.saveItem(&note));
 
213
    }
 
214
}
 
215
 
 
216
void tst_QOrganizerE2E::testInvalidParentId()
 
217
{
 
218
    QFETCH(QString, managerName);
 
219
    QOrganizerManager organizerManager(managerName);
 
220
 
 
221
    QList<QOrganizerItemType::ItemType> supportedItemTypes(organizerManager.supportedItemTypes());
 
222
    foreach (QOrganizerItemType::ItemType itemType, supportedItemTypes) {
 
223
        if (itemType == QOrganizerItemType::TypeEventOccurrence || itemType == QOrganizerItemType::TypeTodoOccurrence) {
 
224
            QOrganizerItem item = createItem(itemType);
 
225
            QCOMPARE(item.type(), itemType);
 
226
 
 
227
            QOrganizerItemParent parent;
 
228
            parent.setParentId(QOrganizerItemId());
 
229
 
 
230
            QVERIFY(item.saveDetail(&parent));
 
231
            QVERIFY(!organizerManager.saveItem(&item));
 
232
        }
 
233
    }
 
234
}
 
235
 
 
236
void tst_QOrganizerE2E::addManager()
 
237
{
 
238
    QTest::addColumn<QString>("managerName");
 
239
 
 
240
    QStringList availableManagers = QOrganizerManager::availableManagers();
 
241
    availableManagers.removeAll("invalid");
 
242
    availableManagers.removeAll("skeleton");
 
243
 
 
244
    foreach (const QString &manager, availableManagers)
 
245
        QTest::newRow(manager.toLatin1().constData()) << manager;
 
246
}
 
247
 
 
248
QOrganizerItem tst_QOrganizerE2E::createItem(QOrganizerItemType::ItemType itemType)
 
249
{
 
250
    if (itemType == QOrganizerItemType::TypeEvent)
 
251
        return QOrganizerEvent();
 
252
    else if (itemType == QOrganizerItemType::TypeEventOccurrence)
 
253
        return QOrganizerEventOccurrence();
 
254
    else if (itemType == QOrganizerItemType::TypeTodo)
 
255
        return QOrganizerTodo();
 
256
    else if (itemType == QOrganizerItemType::TypeTodoOccurrence)
 
257
        return QOrganizerTodoOccurrence();
 
258
    else if (itemType == QOrganizerItemType::TypeJournal)
 
259
        return QOrganizerJournal();
 
260
    else if (itemType == QOrganizerItemType::TypeNote)
 
261
        return QOrganizerNote();
 
262
 
 
263
    return QOrganizerItem();
 
264
}
 
265
 
 
266
QOrganizerItemDetail tst_QOrganizerE2E::createDetail(QOrganizerItemDetail::DetailType detailType)
 
267
{
 
268
    if (detailType == QOrganizerItemDetail::TypeEventTime) {
 
269
        QOrganizerEventTime eventTime;
 
270
        eventTime.setAllDay(false);
 
271
        eventTime.setStartDateTime(QDateTime::fromString(QStringLiteral("1991-08-25T20:57:08+00:00"), Qt::ISODate));
 
272
        eventTime.setEndDateTime(QDateTime::fromString(QStringLiteral("1995-05-20T11:22:33+02:00"), Qt::ISODate));
 
273
        return eventTime;
 
274
    } else if (detailType == QOrganizerItemDetail::TypeJournalTime) {
 
275
        QOrganizerJournalTime journalTime;
 
276
        journalTime.setEntryDateTime(QDateTime::fromString(QStringLiteral("1991-08-25T20:57:08+00:00"), Qt::ISODate));
 
277
        return journalTime;
 
278
    } else if (detailType == QOrganizerItemDetail::TypeTodoTime) {
 
279
        QOrganizerTodoTime todoTime;
 
280
        todoTime.setAllDay(true);
 
281
        todoTime.setStartDateTime(QDateTime::fromString(QStringLiteral("1991-08-25T20:57:08+00:00"), Qt::ISODate));
 
282
        todoTime.setDueDateTime(QDateTime::fromString(QStringLiteral("1995-05-20T11:22:33+02:00"), Qt::ISODate));
 
283
        return todoTime;
 
284
    } else if (detailType == QOrganizerItemDetail::TypeTodoProgress) {
 
285
        QOrganizerTodoProgress todoProgress;
 
286
        todoProgress.setFinishedDateTime(QDateTime::fromString(QStringLiteral("1995-05-20T11:22:33+02:00"), Qt::ISODate));
 
287
        todoProgress.setPercentageComplete(64);
 
288
        todoProgress.setStatus(QOrganizerTodoProgress::StatusInProgress);
 
289
        return todoProgress;
 
290
    } else if (detailType == QOrganizerItemDetail::TypeReminder) {
 
291
        // do nothing, because noboday should directly use this
 
292
    } else if (detailType == QOrganizerItemDetail::TypeAudibleReminder) {
 
293
        QOrganizerItemAudibleReminder audibleReminder;
 
294
        audibleReminder.setDataUrl(QUrl::fromLocalFile(QStringLiteral("some_random_path")));
 
295
        audibleReminder.setRepetition(6, 4);
 
296
        audibleReminder.setSecondsBeforeStart(1989);
 
297
        return audibleReminder;
 
298
    } else if (detailType == QOrganizerItemDetail::TypeVisualReminder) {
 
299
        QOrganizerItemVisualReminder visualReminder;
 
300
        visualReminder.setDataUrl(QUrl::fromLocalFile(QStringLiteral("yet_another_path")));
 
301
        visualReminder.setMessage(QStringLiteral("Qt!!"));
 
302
        visualReminder.setRepetition(6, 4);
 
303
        visualReminder.setSecondsBeforeStart(1989);
 
304
        return visualReminder;
 
305
    } else if (detailType == QOrganizerItemDetail::TypeEmailReminder) {
 
306
        QOrganizerItemEmailReminder emailReminder;
 
307
        emailReminder.setContents(QStringLiteral("Qt Rocks!!"),
 
308
                                  QStringLiteral("Qt - Cross-platform application and UI framework"),
 
309
                                  QVariantList() << QVariant(QStringLiteral("Code once"))
 
310
                                                 << QVariant(QStringLiteral("Create more"))
 
311
                                                 << QVariant(QStringLiteral("Deploy everywhere")));
 
312
        emailReminder.setRecipients(QStringList() << QStringLiteral("Berlin")
 
313
                                                  << QStringLiteral("Brisbane")
 
314
                                                  << QStringLiteral("Oslo")
 
315
                                                  << QStringLiteral("Tampere"));
 
316
        emailReminder.setRepetition(6, 4);
 
317
        emailReminder.setSecondsBeforeStart(1989);
 
318
        return emailReminder;
 
319
    } else if (detailType == QOrganizerItemDetail::TypeComment) {
 
320
        QOrganizerItemComment comment;
 
321
        comment.setComment(QStringLiteral("Qt Everywhere!"));
 
322
        return comment;
 
323
    } else if (detailType == QOrganizerItemDetail::TypeDescription) {
 
324
        QOrganizerItemDescription description;
 
325
        description.setDescription(QStringLiteral("Qt is cute!"));
 
326
        return description;
 
327
    } else if (detailType == QOrganizerItemDetail::TypeDisplayLabel) {
 
328
        QOrganizerItemDisplayLabel displayLabel;
 
329
        displayLabel.setLabel(QStringLiteral("Qt - Cross-platform application and UI framework"));
 
330
        return displayLabel;
 
331
    } else if (detailType == QOrganizerItemDetail::TypeGuid) {
 
332
        // do nothing, because it should be set by the back-end engine
 
333
    } else if (detailType == QOrganizerItemDetail::TypeLocation) {
 
334
        QOrganizerItemLocation location;
 
335
        location.setLabel(QStringLiteral("In the middle of nowhere"));
 
336
        location.setLatitude(19.84);
 
337
        location.setLongitude(6.4);
 
338
        return location;
 
339
    } else if (detailType == QOrganizerItemDetail::TypeParent) {
 
340
        // do nothing, because it's handled specially
 
341
    } else if (detailType == QOrganizerItemDetail::TypePriority) {
 
342
        QOrganizerItemPriority priority;
 
343
        priority.setPriority(QOrganizerItemPriority::HighPriority);
 
344
        return priority;
 
345
    } else if (detailType == QOrganizerItemDetail::TypeRecurrence) {
 
346
        QOrganizerItemRecurrence recurrence;
 
347
 
 
348
        recurrence.setRecurrenceDates(QSet<QDate>() << QDate(2005, 6, 28) << QDate(2005, 12, 19) << QDate(2006, 10, 4)
 
349
                                                    << QDate(2007, 5, 30) << QDate(2008, 5, 6) << QDate(2009, 3, 3)
 
350
                                                    << QDate(2009, 12, 1) << QDate(2010, 9, 21));
 
351
 
 
352
        QOrganizerRecurrenceRule recurrenceRule;
 
353
        recurrenceRule.setFrequency(QOrganizerRecurrenceRule::Yearly);
 
354
        recurrenceRule.setInterval(1);
 
355
        recurrenceRule.setLimit(QOrganizerRecurrenceRule::NoLimit);
 
356
        recurrenceRule.setMonthsOfYear(QSet<QOrganizerRecurrenceRule::Month>() << QOrganizerRecurrenceRule::September);
 
357
        recurrenceRule.setDaysOfMonth(QSet<int>() << 24);
 
358
        recurrence.setRecurrenceRules(QSet<QOrganizerRecurrenceRule>() << recurrenceRule);
 
359
 
 
360
        recurrence.setExceptionDates(QSet<QDate>() << QDate(2008, 9, 24) << QDate(2009, 9, 24) << QDate(2010, 9, 24));
 
361
 
 
362
        QOrganizerRecurrenceRule exceptionRule;
 
363
        exceptionRule.setFrequency(QOrganizerRecurrenceRule::Yearly);
 
364
        exceptionRule.setInterval(2);
 
365
        exceptionRule.setLimit(QOrganizerRecurrenceRule::NoLimit);
 
366
        exceptionRule.setMonthsOfYear(QSet<QOrganizerRecurrenceRule::Month>() << QOrganizerRecurrenceRule::September);
 
367
        exceptionRule.setDaysOfMonth(QSet<int>() << 24);
 
368
        recurrence.setExceptionRules(QSet<QOrganizerRecurrenceRule>() << exceptionRule);
 
369
 
 
370
        return recurrence;
 
371
    } else if (detailType == QOrganizerItemDetail::TypeTimestamp) {
 
372
        // do nothing, because it should be maintained by the back-end engine
 
373
    } else if (detailType == QOrganizerItemDetail::TypeItemType) {
 
374
        // do nothing, because it should not be changed
 
375
    } else if (detailType == QOrganizerItemDetail::TypeTag) {
 
376
        QOrganizerItemTag tag;
 
377
        tag.setTag(QStringLiteral("Qt Open Governance"));
 
378
    } else if (detailType == QOrganizerItemDetail::TypeExtendedDetail) {
 
379
        QOrganizerItemExtendedDetail extendedDetail;
 
380
        extendedDetail.setName(QStringLiteral("My-Stupid-Extended-Detail"));
 
381
        extendedDetail.setData(QVariantList() << QVariant(QStringLiteral("Code once"))
 
382
                               << QVariant(QStringLiteral("Create more"))
 
383
                               << QVariant(QStringLiteral("Deploy everywhere")));
 
384
        return extendedDetail;
 
385
    } else if (detailType == QOrganizerItemDetail::TypeEventAttendee) {
 
386
        QOrganizerEventAttendee attendee;
 
387
        attendee.setName(QStringLiteral("people"));
 
388
        attendee.setAttendeeId(QStringLiteral("123456"));
 
389
        attendee.setEmailAddress(QStringLiteral("people@nokia.com"));
 
390
        attendee.setParticipationRole(QOrganizerEventAttendee::RoleRequiredParticipant);
 
391
        attendee.setParticipationStatus(QOrganizerEventAttendee::StatusAccepted);
 
392
        return attendee;
 
393
    } else if (detailType == QOrganizerItemDetail::TypeVersion) {
 
394
        // do nothing, because it should be maintained by the back-end engine
 
395
    }
 
396
 
 
397
    return QOrganizerItemDetail();
 
398
}
 
399
 
 
400
QTEST_MAIN(tst_QOrganizerE2E)
 
401
#include "tst_qorganizere2e.moc"