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