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

    19 #include "nmcontacthistorymodel.h"

    20 

    21 #include "nmcontacthistorymodel_p.h"

    22 #include "unittest_nmcontacthistorymodel_p.h"

    23 

    24 Q_DEFINE_LATIN1_CONSTANT(QContactEmailAddress::FieldEmailAddress, "EmailAddress");

    25 Q_DEFINE_LATIN1_CONSTANT(QContactName::DefinitionName, "Name");

    26 Q_DEFINE_LATIN1_CONSTANT(QContactEmailAddress::DefinitionName, "EmailAddress");

    27 Q_DEFINE_LATIN1_CONSTANT(QContactName::FieldFirstName, "FirstName");

    28 Q_DEFINE_LATIN1_CONSTANT(QContactName::FieldLastName, "LastName");

    29 

    30 bool constructorCalled;

    31 bool destructorCalled;

    32 bool entryCountCalled;

    33 bool getEntryCalled;

    34 bool nameOrderCalled;

    35 

    36 bool setDetailDefinitionNameCalled;

    37 bool setMatchFlagsCalled;

    38 bool setValueCalled;

    39 bool ContactIdsCalled;

    40 

    41 bool fillMruWithFalseValues;

    42 bool returnZeroEmails;

    43 

    44 // -----------------------------------------------------------------------------

    45 // initTestCase

    46 // -----------------------------------------------------------------------------

    47 //

    48 void TestNmContactHistoryModelPrivate::initTestCase()

    49 {

    50     // Put some allied forces operation names in to array for testing.

    51     mTestNames << "Oatmeal" << "Olive" << "Olympic" << "Open Door" << "Opium" <<

    52     "Orange" << "Oration" << "Outflank" << "Overlord" << "Overthrow";

    53 }

    54 

    55 // -----------------------------------------------------------------------------

    56 // init

    57 // -----------------------------------------------------------------------------

    58 //

    59 void TestNmContactHistoryModelPrivate::init()

    60 {

    61     constructorCalled = false;

    62     destructorCalled = false;

    63     entryCountCalled = false;

    64     getEntryCalled = false;

    65     nameOrderCalled = false;

    66 

    67     setDetailDefinitionNameCalled = false;

    68     setMatchFlagsCalled = false;

    69     setValueCalled = false;

    70     ContactIdsCalled = false;

    71 

    72     fillMruWithFalseValues = false;

    73     returnZeroEmails = false;

    74 

    75     mTestObject = 0;

    76     mSignalEmitted = false;

    77     mTestObject = new NmContactHistoryModelPrivate(EmailAddressModel);

    78 

    79     QVERIFY(mTestObject);

    80 

    81     mTestObject->mModelReady = false;

    82 }

    83 

    84 // -----------------------------------------------------------------------------

    85 // cleanup

    86 // -----------------------------------------------------------------------------

    87 //

    88 void TestNmContactHistoryModelPrivate::cleanup()

    89 {

    90     if(mTestObject)

    91     {

    92         delete mTestObject;

    93         mTestObject = 0;

    94     }

    95 }

    96 

    97 // -----------------------------------------------------------------------------

    98 // cleanupTestCase

    99 // -----------------------------------------------------------------------------

   100 //

   101 

   102 void TestNmContactHistoryModelPrivate::cleanupTestCase()

   103 {

   104     mTestNames.clear();

   105 }

   106 

   107 void TestNmContactHistoryModelPrivate::test_queryMruDatabase() // Ready

   108 {

   109     /* Email MRU Stub will always return following values:

   110        (if fillMruWithFalseValue == true)

   111 

   112     displayName = ""; [0]

   113     address = "camel.case@plusplus.com";

   114 

   115     displayName = "Agent Plus"; [1]

   116     address = "plus@plusplus.com";

   117 

   118     displayName = "Agent Smith"; [2]

   119     address = "noreply@mib.com"; */

   120 

   121     mTestObject->mMruMatches.clear();

   122     mTestObject->mMruList.clear();

   123 

   124     QVERIFY(mTestObject->mMruMatches.count() == 0);

   125 

   126     // Test query with empty string

   127     fillMruWithFalseValues = true;

   128 

   129     bool rValue = mTestObject->queryMruDatabase(QString());

   130 

   131     QVERIFY( entryCountCalled );

   132     QVERIFY( getEntryCalled );

   133     QVERIFY( rValue );

   134 

   135     //TODO: Fix the "bug"

   136     //QVERIFY(mTestObject->mMruMatches.count() == 0);

   137 

   138     // Test query with no display name

   139     // and using the start of the email as display name

   140     mTestObject->mMruMatches.clear();

   141     mTestObject->mMruList.clear();

   142 

   143     rValue = mTestObject->queryMruDatabase("Camel");

   144     QVERIFY( rValue );

   145 

   146     rValue = mTestObject->mMruMatches.contains("camel.case");

   147     QVERIFY( rValue );

   148 

   149     QVERIFY(mTestObject->mMruMatches.count() == 1);

   150 

   151     // Test query with match in email

   152 

   153     mTestObject->mMruMatches.clear();

   154     mTestObject->mMruList.clear();

   155 

   156     rValue = mTestObject->queryMruDatabase("noReply");

   157 

   158     QVERIFY( rValue );

   159     rValue = mTestObject->mMruMatches.contains("camel.case");

   160     QVERIFY(mTestObject->mMruMatches.count() == 1);

   161 }

   162 

   163 void TestNmContactHistoryModelPrivate::test_queryContactDatabase() // Ready.

   164 {

   165     QVERIFY(mTestObject->mModelItemList.count() == 0);

   166     QVERIFY(mTestObject->mPrivateItemList.count() == 0);

   167 

   168     QList<QContactLocalId> rValues;

   169 

   170     rValues = mTestObject->queryContactDatabase("MATRIX");

   171 

   172     QVERIFY( setDetailDefinitionNameCalled );

   173     QVERIFY( setMatchFlagsCalled );

   174     QVERIFY( setValueCalled );

   175     QVERIFY( ContactIdsCalled );

   176 

   177     QVERIFY( rValues.contains(12) );

   178     QVERIFY( rValues.contains(24) );

   179     QVERIFY( rValues.contains(48) );

   180 

   181 }

   182 

   183 void TestNmContactHistoryModelPrivate::test_populateListWithMruItems() // Ready

   184 {

   185     QVERIFY(mTestObject->mModelItemList.count() == 0);

   186     QVERIFY(mTestObject->mPrivateItemList.count() == 0);

   187 

   188     mTestObject->mMruMatches.clear();

   189 

   190     //MRU (key = name, value = address);

   191     mTestObject->mMruMatches.insert("Test Name","name@test.com");

   192     mTestObject->mMruMatches.insert("Tset Eman","eman@tset.com");

   193     mTestObject->mMruMatches.insert("Tset, Tset","test@name.com");

   194 

   195     mTestObject->populateListWithMruItems("Name");

   196 

   197     QVERIFY( mTestObject->mPrivateItemList.count() == 1 );

   198 

   199     QSharedPointer<NmContactHistoryModelItemData> itemData = mTestObject->mPrivateItemList[0];

   200     QVERIFY( itemData->mItems[0].mMatchingRanges.count() == 2 );

   201     QVERIFY( itemData->mItems[1].mMatchingRanges.count() == 2 );

   202 

   203     QString dbgString = itemData->mItems[0].mItemText;

   204 

   205     int markup1Start = itemData->mItems[0].mMatchingRanges[0];

   206     int markup1Stop = itemData->mItems[0].mMatchingRanges[1];

   207 

   208     int markup2Start = itemData->mItems[1].mMatchingRanges[0];

   209     int markup2Stop = itemData->mItems[1].mMatchingRanges[1];

   210 

   211     QVERIFY( markup1Start == 5 );

   212     QVERIFY( markup1Stop == 8 );

   213 

   214     QVERIFY( markup2Start == 0 );

   215     QVERIFY( markup2Stop == 3 );

   216 

   217     // Second Test (Double markup in the name + no email match)

   218     mTestObject->mPrivateItemList.clear();

   219     mTestObject->populateListWithMruItems("Tset");

   220 

   221     QVERIFY( mTestObject->mPrivateItemList.count() == 2 );

   222 

   223     itemData = mTestObject->mPrivateItemList[1];

   224     QVERIFY( itemData->mItems[0].mMatchingRanges.count() == 4 );

   225     QVERIFY( itemData->mItems[1].mMatchingRanges.count() == 0 );

   226 

   227     dbgString = itemData->mItems[0].mItemText;

   228 

   229     markup1Start = itemData->mItems[0].mMatchingRanges[0];

   230     markup1Stop = itemData->mItems[0].mMatchingRanges[1];

   231 

   232     markup2Start = itemData->mItems[0].mMatchingRanges[2];

   233     markup2Stop = itemData->mItems[0].mMatchingRanges[3];

   234 

   235     QVERIFY( markup1Start == 0 );

   236     QVERIFY( markup1Stop == 3 );

   237 

   238     QVERIFY( markup2Start == 6 );

   239     QVERIFY( markup2Stop == 9 );

   240 }

   241 

   242 void TestNmContactHistoryModelPrivate::test_populateListWithContactItems() // Ready

   243 {

   244     QVERIFY(mTestObject->mModelItemList.count() == 0);

   245     QVERIFY(mTestObject->mPrivateItemList.count() == 0);

   246 

   247     QList<QContactLocalId> cnt_ids;

   248     cnt_ids.append(12);

   249 

   250     // Match in first name.

   251     mTestObject->populateListWithContactItems(cnt_ids, "First");

   252     QVERIFY( mTestObject->mPrivateItemList.count() == 1 );

   253     QSharedPointer<NmContactHistoryModelItemData> itemData = mTestObject->mPrivateItemList[0];

   254     QVERIFY( itemData->mItems[0].mMatchingRanges.count() == 2 );

   255     QString dbgString = itemData->mItems[0].mItemText;

   256 

   257     int markup1Start = itemData->mItems[0].mMatchingRanges[0];

   258     int markup1Stop = itemData->mItems[0].mMatchingRanges[1];

   259 

   260     QVERIFY( markup1Start == 0 );

   261     QVERIFY( markup1Stop == 4 );

   262 

   263     mTestObject->mPrivateItemList.clear();

   264 

   265     // Match in last name.

   266     mTestObject->populateListWithContactItems(cnt_ids, "Last");

   267 

   268     QVERIFY( mTestObject->mPrivateItemList.count() == 1 );

   269     itemData = mTestObject->mPrivateItemList[0];

   270     QVERIFY( itemData->mItems[0].mMatchingRanges.count() == 2 );

   271     dbgString = itemData->mItems[0].mItemText;

   272 

   273     markup1Start = itemData->mItems[0].mMatchingRanges[0];

   274     markup1Stop = itemData->mItems[0].mMatchingRanges[1];

   275 

   276     QVERIFY( markup1Start == 10 );

   277     QVERIFY( markup1Stop == 13 );

   278 

   279     mTestObject->mPrivateItemList.clear();

   280 

   281     // Match in email.

   282     mTestObject->populateListWithContactItems(cnt_ids, "Email");

   283     QVERIFY( mTestObject->mPrivateItemList.count() == 1 );

   284     itemData = mTestObject->mPrivateItemList[0];

   285     QVERIFY( itemData->mItems[1].mMatchingRanges.count() == 2 );

   286     dbgString = itemData->mItems[1].mItemText;

   287 

   288     markup1Start = itemData->mItems[1].mMatchingRanges[0];

   289     markup1Stop = itemData->mItems[1].mMatchingRanges[1];

   290 

   291     QVERIFY( markup1Start == 0 );

   292     QVERIFY( markup1Stop == 4 );

   293 

   294     mTestObject->mPrivateItemList.clear();

   295 

   296     // No emails.

   297     returnZeroEmails = true;

   298     mTestObject->populateListWithContactItems(cnt_ids, "First");

   299     QVERIFY( mTestObject->mPrivateItemList.count() == 0 );

   300 }

   301 

   302 void TestNmContactHistoryModelPrivate::test_queryDatabases() // Ready

   303 {

   304     mSignalEmitted = false;

   305     QObject::connect(mTestObject, SIGNAL(queryCompleted(int)), this, SLOT(handleQueryCompleted(int)));

   306 

   307     mTestObject->queryDatabases("Agent");

   308 

   309     QVERIFY( mSignalEmitted );

   310 

   311     QVERIFY( mTestObject->mMruMatches.count() == 1 );

   312     QVERIFY( mTestObject->mPrivateItemList.count() == 1 );

   313 

   314     QVERIFY( constructorCalled );

   315     QVERIFY( destructorCalled );

   316     QVERIFY( entryCountCalled );

   317     QVERIFY( getEntryCalled );

   318     QVERIFY( nameOrderCalled );

   319 

   320     QVERIFY( setDetailDefinitionNameCalled );

   321     QVERIFY( setMatchFlagsCalled );

   322     QVERIFY( setValueCalled );

   323     QVERIFY( ContactIdsCalled );

   324 }

   325 

   326 void TestNmContactHistoryModelPrivate::refreshDataModel() // Ready

   327 {

   328     mTestObject->mPrivateItemList.clear();

   329 

   330     QVERIFY(mTestObject->mModelItemList.count() == 0);

   331     QVERIFY(mTestObject->mPrivateItemList.count() == 0);

   332 

   333     QSharedPointer<NmContactHistoryModelItemData> itemData (new NmContactHistoryModelItemData);

   334 

   335     // For Display name (ex. John Doe)

   336     NmContactHistoryModelSubItem itemSubItem1;

   337     // For Email address (ex. john.doe@company.com)

   338     NmContactHistoryModelSubItem itemSubItem2;

   339 

   340     itemSubItem1.mItemText = "Test Name";

   341     itemSubItem2.mItemText = "test@name.com";

   342 

   343     itemSubItem1.mMatchingRanges.append(0);

   344     itemSubItem1.mMatchingRanges.append(itemSubItem1.mItemText.length()-1);

   345 

   346     itemSubItem2.mMatchingRanges.append(0);

   347     itemSubItem2.mMatchingRanges.append(itemSubItem2.mItemText.length()-1);

   348 

   349     itemData->mContactId = 12;

   350     itemData->mItems.append(itemSubItem1);

   351     itemData->mItems.append(itemSubItem2);

   352 

   353     mTestObject->mPrivateItemList.append(itemData);

   354 

   355     mTestObject->refreshDataModel();

   356 

   357     QVERIFY( mTestObject->mModelReady );

   358 

   359     QVERIFY(mTestObject->mPrivateItemList.count() == 1);

   360     QVERIFY(mTestObject->mModelItemList.count() == 1);

   361 

   362     QSharedPointer<NmContactHistoryModelItemData> testData1

   363     (mTestObject->mPrivateItemList[0]);

   364 

   365 //    NmContactHistoryModelItem testData1 = mTestObject->mPrivateItemList[0];

   366     NmContactHistoryModelItem testData2 = mTestObject->mModelItemList[0];

   367 

   368     QVERIFY(testData1->mContactId == testData2.contactId());

   369     QVERIFY(testData2.subItemCount() == 2);

   370 

   371     NmContactHistoryModelSubItem testItem1 = testData2.subItemAt(0);

   372     NmContactHistoryModelSubItem testItem2 = testData2.subItemAt(1);

   373 

   374     QVERIFY( testItem1.mItemText == itemSubItem1.mItemText );

   375     QVERIFY( testItem2.mItemText == itemSubItem2.mItemText );

   376 

   377     QVERIFY( testItem1.mMatchingRanges.count() == 2 );

   378 }

   379 

   380 void TestNmContactHistoryModelPrivate::test_rowCount() // Ready

   381 {

   382     QVERIFY(mTestObject->mModelItemList.count() == 0);

   383 

   384     NmContactHistoryModelItem item;

   385     item.setContactId(0);

   386     mTestObject->mModelItemList.append(item);

   387 

   388     QVERIFY(mTestObject->mModelItemList.count() == 1);

   389 

   390     mTestObject->mModelItemList.clear();

   391     QVERIFY(mTestObject->mModelItemList.count() == 0);

   392 

   393 }

   394 

   395 void TestNmContactHistoryModelPrivate::test_data() // Ready

   396 {

   397     QModelIndex testIndex = QModelIndex();

   398     QVariant testVariant = mTestObject->data(testIndex, Qt::DisplayRole);

   399     QCOMPARE(testVariant, QVariant());

   400 

   401     for (int i = 0; i < 10; i++)

   402     {

   403         NmContactHistoryModelItem item;

   404         item.setContactId(i);

   405         mTestObject->mModelItemList.append(item);

   406     }

   407 

   408     mTestObject->mModelItemList.clear();

   409 }

   410 

   411 void TestNmContactHistoryModelPrivate::fillMruMatchList() // Ready

   412 {

   413     mTestObject->mMruList.clear();

   414     bool success = mTestObject->fillMruMatchList();

   415 

   416     QVERIFY( constructorCalled );

   417     QVERIFY( destructorCalled );

   418     QVERIFY( entryCountCalled );

   419     QVERIFY( getEntryCalled );

   420     QVERIFY( nameOrderCalled );

   421 

   422     QVERIFY( success );

   423 

   424     QVERIFY(mTestObject->mMruList.count() == 2);

   425 

   426     bool containsValue = mTestObject->mMruList.contains("camel.case@plusplus.com");

   427     QVERIFY(containsValue);

   428 

   429     containsValue = mTestObject->mMruList.contains("byvalue@plusplus.com");

   430     QVERIFY( containsValue );

   431 }

   432 

   433 void TestNmContactHistoryModelPrivate::obeyContactOrder() // Ready

   434 {

   435     QString first = "Test";

   436     QString last = "Name";

   437 

   438     // LastNameFirstName

   439     mTestObject->mNameOrder = 0;

   440     QString resultString = mTestObject->obeyContactOrder(first, last);

   441     QVERIFY(resultString == "Name Test");

   442 

   443     // LastNameCommaFirstName

   444     mTestObject->mNameOrder = 1;

   445     resultString = mTestObject->obeyContactOrder(first, last);

   446     QVERIFY(resultString == "Name, Test");

   447 

   448     // FirstNameLastName

   449     mTestObject->mNameOrder = 2;

   450     resultString = mTestObject->obeyContactOrder(first, last);

   451     QVERIFY(resultString == "Test Name");

   452 

   453     // Invalid / Default

   454     mTestObject->mNameOrder = 0xDEAD;

   455     resultString = mTestObject->obeyContactOrder(first, last);

   456     QVERIFY(resultString == "Test Name");

   457 }

   458 

   459 // Signals

   460 

   461 void TestNmContactHistoryModelPrivate::test_queryCompleted() // Ready

   462 {

   463     mSignalEmitted = false;

   464     QObject::connect(mTestObject, SIGNAL(queryCompleted(int)), this, SLOT(handleQueryCompleted(int)));

   465     mTestObject->queryDatabases(QString());

   466     QVERIFY( mSignalEmitted );

   467 }

   468 

   469 void TestNmContactHistoryModelPrivate::handleQueryCompleted(int err) // Internal

   470 {

   471    Q_UNUSED(err);

   472    mSignalEmitted = true;

   473 }

   474 

   475 QTEST_MAIN(TestNmContactHistoryModelPrivate)

   476