1 /*
2 SPDX-FileCopyrightText: 2014-2021 Laurent Montel <montel@kde.org>
3
4 SPDX-License-Identifier: GPL-2.0-or-later
5 */
6
7 #include "mergecontactstest.h"
8 #include "../job/mergecontacts.h"
9 #include <QTest>
10
11 using namespace KABMergeContacts;
12 using namespace KContacts;
MergeContactsTest(QObject * parent)13 MergeContactsTest::MergeContactsTest(QObject *parent)
14 : QObject(parent)
15 {
16 }
17
shouldReturnDefaultAddressWhenNoListItem()18 void MergeContactsTest::shouldReturnDefaultAddressWhenNoListItem()
19 {
20 MergeContacts contacts;
21 KContacts::Addressee result = contacts.mergedContact();
22 QCOMPARE(result.isEmpty(), true);
23 }
24
shouldReturnDefaultAddressWhenOneItem()25 void MergeContactsTest::shouldReturnDefaultAddressWhenOneItem()
26 {
27 Akonadi::Item::List lst;
28 Akonadi::Item item;
29 KContacts::Addressee address;
30 address.setName(QStringLiteral("foo1"));
31 item.setPayload<KContacts::Addressee>(address);
32 lst << item;
33
34 MergeContacts contacts(lst);
35 KContacts::Addressee result = contacts.mergedContact();
36 QCOMPARE(result.isEmpty(), true);
37 }
38
noNeedManualSelectionCheckWhenEmptyList()39 void MergeContactsTest::noNeedManualSelectionCheckWhenEmptyList()
40 {
41 MergeContacts contacts;
42 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
43 QCOMPARE(result, MergeContacts::None);
44 }
45
noNeedManualSelectionCheckWhenOneItem()46 void MergeContactsTest::noNeedManualSelectionCheckWhenOneItem()
47 {
48 Akonadi::Item::List lst;
49 KContacts::Addressee address;
50 Akonadi::Item item;
51 address.setName(QStringLiteral("foo1"));
52 item.setPayload<KContacts::Addressee>(address);
53 lst << item;
54 MergeContacts contacts(lst);
55 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
56 QCOMPARE(result, MergeContacts::None);
57 }
58
checkNeedManualSelectionWithName_data()59 void MergeContactsTest::checkNeedManualSelectionWithName_data()
60 {
61 QTest::addColumn<QString>("nameItemA");
62 QTest::addColumn<QString>("nameItemB");
63 QTest::addColumn<QString>("nameItemC");
64 QTest::addColumn<bool>("needManualCheck");
65 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
66 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
67 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
68 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
69 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
70 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
71 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
72 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
73 }
74
checkNeedManualSelectionWithName()75 void MergeContactsTest::checkNeedManualSelectionWithName()
76 {
77 QFETCH(QString, nameItemA);
78 QFETCH(QString, nameItemB);
79 QFETCH(QString, nameItemC);
80 QFETCH(bool, needManualCheck);
81
82 Akonadi::Item::List lst;
83 Addressee addressA;
84 Akonadi::Item itemA;
85 addressA.setName(nameItemA);
86 itemA.setPayload<Addressee>(addressA);
87 lst << itemA;
88
89 Addressee addressB;
90 Akonadi::Item itemB;
91 addressB.setName(nameItemB);
92 itemB.setPayload<Addressee>(addressB);
93 lst << itemB;
94
95 Addressee addressC;
96 Akonadi::Item itemC;
97 addressC.setName(nameItemC);
98 itemC.setPayload<Addressee>(addressC);
99 lst << itemC;
100
101 MergeContacts contacts(lst);
102 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
103 const bool bResult = (result == MergeContacts::Name);
104 QCOMPARE(bResult, needManualCheck);
105 }
106
checkNeedManualSelectionWithNickName_data()107 void MergeContactsTest::checkNeedManualSelectionWithNickName_data()
108 {
109 QTest::addColumn<QString>("nameItemA");
110 QTest::addColumn<QString>("nameItemB");
111 QTest::addColumn<QString>("nameItemC");
112 QTest::addColumn<bool>("needManualCheck");
113 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
114 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
115 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
116 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
117 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
118 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
119 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
120 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
121 }
122
checkNeedManualSelectionWithNickName()123 void MergeContactsTest::checkNeedManualSelectionWithNickName()
124 {
125 QFETCH(QString, nameItemA);
126 QFETCH(QString, nameItemB);
127 QFETCH(QString, nameItemC);
128 QFETCH(bool, needManualCheck);
129
130 Akonadi::Item::List lst;
131 Addressee addressA;
132 Akonadi::Item itemA;
133 addressA.setNickName(nameItemA);
134 itemA.setPayload<Addressee>(addressA);
135 lst << itemA;
136
137 Addressee addressB;
138 Akonadi::Item itemB;
139 addressB.setNickName(nameItemB);
140 itemB.setPayload<Addressee>(addressB);
141 lst << itemB;
142
143 Addressee addressC;
144 Akonadi::Item itemC;
145 addressC.setNickName(nameItemC);
146 itemC.setPayload<Addressee>(addressC);
147 lst << itemC;
148
149 MergeContacts contacts(lst);
150 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
151 const bool bResult = (result == MergeContacts::NickName);
152 QCOMPARE(bResult, needManualCheck);
153 }
154
checkNeedManualSelectionWithOrganization_data()155 void MergeContactsTest::checkNeedManualSelectionWithOrganization_data()
156 {
157 QTest::addColumn<QString>("nameItemA");
158 QTest::addColumn<QString>("nameItemB");
159 QTest::addColumn<QString>("nameItemC");
160 QTest::addColumn<bool>("needManualCheck");
161 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
162 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
163 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
164 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
165 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
166 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
167 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
168 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
169 }
170
checkNeedManualSelectionWithOrganization()171 void MergeContactsTest::checkNeedManualSelectionWithOrganization()
172 {
173 QFETCH(QString, nameItemA);
174 QFETCH(QString, nameItemB);
175 QFETCH(QString, nameItemC);
176 QFETCH(bool, needManualCheck);
177
178 Akonadi::Item::List lst;
179 Addressee addressA;
180 Akonadi::Item itemA;
181 addressA.setOrganization(nameItemA);
182 itemA.setPayload<Addressee>(addressA);
183 lst << itemA;
184
185 Addressee addressB;
186 Akonadi::Item itemB;
187 addressB.setOrganization(nameItemB);
188 itemB.setPayload<Addressee>(addressB);
189 lst << itemB;
190
191 Addressee addressC;
192 Akonadi::Item itemC;
193 addressC.setOrganization(nameItemC);
194 itemC.setPayload<Addressee>(addressC);
195 lst << itemC;
196
197 MergeContacts contacts(lst);
198 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
199 const bool bResult = (result == MergeContacts::Organization);
200 QCOMPARE(bResult, needManualCheck);
201 }
202
checkNeedManualSelectionWithTitle_data()203 void MergeContactsTest::checkNeedManualSelectionWithTitle_data()
204 {
205 QTest::addColumn<QString>("nameItemA");
206 QTest::addColumn<QString>("nameItemB");
207 QTest::addColumn<QString>("nameItemC");
208 QTest::addColumn<bool>("needManualCheck");
209 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
210 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
211 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
212 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
213 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
214 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
215 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
216 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
217 }
218
checkNeedManualSelectionWithTitle()219 void MergeContactsTest::checkNeedManualSelectionWithTitle()
220 {
221 QFETCH(QString, nameItemA);
222 QFETCH(QString, nameItemB);
223 QFETCH(QString, nameItemC);
224 QFETCH(bool, needManualCheck);
225
226 Akonadi::Item::List lst;
227 Addressee addressA;
228 Akonadi::Item itemA;
229 addressA.setTitle(nameItemA);
230 itemA.setPayload<Addressee>(addressA);
231 lst << itemA;
232
233 Addressee addressB;
234 Akonadi::Item itemB;
235 addressB.setTitle(nameItemB);
236 itemB.setPayload<Addressee>(addressB);
237 lst << itemB;
238
239 Addressee addressC;
240 Akonadi::Item itemC;
241 addressC.setTitle(nameItemC);
242 itemC.setPayload<Addressee>(addressC);
243 lst << itemC;
244
245 MergeContacts contacts(lst);
246 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
247 const bool bResult = (result == MergeContacts::Title);
248 QCOMPARE(bResult, needManualCheck);
249 }
250
checkNeedManualSelectionWithFamilyName_data()251 void MergeContactsTest::checkNeedManualSelectionWithFamilyName_data()
252 {
253 QTest::addColumn<QString>("nameItemA");
254 QTest::addColumn<QString>("nameItemB");
255 QTest::addColumn<QString>("nameItemC");
256 QTest::addColumn<bool>("needManualCheck");
257 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
258 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
259 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
260 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
261 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
262 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
263 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
264 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
265 }
266
checkNeedManualSelectionWithFamilyName()267 void MergeContactsTest::checkNeedManualSelectionWithFamilyName()
268 {
269 QFETCH(QString, nameItemA);
270 QFETCH(QString, nameItemB);
271 QFETCH(QString, nameItemC);
272 QFETCH(bool, needManualCheck);
273
274 Akonadi::Item::List lst;
275 Addressee addressA;
276 Akonadi::Item itemA;
277 addressA.setFamilyName(nameItemA);
278 itemA.setPayload<Addressee>(addressA);
279 lst << itemA;
280
281 Addressee addressB;
282 Akonadi::Item itemB;
283 addressB.setFamilyName(nameItemB);
284 itemB.setPayload<Addressee>(addressB);
285 lst << itemB;
286
287 Addressee addressC;
288 Akonadi::Item itemC;
289 addressC.setFamilyName(nameItemC);
290 itemC.setPayload<Addressee>(addressC);
291 lst << itemC;
292
293 MergeContacts contacts(lst);
294 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
295 const bool bResult = (result == MergeContacts::FamilyName);
296 QCOMPARE(bResult, needManualCheck);
297 }
298
checkNeedManualSelectionWithDepartement_data()299 void MergeContactsTest::checkNeedManualSelectionWithDepartement_data()
300 {
301 QTest::addColumn<QString>("nameItemA");
302 QTest::addColumn<QString>("nameItemB");
303 QTest::addColumn<QString>("nameItemC");
304 QTest::addColumn<bool>("needManualCheck");
305 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
306 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
307 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
308 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
309 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
310 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
311 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
312 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
313 }
314
checkNeedManualSelectionWithDepartement()315 void MergeContactsTest::checkNeedManualSelectionWithDepartement()
316 {
317 QFETCH(QString, nameItemA);
318 QFETCH(QString, nameItemB);
319 QFETCH(QString, nameItemC);
320 QFETCH(bool, needManualCheck);
321
322 Akonadi::Item::List lst;
323 Addressee addressA;
324 Akonadi::Item itemA;
325 addressA.setDepartment(nameItemA);
326 itemA.setPayload<Addressee>(addressA);
327 lst << itemA;
328
329 Addressee addressB;
330 Akonadi::Item itemB;
331 addressB.setDepartment(nameItemB);
332 itemB.setPayload<Addressee>(addressB);
333 lst << itemB;
334
335 Addressee addressC;
336 Akonadi::Item itemC;
337 addressC.setDepartment(nameItemC);
338 itemC.setPayload<Addressee>(addressC);
339 lst << itemC;
340
341 MergeContacts contacts(lst);
342 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
343 const bool bResult = (result == MergeContacts::Departement);
344 QCOMPARE(bResult, needManualCheck);
345 }
346
checkNeedManualSelectionWithProfession_data()347 void MergeContactsTest::checkNeedManualSelectionWithProfession_data()
348 {
349 QTest::addColumn<QString>("nameItemA");
350 QTest::addColumn<QString>("nameItemB");
351 QTest::addColumn<QString>("nameItemC");
352 QTest::addColumn<bool>("needManualCheck");
353 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
354 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
355 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
356 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
357 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
358 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
359 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
360 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
361 }
362
checkNeedManualSelectionWithProfession()363 void MergeContactsTest::checkNeedManualSelectionWithProfession()
364 {
365 QFETCH(QString, nameItemA);
366 QFETCH(QString, nameItemB);
367 QFETCH(QString, nameItemC);
368 QFETCH(bool, needManualCheck);
369
370 Akonadi::Item::List lst;
371 Addressee addressA;
372 Akonadi::Item itemA;
373 addressA.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Profession"), nameItemA);
374 itemA.setPayload<KContacts::Addressee>(addressA);
375 lst << itemA;
376
377 Addressee addressB;
378 Akonadi::Item itemB;
379 addressB.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Profession"), nameItemB);
380 itemB.setPayload<KContacts::Addressee>(addressB);
381 lst << itemB;
382
383 Addressee addressC;
384 Akonadi::Item itemC;
385 addressC.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Profession"), nameItemC);
386 itemC.setPayload<KContacts::Addressee>(addressC);
387 lst << itemC;
388
389 MergeContacts contacts(lst);
390 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
391 const bool bResult = (result == MergeContacts::Profession);
392 QCOMPARE(bResult, needManualCheck);
393 }
394
checkNeedManualSelectionWithOffice_data()395 void MergeContactsTest::checkNeedManualSelectionWithOffice_data()
396 {
397 QTest::addColumn<QString>("nameItemA");
398 QTest::addColumn<QString>("nameItemB");
399 QTest::addColumn<QString>("nameItemC");
400 QTest::addColumn<bool>("needManualCheck");
401 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
402 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
403 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
404 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
405 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
406 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
407 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
408 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
409 }
410
checkNeedManualSelectionWithOffice()411 void MergeContactsTest::checkNeedManualSelectionWithOffice()
412 {
413 QFETCH(QString, nameItemA);
414 QFETCH(QString, nameItemB);
415 QFETCH(QString, nameItemC);
416 QFETCH(bool, needManualCheck);
417
418 Akonadi::Item::List lst;
419 Addressee addressA;
420 Akonadi::Item itemA;
421 addressA.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Office"), nameItemA);
422 itemA.setPayload<KContacts::Addressee>(addressA);
423 lst << itemA;
424
425 Addressee addressB;
426 Akonadi::Item itemB;
427 addressB.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Office"), nameItemB);
428 itemB.setPayload<KContacts::Addressee>(addressB);
429 lst << itemB;
430
431 Addressee addressC;
432 Akonadi::Item itemC;
433 addressC.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Office"), nameItemC);
434 itemC.setPayload<KContacts::Addressee>(addressC);
435 lst << itemC;
436
437 MergeContacts contacts(lst);
438 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
439 const bool bResult = (result == MergeContacts::Office);
440 QCOMPARE(bResult, needManualCheck);
441 }
442
checkNeedManualSelectionWithManagerName_data()443 void MergeContactsTest::checkNeedManualSelectionWithManagerName_data()
444 {
445 QTest::addColumn<QString>("nameItemA");
446 QTest::addColumn<QString>("nameItemB");
447 QTest::addColumn<QString>("nameItemC");
448 QTest::addColumn<bool>("needManualCheck");
449 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
450 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
451 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
452 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
453 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
454 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
455 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
456 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
457 }
458
checkNeedManualSelectionWithManagerName()459 void MergeContactsTest::checkNeedManualSelectionWithManagerName()
460 {
461 QFETCH(QString, nameItemA);
462 QFETCH(QString, nameItemB);
463 QFETCH(QString, nameItemC);
464 QFETCH(bool, needManualCheck);
465
466 Akonadi::Item::List lst;
467 Addressee addressA;
468 Akonadi::Item itemA;
469 addressA.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-ManagersName"), nameItemA);
470 itemA.setPayload<KContacts::Addressee>(addressA);
471 lst << itemA;
472
473 Addressee addressB;
474 Akonadi::Item itemB;
475 addressB.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-ManagersName"), nameItemB);
476 itemB.setPayload<KContacts::Addressee>(addressB);
477 lst << itemB;
478
479 Addressee addressC;
480 Akonadi::Item itemC;
481 addressC.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-ManagersName"), nameItemC);
482 itemC.setPayload<KContacts::Addressee>(addressC);
483 lst << itemC;
484
485 MergeContacts contacts(lst);
486 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
487 const bool bResult = (result == MergeContacts::ManagerName);
488 QCOMPARE(bResult, needManualCheck);
489 }
490
checkNeedManualSelectionWithAssistantName_data()491 void MergeContactsTest::checkNeedManualSelectionWithAssistantName_data()
492 {
493 QTest::addColumn<QString>("nameItemA");
494 QTest::addColumn<QString>("nameItemB");
495 QTest::addColumn<QString>("nameItemC");
496 QTest::addColumn<bool>("needManualCheck");
497 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
498 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
499 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
500 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
501 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
502 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
503 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
504 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
505 }
506
checkNeedManualSelectionWithAssistantName()507 void MergeContactsTest::checkNeedManualSelectionWithAssistantName()
508 {
509 QFETCH(QString, nameItemA);
510 QFETCH(QString, nameItemB);
511 QFETCH(QString, nameItemC);
512 QFETCH(bool, needManualCheck);
513
514 Akonadi::Item::List lst;
515 Addressee addressA;
516 Akonadi::Item itemA;
517 addressA.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-AssistantsName"), nameItemA);
518 itemA.setPayload<KContacts::Addressee>(addressA);
519 lst << itemA;
520
521 Addressee addressB;
522 Akonadi::Item itemB;
523 addressB.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-AssistantsName"), nameItemB);
524 itemB.setPayload<KContacts::Addressee>(addressB);
525 lst << itemB;
526
527 Addressee addressC;
528 Akonadi::Item itemC;
529 addressC.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-AssistantsName"), nameItemC);
530 itemC.setPayload<KContacts::Addressee>(addressC);
531 lst << itemC;
532
533 MergeContacts contacts(lst);
534 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
535 const bool bResult = (result == MergeContacts::Assistant);
536 QCOMPARE(bResult, needManualCheck);
537 }
538
checkNeedManualSelectionWithAnniversary_data()539 void MergeContactsTest::checkNeedManualSelectionWithAnniversary_data()
540 {
541 QTest::addColumn<QString>("nameItemA");
542 QTest::addColumn<QString>("nameItemB");
543 QTest::addColumn<QString>("nameItemC");
544 QTest::addColumn<bool>("needManualCheck");
545 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
546 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
547 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
548 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
549 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
550 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
551 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
552 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
553 }
554
checkNeedManualSelectionWithAnniversary()555 void MergeContactsTest::checkNeedManualSelectionWithAnniversary()
556 {
557 QFETCH(QString, nameItemA);
558 QFETCH(QString, nameItemB);
559 QFETCH(QString, nameItemC);
560 QFETCH(bool, needManualCheck);
561
562 Akonadi::Item::List lst;
563 Addressee addressA;
564 Akonadi::Item itemA;
565 addressA.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Anniversary"), nameItemA);
566 itemA.setPayload<KContacts::Addressee>(addressA);
567 lst << itemA;
568
569 Addressee addressB;
570 Akonadi::Item itemB;
571 addressB.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Anniversary"), nameItemB);
572 itemB.setPayload<KContacts::Addressee>(addressB);
573 lst << itemB;
574
575 Addressee addressC;
576 Akonadi::Item itemC;
577 addressC.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-Anniversary"), nameItemC);
578 itemC.setPayload<KContacts::Addressee>(addressC);
579 lst << itemC;
580
581 MergeContacts contacts(lst);
582 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
583 const bool bResult = (result == MergeContacts::Anniversary);
584 QCOMPARE(bResult, needManualCheck);
585 }
586
shouldMergeTitle_data()587 void MergeContactsTest::shouldMergeTitle_data()
588 {
589 QTest::addColumn<QString>("nameItemA");
590 QTest::addColumn<QString>("nameItemB");
591 QTest::addColumn<QString>("nameItemC");
592 QTest::addColumn<bool>("isEmpty");
593 QTest::addColumn<QString>("result");
594 QTest::newRow("empty") << QString() << QString() << QString() << false << QString();
595 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false << QStringLiteral("foo");
596 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false << QStringLiteral("foo");
597 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false << QStringLiteral("foo");
598 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false << QStringLiteral("foo");
599 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false << QStringLiteral("foo");
600 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << false << QStringLiteral("foo");
601 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << false << QStringLiteral("foo1");
602 }
603
shouldMergeTitle()604 void MergeContactsTest::shouldMergeTitle()
605 {
606 QFETCH(QString, nameItemA);
607 QFETCH(QString, nameItemB);
608 QFETCH(QString, nameItemC);
609 QFETCH(bool, isEmpty);
610 QFETCH(QString, result);
611
612 Akonadi::Item::List lst;
613 Addressee addressA;
614 addressA.setTitle(nameItemA);
615 Akonadi::Item itemA;
616 itemA.setPayload<Addressee>(addressA);
617 lst << itemA;
618
619 Addressee addressB;
620 Akonadi::Item itemB;
621 addressB.setTitle(nameItemB);
622 itemB.setPayload<Addressee>(addressB);
623 lst << itemB;
624
625 Addressee addressC;
626 Akonadi::Item itemC;
627 addressC.setTitle(nameItemC);
628 itemC.setPayload<Addressee>(addressC);
629 lst << itemC;
630
631 MergeContacts contacts(lst);
632 KContacts::Addressee resultAddr = contacts.mergedContact();
633 QCOMPARE(resultAddr.isEmpty(), isEmpty);
634 QCOMPARE(resultAddr.title(), result);
635 }
636
shouldMergeDepartement_data()637 void MergeContactsTest::shouldMergeDepartement_data()
638 {
639 QTest::addColumn<QString>("nameItemA");
640 QTest::addColumn<QString>("nameItemB");
641 QTest::addColumn<QString>("nameItemC");
642 QTest::addColumn<bool>("isEmpty");
643 QTest::addColumn<QString>("result");
644 QTest::newRow("empty") << QString() << QString() << QString() << false << QString();
645 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false << QStringLiteral("foo");
646 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false << QStringLiteral("foo");
647 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false << QStringLiteral("foo");
648 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false << QStringLiteral("foo");
649 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false << QStringLiteral("foo");
650 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << false << QStringLiteral("foo");
651 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << false << QStringLiteral("foo1");
652 }
653
shouldMergeDepartement()654 void MergeContactsTest::shouldMergeDepartement()
655 {
656 QFETCH(QString, nameItemA);
657 QFETCH(QString, nameItemB);
658 QFETCH(QString, nameItemC);
659 QFETCH(bool, isEmpty);
660 QFETCH(QString, result);
661
662 Akonadi::Item::List lst;
663 Addressee addressA;
664 addressA.setDepartment(nameItemA);
665 Akonadi::Item itemA;
666 itemA.setPayload<Addressee>(addressA);
667 lst << itemA;
668
669 Addressee addressB;
670 Akonadi::Item itemB;
671 addressB.setDepartment(nameItemB);
672 itemB.setPayload<Addressee>(addressB);
673 lst << itemB;
674
675 Addressee addressC;
676 Akonadi::Item itemC;
677 addressC.setDepartment(nameItemC);
678 itemC.setPayload<Addressee>(addressC);
679 lst << itemC;
680
681 MergeContacts contacts(lst);
682 KContacts::Addressee resultAddr = contacts.mergedContact();
683 QCOMPARE(resultAddr.isEmpty(), isEmpty);
684 QCOMPARE(resultAddr.department(), result);
685 }
686
checkNeedManualSelectionWithPartnersName_data()687 void MergeContactsTest::checkNeedManualSelectionWithPartnersName_data()
688 {
689 QTest::addColumn<QString>("nameItemA");
690 QTest::addColumn<QString>("nameItemB");
691 QTest::addColumn<QString>("nameItemC");
692 QTest::addColumn<bool>("needManualCheck");
693 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
694 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
695 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
696 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
697 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
698 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
699 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
700 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
701 }
702
checkNeedManualSelectionWithPartnersName()703 void MergeContactsTest::checkNeedManualSelectionWithPartnersName()
704 {
705 QFETCH(QString, nameItemA);
706 QFETCH(QString, nameItemB);
707 QFETCH(QString, nameItemC);
708 QFETCH(bool, needManualCheck);
709
710 Akonadi::Item::List lst;
711 Addressee addressA;
712 Akonadi::Item itemA;
713 addressA.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-SpousesName"), nameItemA);
714 itemA.setPayload<KContacts::Addressee>(addressA);
715 lst << itemA;
716
717 Addressee addressB;
718 Akonadi::Item itemB;
719 addressB.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-SpousesName"), nameItemB);
720 itemB.setPayload<KContacts::Addressee>(addressB);
721 lst << itemB;
722
723 Addressee addressC;
724 Akonadi::Item itemC;
725 addressC.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("X-SpousesName"), nameItemC);
726 itemC.setPayload<KContacts::Addressee>(addressC);
727 lst << itemC;
728
729 MergeContacts contacts(lst);
730 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
731 const bool bResult = (result == MergeContacts::PartnerName);
732 QCOMPARE(bResult, needManualCheck);
733 }
734
checkNeedManualSelectionWithBlog_data()735 void MergeContactsTest::checkNeedManualSelectionWithBlog_data()
736 {
737 QTest::addColumn<QString>("nameItemA");
738 QTest::addColumn<QString>("nameItemB");
739 QTest::addColumn<QString>("nameItemC");
740 QTest::addColumn<bool>("needManualCheck");
741 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
742 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false;
743 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false;
744 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false;
745 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false;
746 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false;
747 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << true;
748 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << true;
749 }
750
checkNeedManualSelectionWithBlog()751 void MergeContactsTest::checkNeedManualSelectionWithBlog()
752 {
753 QFETCH(QString, nameItemA);
754 QFETCH(QString, nameItemB);
755 QFETCH(QString, nameItemC);
756 QFETCH(bool, needManualCheck);
757
758 Akonadi::Item::List lst;
759 Addressee addressA;
760 Akonadi::Item itemA;
761 addressA.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("BlogFeed"), nameItemA);
762 itemA.setPayload<KContacts::Addressee>(addressA);
763 lst << itemA;
764
765 Addressee addressB;
766 Akonadi::Item itemB;
767 addressB.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("BlogFeed"), nameItemB);
768 itemB.setPayload<KContacts::Addressee>(addressB);
769 lst << itemB;
770
771 Addressee addressC;
772 Akonadi::Item itemC;
773 addressC.insertCustom(QStringLiteral("KADDRESSBOOK"), QStringLiteral("BlogFeed"), nameItemC);
774 itemC.setPayload<KContacts::Addressee>(addressC);
775 lst << itemC;
776
777 MergeContacts contacts(lst);
778 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
779 const bool bResult = (result == MergeContacts::Blog);
780 QCOMPARE(bResult, needManualCheck);
781 }
782
checkNeedManualSelectionWithHomePage_data()783 void MergeContactsTest::checkNeedManualSelectionWithHomePage_data()
784 {
785 QTest::addColumn<QUrl>("nameItemA");
786 QTest::addColumn<QUrl>("nameItemB");
787 QTest::addColumn<QUrl>("nameItemC");
788 QTest::addColumn<bool>("needManualCheck");
789 QTest::newRow("noConflict") << QUrl() << QUrl() << QUrl() << false;
790 QTest::newRow("noWithOneNameConflict") << QUrl() << QUrl() << QUrl(QStringLiteral("http://www.kde.org")) << false;
791 QTest::newRow("noWithOneNameConflict1") << QUrl() << QUrl(QStringLiteral("http://www.kde.org")) << QUrl() << false;
792 QTest::newRow("noWithOneNameConflict2") << QUrl(QStringLiteral("http://www.kde.org")) << QUrl() << QUrl() << false;
793 QTest::newRow("noConflictWithSameName") << QUrl(QStringLiteral("http://www.kde.org")) << QUrl(QStringLiteral("http://www.kde.org")) << QUrl() << false;
794 QTest::newRow("noConflictWithSameName2") << QUrl(QStringLiteral("http://www.kde.org")) << QUrl(QStringLiteral("http://www.kde.org"))
795 << QUrl(QStringLiteral("http://www.kde.org")) << false;
796 QTest::newRow("conflictUrl") << QUrl(QStringLiteral("http://www.kde.org")) << QUrl(QStringLiteral("http://www.kde.org1"))
797 << QUrl(QStringLiteral("http://www.kde.org")) << true;
798 QTest::newRow("conflict1") << QUrl() << QUrl(QStringLiteral("http://www.kde.org1")) << QUrl(QStringLiteral("http://www.kde.org")) << true;
799 }
800
checkNeedManualSelectionWithHomePage()801 void MergeContactsTest::checkNeedManualSelectionWithHomePage()
802 {
803 QFETCH(QUrl, nameItemA);
804 QFETCH(QUrl, nameItemB);
805 QFETCH(QUrl, nameItemC);
806 QFETCH(bool, needManualCheck);
807
808 Akonadi::Item::List lst;
809 Addressee addressA;
810 Akonadi::Item itemA;
811 KContacts::ResourceLocatorUrl url;
812 url.setUrl(nameItemA);
813 addressA.setUrl(url);
814 itemA.setPayload<Addressee>(addressA);
815 lst << itemA;
816
817 Addressee addressB;
818 Akonadi::Item itemB;
819 url.setUrl(nameItemB);
820 addressB.setUrl(url);
821 itemB.setPayload<Addressee>(addressB);
822 lst << itemB;
823
824 Addressee addressC;
825 Akonadi::Item itemC;
826 url.setUrl(nameItemC);
827 addressC.setUrl(url);
828 itemC.setPayload<Addressee>(addressC);
829 lst << itemC;
830
831 MergeContacts contacts(lst);
832 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
833 const bool bResult = (result == MergeContacts::HomePage);
834 QCOMPARE(bResult, needManualCheck);
835 }
836
shouldMergeNotes_data()837 void MergeContactsTest::shouldMergeNotes_data()
838 {
839 QTest::addColumn<QString>("noteItemA");
840 QTest::addColumn<QString>("noteItemB");
841 QTest::addColumn<QString>("noteItemC");
842 QTest::addColumn<QString>("note");
843 QTest::newRow("noNotes") << QString() << QString() << QString() << QString();
844 QTest::newRow("oneNotes") << QStringLiteral("one") << QString() << QString() << QStringLiteral("one");
845 QTest::newRow("twoNotes") << QString() << QStringLiteral("one") << QStringLiteral("one") << QStringLiteral("one\none");
846 QTest::newRow("threeNotes") << QStringLiteral("one") << QStringLiteral("one") << QStringLiteral("one") << QStringLiteral("one\none\none");
847 }
848
shouldMergeNotes()849 void MergeContactsTest::shouldMergeNotes()
850 {
851 QFETCH(QString, noteItemA);
852 QFETCH(QString, noteItemB);
853 QFETCH(QString, noteItemC);
854 QFETCH(QString, note);
855
856 Akonadi::Item::List lst;
857 Addressee addressA;
858 Akonadi::Item itemA;
859 addressA.setName(QStringLiteral("foo1"));
860 addressA.setNote(noteItemA);
861 itemA.setPayload<Addressee>(addressA);
862 lst << itemA;
863
864 Addressee addressB;
865 Akonadi::Item itemB;
866 addressB.setName(QStringLiteral("foo1"));
867 addressB.setNote(noteItemB);
868 itemB.setPayload<Addressee>(addressB);
869 lst << itemB;
870
871 Addressee addressC;
872 Akonadi::Item itemC;
873 addressC.setName(QStringLiteral("foo1"));
874 addressC.setNote(noteItemC);
875 itemC.setPayload<Addressee>(addressC);
876 lst << itemC;
877
878 MergeContacts contacts(lst);
879
880 const Addressee result = contacts.mergedContact();
881 QCOMPARE(result.note(), note);
882 }
883
shouldMergeEmails_data()884 void MergeContactsTest::shouldMergeEmails_data()
885 {
886 QTest::addColumn<QStringList>("emailsItemA");
887 QTest::addColumn<QStringList>("emailsItemB");
888 QTest::addColumn<QStringList>("emailsItemC");
889 QTest::addColumn<QStringList>("emails");
890 QTest::newRow("noEmails") << QStringList() << QStringList() << QStringList() << QStringList();
891 QStringList lst;
892 lst << QStringLiteral("foo");
893 lst << QStringLiteral("foo1");
894 lst << QStringLiteral("foo2");
895 QTest::newRow("copyFromOnContact") << lst << QStringList() << QStringList() << lst;
896 QTest::newRow("copyFromTwoIdenticContact") << lst << lst << QStringList() << lst;
897 QStringList lst2;
898 lst2 << QStringLiteral("foo5");
899 lst2 << QStringLiteral("foo6");
900 lst2 << QStringLiteral("foo7");
901
902 QTest::newRow("copyFromTwoDifferentContact") << lst << lst2 << QStringList() << (QStringList() << lst << lst2);
903 QStringList lst3;
904 lst3 << QStringLiteral("foo2");
905 lst3 << lst2;
906 // Identic => we will return merge between lst and lst2
907 QTest::newRow("copyWithSomeIdenticEmail") << lst << lst3 << QStringList() << (QStringList() << lst << lst2);
908 }
909
shouldMergeEmails()910 void MergeContactsTest::shouldMergeEmails()
911 {
912 QFETCH(QStringList, emailsItemA);
913 QFETCH(QStringList, emailsItemB);
914 QFETCH(QStringList, emailsItemC);
915 QFETCH(QStringList, emails);
916
917 Akonadi::Item::List lst;
918 Addressee addressA;
919 Akonadi::Item itemA;
920 addressA.setName(QStringLiteral("foo1"));
921 addressA.setEmails(emailsItemA);
922 itemA.setPayload<Addressee>(addressA);
923 lst << itemA;
924
925 Addressee addressB;
926 Akonadi::Item itemB;
927 addressB.setName(QStringLiteral("foo1"));
928 addressB.setEmails(emailsItemB);
929 itemB.setPayload<Addressee>(addressB);
930 lst << itemB;
931
932 Addressee addressC;
933 Akonadi::Item itemC;
934 addressC.setName(QStringLiteral("foo1"));
935 addressC.setEmails(emailsItemC);
936 itemC.setPayload<Addressee>(addressC);
937 lst << itemC;
938
939 MergeContacts contacts(lst);
940
941 const Addressee result = contacts.mergedContact();
942 QCOMPARE(result.emails(), emails);
943 }
944
shouldMergeFamilyname_data()945 void MergeContactsTest::shouldMergeFamilyname_data()
946 {
947 QTest::addColumn<QString>("nameItemA");
948 QTest::addColumn<QString>("nameItemB");
949 QTest::addColumn<QString>("nameItemC");
950 QTest::addColumn<bool>("isEmpty");
951 QTest::addColumn<QString>("result");
952 QTest::newRow("empty") << QString() << QString() << QString() << false << QString();
953 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false << QStringLiteral("foo");
954 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false << QStringLiteral("foo");
955 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false << QStringLiteral("foo");
956 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false << QStringLiteral("foo");
957 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false << QStringLiteral("foo");
958 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << false << QStringLiteral("foo");
959 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << false << QStringLiteral("foo1");
960 }
961
shouldMergeFamilyname()962 void MergeContactsTest::shouldMergeFamilyname()
963 {
964 QFETCH(QString, nameItemA);
965 QFETCH(QString, nameItemB);
966 QFETCH(QString, nameItemC);
967 QFETCH(bool, isEmpty);
968 QFETCH(QString, result);
969
970 Akonadi::Item::List lst;
971 Addressee addressA;
972 addressA.setFamilyName(nameItemA);
973 Akonadi::Item itemA;
974 itemA.setPayload<Addressee>(addressA);
975 lst << itemA;
976
977 Addressee addressB;
978 Akonadi::Item itemB;
979 addressB.setFamilyName(nameItemB);
980 itemB.setPayload<Addressee>(addressB);
981 lst << itemB;
982
983 Addressee addressC;
984 Akonadi::Item itemC;
985 addressC.setFamilyName(nameItemC);
986 itemC.setPayload<Addressee>(addressC);
987 lst << itemC;
988
989 MergeContacts contacts(lst);
990 Addressee resultAddr = contacts.mergedContact();
991 QCOMPARE(resultAddr.isEmpty(), isEmpty);
992 QCOMPARE(resultAddr.familyName(), result);
993 }
994
shouldMergeBlogFeed_data()995 void MergeContactsTest::shouldMergeBlogFeed_data()
996 {
997 QTest::addColumn<QString>("nameItemA");
998 QTest::addColumn<QString>("nameItemB");
999 QTest::addColumn<QString>("nameItemC");
1000 QTest::addColumn<bool>("isEmpty");
1001 QTest::addColumn<QString>("result");
1002 QTest::newRow("empty") << QString() << QString() << QString() << false << QString();
1003 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("foo") << false << QStringLiteral("foo");
1004 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("foo") << QString() << false << QStringLiteral("foo");
1005 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("foo") << QString() << QString() << false << QStringLiteral("foo");
1006 QTest::newRow("noConflictWithSameName") << QStringLiteral("foo") << QStringLiteral("foo") << QString() << false << QStringLiteral("foo");
1007 QTest::newRow("noConflictWithSameName2") << QStringLiteral("foo") << QStringLiteral("foo") << QStringLiteral("foo") << false << QStringLiteral("foo");
1008 QTest::newRow("conflict") << QStringLiteral("foo") << QStringLiteral("foo1") << QStringLiteral("foo") << false << QStringLiteral("foo");
1009 QTest::newRow("conflict1") << QString() << QStringLiteral("foo1") << QStringLiteral("foo") << false << QStringLiteral("foo1");
1010 }
1011
shouldMergeBlogFeed()1012 void MergeContactsTest::shouldMergeBlogFeed()
1013 {
1014 QFETCH(QString, nameItemA);
1015 QFETCH(QString, nameItemB);
1016 QFETCH(QString, nameItemC);
1017 QFETCH(bool, isEmpty);
1018 QFETCH(QString, result);
1019
1020 const QString valueCustomStr = QStringLiteral("BlogFeed");
1021 Akonadi::Item::List lst;
1022 Addressee addressA;
1023 addressA.insertCustom(QStringLiteral("KADDRESSBOOK"), valueCustomStr, nameItemA);
1024 Akonadi::Item itemA;
1025 itemA.setPayload<Addressee>(addressA);
1026 lst << itemA;
1027
1028 Addressee addressB;
1029 Akonadi::Item itemB;
1030 addressB.insertCustom(QStringLiteral("KADDRESSBOOK"), valueCustomStr, nameItemB);
1031 itemB.setPayload<Addressee>(addressB);
1032 lst << itemB;
1033
1034 Addressee addressC;
1035 Akonadi::Item itemC;
1036 addressC.insertCustom(QStringLiteral("KADDRESSBOOK"), valueCustomStr, nameItemC);
1037 itemC.setPayload<Addressee>(addressC);
1038 lst << itemC;
1039
1040 MergeContacts contacts(lst);
1041 Addressee resultAddr = contacts.mergedContact();
1042 QCOMPARE(resultAddr.isEmpty(), isEmpty);
1043 const QString resultStr = resultAddr.custom(QStringLiteral("KADDRESSBOOK"), valueCustomStr);
1044 QCOMPARE(resultStr, result);
1045 }
1046
shouldMergeHomePage_data()1047 void MergeContactsTest::shouldMergeHomePage_data()
1048 {
1049 QTest::addColumn<QUrl>("nameItemA");
1050 QTest::addColumn<QUrl>("nameItemB");
1051 QTest::addColumn<QUrl>("nameItemC");
1052 QTest::addColumn<bool>("isEmpty");
1053 QTest::addColumn<QUrl>("result");
1054 QTest::newRow("noConflict") << QUrl() << QUrl() << QUrl() << false << QUrl();
1055 QTest::newRow("noWithOneNameConflict") << QUrl() << QUrl() << QUrl(QStringLiteral("http://www.kde.org")) << false
1056 << QUrl(QStringLiteral("http://www.kde.org"));
1057 QTest::newRow("noWithOneNameConflict1") << QUrl() << QUrl(QStringLiteral("http://www.kde.org")) << QUrl() << false
1058 << QUrl(QStringLiteral("http://www.kde.org"));
1059 QTest::newRow("noWithOneNameConflict2") << QUrl(QStringLiteral("http://www.kde.org")) << QUrl() << QUrl() << false
1060 << QUrl(QStringLiteral("http://www.kde.org"));
1061 QTest::newRow("noConflictWithSameName") << QUrl(QStringLiteral("http://www.kde.org")) << QUrl(QStringLiteral("http://www.kde.org")) << QUrl() << false
1062 << QUrl(QStringLiteral("http://www.kde.org"));
1063 QTest::newRow("noConflictWithSameName2") << QUrl(QStringLiteral("http://www.kde.org")) << QUrl(QStringLiteral("http://www.kde.org"))
1064 << QUrl(QStringLiteral("http://www.kde.org")) << false << QUrl(QStringLiteral("http://www.kde.org"));
1065 QTest::newRow("conflictUrl") << QUrl(QStringLiteral("http://www.kde.org")) << QUrl(QStringLiteral("http://www.kde.org1"))
1066 << QUrl(QStringLiteral("http://www.kde.org")) << false << QUrl(QStringLiteral("http://www.kde.org"));
1067 QTest::newRow("conflict1") << QUrl() << QUrl(QStringLiteral("http://www.kde.org1")) << QUrl(QStringLiteral("http://www.kde.org")) << false
1068 << QUrl(QStringLiteral("http://www.kde.org1"));
1069 }
1070
shouldMergeHomePage()1071 void MergeContactsTest::shouldMergeHomePage()
1072 {
1073 QFETCH(QUrl, nameItemA);
1074 QFETCH(QUrl, nameItemB);
1075 QFETCH(QUrl, nameItemC);
1076 QFETCH(bool, isEmpty);
1077 QFETCH(QUrl, result);
1078 Akonadi::Item::List lst;
1079 Addressee addressA;
1080 Akonadi::Item itemA;
1081 KContacts::ResourceLocatorUrl url;
1082 url.setUrl(nameItemA);
1083 addressA.setUrl(url);
1084 itemA.setPayload<KContacts::Addressee>(addressA);
1085 lst << itemA;
1086
1087 Addressee addressB;
1088 Akonadi::Item itemB;
1089
1090 url.setUrl(nameItemB);
1091 addressB.setUrl(url);
1092 itemB.setPayload<KContacts::Addressee>(addressB);
1093 lst << itemB;
1094
1095 Addressee addressC;
1096 Akonadi::Item itemC;
1097 url.setUrl(nameItemC);
1098 addressC.setUrl(url);
1099 itemC.setPayload<KContacts::Addressee>(addressC);
1100 lst << itemC;
1101
1102 MergeContacts contacts(lst);
1103 Addressee resultAddr = contacts.mergedContact();
1104 QCOMPARE(resultAddr.isEmpty(), isEmpty);
1105 QCOMPARE(resultAddr.url().url(), result);
1106 }
1107
checkNeedManualSelectionWithBirthday_data()1108 void MergeContactsTest::checkNeedManualSelectionWithBirthday_data()
1109 {
1110 QTest::addColumn<QString>("nameItemA");
1111 QTest::addColumn<QString>("nameItemB");
1112 QTest::addColumn<QString>("nameItemC");
1113 QTest::addColumn<bool>("needManualCheck");
1114 QTest::newRow("noConflict") << QString() << QString() << QString() << false;
1115 QTest::newRow("noWithOneNameConflict") << QString() << QString() << QStringLiteral("20150606") << false;
1116 QTest::newRow("noWithOneNameConflict1") << QString() << QStringLiteral("20150606") << QString() << false;
1117 QTest::newRow("noWithOneNameConflict2") << QStringLiteral("20150606") << QString() << QString() << false;
1118 QTest::newRow("noConflictWithSameBirthday") << QStringLiteral("20150606") << QStringLiteral("20150606") << QString() << false;
1119 QTest::newRow("noConflictWithSameBirthday2") << QStringLiteral("20150606") << QStringLiteral("20150606") << QStringLiteral("20150606") << false;
1120 QTest::newRow("conflict") << QStringLiteral("20150606") << QStringLiteral("20150608") << QStringLiteral("20150606") << true;
1121 QTest::newRow("conflict1") << QString() << QStringLiteral("20150606") << QStringLiteral("20150608") << true;
1122 QTest::newRow("conflict2") << QStringLiteral("20150606") << QString() << QStringLiteral("20150608") << true;
1123 QTest::newRow("conflict2") << QStringLiteral("20150606") << QStringLiteral("20150608") << QString() << true;
1124 QTest::newRow("conflict4") << QStringLiteral("20180606") << QStringLiteral("20150608") << QStringLiteral("20150606") << true;
1125 }
1126
checkNeedManualSelectionWithBirthday()1127 void MergeContactsTest::checkNeedManualSelectionWithBirthday()
1128 {
1129 QFETCH(QString, nameItemA);
1130 QFETCH(QString, nameItemB);
1131 QFETCH(QString, nameItemC);
1132 QFETCH(bool, needManualCheck);
1133
1134 Akonadi::Item::List lst;
1135 Addressee addressA;
1136 Akonadi::Item itemA;
1137 QDate date = QDate::fromString(nameItemA, QStringLiteral("yyyyMMdd"));
1138 QDateTime dt(date.startOfDay());
1139 addressA.setBirthday(dt);
1140 itemA.setPayload<Addressee>(addressA);
1141 lst << itemA;
1142
1143 Addressee addressB;
1144 Akonadi::Item itemB;
1145 date = QDate::fromString(nameItemB, QStringLiteral("yyyyMMdd"));
1146 dt = QDateTime(date.startOfDay());
1147
1148 addressB.setBirthday(dt);
1149 itemB.setPayload<Addressee>(addressB);
1150 lst << itemB;
1151
1152 Addressee addressC;
1153 Akonadi::Item itemC;
1154 date = QDate::fromString(nameItemC, QStringLiteral("yyyyMMdd"));
1155 dt = QDateTime(date.startOfDay());
1156 addressC.setBirthday(dt);
1157 itemC.setPayload<Addressee>(addressC);
1158 lst << itemC;
1159
1160 MergeContacts contacts(lst);
1161 const MergeContacts::ConflictInformations result = contacts.requiresManualSelectionOfInformation();
1162 const bool bResult = (result == MergeContacts::Birthday);
1163 QCOMPARE(bResult, needManualCheck);
1164 }
1165
1166 QTEST_MAIN(MergeContactsTest)
1167