qtmobility/tests/auto/ut_qtcontacts_trackerplugin/ut_qtcontacts_trackerplugin.cpp
/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the Qt Mobility Components.
**
** $QT_BEGIN_LICENSE:LGPL$
** No Commercial Usage
** This file contains pre-release code and may not be distributed.
** You may use this file in accordance with the terms and conditions
** contained in the Technology Preview License Agreement accompanying
** this package.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
**
**
**
**
**
**
**
**
** $QT_END_LICENSE$
**
****************************************************************************/
#include "ut_qtcontacts_trackerplugin.h"
#include <QMap>
#include <QPair>
#include <QUuid>
#include <QtTracker/Tracker>
#include <QtTracker/ontologies/nco.h>
#include <QtTracker/ontologies/nie.h>
#include <qcontactfilters.h>
#include <QContactChangeLogFilter>
#include <qtcontacts.h>
#include <trackerchangelistener.h>
#include <qcontactrelationshipsaverequest.h>
#include <qcontactrelationshipfetchrequest.h>
#include <qtrackercontactidfetchrequest.h>
#include <qcontacttrackerbackend_p.h>
#include <qtrackercontactasyncrequest.h>
#include "contactmanager.h"
// update this when creating debian package
const QString PATH_TO_SPARQL_TESTS("./ut_qtcontacts_trackerplugin_data");
ut_qtcontacts_trackerplugin::ut_qtcontacts_trackerplugin()
{
}
void ut_qtcontacts_trackerplugin::initTestCase()
{
QMap<QString, QString> trackerEngineParams;
trackerEngine = new QContactTrackerEngine(trackerEngineParams);
errorMap = new QMap<int, QContactManager::Error>();
}
void ut_qtcontacts_trackerplugin::testContacts()
{
QContact c1;
QContact c2;
trackerEngine->saveContact(&c1, error);
trackerEngine->saveContact(&c2, error);
QVERIFY2((error == QContactManager::NoError),"Saving contact");
QList<QContactLocalId> contacts = trackerEngine->contactIds(queryFilter, sortOrders, error);
QVERIFY2(contacts.contains(c1.localId()), "Previously added contact is not found");
QVERIFY2(contacts.contains(c2.localId()), "Previously added contact is not found");
}
void ut_qtcontacts_trackerplugin::testContact()
{
// Test invalid contact id
QContact invalidContact = trackerEngine->contact_impl( -1, error);
QVERIFY(error != QContactManager::NoError);
// Add a contact
QContact newContact;
const QContactLocalId oldid = newContact.localId();
QVERIFY( trackerEngine->saveContact( &newContact, error ) );
QContactLocalId id = newContact.localId();
QVERIFY( id != oldid );
// Find the added contact
QContact c = trackerEngine->contact_impl( id, error );
QVERIFY( c.localId() == newContact.localId() );
}
void ut_qtcontacts_trackerplugin::testSaveName()
{
QContact c;
QContactLocalId initialId = c.localId();
int detailsAdded = 0;
QMap<QString,QString> nameValues;
QContactName name;
nameValues.insert(QLatin1String(QContactName::FieldPrefix), "Mr");
nameValues.insert(QLatin1String(QContactName::FieldFirst), "John");
nameValues.insert(QLatin1String(QContactName::FieldMiddle), "Rupert");
nameValues.insert(QLatin1String(QContactName::FieldLast), "Doe");
// nameValues.insert(QContactName::FieldSuffix, "III");
foreach (QString field, nameValues.keys()) {
name.setValue(field, nameValues.value(field));
}
c.saveDetail(&name);
QContactNickname nick;
nick.setValue(QLatin1String(QContactNickname::FieldNickname), "Johnny");
c.saveDetail(&nick);
QVERIFY(c.detail<QContactName>().prefix() == "Mr");
QVERIFY(c.detail<QContactName>().firstName() == "John");
QVERIFY(c.detail<QContactName>().middleName() == "Rupert");
QVERIFY(c.detail<QContactName>().lastName() == "Doe");
QVERIFY(c.detail<QContactNickname>().nickname() == "Johnny");
detailsAdded++;
trackerEngine->saveContact(&c, error);
QCOMPARE(error, QContactManager::NoError);
QVERIFY(c.localId() != initialId);
QContact contact = trackerEngine->contact_impl(c.localId(), error);
QList<QContactName> details = contact.details<QContactName>();
QList<QContactNickname> details2 = contact.details<QContactNickname>();
QCOMPARE(details.count(), detailsAdded);
QCOMPARE(details2.count(), detailsAdded);
// Name is unique
foreach(QString field, nameValues.keys()) {
QCOMPARE(details.at(0).value(field), nameValues.value(field));
}
QCOMPARE(details2.at(0).value(QLatin1String(QContactNickname::FieldNickname)), QString("Johnny"));
// Try changing the name of the saved contact.
{
QMap<QString,QString> nameValues;
QContactName name = c.detail<QContactName>();
nameValues.insert(QLatin1String(QContactName::FieldPrefix), "Mr2");
nameValues.insert(QLatin1String(QContactName::FieldFirst), "John2");
nameValues.insert(QLatin1String(QContactName::FieldMiddle), "Rupert2");
nameValues.insert(QLatin1String(QContactName::FieldLast), "");
// nameValues.insert(QContactName::FieldSuffix, "III");
foreach (QString field, nameValues.keys()) {
name.setValue(field, nameValues.value(field));
}
c.saveDetail(&name);
QContactNickname nick = c.detail<QContactNickname>();
nick.setValue(QLatin1String(QContactNickname::FieldNickname), "Johnny2");
c.saveDetail(&nick);
QVERIFY(trackerEngine->saveContact(&c, error));
QCOMPARE(error, QContactManager::NoError);
QVERIFY(c.localId() != initialId);
QContact contact = trackerEngine->contact_impl(c.localId(), error);
QCOMPARE(error, QContactManager::NoError);
QList<QContactName> details = contact.details<QContactName>();
QList<QContactNickname> details2 = contact.details<QContactNickname>();
QCOMPARE(details.count(), detailsAdded);
QCOMPARE(details2.count(), detailsAdded);
// Name is unique
foreach(QString field, nameValues.keys()) {
QCOMPARE(details.at(0).value(field), nameValues.value(field));
}
QCOMPARE(details2.at(0).value(QLatin1String(QContactNickname::FieldNickname)), QString("Johnny2"));
// now try to add new name detail fails - this is how currently unique fields are implemented
// so cover it in unit tests
QContactName name1;
name1.setValue(QContactName::FieldFirst, "Something that wont be stored as name is unique");
c.saveDetail(&name1);
// validate that unique name is not saved
QVERIFY(!trackerEngine->saveContact(&c, error));
details = contact.details<QContactName>();
details2 = contact.details<QContactNickname>();
QCOMPARE(details.count(), detailsAdded);
QCOMPARE(details2.count(), detailsAdded);
}
}
void ut_qtcontacts_trackerplugin::testSavePhoneNumber()
{
// use the same values for 2 contacts
for (int i = 0; i <2; i++ )
{
QContact c;
QContactLocalId initialId = c.localId();
int detailsAdded = 0;
QContactName name;
name.setFirstName("I have phone numbers");
name.setLastName("Girl");
c.saveDetail(&name);
// key: phonenumber; value: context,subtype
QMap<QString,QPair<QString,QString> > phoneValues;
phoneValues.insert("(704)486-6472", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome), QString()));
phoneValues.insert("(765)957-1663", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome), QString()));
phoneValues.insert("(999)888-1111", QPair<QString,QString>(QLatin1String(QContactDetail::ContextHome),
QLatin1String(QContactPhoneNumber::SubTypeMobile)));
phoneValues.insert("(792)123-6113", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork), QString()));
phoneValues.insert("(918)491-7361", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork),
QLatin1String(QContactPhoneNumber::SubTypeMobile)));
phoneValues.insert("(412)670-1514", QPair<QString,QString>(QLatin1String(QContactDetail::ContextWork),
QLatin1String(QContactPhoneNumber::SubTypeCar)));
QMap<QString,QPair<QString,QString> > formattedPhoneValues;
foreach (QString number, phoneValues.keys()) {
QContactPhoneNumber phone;
phone.setNumber(number);
// Stripped automatically on saving RFC 3966 visual-separators reg exp "[(|-|.|)| ]"
formattedPhoneValues.insert(QString(number).replace( QRegExp("[\\(|" \
"\\-|" \
"\\.|" \
"\\)|" \
" ]"), ""),phoneValues.value(number));
if (!phoneValues.value(number).first.isEmpty()) {
phone.setContexts(phoneValues.value(number).first);
}
if (!phoneValues.value(number).second.isEmpty()) {
phone.setSubTypes(phoneValues.value(number).second);
}
c.saveDetail(&phone);
detailsAdded++;
}
trackerEngine->saveContact(&c, error);
QCOMPARE(error, QContactManager::NoError);
QVERIFY(c.localId() != initialId);
// wait for commit transaction to be done, no signals yet
for(int i = 0; i < 100; i++)
{
usleep(10000);
QCoreApplication::processEvents();
}
// verify with synchronous read too
QContact contact = trackerEngine->contact_impl(c.localId(), error);
QCOMPARE(error, QContactManager::NoError);
QList<QContactPhoneNumber> details = contact.details<QContactPhoneNumber>();
QCOMPARE(details.count(), detailsAdded);
foreach (QContactPhoneNumber detail, details) {
// Verify that the stored values and attributes are the same as given
QVERIFY(formattedPhoneValues.contains(detail.number()));
QCOMPARE(detail.contexts()[0], formattedPhoneValues.value(detail.number()).first);
if( formattedPhoneValues.value(detail.number()).second.isEmpty()) // default empty is voice
QCOMPARE(detail.subTypes()[0], QLatin1String(QContactPhoneNumber::SubTypeVoice));
else
QCOMPARE(detail.subTypes()[0], formattedPhoneValues.value(detail.number()).second);
}
// edit one of numbers . values, context and subtypes and save again
QString editedPhoneValue = "+7044866473";
QContactPhoneNumber phone = details[0];
phone.setNumber(editedPhoneValue);
phone.setContexts(QContactDetail::ContextWork);
phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);
c = contact;
c.saveDetail(&phone);
trackerEngine->saveContact(&c, error);
QCOMPARE(error, QContactManager::NoError);
c = this->contact(c.localId(), QStringList()<<QContactPhoneNumber::DefinitionName);
details = c.details<QContactPhoneNumber>();
QCOMPARE(details.count(), detailsAdded);
bool found = false;
foreach (QContactPhoneNumber detail, details) {
if(detail.number() == phone.number())
{
found = true;
QVERIFY(detail.subTypes().contains(QContactPhoneNumber::SubTypeMobile));
QVERIFY(detail.contexts().contains(QContactPhoneNumber::ContextWork));
break;
}
}
QVERIFY(found);
}
}
void ut_qtcontacts_trackerplugin::testPhoneNumberContext()
{
QContact c;
QContactPhoneNumber phone;
phone.setContexts(QContactDetail::ContextHome);
phone.setNumber("555-888");
phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);
c.saveDetail(&phone);
QContact contactToSave = c;
// Let's do this all twice, first time save new detail, and next iteration change the context
for (int iterations = 0; iterations < 2; iterations++) {
QVERIFY(trackerEngine->saveContact(&contactToSave, error));
// wait for commit transaction to be done, no signals yet
for(int i = 0; i < 100; i++) {
usleep(10000);
QCoreApplication::processEvents();
}
QContactFetchRequest request;
QContactLocalIdFilter filter;
QList<QContactLocalId> ids;
ids.append(contactToSave.localId());
filter.setIds(ids);
request.setFilter(filter);
QStringList details;
details << QContactPhoneNumber::DefinitionName;
request.setDefinitionRestrictions(details);
Slots slot;
QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),
&slot, SLOT(progress(QContactFetchRequest*, bool )));
trackerEngine->startRequest(&request);
for(int i = 0; i < 100; i++) {
usleep(100000);
QCoreApplication::processEvents();
if(request.isFinished() )
break;
}
// if it takes more, then something is wrong
QVERIFY(request.isFinished());
QVERIFY(!slot.contacts.isEmpty());
QContact contactToTest;
foreach (QContact savedContact, slot.contacts) {
if (savedContact.localId() == contactToSave.localId()) {
contactToTest = savedContact;
}
}
QVERIFY(contactToTest.localId() == contactToSave.localId()); // Just to be sure we got the saved contact
qDebug()<<contactToTest.details<QContactPhoneNumber>().count();
QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);
if (0 == iterations) {
// perform context change
QContactPhoneNumber phoneToEdit = contactToTest.detail<QContactPhoneNumber>();
phoneToEdit.setContexts(QContactDetail::ContextWork);
contactToTest.saveDetail(&phoneToEdit);
contactToSave = contactToTest;
}
QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);
}
}
void ut_qtcontacts_trackerplugin::testWritingOnlyWorkMobile()
{
QContact c;
QContactPhoneNumber phone;
phone.setContexts(QContactDetail::ContextWork);
phone.setNumber("555999");
phone.setSubTypes(QContactPhoneNumber::SubTypeMobile);
c.saveDetail(&phone);
QContact& contactToSave = c;
QVERIFY(trackerEngine->saveContact(&contactToSave, error));
// wait for commit transaction to be done, no signals yet
for(int i = 0; i < 100; i++) {
usleep(10000);
QCoreApplication::processEvents();
}
QContactFetchRequest request;
QContactLocalIdFilter filter;
QList<QContactLocalId> ids;
ids.append(contactToSave.localId());
filter.setIds(ids);
request.setFilter(filter);
QStringList details;
details << QContactPhoneNumber::DefinitionName;
request.setDefinitionRestrictions(details);
Slots slot;
QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),
&slot, SLOT(progress(QContactFetchRequest*, bool )));
trackerEngine->startRequest(&request);
for(int i = 0; i < 100; i++) {
usleep(100000);
QCoreApplication::processEvents();
if(request.isFinished() )
break;
}
// if it takes more, then something is wrong
QVERIFY(request.isFinished());
QVERIFY(!slot.contacts.isEmpty());
QContact contactToTest;
foreach (QContact savedContact, slot.contacts) {
if (savedContact.localId() == c.localId()) {
contactToTest = savedContact;
}
}
QVERIFY(contactToTest.localId() == c.localId()); // Just to be sure we got the saved contact
QVERIFY(contactToTest.details<QContactPhoneNumber>().count() == 1);
QVERIFY(contactToTest.detail<QContactPhoneNumber>().number() == phone.number());
QVERIFY(contactToTest.detail<QContactPhoneNumber>().subTypes() == phone.subTypes());
QVERIFY(contactToTest.detail<QContactPhoneNumber>().contexts() == phone.contexts());
}
void ut_qtcontacts_trackerplugin::testSaveAddress()
{
QContact c;
QContactName name;
name.setFirstName("Aruba & Barbados");
name.setLastName("Girl");
c.saveDetail(&name);
QContactLocalId initialId = c.localId();
int detailsAdded = 0;
// List of pairs of field-value map and context
typedef QMap<QString,QString> typeAddress;
typedef QPair<typeAddress,QString> typeAddressWithContext;
QList<typeAddressWithContext> addressValues;
// TODO check status of 137174 and other libqttracker1pre6 bugs before refactoring
typeAddress values;
values.insert(QLatin1String(QContactAddress::FieldCountry), "Barbados");
values.insert(QLatin1String(QContactAddress::FieldPostcode), "55555");
values.insert(QLatin1String(QContactAddress::FieldStreet), "Martindales Rd");
values.insert(QLatin1String(QContactAddress::FieldRegion), "Bridgetown");
addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));
values.clear();
values.insert(QLatin1String(QContactAddress::FieldCountry), "Aruba");
values.insert(QLatin1String(QContactAddress::FieldPostcode), "44444");
values.insert(QLatin1String(QContactAddress::FieldStreet), "Brazilie Straat");
values.insert(QLatin1String(QContactAddress::FieldRegion), "Oranjestad");
addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));
values.clear();
values.insert(QLatin1String(QContactAddress::FieldCountry), "ArubaWork");
values.insert(QLatin1String(QContactAddress::FieldPostcode), "44445");
values.insert(QLatin1String(QContactAddress::FieldStreet), "Sunset Blvd");
values.insert(QLatin1String(QContactAddress::FieldRegion), "Oranjestad");
addressValues.append(typeAddressWithContext(values, QLatin1String(QContactDetail::ContextHome)));
foreach (typeAddressWithContext addressWithContext, addressValues) {
QContactAddress address;
foreach (QString field, addressWithContext.first.keys()) {
address.setValue(field, addressWithContext.first.value(field));
}
address.setContexts(addressWithContext.second);
c.saveDetail(&address);
detailsAdded++;
}
trackerEngine->saveContact(&c, error);
QCOMPARE(error, QContactManager::NoError);
QVERIFY(c.localId() != initialId);
QContact contact = trackerEngine->contact_impl(c.localId(), error);
QList<QContactAddress> details = contact.details<QContactAddress>();
QCOMPARE(details.count(), detailsAdded);
bool found = false;
// Test if inserted values are found in some of the details
foreach (typeAddressWithContext addressWithContext, addressValues) {
foreach (QContactAddress detail, details) {
foreach (QString field, addressWithContext.first.keys()) {
found = (detail.value(field) == addressWithContext.first.value(field));
if (!found)
break;
}
if (found)
break;
}
QVERIFY2(found, "Inserted detail was not found in the fetched details");
}
}
void ut_qtcontacts_trackerplugin::testSaveEmailAddress()
{
QContact c;
QContactLocalId initialId = c.localId();
int detailsAdded = 0;
QMap<QString,QString> values;
values.insert("john.does@hotmail.com", QContactDetail::ContextHome);
values.insert("john.doe@gmail.com", QContactDetail::ContextWork);
values.insert("john.doe@nokia.com", QContactDetail::ContextWork);
values.insert("john.doe@johndoe.com", QContactDetail::ContextHome);
foreach(QString address, values.keys()) {
QContactEmailAddress emailAddress;
emailAddress.setEmailAddress(address);
emailAddress.setContexts(values.value(address));
c.saveDetail(&emailAddress);
detailsAdded++;
}
QContactName name;
name.setFirstName("Jo");
name.setLastName("H N Doe");
c.saveDetail(&name);
trackerEngine->saveContact(&c, error);
QCOMPARE(error, QContactManager::NoError);
QVERIFY(c.localId() != initialId);
QContact contact = trackerEngine->contact_impl(c.localId(), error);
QList<QContactEmailAddress> details = contact.details<QContactEmailAddress>();
QCOMPARE(details.count(), detailsAdded);
foreach (QContactEmailAddress detail, details) {
QString address = detail.value(QContactEmailAddress::FieldEmailAddress);
QVERIFY(values.contains(address));
QCOMPARE(detail.contexts()[0], values.value(address));
}
}
void ut_qtcontacts_trackerplugin::testRemoveContact()
{
QContact c;
QContactPhoneNumber phone;
phone.setNumber("+358501234567");
c.saveDetail(&phone);
QContactEmailAddress email;
email.setEmailAddress("super.man@hotmail.com");
c.saveDetail(&email);
QContactName name;
name.setFirstName("Super");
name.setLastName("Man");
c.saveDetail(&name);
QVERIFY2(trackerEngine->saveContact(&c, error) && error == QContactManager::NoError, "Saving a contact failed");
QVERIFY2(trackerEngine->removeContact(c.localId(), error), "Removing a contact failed");
QCOMPARE(error, QContactManager::NoError);
QVERIFY2(trackerEngine->contact_impl(c.localId(), error) == QContact(), "Found a contact, which should have been removed");
}
void ut_qtcontacts_trackerplugin::testSaveContacts()
{
QList<QContact> contacts;
for (int i = 0; i < 3; i++) {
QContact c;
QContactName name;
name.setFirstName("John");
name.setLastName(QString::number(i,10));
c.saveDetail(&name);
contacts.append(c);
}
QMap<int, QContactManager::Error>* errorMap;
trackerEngine->saveContacts(&contacts, errorMap, error);
QCOMPARE(error, QContactManager::NoError);
for (int i = 0; i < contacts.count(); i++) {
QVERIFY(contacts[i].localId() != 0);
QList<QContactName> details = trackerEngine->contact_impl(contacts[i].localId(), error).details<QContactName>();
QVERIFY(details.count());
QCOMPARE(details.at(0).lastName(),
QString("%1").arg(QString::number(i,10)));
}
}
void ut_qtcontacts_trackerplugin::testRemoveContacts()
{
QList<QContactLocalId> addedIds;
for (int i = 0; i < 5; i++) {
QContact c;
QContactName name;
name.setFirstName(QString("John%1").arg(QString::number(i,10)));
c.saveDetail(&name);
QVERIFY2(trackerEngine->saveContact(&c, error) && error == QContactManager::NoError, "Saving a contact failed");
addedIds.append(c.localId());
}
QList<QContactLocalId> toApiRemove;
toApiRemove.append(addedIds.takeLast());
toApiRemove.append(addedIds.takeLast());
QList<QContactLocalId> toPluginRemove(addedIds);
// Remove all, but last of the added contacts
bool success = trackerEngine->removeContacts(&toPluginRemove, errorMap, error);
QCOMPARE(success, true);
for (int i = 0; i < errorMap->count(); i++) {
QVERIFY(toPluginRemove[i] == 0);
}
QCOMPARE(error, QContactManager::NoError);
success = ContactManager::instance()->removeContacts(&toApiRemove, errorMap);
QCOMPARE(success, true);
for (int i = 0; i < errorMap->count(); i++) {
QVERIFY(toApiRemove[i] == 0);
}
// Try to remove some previously removed contacts, but one valid contact
success = trackerEngine->removeContacts(&addedIds, errorMap, error);
QCOMPARE(errorMap->count(), addedIds.count());
for (int i = 0; i < errorMap->count() - 1; i++) {
QVERIFY2(addedIds[i] != 0, "Manager should not mark id as zero");
}
}
void ut_qtcontacts_trackerplugin::testAvatar()
{
QContact contactWithAvatar;
QContactAvatar avatar;
avatar.setAvatar("file:///home/user/.contacts/avatars/default_avatar.png");
contactWithAvatar.saveDetail(&avatar);
QContactName name;
name.setFirstName("John");name.setLastName("A Frog");
contactWithAvatar.saveDetail(&name);
QVERIFY(trackerEngine->saveContact( &contactWithAvatar, error));
QContact c = trackerEngine->contact_impl( contactWithAvatar.localId(), error);
QList<QContactAvatar> avatars = c.details<QContactAvatar>();
QVERIFY( avatars.size() );
QCOMPARE( avatars[0].avatar(), avatar.avatar() );
}
void ut_qtcontacts_trackerplugin::testUrl()
{
//Context home, homepage url
QContact contactWithUrl1;
QContactUrl url1;
url1.setUrl("http://home.homepage");
url1.setContexts(QContactDetail::ContextHome);
url1.setSubType(QContactUrl::SubTypeHomePage);
QContactName name;
name.setFirstName("John");name.setLastName("TestUrl1");
contactWithUrl1.saveDetail(&name);
contactWithUrl1.saveDetail(&url1);
QVERIFY(trackerEngine->saveContact(&contactWithUrl1, error));
//Context work, homepage url
QContact contactWithUrl2;
QContactUrl url2;
url2.setUrl("http://work.homepage");
url2.setContexts(QContactDetail::ContextWork);
url2.setSubType(QContactUrl::SubTypeHomePage);
QContactName name2;
name2.setLastName("TestUrl2");
contactWithUrl2.saveDetail(&name2);
contactWithUrl2.saveDetail(&url2);
QVERIFY(trackerEngine->saveContact(&contactWithUrl2, error));
//Context home, favourite url
QContact contactWithUrl3;
QContactUrl url3;
url3.setUrl("http://home.favourite");
url3.setContexts(QContactDetail::ContextHome);
url3.setSubType(QContactUrl::SubTypeFavourite);
name2.setLastName("TestUrl3");
contactWithUrl3.saveDetail(&name2);
contactWithUrl3.saveDetail(&url3);
QVERIFY(trackerEngine->saveContact(&contactWithUrl3, error));
QContactLocalId id1 = contactWithUrl1.localId();
QContactLocalId id2 = contactWithUrl2.localId();
QContactLocalId id3 = contactWithUrl3.localId();
QCOMPARE(trackerEngine->contact_impl(id1, error).detail<QContactUrl>().url(), QString("http://home.homepage"));
QCOMPARE(trackerEngine->contact_impl(id2, error).detail<QContactUrl>().url(), QString("http://work.homepage"));
QCOMPARE(trackerEngine->contact_impl(id3, error).detail<QContactUrl>().url(), QString("http://home.favourite"));
QVERIFY(trackerEngine->contact_impl(id1, error).detail<QContactUrl>().contexts()[0] ==
QContactDetail::ContextHome );
QVERIFY(trackerEngine->contact_impl(id2, error).detail<QContactUrl>().contexts()[0] ==
QContactDetail::ContextWork );
QVERIFY(trackerEngine->contact_impl(id3, error).detail<QContactUrl>().contexts()[0] ==
QContactDetail::ContextHome );
QVERIFY(trackerEngine->contact_impl(id1, error).detail<QContactUrl>().subType() ==
QContactUrl::SubTypeHomePage );
QVERIFY(trackerEngine->contact_impl(id2, error).detail<QContactUrl>().subType() ==
QContactUrl::SubTypeHomePage );
QVERIFY(trackerEngine->contact_impl(id3, error).detail<QContactUrl>().subType() ==
QContactUrl::SubTypeFavourite );
}
/*
void ut_qtcontacts_trackerplugin::testGroups()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testGroup()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testSaveGroup()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testRemoveGroup()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testDetailDefinitions()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testDetailDefinition()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testSaveDetailDefinition()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testRemoveDetailDefinition()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
*/
void ut_qtcontacts_trackerplugin::testSyncContactManagerContactsAddedSince()
{
QDateTime start;
QList<QContactLocalId> addedIds;
syncContactsAddedSinceHelper(start, addedIds);
QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);
filter.setSince(start);
QList<QContactSortOrder> sortOrder;
QList<QContact> contactIds = ContactManager::instance()->contacts( filter, sortOrder, QStringList() );
qDebug() << "addedIds" << addedIds.size();
qDebug() << "contactIds" << contactIds.size();
QEXPECT_FAIL("", "ContactManager is returning an empty list", Continue);
QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");
}
void ut_qtcontacts_trackerplugin::testSyncTrackerEngineContactsIdsAddedSince()
{
QDateTime start;
QList<QContactLocalId> addedIds;
syncContactsAddedSinceHelper(start, addedIds);
QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);
filter.setSince(start);
QList<QContactSortOrder> sortOrder;
QContactManager::Error error;
QList<QContactLocalId> contactIds = trackerEngine->contactIds( filter, sortOrder, error );
qDebug() << "addedIds" << addedIds;
qDebug() << "contactIds" << contactIds;
QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");
}
void ut_qtcontacts_trackerplugin::testSyncContactManagerContactIdsAddedSince()
{
QDateTime start;
QList<QContactLocalId> addedIds;
syncContactsAddedSinceHelper(start, addedIds);
QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);
filter.setSince(start);
QList<QContactSortOrder> sortOrder;
QList<QContactLocalId> contactIds = ContactManager::instance()->contactIds(filter, sortOrder);
qDebug() << "addedIds" << addedIds;
qDebug() << "contactIds" << contactIds;
QEXPECT_FAIL("", "ContactManager is returning an empty list", Continue);
QVERIFY2( contactIds.size() == addedIds.size(), "Incorrect number of filtered contacts");
}
void ut_qtcontacts_trackerplugin::syncContactsAddedSinceHelper(QDateTime& start, QList<QContactLocalId>& addedIds)
{
for (int i = 0; i < 3; i++) {
QContact c;
QContactName name;
name.setFirstName("A"+QString::number(i));
QVERIFY2(c.saveDetail(&name), "Failed to save detail");
QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
}
QTest::qWait(1000);
start = QDateTime::currentDateTime();
for (int i = 0; i < 3; i++) {
QContact c;
QContactName name;
name.setFirstName("B"+QString::number(i));
QVERIFY2(c.saveDetail(&name), "Failed to save detail");
QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
addedIds.append(c.localId());
}
}
void ut_qtcontacts_trackerplugin::testContactsAddedSince()
{
QList<QContactLocalId> addedIds;
QDateTime start;
for (int i = 0; i < 3; i++) {
QContact c;
QContactName name;
name.setFirstName("A"+QString::number(i));
QVERIFY2(c.saveDetail(&name), "Failed to save detail");
QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
}
QTest::qWait(1000);
start = QDateTime::currentDateTime();
for (int i = 0; i < 3; i++) {
QContact c;
QContactName name;
name.setFirstName("B"+QString::number(i));
QVERIFY2(c.saveDetail(&name), "Failed to save detail");
QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
addedIds.append(c.localId());
}
// now one asynchronous request to read all the
QContactFetchRequest request;
QContactChangeLogFilter filter(QContactChangeLogFilter::EventAdded);
filter.setSince(start);
request.setFilter(filter);
// here You specify which details are of interest
QStringList details;
details << QContactAvatar::DefinitionName
<< QContactBirthday::DefinitionName
<< QContactAddress::DefinitionName
<< QContactEmailAddress::DefinitionName
<< QContactDisplayLabel::DefinitionName
<< QContactGender::DefinitionName
<< QContactAnniversary::DefinitionName
<< QContactName::DefinitionName
<< QContactOnlineAccount::DefinitionName
<< QContactOrganization::DefinitionName
<< QContactPhoneNumber::DefinitionName;
request.setDefinitionRestrictions(details);
Slots slot;
QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),
&slot, SLOT(progress(QContactFetchRequest*, bool )));
// start. clients should, instead of following use
// request.setManager(trackermanagerinstance);
// request.start();
trackerEngine->startRequest(&request);
trackerEngine->waitForRequestFinished(&request, 10000);
// if it takes more, then something is wrong
QVERIFY(request.isFinished());
QCOMPARE(slot.contacts.count(), addedIds.count());
foreach(QContact cont, slot.contacts) {
QVERIFY2(addedIds.contains(cont.localId()), "One of the added contacts was not reported as added");
}
QContactLocalIdFetchRequest idreq;
filter.setSince(start);
idreq.setFilter(filter);
Slots slot2;
QObject::connect(&idreq, SIGNAL(progress(QContactLocalIdFetchRequest*, bool)),
&slot2, SLOT(progress(QContactLocalIdFetchRequest*, bool )));
trackerEngine->startRequest(&idreq);
trackerEngine->waitForRequestFinished(&idreq, 10000);
QVERIFY(idreq.isFinished());
QCOMPARE(slot2.ids.count(), addedIds.count());
foreach(QContactLocalId id, slot2.ids) {
QVERIFY2(addedIds.contains(id), "One of the added contacts was not reported as added");
}
}
void ut_qtcontacts_trackerplugin::testContactsModifiedSince()
{
QDateTime start;
QList<QContactLocalId> addedIds;
QList<QContactLocalId> modified;
const int contactsToAdd = 5;
const int contactsToModify = 3;
QVERIFY2(contactsToAdd >= contactsToModify, "Cannot modify more contacts than this test has added");
QVERIFY2(contactsToModify+1 <= contactsToAdd, "Cannot modify more contacts than this test has added");
// Add contacts with only first name and store them to list of added
for (int i = 0; i < contactsToAdd; i++) {
QContact c;
QContactName name;
name.setFirstName("A"+QString::number(i));
QVERIFY2(c.saveDetail(&name), "Failed to save detail");
QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
addedIds.append(c.localId());
}
QTest::qWait(2000);
start = QDateTime::currentDateTime();
// Modify and save rest of the contacts
for (int i = 0; i < contactsToModify; i++) {
QContact c = trackerEngine->contact_impl(addedIds[i], error);
QContactName name = c.detail<QContactName>();
// Modify name
name.setFirstName("B"+QString::number(i));
QVERIFY2(c.saveDetail(&name), "Failed to save detail");
QVERIFY2(trackerEngine->saveContact(&c, error), "Failed to save contact");
modified.append(c.localId());
}
// Set filter
QContactChangeLogFilter filter(QContactChangeLogFilter::EventChanged);
filter.setSince(start);
QContactLocalIdFetchRequest idfetch;
QContactFetchRequest fetch;
idfetch.setFilter(filter);
fetch.setFilter(filter);
trackerEngine->startRequest(&idfetch);
trackerEngine->waitForRequestFinished(&idfetch, 10000);
QVERIFY2(idfetch.isFinished(), "Id fetch request did not finish on time");
QVERIFY2(idfetch.error() == QContactManager::NoError, "Id fetch request finished with errors");
QList<QContactLocalId> actuallyModifiedIds = idfetch.ids();
trackerEngine->startRequest(&fetch);
trackerEngine->waitForRequestFinished(&fetch, 10000);
QVERIFY2(fetch.isFinished(), "Fetch request did not finish on time");
QVERIFY2(fetch.error() == QContactManager::NoError, "Fetch request finished with errors");
QList<QContact> actuallyModified = fetch.contacts();
// Num of actually modified should be same as supposedly modified
QCOMPARE(actuallyModifiedIds.count(), modified.count());
QCOMPARE(actuallyModified.count(), modified.count());
// All the ids of the modified contacts should be found in the result list
foreach (QContactLocalId id, modified) {
QVERIFY2(actuallyModifiedIds.contains(id), "One the modified contacts was not reported as modified");
}
}
void ut_qtcontacts_trackerplugin::testContactsRemovedSince()
{
QDateTime start = QDateTime::currentDateTime();
QContactChangeLogFilter filter(QContactChangeLogFilter::EventRemoved);
filter.setSince(start);
QList<QContactSortOrder> sorts;
QList<QContactLocalId> actuallyRemoved = trackerEngine->contactIds(filter, sorts, error);
QVERIFY(actuallyRemoved.isEmpty());
QVERIFY(error == QContactManager::NotSupportedError);
}
/*
void ut_qtcontacts_trackerplugin::testGroupsAddedSince()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testGroupsModifiedSince()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
void ut_qtcontacts_trackerplugin::testGroupsRemovedSince()
{
qDebug() << "Not implemented";
QVERIFY(false);
}
*/
void ut_qtcontacts_trackerplugin::cleanupTestCase()
{
delete trackerEngine;
delete errorMap;
}
void ut_qtcontacts_trackerplugin::cleanup()
{
foreach (QContactLocalId id, addedContacts) {
trackerEngine->removeContact(id, error);
}
addedContacts.clear();
}
void ut_qtcontacts_trackerplugin::testNcoTypes()
{
using namespace SopranoLive;
QList<QContactLocalId> ids;
RDFVariable RDFContact = RDFVariable::fromType<nco::PersonContact>();
RDFSelect query;
query.addColumn("contact_uri", RDFContact);
query.addColumn("contactId", RDFContact.property<nco::contactUID>());
LiveNodes ncoContacts = ::tracker()->modelQuery(query);
foreach( Live<nco::PersonContact> p, ncoContacts ) {
QVERIFY(p.hasType<nco::Contact>());
QVERIFY(p.hasType<nco::Role>());
QVERIFY(p.hasType<nco::PersonContact>());
}
}
void ut_qtcontacts_trackerplugin::testAsyncReadContacts()
{
addedContacts.clear();
// Add at least one contact to be sure that this doesn't fail because tracker is clean
QStringList firstNames, lastNames;
firstNames << "aa" << "ab" << "ac" << "dd" << "fe";
lastNames << "fe" << "ab" << "dd" << "dd" << "aa";
for (int i = 0; i < firstNames.count(); i++) {
QContact c;
QContactName name;
name.setFirstName(firstNames.at(i));
name.setLastName(lastNames.at(i));
QContactAvatar avatar;
avatar.setAvatar("default_avatar.png");
avatar.setSubType(QContactAvatar::SubTypeImage);
QVERIFY(c.saveDetail(&name));
QVERIFY(c.saveDetail(&avatar));
QVERIFY(trackerEngine->saveContact(&c, error));
addedContacts.append(c.localId());
}
// Prepare the filter for the request - we really should test only the contact we add here.
QContactLocalIdFilter filter;
filter.setIds(addedContacts);
// this one will get complete contacts
Slots slot;
QContactFetchRequest request;
QList<QContactSortOrder> sorting;
QContactSortOrder sort, sort1;
sort.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldLast);
sort1.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldFirst);
sorting << sort << sort1;
QStringList details; details << QContactName::DefinitionName << QContactAvatar::DefinitionName;
request.setDefinitionRestrictions(details);
request.setSorting(sorting);
request.setFilter(filter);
QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),
&slot, SLOT(progress(QContactFetchRequest*, bool )));
// this one only ids
QContactLocalIdFetchRequest request1;
request1.setFilter(filter);
QObject::connect(&request1, SIGNAL(progress(QContactLocalIdFetchRequest*, bool)),
&slot, SLOT(progress(QContactLocalIdFetchRequest*, bool )));
// the purpose is to compare if all contacts are loaded, and
// if optional fields are defined properly in request
// start both at once
trackerEngine->startRequest(&request);
trackerEngine->startRequest(&request1);
trackerEngine->waitForRequestFinished(&request, 10000);
trackerEngine->waitForRequestFinished(&request1, 10000);
// if it takes more, then something is wrong
QVERIFY(request.isFinished());
QVERIFY(request1.isFinished());
// there need1 to be something added to be verified
QVERIFY(!request.contacts().isEmpty());
// now ask for one contact
QVERIFY(!slot.contacts.isEmpty());
// there need to be something added to be verified
QVERIFY(!request1.ids().isEmpty());
// now ask for one contact
QVERIFY(!slot.ids.isEmpty());
QVERIFY2(slot.contacts.count() == slot.ids.count(), "not all contacts were loaded");
QVERIFY(slot.contacts.count() >= firstNames.count());
for( int i = 0; i < slot.contacts.size() -1 ; i++)
{
QContact contact = slot.contacts[i];
QContact contact1 = slot.contacts[i+1];
QString last0 = contact.detail<QContactName>().lastName();
QString first0 = contact.detail<QContactName>().firstName();
QString last1 = contact1.detail<QContactName>().lastName();
QString first1 = contact1.detail<QContactName>().firstName();
// sorting
qDebug() << "contacts:" << contact.localId() << first0 << last0;
bool test = last0 < last1 || (last0 == last1 && first0 <= first1);
if (!test) {
qDebug() << "contacts sort failed. First: " << contact1.localId() << first0 << last1 << "lasts: " << last0 << last1;
}
QVERIFY2(test, "Sorting failed.");
}
}
void ut_qtcontacts_trackerplugin::testFilterContacts()
{
// this one will get complete contacts
QContact c;
QContactName name;
name.setFirstName("Zuba");
name.setLastName("Zub");
c.saveDetail(&name);
QContactPhoneNumber phone;
phone.setNumber("4872444");
c.saveDetail(&phone);
QContactBirthday birthday;
birthday.setDate(QDate(2010, 2, 14));
c.saveDetail(&birthday);
trackerEngine->saveContact(&c, error);
QStringList details;
details << QContactName::DefinitionName << QContactAvatar::DefinitionName
<< QContactPhoneNumber::DefinitionName;
QContactFetchRequest request;
QContactDetailFilter filter;
filter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldNumber);
Slots slot;
QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),
&slot, SLOT(progress(QContactFetchRequest*, bool )));
filter.setValue(QString("4872444"));
filter.setMatchFlags(QContactFilter::MatchEndsWith);
request.setDefinitionRestrictions(details);
request.setFilter(filter);
trackerEngine->startRequest(&request);
for(int i = 0; i < 100; i++)
{
usleep(100000);
QCoreApplication::processEvents();
if(request.isFinished() )
break;
}
// if it takes more, then something is wrong
QVERIFY(request.isFinished());
QVERIFY(!request.contacts().isEmpty());
QVERIFY(!slot.contacts.isEmpty());
bool containsThisId = false;
foreach(const QContact &contact, slot.contacts)
{
if( contact.localId() == c.localId())
containsThisId = true;
bool containsPhone = false;
foreach(const QContactDetail &detail, contact.details(QContactPhoneNumber::DefinitionName))
{
if(detail.value(QContactPhoneNumber::FieldNumber).contains("4872444"))
{
containsPhone = true;
break;
}
}
QVERIFY(containsPhone);
}
QVERIFY(containsThisId);
// filter by birthday range
QContactDetailRangeFilter rangeFilter;
rangeFilter.setDetailDefinitionName(QContactBirthday::DefinitionName, QContactBirthday::FieldBirthday);
// include lower & exclude upper by default
rangeFilter.setRange(QDate(2010, 2, 14), QDate(2010, 2, 15));
QList<QContact> contacts = trackerEngine->contacts(rangeFilter, QList<QContactSortOrder>(), QStringList()<< QContactBirthday::DefinitionName, error);
QVERIFY(!contacts.isEmpty());
bool containsOurContact(false);
foreach(const QContact &cont, contacts)
{
QVERIFY(cont.detail<QContactBirthday>().date() == QDate(2010, 2, 14));
if( c.id() == cont.id() )
containsOurContact = true;
}
QVERIFY(containsOurContact);
}
void ut_qtcontacts_trackerplugin::testFilterContactsEndsWith()
{
QSettings settings(QSettings::IniFormat, QSettings::UserScope, "Nokia", "Trackerplugin");
QString restoreValue = settings.value("phoneNumberMatchDigitCount", "7").toString();
QContact matchingContact;
QContactName name;
name.setFirstName("Zuba");
name.setLastName("Zub");
matchingContact.saveDetail(&name);
QContactPhoneNumber phone;
// TODO doesnt work yet phone.setContexts(QContactPhoneNumber::ContextWork);
phone.setNumber("3210987654321");
matchingContact.saveDetail(&phone);
trackerEngine->saveContact(&matchingContact, error);
QStringList details;
details << QContactName::DefinitionName << QContactAvatar::DefinitionName
<< QContactPhoneNumber::DefinitionName;
QContactFetchRequest request;
QContactDetailFilter filter;
filter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldNumber);
Slots slot;
QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),
&slot, SLOT(progress(QContactFetchRequest*, bool )));
{
// test matching of 7 last digits
int matchCount = 7;
qDebug() << "Test matching of" << matchCount << "last digits.";
settings.setValue("phoneNumberMatchDigitCount", matchCount);
QString matchValue = "3000007654321";
QContact nonMatchingContact;
nonMatchingContact.saveDetail(&name);
phone.setNumber("3210980654321");
nonMatchingContact.saveDetail(&phone);
trackerEngine->saveContact(&nonMatchingContact, error);
filter.setValue(matchValue);
filter.setMatchFlags(QContactFilter::MatchEndsWith);
request.setDefinitionRestrictions(details);
request.setFilter(filter);
trackerEngine->startRequest(&request);
for(int i = 0; i < 100; i++) {
usleep(100000);
QCoreApplication::processEvents();
if (request.isFinished())
break;
}
QVERIFY(request.isFinished());
QVERIFY(!slot.contacts.isEmpty());
bool containsMatchingId = false;
bool containsNonMatchingId = false;
foreach(const QContact &contact, slot.contacts) {
if (contact.localId() == nonMatchingContact.localId())
containsNonMatchingId = true;
if (contact.localId() == matchingContact.localId())
containsMatchingId = true;
bool containsPhone = false;
foreach(const QContactDetail &detail, contact.details(QContactPhoneNumber::DefinitionName)) {
if (detail.value(QContactPhoneNumber::FieldNumber).endsWith(matchValue.right(matchCount))) {
containsPhone = true;
break;
}
}
QVERIFY(containsPhone);
}
QVERIFY(containsMatchingId);
QVERIFY(!containsNonMatchingId);
}
{
// test matching of 11 last digits
int matchCount = 11;
qDebug() << "Test matching of" << matchCount << "last digits.";
settings.setValue("phoneNumberMatchDigitCount", matchCount);
QString matchValue = "3010987654321";
QContact nonMatchingContact;
nonMatchingContact.saveDetail(&name);
phone.setNumber("3200987654321");
nonMatchingContact.saveDetail(&phone);
trackerEngine->saveContact(&nonMatchingContact, error);
QContact matchingContactWithShorterNumber;
QContactName name1;
name1.setFirstName("ShortNumber");
name1.setLastName("Zub1");
matchingContactWithShorterNumber.saveDetail(&name1);
QContactPhoneNumber phone1;
phone1.setNumber("54321");
matchingContactWithShorterNumber.saveDetail(&phone1);
trackerEngine->saveContact(&matchingContactWithShorterNumber, error);
QVERIFY(QContactManager::NoError == error);
filter.setValue(matchValue);
filter.setMatchFlags(QContactFilter::MatchEndsWith);
request.setDefinitionRestrictions(details);
request.setFilter(filter);
trackerEngine->startRequest(&request);
for(int i = 0; i < 100; i++) {
usleep(100000);
QCoreApplication::processEvents();
if (request.isFinished())
break;
}
QVERIFY(request.isFinished());
QVERIFY(!slot.contacts.isEmpty());
bool containsMatchingId = false;
bool containsNonMatchingId = false;
foreach(const QContact &contact, slot.contacts) {
if (contact.localId() == nonMatchingContact.localId())
containsNonMatchingId = true;
if (contact.localId() == matchingContact.localId())
containsMatchingId = true;
bool containsPhone = false;
foreach(const QContactDetail &detail, contact.details(QContactPhoneNumber::DefinitionName)) {
if (detail.value(QContactPhoneNumber::FieldNumber).endsWith(matchValue.right(matchCount))) {
containsPhone = true;
break;
}
}
QVERIFY(containsPhone);
}
QVERIFY(containsMatchingId);
QVERIFY(!containsNonMatchingId);
// now verify with short number
filter.setValue("54321");
filter.setMatchFlags(QContactFilter::MatchEndsWith);
request.setDefinitionRestrictions(details);
request.setFilter(filter);
trackerEngine->startRequest(&request);
for(int i = 0; i < 100; i++) {
usleep(100000);
QCoreApplication::processEvents();
if (request.isFinished())
break;
}
QVERIFY(request.isFinished());
QVERIFY(!slot.contacts.isEmpty());
bool containsShort = false;
foreach(const QContact &contact, slot.contacts) {
if (contact.localId() == matchingContactWithShorterNumber.localId())
containsShort = true;
}
QVERIFY(containsShort);
}
settings.setValue("phoneNumberMatchDigitCount", restoreValue);
}
void ut_qtcontacts_trackerplugin::testFilterTwoNameFields()
{
// init test
QMap<QContactLocalId, QContactName> names;
for (int i = 0; i < 3; i++) {
QContact c;
QContactName name;
name.setFirstName(QUuid::createUuid().toString() + QString::number(i));
name.setLastName(QUuid::createUuid().toString() + QString::number(i));
c.saveDetail(&name);
QContactAvatar avatar;
avatar.setAvatar(QUuid::createUuid().toString());
c.saveDetail(&avatar);
QVERIFY(trackerEngine->saveContact(&c, error));
names.insert(c.localId(), name);
QCOMPARE(error, QContactManager::NoError);
addedContacts.append(c.localId());
}
// Init filter
QContactLocalId searchId = names.keys().at(1);
QString searchFirst = names.value(searchId).firstName();
QString searchLast = names.value(searchId).lastName();
QContactUnionFilter ufilter;
QContactDetailFilter filterFirst;
filterFirst.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldFirst);
filterFirst.setMatchFlags(QContactFilter::MatchExactly);
filterFirst.setValue(searchFirst);
QContactDetailFilter filterLast;
filterLast.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldLast);
filterLast.setMatchFlags(QContactFilter::MatchExactly);
filterLast.setValue(searchLast);
ufilter.setFilters(QList<QContactFilter>() << filterFirst << filterLast);
// Init request
QContactFetchRequest request;
request.setFilter(ufilter);
trackerEngine->startRequest(&request);
trackerEngine->waitForRequestFinished(&request, 10000);
// Test fetch result
QCOMPARE(request.contacts().count(), 1);
QCOMPARE(request.contacts().at(0).localId(), searchId);
QCOMPARE(request.contacts().at(0).detail<QContactName>().firstName(), searchFirst);
QCOMPARE(request.contacts().at(0).detail<QContactName>().lastName(), searchLast);
}
void ut_qtcontacts_trackerplugin::testTrackerUriToUniqueId()
{
QString uri = "contact:1234567";
QContactLocalId id = url2UniqueId( uri );
QCOMPARE( (int)id, 1234567 );
}
void ut_qtcontacts_trackerplugin::testQRelationshipAndMetacontacts()
{
QContact firstContact;
QContactName name;
name.setFirstName("FirstMeta");
firstContact.saveDetail(&name);
QVERIFY(trackerEngine->saveContact(&firstContact, error));
QList<QContactLocalId> secondIds;
QStringList names(QStringList()<<"SecondMeta"<<"ThirdMeta");
foreach (QString firstname, names)
{
QContact secondContact;
QContactName name1;
name1.setFirstName(firstname);
secondContact.saveDetail(&name1);
QVERIFY(trackerEngine->saveContact(&secondContact, error));
secondIds<<secondContact.id().localId();
QContactRelationship rel;
rel.setRelationshipType(QContactRelationship::Is);
rel.setFirst(firstContact.id());
rel.setSecond(secondContact.id());
QContactRelationshipSaveRequest req;
req.setRelationships(QList<QContactRelationship>()<<rel);
QVERIFY(trackerEngine->startRequest(&req));
trackerEngine->waitForRequestFinished(&req, 10000);
// if it takes more, then something is wrong
QVERIFY(req.isFinished());
QVERIFY(QContactManager::NoError == req.error());
}
QContactRelationshipFetchRequest req1;
req1.setFirst(firstContact.id());
QVERIFY(trackerEngine->startRequest(&req1));
trackerEngine->waitForRequestFinished(&req1, 10000);
// if it takes more, then something is wrong
QVERIFY(req1.isFinished());
QVERIFY(QContactManager::NoError == req1.error());
QVERIFY(2 == req1.relationships().size());
foreach(QContactRelationship r, req1.relationships())
{
QVERIFY(secondIds.removeOne(r.second().localId()));
}
}
void ut_qtcontacts_trackerplugin::insertContact(const QString& URI, QContactLocalId uid, QString imId, QString imStatus, QString accountPath, QString protocol )
{
QProcess inserter;
QStringList args;
args << URI << QString::number(uid) << imId << accountPath << imStatus << "In Helsinki" << protocol << "Some" << "Guy";
inserter.start( PATH_TO_SPARQL_TESTS+"/insertTpContact.sparql", args );
inserter.waitForFinished();
}
void ut_qtcontacts_trackerplugin::updateIMContactStatus(const QString& uri, QString imStatus)
{
QProcess inserter;
QStringList args;
args << uri << imStatus;
inserter.start( PATH_TO_SPARQL_TESTS+"/updateTpStatus.sparql", args );
inserter.waitForFinished();
}
void ut_qtcontacts_trackerplugin::testIMContactsAndMetacontactMasterPresence()
{
if( !QFileInfo(PATH_TO_SPARQL_TESTS).exists() )
{
qWarning()<<Q_FUNC_INFO<<"is disabled - test scripts are not installed";
return;
}
QList<unsigned int> idstoremove;
QContactLocalId masterContactId; // using one master contact later for additional testing
for( int i = 0; i < 2; i++ )
{
unsigned int contactid = qHash(QString("/org/freedesktop/fake/account/") + QString::number(999998+i) + "@ovi.com");
idstoremove << contactid;
insertContact(QString("telepathy://org/freedesktop/fake/account/") + QString::number(999998+i) + "@ovi.com",
contactid, QString::number(999998 + i)+ "@ovi.com", "nco:presence-status-available", QString("http://www.sopranolive.org/backends/tracker/generated_unique_id/105323876#%1").arg(999998+i),"ovi.com");
QContact c = contact(contactid, QStringList()<<QContactOnlineAccount::DefinitionName);
QVERIFY(c.localId() == contactid);
QVERIFY(c.detail<QContactOnlineAccount>().serviceProvider() == "ovi.com");
QContact firstContact;
QContactName name;
name.setFirstName("FirstMetaWithIM"+QString::number(contactid));
firstContact.saveDetail(&name);
QVERIFY(trackerEngine->saveContact(&firstContact, error));
// save metarelationship
QContactRelationship rel;
rel.setRelationshipType(QContactRelationship::Is);
rel.setFirst(firstContact.id());
idstoremove << firstContact.localId();
masterContactId = firstContact.localId();
rel.setSecond(c.id());
QContactRelationshipSaveRequest req;
req.setRelationships(QList<QContactRelationship>()<<rel);
QVERIFY(trackerEngine->startRequest(&req));
trackerEngine->waitForRequestFinished(&req, 1000);
QVERIFY(req.isFinished());
QVERIFY(QContactManager::NoError == req.error());
}
// expected behavior - for now - is that master contact contains details from
// IMContacts - that way we don't have to use QContactRelationships to fetch
// all contacts in master contact in order to calculate master presence
{
QList<QContact> cons = contacts(QList<QContactLocalId> ()
<< masterContactId << qHash(QString("/org/freedesktop/fake/account/") + QString::number(999999) + "@ovi.com"), QStringList()
<< QContactOnlineAccount::DefinitionName);
QVERIFY(cons.size() == 1);
QVERIFY(cons[0].id().localId() == masterContactId);
bool containDetail = false;
foreach(QContactOnlineAccount det, cons[0].details<QContactOnlineAccount>())
{
if (det.value("Account") == "999999@ovi.com" // deprecated, going to account URI
|| det.accountUri() == "999999@ovi.com")
{
QVERIFY(det.presence() == QContactOnlineAccount::PresenceAvailable);
// keeping the reference to tp contact
QVERIFY(det.value("QContactLocalId") == QString::number(qHash(QString("/org/freedesktop/fake/account/") + QString::number(999999) + "@ovi.com")));
containDetail = true;
}
}
QVERIFY(containDetail);
}
//now update presence to IM contact and check it in metacontact (TODO and if signal is emitted)
updateIMContactStatus(QString("telepathy://org/freedesktop/fake/account/") + QString::number(999999) + "@ovi.com", "nco:presence-status-offline");
{
QList<QContact> cons = contacts(QList<QContactLocalId> ()
<< masterContactId << qHash(QString("/org/freedesktop/fake/account/") + QString::number(999999) + "@ovi.com"), QStringList()
<< QContactOnlineAccount::DefinitionName);
QVERIFY(cons.size() == 1);
QVERIFY(cons[0].id().localId() == masterContactId);
bool containDetail = false;
foreach(QContactOnlineAccount det, cons[0].details<QContactOnlineAccount>())
{
if (det.value("Account") == "999999@ovi.com" // deprecated, going to account URI
|| det.accountUri() == "999999@ovi.com")
{
QVERIFY(det.presence() == QContactOnlineAccount::PresenceOffline);
// keeping the reference to tp contact
QVERIFY(det.value("QContactLocalId") == QString::number(qHash(QString("/org/freedesktop/fake/account/") + QString::number(999999) + "@ovi.com")));
containDetail = true;
}
}
QVERIFY(containDetail);
}
// TODO load only one contact should load also content from other in the same metacontacts
{
QList<QContact> cons = contacts(QList<QContactLocalId> ()
<< masterContactId, QStringList()
<< QContactOnlineAccount::DefinitionName);
QVERIFY(cons.size() == 1);
QVERIFY(cons[0].id().localId() == masterContactId);
bool containDetail = false;
foreach(QContactOnlineAccount det, cons[0].details<QContactOnlineAccount>())
{
if (det.value("Account") == "999999@ovi.com" // deprecated, going to account URI
|| det.accountUri() == "999999@ovi.com")
{
QVERIFY(det.presence() == QContactOnlineAccount::PresenceOffline);
// keeping the reference to tp contact
QVERIFY(det.value("QContactLocalId") == QString::number(qHash(QString("/org/freedesktop/fake/account/") + QString::number(999999) + "@ovi.com")));
containDetail = true;
}
}
QVERIFY(containDetail);
}
// remove them
foreach(unsigned int id, idstoremove)
{
QVERIFY2(trackerEngine->removeContact(id, error), "Removing a contact failed");
}
}
void ut_qtcontacts_trackerplugin::testIMContactsFilterring()
{
QList<unsigned int> idstoremove;
QList<QContactLocalId> idsToRetrieveThroughFilter;
for( int i = 0; i < 3; i++ )
{
unsigned int contactid = qHash(QString("/org/freedesktop/fake/account/") + QString::number(999995+i) + "@ovi.com");
idstoremove << contactid;
insertContact(QString("telepathy://org/freedesktop/fake/account/") + QString::number(999995+i) + "@ovi.com",
contactid, QString::number(999995 + i)+ "@ovi.com", "nco:presence-status-available",
QString("www.sopranolive.org/backends/tracker/generated_unique_id/105323876#ovi%1").arg(i/2), QString("ovi%1.com").arg(i/2));
if(!i/2)
idsToRetrieveThroughFilter << contactid;
}
{
// now filter by service provider ovi0.com needs to return 2 contacts, 999995 & 999996
QList<QContactLocalId> ids(idsToRetrieveThroughFilter);
QContactFetchRequest request;
QContactDetailFilter filter;
filter.setDetailDefinitionName(QContactOnlineAccount::DefinitionName, QContactOnlineAccount::FieldServiceProvider);
Slots slot;
QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),
&slot, SLOT(progress(QContactFetchRequest*, bool )));
filter.setValue(QString("ovi0.com"));
filter.setMatchFlags(QContactFilter::MatchExactly);
request.setDefinitionRestrictions(QStringList()<<QContactOnlineAccount::DefinitionName);
request.setFilter(filter);
trackerEngine->startRequest(&request);
for(int i = 0; i < 100; i++)
{
usleep(100000);
QCoreApplication::processEvents();
if(request.isFinished() )
break;
}
// if it takes more, then something is wrong
QVERIFY(request.isFinished());
QVERIFY(!request.contacts().isEmpty());
QVERIFY(request.contacts().size() >= 2);
foreach(const QContact &contact, request.contacts())
{
QVERIFY(contact.detail<QContactOnlineAccount>().serviceProvider() == "ovi0.com");
ids.removeOne(contact.localId());
}
QVERIFY(ids.isEmpty());
}
// now account path filter
{
// now filter by account path 999995 & 999996
QList<QContactLocalId> ids(idsToRetrieveThroughFilter);
QContactFetchRequest request;
QContactDetailFilter filter;
filter.setDetailDefinitionName(QContactOnlineAccount::DefinitionName, "AccountPath");
Slots slot;
QObject::connect(&request, SIGNAL(progress(QContactFetchRequest*, bool)),
&slot, SLOT(progress(QContactFetchRequest*, bool )));
// see insertTpContact
filter.setValue(QString("www.sopranolive.org/backends/tracker/generated_unique_id/105323876#ovi0"));
filter.setMatchFlags(QContactFilter::MatchExactly);
request.setDefinitionRestrictions(QStringList()<<QContactOnlineAccount::DefinitionName);
request.setFilter(filter);
trackerEngine->startRequest(&request);
for(int i = 0; i < 100; i++)
{
usleep(100000);
QCoreApplication::processEvents();
if(request.isFinished() )
break;
}
// if it takes more, then something is wrong
QVERIFY(request.isFinished());
QVERIFY(!request.contacts().isEmpty());
QVERIFY(request.contacts().size() >= 2);
foreach(const QContact &contact, request.contacts())
{
QVERIFY(contact.detail<QContactOnlineAccount>().serviceProvider() == "ovi0.com");
ids.removeOne(contact.localId());
}
QVERIFY(ids.isEmpty());
}
// remove them
foreach(unsigned int id, idstoremove)
{
QVERIFY2(trackerEngine->removeContact(id, error), "Removing a contact failed");
}
}
void ut_qtcontacts_trackerplugin::testContactsWithoutMeContact() {
QContact c;
QContactName name;
name.setFirstName("Totally");
name.setLastName("Unique");
c.saveDetail(&name);
trackerEngine->saveContact(&c, error);
QContactLocalId id = c.localId(); // Store ID for later removal.
// Prepare the filter for the request - we fetch only the one contact saved above.
QList<QContactLocalId> ids;
ids << id;
QContactLocalIdFilter filter;
filter.setIds(ids);
// Prepare the requst - give filter to it and specify which fields to fetch. We fetch only the name.
QStringList details;
details << QContactName::DefinitionName;
QContactLocalIdFetchRequest nameFetchRequest;
nameFetchRequest.setFilter(filter);
// Start the request and wait for it to finish.
trackerEngine->startRequest(&nameFetchRequest);
trackerEngine->waitForRequestFinished(&nameFetchRequest, 1000);
// Requst finished. Test that only one contact is removed.
QList<QContactLocalId> contacts = nameFetchRequest.ids();
QVERIFY2(contacts.count() < 2, "We expected to get only one contact. Got more.");
QVERIFY2(contacts.count() != 0, "We expected to get one contact. Got none.");
QVERIFY2(contacts.first() == id, "Did not get the requested contact back.");
// Cleaning up.
trackerEngine->removeContact(id, error);
}
/*************************** Helper functions for unit tests ***************'*/
QContact ut_qtcontacts_trackerplugin::contact(QContactLocalId id, QStringList details)
{
QList<QContact> conts = contacts(QList<QContactLocalId>()<<id, details);
return conts.size()?conts[0]:QContact();
}
QList<QContact> ut_qtcontacts_trackerplugin::contacts(QList<QContactLocalId> ids, QStringList details)
{
QContactFetchRequest request;
QContactLocalIdFilter filter;
filter.setIds(ids);
request.setFilter(filter);
request.setDefinitionRestrictions(details);
trackerEngine->startRequest(&request);
trackerEngine->waitForRequestFinished(&request, 1000);
return request.contacts();
}
void Slots::progress(QContactLocalIdFetchRequest* self, bool appendOnly)
{
Q_UNUSED(appendOnly)
if( self->state() == QContactAbstractRequest::FinishedState )
{
ids << self->ids();
}
}
void Slots::progress(QContactFetchRequest* self, bool appendOnly)
{
Q_UNUSED(appendOnly)
contacts = self->contacts();
QList<QContactLocalId> idsFromAllContactReq;
foreach( QContact contact, contacts)
{
idsFromAllContactReq << contact.localId();
}
}
QString Slots::requestStatusToString(QContactAbstractRequest::Status status)
{
switch (status) {
case QContactAbstractRequest::Inactive:
return "Inactive";
case QContactAbstractRequest::Active:
return "Active";
case QContactAbstractRequest::Cancelling:
return "Cancelling";
case QContactAbstractRequest::Cancelled:
return "Cancelled";
case QContactAbstractRequest::Finished:
return "Finished";
default:
return QString::number((int)status);
}
}
QTEST_MAIN(ut_qtcontacts_trackerplugin)