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_cntlistmodel.h"

    19 #include "cntlistmodel.h"

    20 #include "cntlistmodel_p.h"

    21 

    22 #include <hbnamespace.h>

    23 #include <qtcontacts.h>

    24 #include <QUrl>

    25 

    26 void TestCntListModel::initTestCase()

    27 {

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

    29     mManager = new QContactManager("symbian");

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

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

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

    33     mManager->removeContact(mManager->selfContactId());

    34 }

    35 

    36 void TestCntListModel::contactReady(int startRow, int endRow)

    37 {

    38     QVERIFY(startRow == endRow);

    39     mDataReady = true;

    40 }

    41 

    42 void TestCntListModel::create()

    43 {

    44     mCntModel = new CntListModel();

    45     QVERIFY(mCntModel != NULL);

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

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

    48     QVERIFY(mCntModel->d->m_ownedContactManager);

    49     QVERIFY(mCntModel->d->m_contactManager != NULL);

    50     

    51     delete mCntModel;

    52     mCntModel = NULL;

    53     

    54     mCntModel = new CntListModel(mManager);

    55     QVERIFY(mCntModel != NULL);

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

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

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

    59     QVERIFY(!mCntModel->d->m_ownedContactManager);

    60     QVERIFY(mCntModel->d->m_contactManager != NULL);

    61 }

    62 

    63 void TestCntListModel::data()

    64 {

    65     mModelListener = new ModelListener(this);

    66     mDataReady = false;

    67 

    68     //create and save contact

    69     QContact c;

    70     QContactName name;

    71     name.setFirstName("firstname");

    72     name.setLastName("lastname");

    73     c.saveDetail(&name);

    74     QContactPhoneNumber number;

    75     number.setNumber("1234567");

    76     number.setContexts(QContactDetail::ContextHome);

    77     number.setSubTypes(QContactPhoneNumber::SubTypeMobile);

    78     c.saveDetail(&number);

    79     QContactEmailAddress email;

    80     email.setEmailAddress("dummyemail");

    81     c.saveDetail(&email);

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

    83     QTest::qWait(1000);

    84     

    85     //check invalid row and column

    86     QVariant ret;

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

    88     QVERIFY(ret.isNull());

    89     

    90     //check the saved contact's info

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

    92     int row = modelIndex.row();

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

    94     QVERIFY(c == contactFromModel);

    95     

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

    97     QVERIFY(ret.isNull());

    98     

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

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

   101     QStringList displayContent;

   102     displayContent = ret.toStringList();

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

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

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

   106 

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

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

   109     mDataReady = false;

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

   111 

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

   113     displayContent = ret.toStringList();

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

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

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

   117    

   118     // check backgroundrole

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

   120     QVERIFY(ret.isNull());

   121     

   122     //check decoration role

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

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

   125     

   126     ret = mCntModel->data(modelIndex, Hb::IndexFeedbackRole); 

   127     QVERIFY(ret.type() == QVariant::String);

   128 

   129     // add empty avatar and check decoration

   130     QContactAvatar avatar;

   131     c.saveDetail(&avatar);

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

   133     QTest::qWait(1000);

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

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

   136     

   137     // add data to the avatar and check decoration

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

   139     c.saveDetail(&avatar);

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

   141     QTest::qWait(1000);

   142     modelIndex = mCntModel->indexOfContact(c);

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

   144 

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

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

   147     mDataReady = false;

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

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

   150     

   151     // check MyCard info from the model

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

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

   154     QVERIFY(!ret.isNull());

   155     

   156     // create and assign empty MyCard

   157     QContact myCard;

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

   159     QTest::qWait(1000);

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

   161     QTest::qWait(1000);

   162     

   163     // check that MyCard was really saved

   164     QCOMPARE(mCntModel->myCardId(), myCard.localId());

   165     

   166     // check MyCard info from the model

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

   168     modelIndex = mCntModel->indexOfContact(myCard);

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

   170     QVERIFY(!ret.isNull());

   171     

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

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

   174     displayContent = ret.toStringList();

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

   176     

   177     // add some content to MyCard

   178     myCard.saveDetail(&number);

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

   180     QTest::qWait(1000);

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

   182     // wait for cache

   183     QTest::qWait(1000);

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

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

   186     displayContent = ret.toStringList();

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

   188     

   189     ret = mCntModel->data(modelIndex, Hb::IndexFeedbackRole); 

   190     QVERIFY(ret.isNull());

   191 }

   192 

   193 void TestCntListModel::rowCount()

   194 {

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

   196     QTest::qWait(5000);

   197     QCOMPARE(mCntModel->rowCount(), 2);

   198 }

   199 

   200 void TestCntListModel::contact()

   201 {

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

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

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

   205     QTest::qWait(1000);

   206     

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

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

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

   210     

   211     //create and save contact

   212     QContact c;

   213     QContactName name;

   214     name.setFirstName("firstname");

   215     name.setLastName("lastname");

   216     c.saveDetail(&name);

   217     QContactPhoneNumber number;

   218     number.setNumber("1234567");

   219     number.setContexts(QContactDetail::ContextHome);

   220     number.setSubTypes(QContactPhoneNumber::SubTypeMobile);

   221     c.saveDetail(&number);

   222     QContactEmailAddress email;

   223     email.setEmailAddress("dummyemail");

   224     c.saveDetail(&email);

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

   226     QTest::qWait(1000);

   227     

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

   229     c = mCntModel->contact(modelIndex);

   230     QVERIFY(c.isEmpty());

   231     

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

   233     c = mCntModel->contact(modelIndex);

   234     QVERIFY(!c.isEmpty());

   235 }

   236 

   237 void TestCntListModel::indexOfContact()

   238 {

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

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

   241     

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

   243 }

   244 

   245 void TestCntListModel::contactManager()

   246 {

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

   248 }

   249 

   250 void TestCntListModel::setFilter()

   251 {

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

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

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

   255     QTest::qWait(1000);

   256     

   257     QContact c;

   258     QContactName name;

   259     name.setFirstName("firstname");

   260     name.setLastName("lastname");

   261     c.saveDetail(&name);

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

   263     

   264     QContactUnionFilter unionFilter;

   265 

   266     QContactDetailFilter landlineFilter;

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

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

   269     unionFilter << landlineFilter;

   270 

   271     QContactDetailFilter mobileFilter;

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

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

   274     unionFilter << mobileFilter;

   275     

   276     mCntModel->setFilter(unionFilter);

   277     

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

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

   280     QVERIFY(mCntModel->d->m_filter == unionFilter);

   281     QVERIFY(mCntModel->d->m_sortOrders.count() == 3);

   282 }

   283 

   284 void TestCntListModel::myCard()

   285 {

   286     delete mCntModel;

   287     mCntModel = 0;

   288     

   289     mCntModel = new CntListModel(mManager);

   290     

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

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

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

   294     QTest::qWait(1000);

   295     

   296     QContact c;

   297     QContactName name;

   298     name.setFirstName("firstname");

   299     name.setLastName("lastname");

   300     c.saveDetail(&name);

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

   302     

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

   304     

   305     QVERIFY(mCntModel->myCardStatus());

   306     

   307     mCntModel->showMyCard(false);

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

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

   310     

   311     mCntModel->showMyCard(true);

   312     QVERIFY(mCntModel->myCardStatus());

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

   314     

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

   316     QTest::qWait(1000);

   317     spy.clear();

   318     

   319     mCntModel->showMyCard(false);

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

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

   322     

   323     mCntModel->showMyCard(true);

   324     QVERIFY(mCntModel->myCardStatus());

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

   326     mCntModel->showMyCard(true);

   327     QVERIFY(mCntModel->myCardStatus());

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

   329 }

   330 

   331 void TestCntListModel::rowId()

   332 {

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

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

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

   336     QTest::qWait(1000);

   337     

   338     QContact c;

   339     QContactName name;

   340     name.setFirstName("firstname");

   341     name.setLastName("lastname");

   342     c.saveDetail(&name);

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

   344     

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

   346     QVERIFY(row > 0);

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

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

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

   350 }

   351 

   352 void TestCntListModel::dataForDisplayRole()

   353 {

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

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

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

   357     QTest::qWait(1000);

   358     

   359     QContact c;

   360     QContactName name;

   361     name.setFirstName("firstname");

   362     name.setLastName("lastname");

   363     c.saveDetail(&name);

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

   365     

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

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

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

   369     

   370     var = mCntModel->dataForDisplayRole(0);

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

   372 }

   373 

   374 void TestCntListModel::handleAdded()

   375 {

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

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

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

   379     QTest::qWait(1000);

   380 

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

   382     

   383     QContact c;

   384     QContactName name;

   385     name.setFirstName("firstname");

   386     name.setLastName("lastname");

   387     c.saveDetail(&name);

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

   389 

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

   391     

   392     QList<QContactLocalId> emptyList;

   393     mCntModel->handleAdded(emptyList);

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

   395 }

   396 

   397 void TestCntListModel::handleChanged()

   398 {

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

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

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

   402     QTest::qWait(1000);

   403     

   404     QContact c;

   405     QContactName name;

   406     name.setFirstName("firstname");

   407     name.setLastName("lastname");

   408     c.saveDetail(&name);

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

   410     

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

   412 

   413     name.setMiddleName("mid");

   414     c.saveDetail(&name);

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

   416 

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

   418     

   419     QList<QContactLocalId> emptyList;

   420     mCntModel->handleChanged(emptyList);

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

   422 }

   423 

   424 void TestCntListModel::handleRemoved()

   425 {

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

   427     

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

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

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

   431     QTest::qWait(1000);

   432     

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

   434     

   435     QList<QContactLocalId> emptyList;

   436     mCntModel->handleRemoved(emptyList);

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

   438 }

   439 

   440 void TestCntListModel::handleMyCardChanged()

   441 {

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

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

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

   445     QTest::qWait(1000);

   446     

   447     QContact c;

   448     QContactName name;

   449     name.setFirstName("firstname");

   450     name.setLastName("lastname");

   451     c.saveDetail(&name);

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

   453     

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

   455     QVERIFY(mCntModel->d->m_myCardId == c.localId());

   456 }

   457 

   458 void TestCntListModel::cleanupTestCase()

   459 {

   460     mCntModel->d->m_cache->onShutdown();

   461     delete mCntModel;

   462     mCntModel = 0;

   463     

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

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

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

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

   468     delete mManager;

   469     mManager = 0;

   470     delete mModelListener;

   471     mModelListener = 0;

   472 }

   473 

   474 

   475 ModelListener::ModelListener(TestCntListModel* parent)

   476     : mParent(parent)

   477 {

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

   479 }

   480 

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

   482 {

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

   484 }

   485