|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: Main test class for hspluginmodel library. |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <QSignalSpy> |
|
19 |
|
20 #include "caclient_defines.h" |
|
21 #include "t_caclient.h" |
|
22 #include "caservice.h" |
|
23 #include "caquery.h" |
|
24 #include "caitemmodel.h" |
|
25 #include "caitemmodel_p.h" |
|
26 // --------------------------------------------------------------------------- |
|
27 // --------------------------------------------------------------------------- |
|
28 // |
|
29 void TestCaClient::TestCaItemModelConstruct() |
|
30 { |
|
31 { |
|
32 CaQuery query; |
|
33 query.setEntryRoles(ItemEntryRole); |
|
34 CaItemModel model(query,NULL); |
|
35 QVERIFY(model.rowCount() > 0); |
|
36 QCOMPARE(model.columnCount(),1); |
|
37 QCOMPARE(model.isAutoUpdate(), true); |
|
38 } |
|
39 } |
|
40 |
|
41 // --------------------------------------------------------------------------- |
|
42 // --------------------------------------------------------------------------- |
|
43 // |
|
44 void TestCaClient::TestCaItemModelAutoUpdate() |
|
45 { |
|
46 { |
|
47 // ensure that entries are not present in a storage |
|
48 removeEntry("TestGroup"); |
|
49 removeEntry("TestItem1"); |
|
50 removeEntry("TestItem2"); |
|
51 //test |
|
52 QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder"); |
|
53 QSharedPointer<CaEntry> item1 = createItem("TestItem1","testitem"); |
|
54 QSharedPointer<CaEntry> item2 = createItem("TestItem2","testitem"); |
|
55 addItemToGroup(group->id(), item1->id()); |
|
56 CaQuery query; |
|
57 query.setParentId(group->id()); |
|
58 CaItemModel model(query,NULL); |
|
59 model.setAutoUpdate(true); |
|
60 QCOMPARE(model.isAutoUpdate(), true); |
|
61 QCOMPARE(model.rowCount() , 1); |
|
62 addItemToGroup(group->id(), item2->id()); |
|
63 QTest::qWait(50); |
|
64 QCOMPARE(model.rowCount() , 2); |
|
65 removeItemFromGroup(group->id(), item2->id()); |
|
66 QTest::qWait(50); |
|
67 QCOMPARE(model.rowCount() , 1); |
|
68 model.setAutoUpdate(false); |
|
69 addItemToGroup(group->id(), item2->id()); |
|
70 QTest::qWait(50); |
|
71 QCOMPARE(model.rowCount() , 1); |
|
72 QCOMPARE(model.isAutoUpdate(), false); |
|
73 model.updateModel(); |
|
74 QCOMPARE(model.rowCount() , 2); |
|
75 QCOMPARE(model.isAutoUpdate(), false); |
|
76 model.setAutoUpdate(true); |
|
77 removeEntry(item1->id()); |
|
78 QTest::qWait(50); |
|
79 QCOMPARE(model.rowCount() , 1); |
|
80 //cleanup |
|
81 removeEntry("TestItem2"); |
|
82 removeEntry("TestItem1"); |
|
83 removeEntry("TestGroup"); |
|
84 } |
|
85 } |
|
86 |
|
87 // --------------------------------------------------------------------------- |
|
88 // --------------------------------------------------------------------------- |
|
89 // |
|
90 void TestCaClient::TestCaItemModelIndex() |
|
91 { |
|
92 // ensure that entries are not present in a storage |
|
93 removeEntry("TestGroup"); |
|
94 removeEntry("TestItem1"); |
|
95 removeEntry("TestItem2"); |
|
96 //test |
|
97 QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder"); |
|
98 QSharedPointer<CaEntry> item1 = createItem("TestItem1","testitem"); |
|
99 QSharedPointer<CaEntry> item2 = createItem("TestItem2","testitem"); |
|
100 addItemToGroup(group->id(), item1->id()); |
|
101 addItemToGroup(group->id(), item2->id()); |
|
102 CaQuery query; |
|
103 query.setParentId(group->id()); |
|
104 CaItemModel model(query,NULL); |
|
105 QCOMPARE(model.index(-1), QModelIndex()); |
|
106 QCOMPARE(model.index(0).row(), 0); |
|
107 QCOMPARE(model.index(1).row(), 1); |
|
108 QCOMPARE(model.index(2), QModelIndex()); |
|
109 QCOMPARE(model.parent(model.index(1)), QModelIndex()); |
|
110 QCOMPARE(model.root().row(),0); |
|
111 QCOMPARE(model.root().column(),1); |
|
112 |
|
113 CaQuery query2; |
|
114 CaItemModel modelWithoutParent(query2,NULL); |
|
115 QCOMPARE(modelWithoutParent.root().isValid(),false); |
|
116 |
|
117 //cleanup |
|
118 removeEntry("TestItem2"); |
|
119 removeEntry("TestItem1"); |
|
120 removeEntry("TestGroup"); |
|
121 |
|
122 } |
|
123 |
|
124 // --------------------------------------------------------------------------- |
|
125 // --------------------------------------------------------------------------- |
|
126 // |
|
127 void TestCaClient::TestCaItemModelData() |
|
128 { |
|
129 // ensure that entries are not present in a storage |
|
130 removeEntry("TestGroup"); |
|
131 removeEntry("TestItem1"); |
|
132 //test |
|
133 QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder"); |
|
134 QSharedPointer<CaEntry> item1 = createItem("TestItem1","TestDescription","testitem", UsedEntryFlag); |
|
135 QString progressString = "100"; |
|
136 item1->setAttribute(UNINSTALL_PROGRESS_APPLICATION_ATTRIBUTE_NAME, progressString); |
|
137 QSharedPointer<CaService> service = CaService::instance(); |
|
138 service->updateEntry(*item1.data()); |
|
139 QCOMPARE(item1->attribute(UNINSTALL_PROGRESS_APPLICATION_ATTRIBUTE_NAME), progressString); |
|
140 |
|
141 addItemToGroup(group->id(), item1->id()); |
|
142 CaQuery query; |
|
143 query.setParentId(group->id()); |
|
144 CaItemModel model(query,NULL); |
|
145 |
|
146 QCOMPARE(model.data(QModelIndex()),QVariant()); |
|
147 |
|
148 QModelIndex index = model.index(0); |
|
149 |
|
150 model.setSecondLineVisibility(false); |
|
151 QCOMPARE(model.secondLineVisibility(),false); |
|
152 QCOMPARE(model.data(index, Qt::DisplayRole).toString(), QString("TestItem1")); |
|
153 model.setSecondLineVisibility(true); |
|
154 QCOMPARE(model.secondLineVisibility(),true); |
|
155 QList<QVariant> displayRoleList = model.data(index, Qt::DisplayRole).toList(); |
|
156 QString text = displayRoleList.at(0).toString(); |
|
157 QString description = displayRoleList.at(1).toString(); |
|
158 QCOMPARE(text,QString("TestItem1")); |
|
159 QCOMPARE(description,QString("TestDescription")); |
|
160 QCOMPARE(model.data(index, CaItemModel::IdRole).toInt(), item1->id()); |
|
161 QCOMPARE(model.data(index, CaItemModel::TypeRole).toString(),QString("testitem")); |
|
162 QVERIFY(model.data(index, CaItemModel::FlagsRole).value<EntryFlags>()== UsedEntryFlag); |
|
163 QCOMPARE(model.data(index, CaItemModel::TextRole).toString(),QString("TestItem1")); |
|
164 QCOMPARE(model.entry(index)->text(),QString("TestItem1")); |
|
165 QCOMPARE(model.data(index, 777), QVariant(QVariant::Invalid)); |
|
166 QCOMPARE(model.data(index, CaItemModel::UninstalRole).value<int>(), progressString.toInt()); |
|
167 |
|
168 //cleanup |
|
169 removeEntry("TestItem1"); |
|
170 removeEntry("TestGroup"); |
|
171 } |
|
172 |
|
173 // --------------------------------------------------------------------------- |
|
174 // --------------------------------------------------------------------------- |
|
175 // |
|
176 void TestCaClient::TestCaItemModelIconSize() |
|
177 { |
|
178 // ensure that entries are not present in a storage |
|
179 removeEntry("TestGroup"); |
|
180 removeEntry("TestItem1"); |
|
181 //test |
|
182 QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder"); |
|
183 QSharedPointer<CaEntry> item1 = createItem("TestItem1","testitem"); |
|
184 addItemToGroup(group->id(), item1->id()); |
|
185 CaQuery query; |
|
186 query.setParentId(group->id()); |
|
187 CaItemModel model(query,NULL); |
|
188 QSizeF size1(30,30); |
|
189 QSizeF size2(130,130); |
|
190 model.setIconSize(size1); |
|
191 QVERIFY(model.getIconSize() == size1); |
|
192 model.setIconSize(size2); |
|
193 QVERIFY(model.getIconSize() == size2); |
|
194 //cleanup |
|
195 removeEntry("TestItem1"); |
|
196 removeEntry("TestGroup"); |
|
197 } |
|
198 |
|
199 // --------------------------------------------------------------------------- |
|
200 // --------------------------------------------------------------------------- |
|
201 // |
|
202 void TestCaClient::TestCaItemModelChangeParent() |
|
203 { |
|
204 // ensure that entries are not present in a storage |
|
205 removeEntry("TestGroup1"); |
|
206 removeEntry("TestGroup2"); |
|
207 removeEntry("TestItem1"); |
|
208 removeEntry("TestItem2"); |
|
209 removeEntry("TestItem3"); |
|
210 //test |
|
211 QSharedPointer<CaEntry> group1 = createGroup("TestGroup1","testfolder"); |
|
212 QSharedPointer<CaEntry> group2 = createGroup("TestGroup2","testfolder"); |
|
213 QSharedPointer<CaEntry> item1 = createItem("TestItem1","testitem"); |
|
214 QSharedPointer<CaEntry> item2 = createItem("TestItem2","testitem"); |
|
215 QSharedPointer<CaEntry> item3 = createItem("TestItem3","testitem"); |
|
216 addItemToGroup(group1->id(), item1->id()); |
|
217 addItemToGroup(group2->id(), item2->id()); |
|
218 addItemToGroup(group2->id(), item3->id()); |
|
219 CaQuery query; |
|
220 query.setParentId(group1->id()); |
|
221 CaItemModel model(query,NULL); |
|
222 model.setAutoUpdate(true); |
|
223 QCOMPARE(model.isAutoUpdate(), true); |
|
224 QCOMPARE(model.rowCount() , 1); |
|
225 QCOMPARE(itemName(model,0),QString("TestItem1")); |
|
226 model.setFlagsOn(VisibleEntryFlag); |
|
227 model.setFlagsOff(MissingEntryFlag); |
|
228 model.setParentId(group2->id()); |
|
229 QTest::qWait(50); |
|
230 QCOMPARE(model.rowCount() , 2); |
|
231 QCOMPARE(itemName(model,0),QString("TestItem2")); |
|
232 QCOMPARE(itemName(model,1),QString("TestItem3")); |
|
233 model.setParentId(group1->id()); |
|
234 QTest::qWait(50); |
|
235 QCOMPARE(model.rowCount() , 1); |
|
236 QCOMPARE(itemName(model,0),QString("TestItem1")); |
|
237 model.setAutoUpdate(false); |
|
238 model.setFlagsOn(VisibleEntryFlag); |
|
239 model.setFlagsOff(MissingEntryFlag); |
|
240 model.setParentId(group2->id()); |
|
241 QTest::qWait(50); |
|
242 QCOMPARE(model.rowCount(), 2); |
|
243 QCOMPARE(itemName(model,0),QString("TestItem2")); |
|
244 QCOMPARE(itemName(model,1),QString("TestItem3")); |
|
245 |
|
246 //cleanup |
|
247 removeEntry("TestItem3"); |
|
248 removeEntry("TestItem2"); |
|
249 removeEntry("TestItem1"); |
|
250 removeEntry("TestGroup2"); |
|
251 removeEntry("TestGroup1"); |
|
252 |
|
253 } |
|
254 |
|
255 // --------------------------------------------------------------------------- |
|
256 // --------------------------------------------------------------------------- |
|
257 // |
|
258 void TestCaClient::TestCaItemModelSortOrder() |
|
259 { |
|
260 // ensure that entries are not present in a storage |
|
261 removeEntry("TestGroup"); |
|
262 removeEntry("ATestItem"); |
|
263 removeEntry("BTestItem"); |
|
264 //test |
|
265 QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder"); |
|
266 QSharedPointer<CaEntry> item1 = createItem("ATestItem","testitem"); |
|
267 QSharedPointer<CaEntry> item2 = createItem("BTestItem","testitem"); |
|
268 addItemToGroup(group->id(), item2->id()); |
|
269 addItemToGroup(group->id(), item1->id()); |
|
270 CaQuery query; |
|
271 query.setParentId(group->id()); |
|
272 CaItemModel model(query,NULL); |
|
273 model.setAutoUpdate(false); //should work even without autoupdate |
|
274 model.setSort(NameSortAttribute, Qt::DescendingOrder); |
|
275 QCOMPARE(itemName(model,0),QString("BTestItem")); |
|
276 QCOMPARE(itemName(model,1),QString("ATestItem")); |
|
277 model.setSort(NameSortAttribute, Qt::AscendingOrder); |
|
278 QCOMPARE(itemName(model,0),QString("ATestItem")); |
|
279 QCOMPARE(itemName(model,1),QString("BTestItem")); |
|
280 model.setSort(DefaultSortAttribute, Qt::DescendingOrder); |
|
281 QCOMPARE(itemName(model,0),QString("ATestItem")); |
|
282 QCOMPARE(itemName(model,1),QString("BTestItem")); |
|
283 model.setSort(DefaultSortAttribute, Qt::AscendingOrder); |
|
284 QCOMPARE(itemName(model,0),QString("BTestItem")); |
|
285 QCOMPARE(itemName(model,1),QString("ATestItem")); |
|
286 model.setAutoUpdate(true); |
|
287 model.setSort(NameSortAttribute, Qt::DescendingOrder); |
|
288 QCOMPARE(itemName(model,0),QString("BTestItem")); |
|
289 QCOMPARE(itemName(model,1),QString("ATestItem")); |
|
290 model.setSort(NameSortAttribute, Qt::AscendingOrder); |
|
291 QCOMPARE(itemName(model,0),QString("ATestItem")); |
|
292 QCOMPARE(itemName(model,1),QString("BTestItem")); |
|
293 model.setSort(DefaultSortAttribute, Qt::DescendingOrder); |
|
294 QCOMPARE(itemName(model,0),QString("ATestItem")); |
|
295 QCOMPARE(itemName(model,1),QString("BTestItem")); |
|
296 model.setSort(DefaultSortAttribute, Qt::AscendingOrder); |
|
297 QCOMPARE(itemName(model,0),QString("BTestItem")); |
|
298 QCOMPARE(itemName(model,1),QString("ATestItem")); |
|
299 //cleanup |
|
300 removeEntry("BTestItem"); |
|
301 removeEntry("ATestItem"); |
|
302 removeEntry("TestGroup"); |
|
303 |
|
304 } |
|
305 |
|
306 // --------------------------------------------------------------------------- |
|
307 // --------------------------------------------------------------------------- |
|
308 // |
|
309 void TestCaClient::TestCaItemModelUpdateItem() |
|
310 { |
|
311 // ensure that entries are not present in a storage |
|
312 removeEntry("TestItemBeforeUpdate"); |
|
313 removeEntry("TestItemAfterUpdate"); |
|
314 removeEntry("TestItemAfterSecondUpdate"); |
|
315 //test |
|
316 CaQuery query; |
|
317 query.addEntryTypeName("test_item"); |
|
318 CaItemModel model(query,NULL); |
|
319 model.setAutoUpdate(true); |
|
320 QSharedPointer<CaEntry> item1 = createItem("TestItemBeforeUpdate","test_item"); |
|
321 QTest::qWait(50); |
|
322 QCOMPARE(model.rowCount(),1); |
|
323 QCOMPARE(itemName(model,0),QString("TestItemBeforeUpdate")); |
|
324 item1->setText("TestItemAfterUpdate"); |
|
325 CaService::instance()->updateEntry(*item1); |
|
326 QTest::qWait(50); |
|
327 QCOMPARE(model.rowCount(),1); |
|
328 QCOMPARE(itemName(model,0),QString("TestItemAfterUpdate")); |
|
329 model.setAutoUpdate(false); |
|
330 item1->setText("TestItemAfterSecondUpdate"); |
|
331 CaService::instance()->updateEntry(*item1); |
|
332 QTest::qWait(50); |
|
333 QCOMPARE(model.rowCount(),1); |
|
334 QCOMPARE(itemName(model,0),QString("TestItemAfterUpdate"));// model not updated |
|
335 |
|
336 //cleanup |
|
337 removeEntry("TestItemBeforeUpdate"); |
|
338 removeEntry("TestItemAfterUpdate"); |
|
339 removeEntry("TestItemAfterSecondUpdate"); |
|
340 } |
|
341 |
|
342 // --------------------------------------------------------------------------- |
|
343 // --------------------------------------------------------------------------- |
|
344 // |
|
345 void TestCaClient::TestCaItemModelAddItems() |
|
346 { |
|
347 QSharedPointer<CaService> service = CaService::instance(); |
|
348 |
|
349 // ensure that entries are not present in a storage |
|
350 removeEntry("TestGroup"); |
|
351 |
|
352 removeEntry("1TestItem1"); |
|
353 removeEntry("1TestItem2"); |
|
354 removeEntry("1TestItem3"); |
|
355 |
|
356 removeEntry("2TestItem1"); |
|
357 |
|
358 removeEntry("3TestItem1"); |
|
359 removeEntry("3TestItem2"); |
|
360 removeEntry("3TestItem3"); |
|
361 |
|
362 removeEntry("0TestItem1"); |
|
363 removeEntry("0TestItem2"); |
|
364 |
|
365 removeEntry("1TestItem4"); |
|
366 removeEntry("1TestItem5"); |
|
367 |
|
368 removeEntry("2TestItem2"); |
|
369 removeEntry("2TestItem3"); |
|
370 |
|
371 removeEntry("3TestItem4"); |
|
372 removeEntry("3TestItem5"); |
|
373 |
|
374 // test group |
|
375 QSharedPointer<CaEntry> testGroup = createGroup("TestGroup","testfolder"); |
|
376 |
|
377 // test entries |
|
378 QList< QSharedPointer<CaEntry> > entryList; |
|
379 entryList << createItem("1TestItem1","testitem"); |
|
380 entryList << createItem("1TestItem2","testitem"); |
|
381 entryList << createItem("1TestItem3","testitem"); |
|
382 |
|
383 entryList << createItem("2TestItem1","testitem"); |
|
384 |
|
385 entryList << createItem("3TestItem1","testitem"); |
|
386 entryList << createItem("3TestItem2","testitem"); |
|
387 entryList << createItem("3TestItem3","testitem"); |
|
388 |
|
389 // entries for inserting into sorted order - notice the names |
|
390 entryList << createItem("0TestItem1","testitem"); |
|
391 entryList << createItem("0TestItem2","testitem"); |
|
392 |
|
393 entryList << createItem("1TestItem4","testitem"); |
|
394 entryList << createItem("1TestItem5","testitem"); |
|
395 |
|
396 entryList << createItem("2TestItem2","testitem"); |
|
397 entryList << createItem("2TestItem3","testitem"); |
|
398 |
|
399 entryList << createItem("3TestItem4","testitem"); |
|
400 entryList << createItem("3TestItem5","testitem"); |
|
401 |
|
402 // create a model to test |
|
403 CaQuery query; |
|
404 query.setParentId(testGroup->id()); |
|
405 CaItemModel model(query, NULL); |
|
406 model.setAutoUpdate(true); |
|
407 |
|
408 // create row insertion signal spyes; |
|
409 qRegisterMetaType<QModelIndex>("QModelIndex"); |
|
410 QSignalSpy rowsAboutToBeInsertedSpy( |
|
411 &model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int))); |
|
412 QSignalSpy rowsInsertedSpy( |
|
413 &model, SIGNAL(rowsInserted(QModelIndex,int,int))); |
|
414 QSignalSpy resetSpy( |
|
415 &model, SIGNAL(modelReset())); |
|
416 QList<QVariant> spyArguments; |
|
417 |
|
418 // ***[1]*** test adding 3 entries to an empty collection |
|
419 service->appendEntriesToGroup(*testGroup, entryList.mid(0, 3)); |
|
420 QTest::qWait(50); |
|
421 |
|
422 QCOMPARE(rowsAboutToBeInsertedSpy.count(), 1); |
|
423 spyArguments = rowsAboutToBeInsertedSpy.takeFirst(); |
|
424 // added 3 entries to the beginning of the group |
|
425 // first row in the signal should be 0 and the last row 2 |
|
426 QVERIFY(spyArguments.at(1).toInt() == 0); |
|
427 QVERIFY(spyArguments.at(2).toInt() == 2); |
|
428 |
|
429 QCOMPARE(rowsInsertedSpy.count(), 1); |
|
430 spyArguments = rowsInsertedSpy.takeFirst(); |
|
431 QVERIFY(spyArguments.at(1).toInt() == 0); |
|
432 QVERIFY(spyArguments.at(2).toInt() == 2); |
|
433 |
|
434 // ***[2]*** add 1 entry to a collection already containing items |
|
435 service->appendEntryToGroup(*testGroup, *entryList[3]); |
|
436 QTest::qWait(50); |
|
437 |
|
438 QCOMPARE(resetSpy.count(), 1); |
|
439 |
|
440 // ***[5]*** rearrange items |
|
441 model.setSort(DefaultSortAttribute); |
|
442 |
|
443 QSignalSpy layoutAboutToBeChangedSpy(&model, SIGNAL(layoutAboutToBeChanged())); |
|
444 QSignalSpy layoutChangedSpy(&model, SIGNAL(layoutChanged())); |
|
445 |
|
446 QList<int> idList; |
|
447 QSharedPointer<CaEntry> entry; |
|
448 foreach(entry, entryList) { |
|
449 idList << entry->id(); |
|
450 } |
|
451 // swap the first and last element to trigger a layout update |
|
452 idList.swap(0, idList.count() - 1); |
|
453 |
|
454 service->customSort(testGroup->id(), idList); |
|
455 QTest::qWait(50); |
|
456 |
|
457 QCOMPARE(layoutAboutToBeChangedSpy.count(), 1); |
|
458 QCOMPARE(layoutChangedSpy.count(), 1); |
|
459 |
|
460 |
|
461 removeEntry("1TestItem1"); |
|
462 removeEntry("1TestItem2"); |
|
463 removeEntry("1TestItem3"); |
|
464 removeEntry("2TestItem1"); |
|
465 removeEntry("3TestItem1"); |
|
466 removeEntry("3TestItem2"); |
|
467 removeEntry("3TestItem3"); |
|
468 removeEntry("0TestItem1"); |
|
469 removeEntry("0TestItem2"); |
|
470 removeEntry("1TestItem4"); |
|
471 removeEntry("1TestItem5"); |
|
472 removeEntry("2TestItem2"); |
|
473 removeEntry("2TestItem3"); |
|
474 removeEntry("3TestItem4"); |
|
475 removeEntry("3TestItem5"); |
|
476 removeEntry("TestGroup"); |
|
477 } |
|
478 |
|
479 // --------------------------------------------------------------------------- |
|
480 // --------------------------------------------------------------------------- |
|
481 // |
|
482 void TestCaClient::TestCaItemModelEmptySignal() |
|
483 { |
|
484 QSharedPointer<CaService> service = CaService::instance(); |
|
485 |
|
486 // ensure that entries are not present in a storage |
|
487 removeEntry("TestGroup_EmptySignal"); |
|
488 removeEntry("TestItem1"); |
|
489 removeEntry("TestItem2"); |
|
490 // test group |
|
491 QSharedPointer<CaEntry> testGroup = createGroup("TestGroup_EmptySignal","testfolder"); |
|
492 |
|
493 // test entries |
|
494 QSharedPointer<CaEntry> entry1 = createItem("TestItem1","testitem"); |
|
495 QSharedPointer<CaEntry> entry2 = createItem("TestItem2","testitem"); |
|
496 |
|
497 // create a model to test |
|
498 CaQuery query; |
|
499 query.setParentId(testGroup->id()); |
|
500 CaItemModel model(query, NULL); |
|
501 |
|
502 // create signal spyes; |
|
503 //qRegisterMetaType<QModelIndex>("QModelIndex"); |
|
504 QSignalSpy emptySignalSpy( |
|
505 &model, SIGNAL(empty(bool))); |
|
506 QList<QVariant> spyArguments; |
|
507 |
|
508 //test |
|
509 service->appendEntryToGroup(*testGroup.data(), *entry1.data()); |
|
510 QTest::qWait(50); |
|
511 QCOMPARE(emptySignalSpy.count(),1); |
|
512 |
|
513 spyArguments = emptySignalSpy.takeAt(0); |
|
514 QCOMPARE(spyArguments.at(0).toBool(), false); |
|
515 spyArguments.clear(); |
|
516 emptySignalSpy.clear(); |
|
517 |
|
518 service->appendEntryToGroup(*testGroup.data(), *entry2.data()); |
|
519 QTest::qWait(50); |
|
520 QCOMPARE(emptySignalSpy.count(),0); |
|
521 removeEntry("TestItem1"); |
|
522 QTest::qWait(50); |
|
523 QCOMPARE(emptySignalSpy.count(),0); |
|
524 removeEntry("TestItem2"); |
|
525 QTest::qWait(50); |
|
526 QCOMPARE(emptySignalSpy.count(),1); |
|
527 |
|
528 spyArguments = emptySignalSpy.takeAt(0); |
|
529 QCOMPARE(spyArguments.at(0).toBool(), true); |
|
530 |
|
531 |
|
532 //cleanup |
|
533 removeEntry("TestGroup_EmptySignal"); |
|
534 } |
|
535 |
|
536 // --------------------------------------------------------------------------- |
|
537 // UTILS |
|
538 // --------------------------------------------------------------------------- |
|
539 // |
|
540 QSharedPointer<CaEntry> TestCaClient::createGroup(const QString &groupName, const QString &typeName) |
|
541 { |
|
542 CaEntry item(GroupEntryRole); |
|
543 item.setText(groupName); |
|
544 item.setEntryTypeName(typeName); |
|
545 QSharedPointer<CaService> service = CaService::instance(); |
|
546 return service->createEntry(item); |
|
547 } |
|
548 |
|
549 // --------------------------------------------------------------------------- |
|
550 // --------------------------------------------------------------------------- |
|
551 // |
|
552 QSharedPointer<CaEntry> TestCaClient::createItem(const QString &itemName, const QString &description, |
|
553 const QString &typeName, EntryFlags flags) |
|
554 { |
|
555 CaEntry item(ItemEntryRole); |
|
556 item.setText(itemName); |
|
557 item.setDescription(description); |
|
558 item.setEntryTypeName(typeName); |
|
559 item.setFlags(flags); |
|
560 QSharedPointer<CaService> service = CaService::instance(); |
|
561 return service->createEntry(item); |
|
562 } |
|
563 |
|
564 // --------------------------------------------------------------------------- |
|
565 // --------------------------------------------------------------------------- |
|
566 // |
|
567 QSharedPointer<CaEntry> TestCaClient::createItem(const QString &itemName, const QString &typeName) |
|
568 { |
|
569 CaEntry item(ItemEntryRole); |
|
570 item.setText(itemName); |
|
571 item.setEntryTypeName(typeName); |
|
572 QSharedPointer<CaService> service = CaService::instance(); |
|
573 return service->createEntry(item); |
|
574 } |
|
575 |
|
576 // --------------------------------------------------------------------------- |
|
577 // --------------------------------------------------------------------------- |
|
578 // |
|
579 void TestCaClient::addItemToGroup(int groupId, int itemId) |
|
580 { |
|
581 QSharedPointer<CaService> service = CaService::instance(); |
|
582 service->appendEntryToGroup(groupId, itemId) ; |
|
583 } |
|
584 |
|
585 // --------------------------------------------------------------------------- |
|
586 // --------------------------------------------------------------------------- |
|
587 // |
|
588 void TestCaClient::removeItemFromGroup(int groupId, int itemId) |
|
589 { |
|
590 QSharedPointer<CaService> service = CaService::instance(); |
|
591 service->removeEntryFromGroup(groupId, itemId) ; |
|
592 } |
|
593 |
|
594 // --------------------------------------------------------------------------- |
|
595 // --------------------------------------------------------------------------- |
|
596 // |
|
597 void TestCaClient::removeEntry(int entryId) |
|
598 { |
|
599 QSharedPointer<CaService> service = CaService::instance(); |
|
600 service->removeEntry(entryId); |
|
601 } |
|
602 |
|
603 // --------------------------------------------------------------------------- |
|
604 // --------------------------------------------------------------------------- |
|
605 // |
|
606 bool TestCaClient::removeEntry(const QString &entryName) |
|
607 { |
|
608 bool found(false); |
|
609 QSharedPointer<CaService> service = CaService::instance(); |
|
610 CaQuery query; |
|
611 QList< QSharedPointer<CaEntry> > entries = service->getEntries(query); |
|
612 foreach(QSharedPointer<CaEntry> entry, entries) { |
|
613 if (entry->text() == entryName) { |
|
614 service->removeEntry(*entry); |
|
615 found = true; |
|
616 } |
|
617 } |
|
618 return found; |
|
619 } |
|
620 |
|
621 // --------------------------------------------------------------------------- |
|
622 // --------------------------------------------------------------------------- |
|
623 // |
|
624 QString TestCaClient::itemName(const CaItemModel &model, int row) |
|
625 { |
|
626 return model.data(model.index(row),CaItemModel::TextRole).toString(); |
|
627 } |