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 void TestCaClient::TestRemoveItem()

    27 {

    28     {

    29         CaEntry item;

    30         item.setText("testName");

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

    32         item.setEntryTypeName("test");

    33         item.setFlags(RemovableEntryFlag);

    34 

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

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

    37         QVERIFY(!resultItem1.isNull());

    38         QVERIFY(!service->removeEntry(9999));

    39         QVERIFY(service->removeEntry(resultItem1->id()));

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

    41 

    42         QSharedPointer<CaEntry> storageItem1 = service->getEntry(resultItem1->id());

    43         QVERIFY(storageItem1.isNull());  // entry not present in the storage

    44         QVERIFY(!service->removeEntry(resultItem1->id()));

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

    46 

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

    48         QVERIFY(!resultItem2.isNull());

    49 

    50         QVERIFY(service->removeEntry(*resultItem2));

    51         QSharedPointer<CaEntry> storageItem2 = service->getEntry(resultItem2->id());

    52         QVERIFY(storageItem2.isNull());  // entry not present in the storage

    53         QVERIFY(!service->removeEntry(*resultItem2));

    54 

    55         //cleanup

    56         service->removeEntry(*resultItem1);

    57         service->removeEntry(*resultItem2);

    58     }

    59 }

    60 

    61 // ---------------------------------------------------------------------------

    62 // ---------------------------------------------------------------------------

    63 //

    64 void TestCaClient::TestRemoveGroup()

    65 {

    66     {

    67         CaEntry group(GroupEntryRole);

    68         group.setText("testName");

    69         group.setAttribute("attrName1", "attrVal1");

    70         group.setEntryTypeName("test");

    71         group.setFlags(RemovableEntryFlag);

    72 

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

    74         QSharedPointer<CaEntry> resultgroup1 = service->createEntry(group);

    75         QVERIFY(!resultgroup1.isNull());

    76 

    77         QVERIFY(service->removeEntry(resultgroup1->id()));

    78         QSharedPointer<CaEntry> storagegroup1 = service->getEntry(resultgroup1->id());

    79         QVERIFY(!storagegroup1);  // entry not present in the storage

    80         QVERIFY(!service->removeEntry(resultgroup1->id()));

    81 

    82         QSharedPointer<CaEntry> resultgroup2 = service->createEntry(group);

    83         QVERIFY(!resultgroup2.isNull());

    84 

    85         QVERIFY(service->removeEntry(*resultgroup2));

    86         QSharedPointer<CaEntry> storagegroup2 = service->getEntry(resultgroup2->id());

    87         QVERIFY(!storagegroup2);  // entry not present in the storage

    88         QVERIFY(!service->removeEntry(*resultgroup2));

    89 

    90         //cleanup

    91         service->removeEntry(*resultgroup1);

    92         service->removeEntry(*resultgroup2);

    93     }

    94 }

    95 

    96 // ---------------------------------------------------------------------------

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

    98 //

    99 void TestCaClient::TestRemoveItems()

   100 {

   101     {

   102         CaEntry item;

   103         item.setText("testName");

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

   105         item.setEntryTypeName("test");

   106         item.setFlags(RemovableEntryFlag);

   107 

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

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

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

   111         QVERIFY(!resultItem1.isNull());

   112         QVERIFY(!resultItem2.isNull());

   113 

   114         QList<int> ids;

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

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

   117         QVERIFY(service->removeEntries(ids));

   118         QSharedPointer<CaEntry> storageItem1 = service->getEntry(resultItem1->id());

   119         QSharedPointer<CaEntry> storageItem2 = service->getEntry(resultItem2->id());

   120         QVERIFY(storageItem1.isNull());  // entry not present in the storage

   121         QVERIFY(storageItem2.isNull());  // entry not present in the storage

   122 

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

   124         QSharedPointer<CaEntry> resultItem4 = service->createEntry(item);

   125         QVERIFY(!resultItem3.isNull());

   126         QVERIFY(!resultItem4.isNull());

   127 

   128         QList<QSharedPointer<CaEntry> > entries;

   129         entries.append(resultItem3);

   130         entries.append(resultItem4);

   131 

   132         QVERIFY(service->removeEntries(entries));

   133         QSharedPointer<CaEntry> storageItem3 = service->getEntry(resultItem3->id());

   134         QSharedPointer<CaEntry> storageItem4 = service->getEntry(resultItem4->id());

   135         QVERIFY(storageItem3.isNull());  // entry not present in the storage

   136         QVERIFY(storageItem4.isNull());  // entry not present in the storage

   137 

   138         //cleanup

   139         service->removeEntry(*resultItem1);

   140         service->removeEntry(*resultItem2);

   141         service->removeEntry(*resultItem3);

   142         service->removeEntry(*resultItem4);

   143     }

   144 }

   145 

   146 // ---------------------------------------------------------------------------

   147 // ---------------------------------------------------------------------------

   148 //

   149 void TestCaClient::TestRemoveItemsFail()

   150 {

   151     {

   152         QSharedPointer<CaEntry> item (new CaEntry());

   153         item->setText("testName");

   154         item->setAttribute("attrName1", "attrVal1");

   155         item->setEntryTypeName("test");

   156         item->setFlags(RemovableEntryFlag);

   157 

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

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

   160         QVERIFY(!resultItem1.isNull());

   161 

   162         QList<int> ids;

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

   164         ids.append(9999);// not present in the storage

   165         QVERIFY(!service->removeEntries(ids));

   166         QSharedPointer<CaEntry> storageItem1 = service->getEntry(resultItem1->id());

   167         QVERIFY(!storageItem1.isNull());  // entry present in the storage

   168 

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

   170         QVERIFY(!resultItem2.isNull());

   171 

   172         QList<QSharedPointer<CaEntry> > entries;

   173         entries.append(resultItem2);

   174         entries.append(item);//id not specified

   175 

   176         QVERIFY(!service->removeEntries(entries));

   177         QSharedPointer<CaEntry> storageItem2 = service->getEntry(resultItem2->id());

   178         QVERIFY(storageItem2);  // entry present in the storage

   179 

   180         //cleanup

   181         service->removeEntry(*resultItem1);

   182         service->removeEntry(*resultItem2);

   183 

   184     }

   185 }

   186 

   187 // ---------------------------------------------------------------------------

   188 // ---------------------------------------------------------------------------

   189 //

   190 void TestCaClient::TestRemoveGroups()

   191 {

   192     {

   193         CaEntry group(GroupEntryRole);

   194         group.setText("testName");

   195         group.setAttribute("attrName1", "attrVal1");

   196         group.setEntryTypeName("test");

   197         group.setFlags(RemovableEntryFlag);

   198 

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

   200         QSharedPointer<CaEntry> resultGroup1 = service->createEntry(group);

   201         QSharedPointer<CaEntry> resultGroup2 = service->createEntry(group);

   202         QVERIFY(!resultGroup1.isNull());

   203         QVERIFY(!resultGroup2.isNull());

   204 

   205         QList<int> ids;

   206         ids.append(resultGroup1->id());

   207         ids.append(resultGroup2->id());

   208         QVERIFY(service->removeEntries(ids));

   209         QSharedPointer<CaEntry> storageGroup1 = service->getEntry(resultGroup1->id());

   210         QSharedPointer<CaEntry> storageGroup2 = service->getEntry(resultGroup2->id());

   211         QVERIFY(storageGroup1.isNull());  // entry not present in the storage

   212         QVERIFY(storageGroup2.isNull());  // entry not present in the storage

   213 

   214         QSharedPointer<CaEntry> resultGroup3 = service->createEntry(group);

   215         QSharedPointer<CaEntry> resultGroup4 = service->createEntry(group);

   216         QVERIFY(!resultGroup3.isNull());

   217         QVERIFY(!resultGroup4.isNull());

   218 

   219         QList<QSharedPointer<CaEntry> > entries;

   220         entries.append(resultGroup3);

   221         entries.append(resultGroup4);

   222 

   223         QVERIFY(service->removeEntries(entries));

   224         QSharedPointer<CaEntry> storageGroup3 = service->getEntry(resultGroup3->id());

   225         QSharedPointer<CaEntry> storageGroup4 = service->getEntry(resultGroup4->id());

   226         QVERIFY(storageGroup3.isNull());  // entry not present in the storage

   227         QVERIFY(storageGroup4.isNull());  // entry not present in the storage

   228 

   229         //cleanup

   230         service->removeEntry(*resultGroup1);

   231         service->removeEntry(*resultGroup2);

   232         service->removeEntry(*resultGroup3);

   233         service->removeEntry(*resultGroup4);

   234     }

   235 }

   236 

   237 // ---------------------------------------------------------------------------

   238 // ---------------------------------------------------------------------------

   239 //

   240 void TestCaClient::TestRemoveGroupsFail()

   241 {

   242     {

   243         QSharedPointer<CaEntry> group(new CaEntry(GroupEntryRole));

   244         group->setText("testName");

   245         group->setAttribute("attrName1", "attrVal1");

   246         group->setEntryTypeName("test");

   247         group->setFlags(RemovableEntryFlag);

   248 

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

   250         QSharedPointer<CaEntry> resultGroup1 = service->createEntry(*group);

   251         QVERIFY(!resultGroup1.isNull());

   252 

   253         QList<int> ids;

   254         ids.append(resultGroup1->id());

   255         ids.append(9999);// not present in the storage

   256         QVERIFY(!service->removeEntries(ids));

   257         QSharedPointer<CaEntry> storageGroup1 = service->getEntry(resultGroup1->id());

   258         QVERIFY(!storageGroup1.isNull());  // entry present in the storage

   259 

   260         QSharedPointer<CaEntry> resultGroup2 = service->createEntry(*group);

   261         QVERIFY(!resultGroup2.isNull());

   262 

   263         QList< QSharedPointer<CaEntry> > entries;

   264         entries.append(resultGroup2);

   265         entries.append(group);//id not specified

   266 

   267         QVERIFY(!service->removeEntries(entries));

   268         QSharedPointer<CaEntry> storageGroup2 = service->getEntry(resultGroup2->id());

   269         QVERIFY(!storageGroup2.isNull());  // entry present in the storage

   270 

   271         //cleanup

   272         service->removeEntry(*resultGroup1);

   273         service->removeEntry(*resultGroup2);

   274     }

   275 }