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:  Main test class for hspluginmodel library.

    15 *

    16 */

    17 

    18 

    19 #include "t_caclient.h"

    20 #include "caservice.h"

    21 #include "caquery.h"

    22 

    23 

    24 // ---------------------------------------------------------------------------

    25 //

    26 // ---------------------------------------------------------------------------

    27 //

    28 void TestCaClient::Test_getEntry()

    29 {

    30     {

    31         CaEntry item;

    32         item.setText("testName");

    33         item.setAttribute("attrName1", "attrVal1");

    34         item.setEntryTypeName("test");

    35         item.setFlags(RemovableEntryFlag);

    36 

    37         CaIconDescription iconDescription;

    38         iconDescription.setFilename("iconFileName");

    39         iconDescription.setSkinId("iconSkinId");

    40         iconDescription.setApplicationId("268458321");

    41         item.setIconDescription(iconDescription);

    42 

    43         QSharedPointer<CaService> service = CaService::instance();

    44         QSharedPointer<CaEntry> resultItem = service->createEntry(item);

    45 

    46         QVERIFY(!resultItem.isNull());

    47         // entry from storage

    48         QSharedPointer<CaEntry> storageItem1 = service->getEntry(resultItem->id());

    49         QCOMPARE(service->lastError(), NoErrorCode);

    50         QVERIFY(storageItem1);

    51         QCOMPARE(storageItem1->role(), ItemEntryRole);

    52         QCOMPARE(QString("testName"),storageItem1->text());

    53         QCOMPARE(QString("test"),storageItem1->entryTypeName());

    54         QCOMPARE(QString("attrVal1"),storageItem1->attribute("attrName1"));

    55         QCOMPARE(item.flags(),storageItem1->flags());

    56         QCOMPARE(iconDescription.filename(),storageItem1->iconDescription().filename());

    57         QCOMPARE(iconDescription.skinId(),storageItem1->iconDescription().skinId());

    58         QCOMPARE(iconDescription.applicationId(),storageItem1->iconDescription().applicationId());

    59         QSharedPointer<CaEntry> storageItem2 = service->getEntry(9999);

    60         QVERIFY(service->lastError() !=  NoErrorCode);

    61         QVERIFY(!storageItem2);

    62 

    63         //Cleanup

    64         service->removeEntry(*resultItem);

    65 

    66     }

    67 }

    68 

    69 // ---------------------------------------------------------------------------

    70 //

    71 // ---------------------------------------------------------------------------

    72 //

    73 void TestCaClient::Test_getEntries_ByIds()

    74 {

    75     {

    76         CaEntry item;

    77         item.setText("testName1");

    78         item.setAttribute("attrName1", "attrVal1");

    79         item.setEntryTypeName("test");

    80         item.setFlags(RemovableEntryFlag);

    81 

    82         QSharedPointer<CaService> service = CaService::instance();

    83         QSharedPointer<CaEntry> resultItem1 = service->createEntry(item);

    84         item.setText("testName2");

    85         QSharedPointer<CaEntry> resultItem2 = service->createEntry(item);

    86         item.setText("testName3");

    87         QSharedPointer<CaEntry> resultItem3 = service->createEntry(item);

    88         QVERIFY(!resultItem1.isNull());

    89         QVERIFY(!resultItem2.isNull());

    90         QVERIFY(!resultItem3.isNull());

    91 

    92         QList<int> ids;

    93         ids.append(resultItem1->id());

    94         ids.append(resultItem3->id());

    95         ids.append(resultItem2->id());

    96 

    97         QList< QSharedPointer<CaEntry> > entries = service->getEntries(ids) ;

    98         QCOMPARE(entries.count(), 3);

    99         QCOMPARE(service->lastError(), NoErrorCode);

   100 

   101         QVERIFY(entries.at(0));

   102         QCOMPARE(entries.at(0)->role(), ItemEntryRole);

   103         QCOMPARE(QString("testName1"),entries.at(0)->text());

   104         QCOMPARE(QString("test"),entries.at(0)->entryTypeName());

   105         QCOMPARE(QString("attrVal1"),entries.at(0)->attribute("attrName1"));

   106         QCOMPARE(item.flags(),entries.at(0)->flags());

   107         QVERIFY(entries.at(1));

   108         QCOMPARE(entries.at(1)->role(), ItemEntryRole);

   109         QCOMPARE(QString("testName3"),entries.at(1)->text());

   110         QCOMPARE(QString("test"),entries.at(1)->entryTypeName());

   111         QCOMPARE(QString("attrVal1"),entries.at(1)->attribute("attrName1"));

   112         QCOMPARE(item.flags(),entries.at(1)->flags());

   113         QVERIFY(entries.at(2));

   114         QCOMPARE(entries.at(2)->role(), ItemEntryRole);

   115         QCOMPARE(QString("testName2"),entries.at(2)->text());

   116         QCOMPARE(QString("test"),entries.at(2)->entryTypeName());

   117         QCOMPARE(QString("attrVal1"),entries.at(2)->attribute("attrName1"));

   118         QCOMPARE(item.flags(),entries.at(2)->flags());

   119 

   120         QCOMPARE(entries.at(0)->id(),resultItem1->id());

   121         QCOMPARE(entries.at(1)->id(),resultItem3->id());

   122         QCOMPARE(entries.at(2)->id(),resultItem2->id());

   123 

   124         QList<int> ids2;

   125         ids2.append(resultItem1->id());

   126         ids2.append(9999);

   127 

   128         QList< QSharedPointer<CaEntry> > entries2 = service->getEntries(ids2) ;

   129         QCOMPARE(entries2.count(), 1);

   130         QVERIFY(service->lastError() != NoErrorCode);

   131 

   132         //Cleanup

   133         service->removeEntry(*resultItem1);

   134         service->removeEntry(*resultItem2);

   135         service->removeEntry(*resultItem3);

   136     }

   137 }

   138 

   139 // ---------------------------------------------------------------------------

   140 //

   141 // ---------------------------------------------------------------------------

   142 //

   143 void TestCaClient::Test_getEntries_ByQuery()

   144 {

   145     {

   146         //CHECK INITIAL STATE IN DB

   147         QSharedPointer<CaService> service = CaService::instance();

   148         CaQuery query;

   149         QStringList strList;

   150         strList << QString("test_item1");

   151         query.setEntryTypeNames(strList);

   152         query.addEntryTypeName(QString("test_item2"));

   153         QList< QSharedPointer<CaEntry> > entries12 = service->getEntries(query);

   154         int count12Before = entries12.count();

   155 

   156         //ADD TEST DATA TO THE STORAGE

   157         CaEntry item1;

   158         item1.setText("testName_item1");

   159         item1.setAttribute("attrName1_item", "attrVal1_item");

   160         item1.setEntryTypeName("test_item1");

   161         CaEntry item2;

   162         item2.setText("testName_item2");

   163         item2.setAttribute("attrName2_item", "attrVal2_item");

   164         item2.setEntryTypeName("test_item2");

   165 

   166         QSharedPointer<CaEntry> resultEntry1 = service->createEntry(item1);

   167         QSharedPointer<CaEntry> resultEntry2 = service->createEntry(item2);

   168         QVERIFY(!resultEntry1.isNull());

   169         QVERIFY(!resultEntry2.isNull());

   170 

   171         //GET STATE FROM THE STORAGE AFTER ADD

   172         strList.clear();

   173         strList << QString("test_item1");

   174         query.setEntryTypeNames(strList);

   175         query.addEntryTypeName(QString("test_item2"));

   176         entries12 = service->getEntries(query);

   177         QCOMPARE(service->lastError(), NoErrorCode);

   178         int count12After = entries12.count();

   179 

   180         //CHECK RESULTS

   181         QCOMPARE(count12Before+2,count12After);

   182 

   183         //CLEANUP THE STORAGE AFTER THE TEST

   184         service->removeEntry(*resultEntry1);

   185         service->removeEntry(*resultEntry2);

   186     }

   187 }

   188