1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 #include "ut_mobcntmodel.h"

    19 #include "cntlistmodel.h"

    20 #include "cntlistmodel_p.h"

    21 

    22 #include <qtcontacts.h>

    23 #include <QUrl>

    24 

    25 void TestMobCntModel::initTestCase()

    26 {

    27     //let's have clean database before running tests 

    28     mManager = new QContactManager("symbian");

    29     QList<QContactLocalId> ids = mManager->contactIds();

    30     QMap<int, QContactManager::Error> errorMapInit;

    31     mManager->removeContacts(ids, &errorMapInit);

    32 }

    33 

    34 void TestMobCntModel::contactReady(int startRow, int endRow)

    35 {

    36     QVERIFY(startRow == endRow);

    37     mDataReady = true;

    38 }

    39 

    40 void TestMobCntModel::create()

    41 {

    42     mCntModel = new CntListModel();

    43     QVERIFY(mCntModel != 0);

    44     QVERIFY(mCntModel->rowCount() == 1);

    45     QVERIFY(mCntModel->d->m_cache);

    46     QVERIFY(mCntModel->d->ownedContactManager);

    47     QVERIFY(mCntModel->d->m_contactManager != 0);

    48     

    49     delete mCntModel;

    50     mCntModel = 0;

    51     

    52     mCntModel = new CntListModel(mManager);

    53     QVERIFY(mCntModel != 0);

    54     QCOMPARE(mCntModel->rowCount(),1);

    55     QVERIFY(mCntModel->rowCount() == 1);

    56     QVERIFY(mCntModel->d->m_cache);

    57     QVERIFY(!mCntModel->d->ownedContactManager);

    58     QVERIFY(mCntModel->d->m_contactManager != 0);

    59 }

    60 

    61 void TestMobCntModel::data()

    62 {

    63     mModelListener = new ModelListener(this);

    64     mDataReady = false;

    65 

    66     //create and save contact

    67     QContact c;

    68     QContactName name;

    69     name.setFirstName("firstname");

    70     name.setLastName("lastname");

    71     c.saveDetail(&name);

    72     QContactPhoneNumber number;

    73     number.setNumber("1234567");

    74     number.setContexts(QContactDetail::ContextHome);

    75     number.setSubTypes(QContactPhoneNumber::SubTypeMobile);

    76     c.saveDetail(&number);

    77     QContactEmailAddress email;

    78     email.setEmailAddress("dummyemail");

    79     c.saveDetail(&email);

    80     QVERIFY(mManager->saveContact(&c));

    81     QTest::qWait(1000);

    82     

    83     //check invalid row and column

    84     QVariant ret;

    85     ret = mCntModel->data(QModelIndex(), Qt::UserRole);

    86     QVERIFY(ret.isNull());

    87     

    88     //check the saved contact's info

    89     QModelIndex modelIndex = mCntModel->indexOfContact(c);

    90     int row = modelIndex.row();

    91     QContact contactFromModel = mCntModel->contact(modelIndex);

    92     QVERIFY(c == contactFromModel);

    93     

    94     ret = mCntModel->data(modelIndex, Qt::UserRole); 

    95     QVERIFY(ret.isNull());

    96     

    97     ret = mCntModel->data(modelIndex, Qt::DisplayRole); 

    98     QVERIFY(ret.type() == QVariant::StringList);

    99     QStringList displayContent;

   100     displayContent = ret.toStringList();

   101     QVERIFY(displayContent.count() == 2);

   102     QVERIFY(displayContent.at(0) == "firstname lastname");

   103     // second string is only an empty placeholder, e.g. " ", until cache has fetched the value

   104 

   105     // wait for cache to signal that all contact info is ready

   106     while (!mDataReady) { QTest::qWait(200); QApplication::processEvents(); }

   107     mDataReady = false;

   108     ret = mCntModel->data(modelIndex, Qt::DisplayRole); 

   109 

   110     QVERIFY(ret.type() == QVariant::StringList);

   111     displayContent = ret.toStringList();

   112     QVERIFY(displayContent.count() == 2);

   113     QVERIFY(displayContent.at(0) == "firstname lastname");

   114     QVERIFY(displayContent.at(1) == "1234567");

   115    

   116     // check backgroundrole

   117     ret = mCntModel->data(modelIndex, Qt::BackgroundRole); 

   118     QVERIFY(ret.isNull());

   119     

   120     //check decoration role

   121     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 

   122     QVERIFY(ret.type() == QVariant::List);

   123 

   124     // add empty avatar and check decoration

   125     QContactAvatar avatar;

   126     c.saveDetail(&avatar);

   127     QVERIFY(mManager->saveContact(&c));

   128     QTest::qWait(1000);

   129     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 

   130     QVERIFY(ret.type() == QVariant::List);

   131     

   132     // add data to the avatar and check decoration

   133     avatar.setImageUrl(QUrl("dummyimagepath"));

   134     c.saveDetail(&avatar);

   135     QVERIFY(mManager->saveContact(&c));

   136     QTest::qWait(1000);

   137     modelIndex = mCntModel->indexOfContact(c);

   138     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 

   139 

   140     // wait for cache to signal that all contact info is ready

   141     while (!mDataReady) { QTest::qWait(200); QApplication::processEvents(); }

   142     mDataReady = false;

   143     ret = mCntModel->data(modelIndex, Qt::DecorationRole); 

   144     QVERIFY(ret.type() == QVariant::List);

   145     

   146     // check MyCard info from the model

   147     modelIndex = mCntModel->index(0, 0);

   148     ret = mCntModel->data(modelIndex, Qt::BackgroundRole);

   149     QVERIFY(!ret.isNull());

   150     

   151     // create and assign empty MyCard

   152     QContact myCard;

   153     QVERIFY(mManager->saveContact(&myCard));

   154     QTest::qWait(1000);

   155     mManager->setSelfContactId(myCard.localId());

   156     QTest::qWait(1000);

   157     

   158     // check MyCard info from the model

   159     myCard = mManager->contact(mManager->selfContactId());

   160     modelIndex = mCntModel->indexOfContact(myCard);

   161     ret = mCntModel->data(modelIndex, Qt::BackgroundRole);

   162     QVERIFY(!ret.isNull());

   163     

   164     ret = mCntModel->data(modelIndex, Qt::DisplayRole);

   165     QVERIFY(ret.type() == QVariant::StringList);

   166     displayContent = ret.toStringList();

   167     QVERIFY(displayContent.count() == 1); // "Unnamed"

   168     

   169     // add some content to MyCard

   170     myCard.saveDetail(&number);

   171     QVERIFY(mManager->saveContact(&myCard));

   172     QTest::qWait(1000);

   173     ret = mCntModel->data(modelIndex, Qt::DisplayRole);

   174     // wait for cache

   175     QTest::qWait(1000);

   176     ret = mCntModel->data(modelIndex, Qt::DisplayRole);

   177     QVERIFY(ret.type() == QVariant::StringList);

   178     displayContent = ret.toStringList();

   179     QVERIFY(displayContent.contains(hbTrId("txt_phob_list_unnamed")));

   180 }

   181 

   182 void TestMobCntModel::rowCount()

   183 {

   184     // we should have 2 contacts in the model saved from the last test case

   185     QCOMPARE(mCntModel->rowCount(),3);

   186     QVERIFY(mCntModel->rowCount() == 3);

   187 }

   188 

   189 void TestMobCntModel::contact()

   190 {

   191     QList<QContactLocalId> ids = mManager->contactIds();

   192     QMap<int, QContactManager::Error> errorMapContact;

   193     mManager->removeContacts(ids,&errorMapContact);

   194     QTest::qWait(1000);

   195     

   196     QModelIndex modelIndex = mCntModel->index(0, 0);

   197     QContact empty = mCntModel->contact(modelIndex);

   198     //QVERIFY(empty.isEmpty());

   199     

   200     //create and save contact

   201     QContact c;

   202     QContactName name;

   203     name.setFirstName("firstname");

   204     name.setLastName("lastname");

   205     c.saveDetail(&name);

   206     QContactPhoneNumber number;

   207     number.setNumber("1234567");

   208     number.setContexts(QContactDetail::ContextHome);

   209     number.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   210     c.saveDetail(&number);

   211     QContactEmailAddress email;

   212     email.setEmailAddress("dummyemail");

   213     c.saveDetail(&email);

   214     QVERIFY(mManager->saveContact(&c));

   215     QTest::qWait(1000);

   216     

   217     modelIndex = mCntModel->index(10, 0);

   218     c = mCntModel->contact(modelIndex);

   219     QVERIFY(c.isEmpty());

   220     

   221     modelIndex = mCntModel->index(1, 0);

   222     c = mCntModel->contact(modelIndex);

   223     QVERIFY(!c.isEmpty());

   224 }

   225 

   226 void TestMobCntModel::indexOfContact()

   227 {

   228     QModelIndex modelIndex = mCntModel->index(1, 0);

   229     QContact c = mCntModel->contact(modelIndex);

   230     

   231     QVERIFY(mCntModel->indexOfContact(c) == modelIndex);

   232 }

   233 

   234 void TestMobCntModel::contactManager()

   235 {

   236     QVERIFY(mManager == &(mCntModel->contactManager()));

   237 }

   238 

   239 void TestMobCntModel::setFilterAndSortOrder()

   240 {

   241     QList<QContactLocalId> ids = mManager->contactIds();

   242     QMap<int, QContactManager::Error> errorMap;

   243     mManager->removeContacts(ids,&errorMap);

   244     QTest::qWait(1000);

   245     

   246     QContact c;

   247     QContactName name;

   248     name.setFirstName("firstname");

   249     name.setLastName("lastname");

   250     c.saveDetail(&name);

   251     QVERIFY(mManager->saveContact(&c));

   252     

   253     QContactUnionFilter unionFilter;

   254     QContactDetailFilter landlineFilter;

   255     landlineFilter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldSubTypes); 

   256     landlineFilter.setValue(QLatin1String(QContactPhoneNumber::SubTypeLandline));

   257     unionFilter << landlineFilter;

   258     QContactDetailFilter mobileFilter;

   259     mobileFilter.setDetailDefinitionName(QContactPhoneNumber::DefinitionName, QContactPhoneNumber::FieldSubTypes); 

   260     mobileFilter.setValue(QLatin1String(QContactPhoneNumber::SubTypeMobile));

   261     unionFilter << mobileFilter;

   262     

   263     mCntModel->setFilterAndSortOrder(unionFilter);

   264     

   265     QModelIndex modelIndex = mCntModel->indexOfContact(c);

   266     QVERIFY(modelIndex.row() < 0);

   267     QVERIFY(mCntModel->d->filter == unionFilter);

   268     QVERIFY(mCntModel->d->sortOrders.count() == 0);

   269     

   270     QList<QContactSortOrder> sortOrders;

   271     QContactSortOrder sortOrderFirstName;

   272     sortOrderFirstName.setDetailDefinitionName(QContactName::DefinitionName, QContactName::FieldFirstName);

   273     sortOrders.append(sortOrderFirstName);

   274     

   275     mCntModel->setFilterAndSortOrder(unionFilter, sortOrders);

   276     

   277     modelIndex = mCntModel->indexOfContact(c);

   278     QVERIFY(modelIndex.row() < 0);

   279     QVERIFY(mCntModel->d->filter == unionFilter);

   280     QVERIFY(mCntModel->d->sortOrders.count() == 1);

   281 }

   282 

   283 void TestMobCntModel::myCard()

   284 {

   285     delete mCntModel;

   286     mCntModel = 0;

   287     

   288     mCntModel = new CntListModel(mManager);

   289     

   290     QList<QContactLocalId> ids = mManager->contactIds();

   291     QMap<int, QContactManager::Error> errorMap;

   292     mManager->removeContacts(ids,&errorMap);

   293     QTest::qWait(1000);

   294     

   295     QContact c;

   296     QContactName name;

   297     name.setFirstName("firstname");

   298     name.setLastName("lastname");

   299     c.saveDetail(&name);

   300     QVERIFY(mManager->saveContact(&c));

   301     

   302     QSignalSpy spy(mCntModel, SIGNAL(modelReset()));

   303     

   304     QVERIFY(mCntModel->myCardStatus());

   305     

   306     mCntModel->showMyCard(false);

   307     QVERIFY(!mCntModel->myCardStatus());

   308     QCOMPARE(spy.count(), 2);

   309     

   310     mCntModel->showMyCard(true);

   311     QVERIFY(mCntModel->myCardStatus());

   312     QCOMPARE(spy.count(), 4);

   313     

   314     mManager->setSelfContactId(c.localId());

   315     QTest::qWait(1000);

   316     spy.clear();

   317     

   318     mCntModel->showMyCard(false);

   319     QVERIFY(!mCntModel->myCardStatus());

   320     QCOMPARE(spy.count(), 2);

   321     

   322     mCntModel->showMyCard(true);

   323     QVERIFY(mCntModel->myCardStatus());

   324     QCOMPARE(spy.count(), 4);

   325     mCntModel->showMyCard(true);

   326     QVERIFY(mCntModel->myCardStatus());

   327     QCOMPARE(spy.count(), 4);

   328 }

   329 

   330 void TestMobCntModel::rowId()

   331 {

   332     QList<QContactLocalId> ids = mManager->contactIds();

   333     QMap<int, QContactManager::Error> errorMap;

   334     mManager->removeContacts(ids,&errorMap);

   335     QTest::qWait(1000);

   336     

   337     QContact c;

   338     QContactName name;

   339     name.setFirstName("firstname");

   340     name.setLastName("lastname");

   341     c.saveDetail(&name);

   342     QVERIFY(mManager->saveContact(&c));

   343     

   344     int row = mCntModel->rowId(c.localId());

   345     QVERIFY(row > 0);

   346     QVERIFY(mCntModel->validRowId(row));

   347     QVERIFY(!mCntModel->validRowId(-100));

   348     QVERIFY(!mCntModel->validRowId(100));

   349 }

   350 

   351 void TestMobCntModel::dataForDisplayRole()

   352 {

   353     QList<QContactLocalId> ids = mManager->contactIds();

   354     QMap<int, QContactManager::Error> errorMap;

   355     mManager->removeContacts(ids,&errorMap);

   356     QTest::qWait(1000);

   357     

   358     QContact c;

   359     QContactName name;

   360     name.setFirstName("firstname");

   361     name.setLastName("lastname");

   362     c.saveDetail(&name);

   363     QVERIFY(mManager->saveContact(&c));

   364     

   365     int row = mCntModel->rowId(c.localId());

   366     QVariant var = mCntModel->dataForDisplayRole(row);

   367     QVERIFY(var.type() == QVariant::StringList);

   368     

   369     var = mCntModel->dataForDisplayRole(0);

   370     QVERIFY(var.type() == QVariant::StringList);

   371 }

   372 

   373 void TestMobCntModel::handleAdded()

   374 {

   375     QList<QContactLocalId> ids = mManager->contactIds();

   376     QMap<int, QContactManager::Error> errorMap;

   377     mManager->removeContacts(ids,&errorMap);

   378     QTest::qWait(1000);

   379 

   380     QSignalSpy spy(mCntModel, SIGNAL(rowsAboutToBeInserted(const QModelIndex&, int, int)));

   381     

   382     QContact c;

   383     QContactName name;

   384     name.setFirstName("firstname");

   385     name.setLastName("lastname");

   386     c.saveDetail(&name);

   387     QVERIFY(mManager->saveContact(&c));

   388 

   389     QCOMPARE(spy.count(), 1);

   390 }

   391 

   392 void TestMobCntModel::handleChanged()

   393 {

   394     QList<QContactLocalId> ids = mManager->contactIds();

   395     QMap<int, QContactManager::Error> errorMap;

   396     mManager->removeContacts(ids,&errorMap);

   397     QTest::qWait(1000);

   398     

   399     QContact c;

   400     QContactName name;

   401     name.setFirstName("firstname");

   402     name.setLastName("lastname");

   403     c.saveDetail(&name);

   404     QVERIFY(mManager->saveContact(&c));

   405     

   406     QSignalSpy spy(mCntModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex&)));

   407 

   408     name.setMiddleName("mid");

   409     c.saveDetail(&name);

   410     QVERIFY(mManager->saveContact(&c));

   411 

   412     QCOMPARE(spy.count(), 1);

   413 }

   414 

   415 void TestMobCntModel::handleRemoved()

   416 {

   417     QSignalSpy spy(mCntModel, SIGNAL(rowsAboutToBeRemoved(const QModelIndex&, int, int)));

   418     

   419     QList<QContactLocalId> ids = mManager->contactIds();

   420     QMap<int, QContactManager::Error> errorMap;

   421     mManager->removeContacts(ids,&errorMap);

   422     QTest::qWait(1000);

   423     

   424     QCOMPARE(spy.count(), 1);

   425 }

   426 

   427 void TestMobCntModel::handleMyCardChanged()

   428 {

   429     QList<QContactLocalId> ids = mManager->contactIds();

   430     QMap<int, QContactManager::Error> errorMap;

   431     mManager->removeContacts(ids,&errorMap);

   432     QTest::qWait(1000);

   433     

   434     QContact c;

   435     QContactName name;

   436     name.setFirstName("firstname");

   437     name.setLastName("lastname");

   438     c.saveDetail(&name);

   439     QVERIFY(mManager->saveContact(&c));

   440     

   441     QSignalSpy spy(mCntModel, SIGNAL(dataChanged(const QModelIndex &, const QModelIndex&)));

   442 

   443     mCntModel->handleMyCardChanged(0, c.localId());

   444     QCOMPARE(spy.count(), 1);

   445     QVERIFY(mCntModel->d->mMyCardId == c.localId());

   446 }

   447 

   448 void TestMobCntModel::cleanupTestCase()

   449 {

   450     delete mCntModel;

   451     mCntModel = 0;

   452     

   453     //let's have clean database after running tests

   454     QList<QContactLocalId> ids = mManager->contactIds();

   455     QMap<int, QContactManager::Error> errorMap;

   456     mManager->removeContacts(ids, &errorMap);

   457     delete mManager;

   458     mManager = 0;

   459     delete mModelListener;

   460     mModelListener = 0;

   461 }

   462 

   463 

   464 ModelListener::ModelListener(TestMobCntModel* parent)

   465     : mParent(parent)

   466 {

   467     connect(mParent->mCntModel, SIGNAL(dataChanged(QModelIndex,QModelIndex)), this, SLOT(onDataChanged(QModelIndex,QModelIndex)));

   468 }

   469 

   470 void ModelListener::onDataChanged(QModelIndex start, QModelIndex end)

   471 {

   472     mParent->contactReady(start.row(), end.row());

   473 }

   474