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

    28 {

    29     {

    30         CaEntry itemEntry;

    31         itemEntry.setText("item");

    32         itemEntry.setEntryTypeName("typeok");

    33         CaEntry groupEntry(GroupEntryRole);

    34         groupEntry.setText("group");

    35         groupEntry.setEntryTypeName("typeok");

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

    37 

    38         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

    39         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

    40         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

    41 

    42         CaQuery query;

    43         query.setParentId(group->id());

    44         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

    45 

    46         QVERIFY(!service->appendEntryToGroup(9999, entry1->id()));

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

    48 

    49         QVERIFY(!service->appendEntryToGroup(group->id(), 9999));

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

    51 

    52         QVERIFY(service->appendEntryToGroup(group->id(), entry1->id()));

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

    54 

    55         QList<int> entries = service->getEntryIds(query);

    56         QCOMPARE(entries.count(),1);

    57         QVERIFY(service->appendEntryToGroup(group->id(), entry2->id()));

    58         entries = service->getEntryIds(query);

    59         QCOMPARE(entries.count(),2);

    60         QCOMPARE(entries.at(0),entry1->id());

    61         QCOMPARE(entries.at(1),entry2->id());

    62 

    63         //Cleanup

    64         service->removeEntry(*entry1);

    65         service->removeEntry(*entry2);

    66         service->removeEntry(*group);

    67     }

    68 }

    69 

    70 // ---------------------------------------------------------------------------

    71 //

    72 // ---------------------------------------------------------------------------

    73 //

    74 void TestCaClient::Test_appendEntryToGroup_ByEntry()

    75 {

    76     {

    77         CaEntry itemEntry;

    78         itemEntry.setText("item");

    79         itemEntry.setEntryTypeName("typeok");

    80         CaEntry groupEntry(GroupEntryRole);

    81         groupEntry.setText("group");

    82         groupEntry.setEntryTypeName("typeok");

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

    84 

    85         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

    86         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

    87         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

    88 

    89         CaQuery query;

    90         query.setParentId(group->id());

    91         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

    92 

    93         QVERIFY(!service->appendEntryToGroup(groupEntry, *entry1));

    94         QVERIFY(!service->appendEntryToGroup(*group , itemEntry));

    95         QVERIFY(service->appendEntryToGroup(*group , *entry1));

    96         QList<int> entries = service->getEntryIds(query);

    97         QCOMPARE(entries.count(),1);

    98         QVERIFY(service->appendEntryToGroup(*group, *entry2));

    99         entries = service->getEntryIds(query);

   100         QCOMPARE(entries.count(),2);

   101         QCOMPARE(entries.at(0),entry1->id());

   102         QCOMPARE(entries.at(1),entry2->id());

   103 

   104         //Cleanup

   105         service->removeEntry(*entry1);

   106         service->removeEntry(*entry2);

   107         service->removeEntry(*group);

   108     }

   109 }

   110 

   111 // ---------------------------------------------------------------------------

   112 //

   113 // ---------------------------------------------------------------------------

   114 //

   115 void TestCaClient::Test_appendEntriesToGroup_ByIds()

   116 {

   117     {

   118         CaEntry itemEntry;

   119         itemEntry.setText("item");

   120         itemEntry.setEntryTypeName("typeok");

   121         CaEntry groupEntry(GroupEntryRole);

   122         groupEntry.setText("group");

   123         groupEntry.setEntryTypeName("typeok");

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

   125 

   126         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   127         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

   128         QSharedPointer<CaEntry> entry3 = service->createEntry(itemEntry);

   129         QSharedPointer<CaEntry> entry4 = service->createEntry(itemEntry);

   130         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   131 

   132         QList<int> entries1;

   133         entries1.append(entry1->id());

   134         entries1.append(entry2->id());

   135         QList<int> entries2;

   136         entries2.append(entry3->id());

   137         entries2.append(entry4->id());

   138         QList<int> wrongEntries1;

   139         wrongEntries1.append(entry1->id());

   140         wrongEntries1.append(9999);

   141 

   142 

   143         CaQuery query;

   144         query.setParentId(group->id());

   145         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   146 

   147         QVERIFY(!service->appendEntriesToGroup(9999, entries1));

   148         QVERIFY(!service->appendEntriesToGroup(group->id(), wrongEntries1));

   149         QList<int> entries = service->getEntryIds(query);

   150         QCOMPARE(entries.count(),0);

   151 

   152         QVERIFY(service->appendEntriesToGroup(group->id(), entries1));

   153         entries = service->getEntryIds(query);

   154         QCOMPARE(entries.count(),2);

   155         QVERIFY(service->appendEntriesToGroup(group->id(), entries2));

   156         entries = service->getEntryIds(query);

   157         QCOMPARE(entries.count(),4);

   158 

   159         QCOMPARE(entries.at(0),entry1->id());

   160         QCOMPARE(entries.at(1),entry2->id());

   161         QCOMPARE(entries.at(2),entry3->id());

   162         QCOMPARE(entries.at(3),entry4->id());

   163 

   164         //Cleanup

   165         service->removeEntry(*entry1);

   166         service->removeEntry(*entry2);

   167         service->removeEntry(*entry3);

   168         service->removeEntry(*entry4);

   169         service->removeEntry(*group);

   170     }

   171 }

   172 

   173 // ---------------------------------------------------------------------------

   174 //

   175 // ---------------------------------------------------------------------------

   176 //

   177 void TestCaClient::Test_appendEntriesToGroup_ByEntries()

   178 {

   179     {

   180         QSharedPointer<CaEntry> itemEntry (new CaEntry());

   181         itemEntry->setText("item");

   182         itemEntry->setEntryTypeName("typeok");

   183         CaEntry groupEntry(GroupEntryRole);

   184         groupEntry.setText("group");

   185         groupEntry.setEntryTypeName("typeok");

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

   187 

   188         QSharedPointer<CaEntry> entry1 = service->createEntry(*itemEntry);

   189         QSharedPointer<CaEntry> entry2 = service->createEntry(*itemEntry);

   190         QSharedPointer<CaEntry> entry3 = service->createEntry(*itemEntry);

   191         QSharedPointer<CaEntry> entry4 = service->createEntry(*itemEntry);

   192         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   193 

   194         QList< QSharedPointer<CaEntry> > entries1;

   195         entries1.append(entry1);

   196         entries1.append(entry2);

   197         QList< QSharedPointer<CaEntry> > entries2;

   198         entries2.append(entry3);

   199         entries2.append(entry4);

   200         QList<QSharedPointer<CaEntry> > wrongEntries1;

   201         wrongEntries1.append(entry1);

   202         wrongEntries1.append(itemEntry);  //this item has unspecified id

   203 

   204         CaQuery query;

   205         query.setParentId(group->id());

   206         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   207 

   208         QVERIFY(!service->appendEntriesToGroup(groupEntry, entries1));

   209         QVERIFY(!service->appendEntriesToGroup(*group, wrongEntries1));

   210         QList<int> entries = service->getEntryIds(query);

   211         QCOMPARE(entries.count(),0);

   212         QVERIFY(service->appendEntriesToGroup(*group, entries1));

   213         entries = service->getEntryIds(query);

   214         QCOMPARE(entries.count(),2);

   215         QVERIFY(service->appendEntriesToGroup(*group, entries2));

   216         entries = service->getEntryIds(query);

   217         QCOMPARE(entries.count(),4);

   218 

   219         QCOMPARE(entries.at(0),entry1->id());

   220         QCOMPARE(entries.at(1),entry2->id());

   221         QCOMPARE(entries.at(2),entry3->id());

   222         QCOMPARE(entries.at(3),entry4->id());

   223 

   224         //Cleanup

   225         service->removeEntry(*entry1);

   226         service->removeEntry(*entry2);

   227         service->removeEntry(*entry3);

   228         service->removeEntry(*entry4);

   229         service->removeEntry(*group);

   230     }

   231 }

   232 

   233 // ---------------------------------------------------------------------------

   234 //

   235 // ---------------------------------------------------------------------------

   236 //

   237 void TestCaClient::Test_prependEntryToGroup_ById()

   238 {

   239     {

   240         CaEntry itemEntry;

   241         itemEntry.setText("item");

   242         itemEntry.setEntryTypeName("typeok");

   243         CaEntry groupEntry(GroupEntryRole);

   244         groupEntry.setText("group");

   245         groupEntry.setEntryTypeName("typeok");

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

   247 

   248         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   249         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

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

   251 

   252         CaQuery query;

   253         query.setParentId(group->id());

   254         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   255 

   256         QVERIFY(!service->prependEntryToGroup(9999, entry1->id()));

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

   258         QVERIFY(!service->prependEntryToGroup(group->id(), 9999));

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

   260         QVERIFY(service->prependEntryToGroup(group->id(), entry1->id()));

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

   262 

   263         QList<int> entries = service->getEntryIds(query);

   264         QCOMPARE(entries.count(),1);

   265         QVERIFY(service->prependEntryToGroup(group->id(), entry2->id()));

   266         entries = service->getEntryIds(query);

   267 

   268         QCOMPARE(entries.count(),2);

   269         QCOMPARE(entries.at(0),entry2->id());

   270         QCOMPARE(entries.at(1),entry1->id());

   271 

   272         //Cleanup

   273         service->removeEntry(*entry1);

   274         service->removeEntry(*entry2);

   275         service->removeEntry(*group);

   276     }

   277 }

   278 

   279 // ---------------------------------------------------------------------------

   280 //

   281 // ---------------------------------------------------------------------------

   282 //

   283 void TestCaClient::Test_prependEntryToGroup_ByEntry()

   284 {

   285     {

   286         CaEntry itemEntry;

   287         itemEntry.setText("item");

   288         itemEntry.setEntryTypeName("typeok");

   289         CaEntry groupEntry(GroupEntryRole);

   290         groupEntry.setText("group");

   291         groupEntry.setEntryTypeName("typeok");

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

   293 

   294         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   295         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

   296         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   297 

   298         CaQuery query;

   299         query.setParentId(group->id());

   300         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   301 

   302         QVERIFY(!service->prependEntryToGroup(groupEntry, *entry1));

   303         QVERIFY(!service->prependEntryToGroup(*group , itemEntry));

   304         QVERIFY(service->prependEntryToGroup(*group , *entry1));

   305         QList<int> entries = service->getEntryIds(query);

   306         QCOMPARE(entries.count(),1);

   307         QVERIFY(service->prependEntryToGroup(*group, *entry2));

   308         entries = service->getEntryIds(query);

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

   310         QCOMPARE(entries.at(0),entry2->id());

   311         QCOMPARE(entries.at(1),entry1->id());

   312 

   313         //Cleanup

   314         service->removeEntry(*entry1);

   315         service->removeEntry(*entry2);

   316         service->removeEntry(*group);

   317     }

   318 }

   319 

   320 // ---------------------------------------------------------------------------

   321 //

   322 // ---------------------------------------------------------------------------

   323 //

   324 void TestCaClient::Test_prependEntriesToGroup_ByIds()

   325 {

   326     {

   327         CaEntry itemEntry;

   328         itemEntry.setText("item");

   329         itemEntry.setEntryTypeName("typeok");

   330         CaEntry groupEntry(GroupEntryRole);

   331         groupEntry.setText("group");

   332         groupEntry.setEntryTypeName("typeok");

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

   334 

   335         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   336         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

   337         QSharedPointer<CaEntry> entry3 = service->createEntry(itemEntry);

   338         QSharedPointer<CaEntry> entry4 = service->createEntry(itemEntry);

   339         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   340 

   341         QList<int> entries1;

   342         entries1.append(entry1->id());

   343         entries1.append(entry2->id());

   344         QList<int> entries2;

   345         entries2.append(entry3->id());

   346         entries2.append(entry4->id());

   347         QList<int> wrongEntries1;

   348         wrongEntries1.append(entry1->id());

   349         wrongEntries1.append(9999);

   350 

   351 

   352         CaQuery query;

   353         query.setParentId(group->id());

   354         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   355 

   356         QVERIFY(!service->prependEntriesToGroup(9999, entries1));

   357         QVERIFY(!service->prependEntriesToGroup(group->id(), wrongEntries1));

   358         QList<int> entries = service->getEntryIds(query);

   359         QCOMPARE(entries.count(),0);

   360 

   361         QVERIFY(service->prependEntriesToGroup(group->id(), entries1));

   362         entries = service->getEntryIds(query);

   363         QCOMPARE(entries.count(),2);

   364         QVERIFY(service->prependEntriesToGroup(group->id(), entries2));

   365         entries = service->getEntryIds(query);

   366         QCOMPARE(entries.count(),4);

   367 

   368         QCOMPARE(entries.at(0),entry3->id());

   369         QCOMPARE(entries.at(1),entry4->id());

   370         QCOMPARE(entries.at(2),entry1->id());

   371         QCOMPARE(entries.at(3),entry2->id());

   372 

   373         //Cleanup

   374         service->removeEntry(*entry1);

   375         service->removeEntry(*entry2);

   376         service->removeEntry(*entry3);

   377         service->removeEntry(*entry4);

   378         service->removeEntry(*group);

   379     }

   380 }

   381 

   382 // ---------------------------------------------------------------------------

   383 //

   384 // ---------------------------------------------------------------------------

   385 //

   386 void TestCaClient::Test_prependEntriesToGroup_ByEntries()

   387 {

   388     {

   389         QSharedPointer<CaEntry> itemEntry (new CaEntry());

   390         itemEntry->setText("item");

   391         itemEntry->setEntryTypeName("typeok");

   392         CaEntry groupEntry(GroupEntryRole);

   393         groupEntry.setText("group");

   394         groupEntry.setEntryTypeName("typeok");

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

   396 

   397         QSharedPointer<CaEntry> entry1 = service->createEntry(*itemEntry);

   398         QSharedPointer<CaEntry> entry2 = service->createEntry(*itemEntry);

   399         QSharedPointer<CaEntry> entry3 = service->createEntry(*itemEntry);

   400         QSharedPointer<CaEntry> entry4 = service->createEntry(*itemEntry);

   401         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   402 

   403         QList< QSharedPointer<CaEntry> > entries1;

   404         entries1.append(entry1);

   405         entries1.append(entry2);

   406         QList< QSharedPointer<CaEntry> > entries2;

   407         entries2.append(entry3);

   408         entries2.append(entry4);

   409         QList< QSharedPointer<CaEntry> > wrongEntries1;

   410         wrongEntries1.append(entry1);

   411         wrongEntries1.append(itemEntry);  //this item has unspecified id

   412 

   413         CaQuery query;

   414         query.setParentId(group->id());

   415         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   416 

   417         QVERIFY(!service->prependEntriesToGroup(groupEntry, entries1));

   418         QVERIFY(!service->prependEntriesToGroup(*group, wrongEntries1));

   419         QList<int> entries = service->getEntryIds(query);

   420         QCOMPARE(entries.count(),0);

   421         QVERIFY(service->prependEntriesToGroup(*group, entries1));

   422         entries = service->getEntryIds(query);

   423         QCOMPARE(entries.count(),2);

   424         QVERIFY(service->prependEntriesToGroup(*group, entries2));

   425         entries = service->getEntryIds(query);

   426         QCOMPARE(entries.count(),4);

   427 

   428         QCOMPARE(entries.at(0),entry3->id());

   429         QCOMPARE(entries.at(1),entry4->id());

   430         QCOMPARE(entries.at(2),entry1->id());

   431         QCOMPARE(entries.at(3),entry2->id());

   432 

   433         //Cleanup

   434         service->removeEntry(*entry1);

   435         service->removeEntry(*entry2);

   436         service->removeEntry(*entry3);

   437         service->removeEntry(*entry4);

   438         service->removeEntry(*group);

   439     }

   440 }

   441 

   442 // ---------------------------------------------------------------------------

   443 //

   444 // ---------------------------------------------------------------------------

   445 //

   446 void TestCaClient::Test_insertEntryIntoGroup_ById()

   447 {

   448     {

   449         CaEntry itemEntry;

   450         itemEntry.setText("item");

   451         itemEntry.setEntryTypeName("typeok");

   452         CaEntry groupEntry(GroupEntryRole);

   453         groupEntry.setText("group");

   454         groupEntry.setEntryTypeName("typeok");

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

   456 

   457         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   458         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

   459         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   460 

   461         CaQuery query;

   462         query.setParentId(group->id());

   463         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   464 

   465         QVERIFY(service->prependEntryToGroup(group->id(), entry1->id()));

   466 

   467         QVERIFY(!service->insertEntryIntoGroup(9999, entry2->id(), entry1->id()));

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

   469 

   470         QVERIFY(!service->insertEntryIntoGroup(group->id(), 9999, entry1->id()));

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

   472 

   473         QVERIFY(!service->insertEntryIntoGroup(group->id(), entry2->id(), 9999));

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

   475 

   476         QVERIFY(service->insertEntryIntoGroup(group->id(), entry2->id(), entry1->id()));

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

   478 

   479         QList<int> entries = service->getEntryIds(query);

   480         QCOMPARE(entries.count(),2);

   481         QCOMPARE(entries.at(0),entry2->id());

   482         QCOMPARE(entries.at(1),entry1->id());

   483 

   484         //Cleanup

   485         service->removeEntry(*entry1);

   486         service->removeEntry(*entry2);

   487         service->removeEntry(*group);

   488     }

   489 }

   490 

   491 // ---------------------------------------------------------------------------

   492 //

   493 // ---------------------------------------------------------------------------

   494 //

   495 void TestCaClient::Test_insertEntryIntoGroup_ByEntry()

   496 {

   497     {

   498         CaEntry itemEntry;

   499         itemEntry.setText("item");

   500         itemEntry.setEntryTypeName("typeok");

   501         CaEntry groupEntry(GroupEntryRole);

   502         groupEntry.setText("group");

   503         groupEntry.setEntryTypeName("typeok");

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

   505 

   506         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   507         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

   508         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   509 

   510         CaQuery query;

   511         query.setParentId(group->id());

   512         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   513 

   514         QVERIFY(service->prependEntryToGroup(*group, *entry1));

   515 

   516         QVERIFY(!service->insertEntryIntoGroup(groupEntry, *entry2, entry1->id()));

   517         QVERIFY(!service->insertEntryIntoGroup(*group, itemEntry, entry1->id()));

   518         QVERIFY(!service->insertEntryIntoGroup(*group, *entry2, 9999));

   519 

   520         QVERIFY(service->insertEntryIntoGroup(*group, *entry2, entry1->id()));

   521 

   522         QList<int> entries = service->getEntryIds(query);

   523         QCOMPARE(entries.count(),2);

   524         QCOMPARE(entries.at(0),entry2->id());

   525         QCOMPARE(entries.at(1),entry1->id());

   526 

   527         //Cleanup

   528         service->removeEntry(*entry1);

   529         service->removeEntry(*entry2);

   530         service->removeEntry(*group);

   531     }

   532 }

   533 

   534 // ---------------------------------------------------------------------------

   535 //

   536 // ---------------------------------------------------------------------------

   537 //

   538 void TestCaClient::Test_insertEntriesIntoGroup_ByIds()

   539 {

   540     {

   541         CaEntry itemEntry;

   542         itemEntry.setText("item");

   543         itemEntry.setEntryTypeName("typeok");

   544         CaEntry groupEntry(GroupEntryRole);

   545         groupEntry.setText("group");

   546         groupEntry.setEntryTypeName("typeok");

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

   548 

   549         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   550         QSharedPointer<CaEntry> entry3 = service->createEntry(itemEntry);

   551         QSharedPointer<CaEntry> entry4 = service->createEntry(itemEntry);

   552         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   553 

   554         QList<int> entries2;

   555         entries2.append(entry3->id());

   556         entries2.append(entry4->id());

   557         QList<int> wrongEntries1;

   558         wrongEntries1.append(entry1->id());

   559         wrongEntries1.append(9999);

   560 

   561 

   562         CaQuery query;

   563         query.setParentId(group->id());

   564         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   565 

   566         QVERIFY(service->prependEntryToGroup(group->id(), entry1->id()));

   567 

   568         QVERIFY(!service->insertEntriesIntoGroup(9999, entries2, entry1->id()));

   569         QVERIFY(!service->insertEntriesIntoGroup(group->id(), wrongEntries1, entry1->id()));

   570         QVERIFY(!service->insertEntriesIntoGroup(group->id(), entries2, 9999));

   571 

   572         QVERIFY(service->insertEntriesIntoGroup(group->id(), entries2, entry1->id()));

   573         QList<int> entries = service->getEntryIds(query);

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

   575 

   576         QCOMPARE(entries.at(0),entry3->id());

   577         QCOMPARE(entries.at(1),entry4->id());

   578         QCOMPARE(entries.at(2),entry1->id());

   579 

   580         //Cleanup

   581         service->removeEntry(*entry1);

   582         service->removeEntry(*entry3);

   583         service->removeEntry(*entry4);

   584         service->removeEntry(*group);

   585     }

   586 }

   587 

   588 // ---------------------------------------------------------------------------

   589 //

   590 // ---------------------------------------------------------------------------

   591 //

   592 void TestCaClient::Test_insertEntriesIntoGroup_ByEntries()

   593 {

   594     {

   595         QSharedPointer<CaEntry> itemEntry (new CaEntry());

   596         itemEntry->setText("item");

   597         itemEntry->setEntryTypeName("typeok");

   598         CaEntry groupEntry(GroupEntryRole);

   599         groupEntry.setText("group");

   600         groupEntry.setEntryTypeName("typeok");

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

   602 

   603         QSharedPointer<CaEntry> entry1 = service->createEntry(*itemEntry);

   604         QSharedPointer<CaEntry> entry3 = service->createEntry(*itemEntry);

   605         QSharedPointer<CaEntry> entry4 = service->createEntry(*itemEntry);

   606         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   607 

   608         QList< QSharedPointer<CaEntry> > entries2;

   609         entries2.append(entry3);

   610         entries2.append(entry4);

   611         QList< QSharedPointer<CaEntry> > wrongEntries1;

   612         wrongEntries1.append(entry1);

   613         wrongEntries1.append(itemEntry);  //this item has unspecified id

   614 

   615         CaQuery query;

   616         query.setParentId(group->id());

   617         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   618 

   619         QVERIFY(service->prependEntryToGroup(group->id(), entry1->id()));

   620 

   621         QVERIFY(!service->insertEntriesIntoGroup(groupEntry, entries2, entry1->id()));

   622         QVERIFY(!service->insertEntriesIntoGroup(*group, wrongEntries1, entry1->id()));

   623         QVERIFY(!service->insertEntriesIntoGroup(*group, entries2, 9999));

   624 

   625         QVERIFY(service->insertEntriesIntoGroup(*group, entries2, entry1->id()));

   626 

   627         QList<int> entries = service->getEntryIds(query);

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

   629 

   630         QCOMPARE(entries.at(0),entry3->id());

   631         QCOMPARE(entries.at(1),entry4->id());

   632         QCOMPARE(entries.at(2),entry1->id());

   633 

   634         //Cleanup

   635         service->removeEntry(*entry1);

   636         service->removeEntry(*entry3);

   637         service->removeEntry(*entry4);

   638         service->removeEntry(*group);

   639     }

   640 }

   641 

   642 // ---------------------------------------------------------------------------

   643 //

   644 // ---------------------------------------------------------------------------

   645 //

   646 void TestCaClient::Test_removeEntryFromGroup_ById()

   647 {

   648     {

   649         CaEntry itemEntry;

   650         itemEntry.setText("item");

   651         itemEntry.setEntryTypeName("typeok");

   652         CaEntry groupEntry(GroupEntryRole);

   653         groupEntry.setText("group");

   654         groupEntry.setEntryTypeName("typeok");

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

   656 

   657         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   658         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   659 

   660         CaQuery query;

   661         query.setParentId(group->id());

   662         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   663 

   664         QVERIFY(!service->removeEntryFromGroup(9999, entry1->id()));

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

   666 

   667         QVERIFY(!service->removeEntryFromGroup(group->id(), 9999));

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

   669 

   670         QVERIFY(service->prependEntryToGroup(group->id(), entry1->id()));

   671         QList<int> entries = service->getEntryIds(query);

   672         QCOMPARE(entries.count(),1);

   673         QVERIFY(service->removeEntryFromGroup(group->id(), entry1->id()));

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

   675 

   676 

   677         entries = service->getEntryIds(query);

   678         QCOMPARE(entries.count(),0);

   679 

   680         //Cleanup

   681         service->removeEntry(*entry1);

   682         service->removeEntry(*group);

   683     }

   684 }

   685 

   686 // ---------------------------------------------------------------------------

   687 //

   688 // ---------------------------------------------------------------------------

   689 //

   690 void TestCaClient::Test_removeEntryFromGroup_ByEntry()

   691 {

   692     {

   693         CaEntry itemEntry;

   694         itemEntry.setText("item");

   695         itemEntry.setEntryTypeName("typeok");

   696         CaEntry groupEntry(GroupEntryRole);

   697         groupEntry.setText("group");

   698         groupEntry.setEntryTypeName("typeok");

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

   700 

   701         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   702         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   703 

   704         CaQuery query;

   705         query.setParentId(group->id());

   706         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   707 

   708         QVERIFY(!service->removeEntryFromGroup(groupEntry, *entry1));

   709         QVERIFY(!service->removeEntryFromGroup(*group, itemEntry));

   710 

   711         QVERIFY(service->prependEntryToGroup(group->id(), entry1->id()));

   712         QList<int> entries = service->getEntryIds(query);

   713         QCOMPARE(entries.count(),1);

   714         QVERIFY(service->removeEntryFromGroup(*group, *entry1));

   715 

   716         entries = service->getEntryIds(query);

   717         QCOMPARE(entries.count(),0);

   718 

   719         //Cleanup

   720         service->removeEntry(*entry1);

   721         service->removeEntry(*group);

   722     }

   723 }

   724 

   725 // ---------------------------------------------------------------------------

   726 //

   727 // ---------------------------------------------------------------------------

   728 //

   729 void TestCaClient::Test_removeEntriesFromGroup_ByIds()

   730 {

   731     {

   732         CaEntry itemEntry;

   733         itemEntry.setText("item");

   734         itemEntry.setEntryTypeName("typeok");

   735         CaEntry groupEntry(GroupEntryRole);

   736         groupEntry.setText("group");

   737         groupEntry.setEntryTypeName("typeok");

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

   739 

   740         QSharedPointer<CaEntry> entry1 = service->createEntry(itemEntry);

   741         QSharedPointer<CaEntry> entry2 = service->createEntry(itemEntry);

   742         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   743 

   744         QList<int> entries1;

   745         entries1.append(entry1->id());

   746         entries1.append(entry2->id());

   747         QList<int> wrongEntries1;

   748         wrongEntries1.append(entry1->id());

   749         wrongEntries1.append(9999);

   750 

   751         CaQuery query;

   752         query.setParentId(group->id());

   753         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   754 

   755         QVERIFY(service->prependEntriesToGroup(group->id(), entries1));

   756         QList<int> entries = service->getEntryIds(query);

   757         QCOMPARE(entries.count(),2);

   758         QVERIFY(!service->removeEntriesFromGroup(9999, entries1));

   759         QVERIFY(!service->removeEntriesFromGroup(group->id(), wrongEntries1));

   760         entries = service->getEntryIds(query);

   761         QCOMPARE(entries.count(),2);

   762 

   763         QVERIFY(service->removeEntriesFromGroup(group->id(), entries1));

   764         entries = service->getEntryIds(query);

   765         QCOMPARE(entries.count(),0);

   766 

   767         //Cleanup

   768         service->removeEntry(*entry1);

   769         service->removeEntry(*entry2);

   770         service->removeEntry(*group);

   771     }

   772 }

   773 

   774 // ---------------------------------------------------------------------------

   775 //

   776 // ---------------------------------------------------------------------------

   777 //

   778 void TestCaClient::Test_removeEntriesFromGroup_ByEntries()

   779 {

   780     {

   781         QSharedPointer<CaEntry> itemEntry (new CaEntry);

   782         itemEntry->setText("item");

   783         itemEntry->setEntryTypeName("typeok");

   784         CaEntry groupEntry(GroupEntryRole);

   785         groupEntry.setText("group");

   786         groupEntry.setEntryTypeName("typeok");

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

   788 

   789         QSharedPointer<CaEntry> entry1 = service->createEntry(*itemEntry);

   790         QSharedPointer<CaEntry> entry2 = service->createEntry(*itemEntry);

   791         QSharedPointer<CaEntry> group = service->createEntry(groupEntry);

   792 

   793         QList<QSharedPointer<CaEntry> > entries1;

   794         entries1.append(entry1);

   795         entries1.append(entry2);

   796         QList<QSharedPointer<CaEntry> > wrongEntries1;

   797         wrongEntries1.append(entry1);

   798         wrongEntries1.append(itemEntry);  //this item has unspecified id

   799 

   800         CaQuery query;

   801         query.setParentId(group->id());

   802         query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   803 

   804         QVERIFY(service->prependEntriesToGroup(*group, entries1));

   805         QList<int> entries = service->getEntryIds(query);

   806         QCOMPARE(entries.count(),2);

   807 

   808         QVERIFY(!service->removeEntriesFromGroup(groupEntry, entries1));

   809         QVERIFY(!service->removeEntriesFromGroup(*group, wrongEntries1));

   810         entries = service->getEntryIds(query);

   811         QCOMPARE(entries.count(),2);

   812 

   813         QVERIFY(service->removeEntriesFromGroup(*group, entries1));

   814         entries = service->getEntryIds(query);

   815         QCOMPARE(entries.count(),0);

   816 

   817         //Cleanup

   818         service->removeEntry(*entry1);

   819         service->removeEntry(*entry2);

   820         service->removeEntry(*group);

   821 

   822     }

   823 }

   824 

   825 

   826 // ---------------------------------------------------------------------------

   827 //

   828 // ---------------------------------------------------------------------------

   829 //

   830 void TestCaClient::Test_customSort()

   831 {

   832     CaQuery collectionQuery;

   833     collectionQuery.addEntryTypeName("collection");

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

   835     QList<int> collectionIds = service->getEntryIds(collectionQuery);

   836     QVERIFY(collectionIds.count());

   837     

   838     const int groupId = collectionIds.at(0);

   839 

   840     CaQuery query;

   841     query.setParentId(groupId);

   842     query.setSort(DefaultSortAttribute, Qt::AscendingOrder);

   843 

   844     QList<int> idsBefore = service->getEntryIds(query);

   845     QVERIFY(idsBefore.count());

   846 

   847     int first = idsBefore.takeFirst();

   848     idsBefore.append(first);

   849 

   850     // sort entries is group in custom order

   851     QVERIFY(service->customSort(groupId, idsBefore));

   852 

   853     // check results

   854     QList<int> idsAfter = service->getEntryIds(query);

   855     QVERIFY(idsAfter.count());

   856 

   857     QCOMPARE(idsAfter.count(),idsBefore.count());

   858     QCOMPARE(idsAfter, idsBefore);

   859 }