contentstorage/caclient/tsrc/t_caclient/src/t_caitemmodel.cpp
author Jaakko Haukipuro (Nokia-MS/Oulu) <Jaakko.Haukipuro@nokia.com>
Thu, 16 Sep 2010 12:11:40 +0100
changeset 117 c63ee96dbe5f
permissions -rw-r--r--
Missing activityfw and taskswitcher components - fix for Bug 3670

/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  Main test class for hspluginmodel library.
*
*/

#include <QSignalSpy>

#include "caclient_defines.h"
#include "t_caclient.h"
#include "caservice.h"
#include "caquery.h"
#include "caitemmodel.h"
#include "caitemmodel_p.h"
// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelConstruct()
{
    {
        CaQuery query;
        query.setEntryRoles(ItemEntryRole);
        CaItemModel model(query,NULL);
        QVERIFY(model.rowCount() > 0);
        QCOMPARE(model.columnCount(),1);
        QCOMPARE(model.isAutoUpdate(), true);
    }
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelAutoUpdate()
{
    {
        // ensure that entries are not present in a storage
        removeEntry("TestGroup");
        removeEntry("TestItem1");
        removeEntry("TestItem2");
        //test
        QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder");
        QSharedPointer<CaEntry> item1 = createItem("TestItem1","testitem");
        QSharedPointer<CaEntry> item2 = createItem("TestItem2","testitem");
        addItemToGroup(group->id(), item1->id());
        CaQuery query;
        query.setParentId(group->id());
        CaItemModel model(query,NULL);
        model.setAutoUpdate(true);
        QCOMPARE(model.isAutoUpdate(), true);
        QCOMPARE(model.rowCount() , 1);
        addItemToGroup(group->id(), item2->id());
        QTest::qWait(50);
        QCOMPARE(model.rowCount() , 2);
        removeItemFromGroup(group->id(), item2->id());
        QTest::qWait(50);
        QCOMPARE(model.rowCount() , 1);
        model.setAutoUpdate(false);
        addItemToGroup(group->id(), item2->id());
        QTest::qWait(50);
        QCOMPARE(model.rowCount() , 1);
        QCOMPARE(model.isAutoUpdate(), false);
        model.updateModel();
        QCOMPARE(model.rowCount() , 2);
        QCOMPARE(model.isAutoUpdate(), false);
        model.setAutoUpdate(true);
        removeEntry(item1->id());
        QTest::qWait(50);
        QCOMPARE(model.rowCount() , 1);
        //cleanup
        removeEntry("TestItem2");
        removeEntry("TestItem1");
        removeEntry("TestGroup");
    }
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelIndex()
{
    // ensure that entries are not present in a storage
    removeEntry("TestGroup");
    removeEntry("TestItem1");
    removeEntry("TestItem2");
    //test
    QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder");
    QSharedPointer<CaEntry> item1 = createItem("TestItem1","testitem");
    QSharedPointer<CaEntry> item2 = createItem("TestItem2","testitem");
    addItemToGroup(group->id(), item1->id());
    addItemToGroup(group->id(), item2->id());
    CaQuery query;
    query.setParentId(group->id());
    CaItemModel model(query,NULL);
    QCOMPARE(model.index(-1), QModelIndex());
    QCOMPARE(model.index(0).row(), 0);
    QCOMPARE(model.index(1).row(), 1);
    QCOMPARE(model.index(2), QModelIndex());
    QCOMPARE(model.parent(model.index(1)), QModelIndex());
    QCOMPARE(model.root().row(),0);
    QCOMPARE(model.root().column(),1);

    CaQuery query2;
    CaItemModel modelWithoutParent(query2,NULL);
    QCOMPARE(modelWithoutParent.root().isValid(),false);

    //cleanup
    removeEntry("TestItem2");
    removeEntry("TestItem1");
    removeEntry("TestGroup");
   
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelData()
{
    // ensure that entries are not present in a storage
    removeEntry("TestGroup");
    removeEntry("TestItem1");
    //test
    QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder");
    QSharedPointer<CaEntry> item1 = createItem("TestItem1","TestDescription","testitem", UsedEntryFlag);
    QString progressString = "100";
    item1->setAttribute(UNINSTALL_PROGRESS_APPLICATION_ATTRIBUTE_NAME, progressString);
    QSharedPointer<CaService> service = CaService::instance();
    service->updateEntry(*item1.data());
    QCOMPARE(item1->attribute(UNINSTALL_PROGRESS_APPLICATION_ATTRIBUTE_NAME), progressString);
    
    addItemToGroup(group->id(), item1->id());
    CaQuery query;
    query.setParentId(group->id());
    CaItemModel model(query,NULL);

    QCOMPARE(model.data(QModelIndex()),QVariant());

    QModelIndex index = model.index(0);

    model.setSecondLineVisibility(false);
    QCOMPARE(model.secondLineVisibility(),false);
    QCOMPARE(model.data(index, Qt::DisplayRole).toString(), QString("TestItem1"));
    model.setSecondLineVisibility(true);
    QCOMPARE(model.secondLineVisibility(),true);
    QList<QVariant> displayRoleList = model.data(index, Qt::DisplayRole).toList();
    QString text = displayRoleList.at(0).toString();
    QString description = displayRoleList.at(1).toString();
    QCOMPARE(text,QString("TestItem1"));
    QCOMPARE(description,QString("TestDescription"));
    QCOMPARE(model.data(index, CaItemModel::IdRole).toInt(), item1->id());
    QCOMPARE(model.data(index, CaItemModel::TypeRole).toString(),QString("testitem"));
    QVERIFY(model.data(index, CaItemModel::FlagsRole).value<EntryFlags>()== UsedEntryFlag);
    QCOMPARE(model.data(index, CaItemModel::TextRole).toString(),QString("TestItem1"));
    QCOMPARE(model.entry(index)->text(),QString("TestItem1"));
    QCOMPARE(model.data(index, 777), QVariant(QVariant::Invalid));
    QCOMPARE(model.data(index, CaItemModel::UninstalRole).value<int>(), progressString.toInt());

    //cleanup
    removeEntry("TestItem1");
    removeEntry("TestGroup");
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelIconSize()
{
    // ensure that entries are not present in a storage
    removeEntry("TestGroup");
    removeEntry("TestItem1");
    //test
    QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder");
    QSharedPointer<CaEntry> item1 = createItem("TestItem1","testitem");
    addItemToGroup(group->id(), item1->id());
    CaQuery query;
    query.setParentId(group->id());
    CaItemModel model(query,NULL);
    QSizeF size1(30,30);
    QSizeF size2(130,130);
    model.setIconSize(size1);
    QVERIFY(model.getIconSize() == size1);
    model.setIconSize(size2);
    QVERIFY(model.getIconSize() == size2);
    //cleanup
    removeEntry("TestItem1");
    removeEntry("TestGroup");
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelChangeParent()
{
    // ensure that entries are not present in a storage
    removeEntry("TestGroup1");
    removeEntry("TestGroup2");
    removeEntry("TestItem1");
    removeEntry("TestItem2");
    removeEntry("TestItem3");
//test
    QSharedPointer<CaEntry> group1 = createGroup("TestGroup1","testfolder");
    QSharedPointer<CaEntry> group2 = createGroup("TestGroup2","testfolder");
    QSharedPointer<CaEntry> item1 = createItem("TestItem1","testitem");
    QSharedPointer<CaEntry> item2 = createItem("TestItem2","testitem");
    QSharedPointer<CaEntry> item3 = createItem("TestItem3","testitem");
    addItemToGroup(group1->id(), item1->id());
    addItemToGroup(group2->id(), item2->id());
    addItemToGroup(group2->id(), item3->id());
    CaQuery query;
    query.setParentId(group1->id());
    CaItemModel model(query,NULL);
    model.setAutoUpdate(true);
    QCOMPARE(model.isAutoUpdate(), true);
    QCOMPARE(model.rowCount() , 1);
    QCOMPARE(itemName(model,0),QString("TestItem1"));
    model.setFlagsOn(VisibleEntryFlag);
    model.setFlagsOff(MissingEntryFlag);
    model.setParentId(group2->id());
    QTest::qWait(50);
    QCOMPARE(model.rowCount() , 2);
    QCOMPARE(itemName(model,0),QString("TestItem2"));
    QCOMPARE(itemName(model,1),QString("TestItem3"));
    model.setParentId(group1->id());
    QTest::qWait(50);
    QCOMPARE(model.rowCount() , 1);
    QCOMPARE(itemName(model,0),QString("TestItem1"));
    model.setAutoUpdate(false);
    model.setFlagsOn(VisibleEntryFlag);
    model.setFlagsOff(MissingEntryFlag);
    model.setParentId(group2->id());
    QTest::qWait(50);
    QCOMPARE(model.rowCount(), 2);
    QCOMPARE(itemName(model,0),QString("TestItem2"));
    QCOMPARE(itemName(model,1),QString("TestItem3"));

    //cleanup
    removeEntry("TestItem3");
    removeEntry("TestItem2");
    removeEntry("TestItem1");
    removeEntry("TestGroup2");
    removeEntry("TestGroup1");
    
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelSortOrder()
{
    // ensure that entries are not present in a storage
    removeEntry("TestGroup");
    removeEntry("ATestItem");
    removeEntry("BTestItem");
    //test
    QSharedPointer<CaEntry> group = createGroup("TestGroup","testfolder");
    QSharedPointer<CaEntry> item1 = createItem("ATestItem","testitem");
    QSharedPointer<CaEntry> item2 = createItem("BTestItem","testitem");
    addItemToGroup(group->id(), item2->id());
    addItemToGroup(group->id(), item1->id());
    CaQuery query;
    query.setParentId(group->id());
    CaItemModel model(query,NULL);
    model.setAutoUpdate(false);   //should work even without autoupdate
    model.setSort(NameSortAttribute, Qt::DescendingOrder);
    QCOMPARE(itemName(model,0),QString("BTestItem"));
    QCOMPARE(itemName(model,1),QString("ATestItem"));
    model.setSort(NameSortAttribute, Qt::AscendingOrder);
    QCOMPARE(itemName(model,0),QString("ATestItem"));
    QCOMPARE(itemName(model,1),QString("BTestItem"));
    model.setSort(DefaultSortAttribute, Qt::DescendingOrder);
    QCOMPARE(itemName(model,0),QString("ATestItem"));
    QCOMPARE(itemName(model,1),QString("BTestItem"));
    model.setSort(DefaultSortAttribute, Qt::AscendingOrder);
    QCOMPARE(itemName(model,0),QString("BTestItem"));
    QCOMPARE(itemName(model,1),QString("ATestItem"));
    model.setAutoUpdate(true);
    model.setSort(NameSortAttribute, Qt::DescendingOrder);
    QCOMPARE(itemName(model,0),QString("BTestItem"));
    QCOMPARE(itemName(model,1),QString("ATestItem"));
    model.setSort(NameSortAttribute, Qt::AscendingOrder);
    QCOMPARE(itemName(model,0),QString("ATestItem"));
    QCOMPARE(itemName(model,1),QString("BTestItem"));
    model.setSort(DefaultSortAttribute, Qt::DescendingOrder);
    QCOMPARE(itemName(model,0),QString("ATestItem"));
    QCOMPARE(itemName(model,1),QString("BTestItem"));
    model.setSort(DefaultSortAttribute, Qt::AscendingOrder);
    QCOMPARE(itemName(model,0),QString("BTestItem"));
    QCOMPARE(itemName(model,1),QString("ATestItem"));
    //cleanup
    removeEntry("BTestItem");
    removeEntry("ATestItem");
    removeEntry("TestGroup");
    
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelUpdateItem()
{
    // ensure that entries are not present in a storage
    removeEntry("TestItemBeforeUpdate");
    removeEntry("TestItemAfterUpdate");
    removeEntry("TestItemAfterSecondUpdate");
    //test
    CaQuery query;
    query.addEntryTypeName("test_item");
    CaItemModel model(query,NULL);
    model.setAutoUpdate(true);
    QSharedPointer<CaEntry> item1 = createItem("TestItemBeforeUpdate","test_item");
    QTest::qWait(50);
    QCOMPARE(model.rowCount(),1);
    QCOMPARE(itemName(model,0),QString("TestItemBeforeUpdate"));
    item1->setText("TestItemAfterUpdate");
    CaService::instance()->updateEntry(*item1);
    QTest::qWait(50);
    QCOMPARE(model.rowCount(),1);
    QCOMPARE(itemName(model,0),QString("TestItemAfterUpdate"));
    model.setAutoUpdate(false);
    item1->setText("TestItemAfterSecondUpdate");
    CaService::instance()->updateEntry(*item1);
    QTest::qWait(50);
    QCOMPARE(model.rowCount(),1);
    QCOMPARE(itemName(model,0),QString("TestItemAfterUpdate"));// model not updated

    //cleanup
    removeEntry("TestItemBeforeUpdate");
    removeEntry("TestItemAfterUpdate");
    removeEntry("TestItemAfterSecondUpdate");
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelAddItems()
{
    QSharedPointer<CaService> service = CaService::instance();
    
    // ensure that entries are not present in a storage
    removeEntry("TestGroup");
    
    removeEntry("1TestItem1");
    removeEntry("1TestItem2");
    removeEntry("1TestItem3");
    
    removeEntry("2TestItem1");
    
    removeEntry("3TestItem1");
    removeEntry("3TestItem2");
    removeEntry("3TestItem3");
    
    removeEntry("0TestItem1");
    removeEntry("0TestItem2");
        
    removeEntry("1TestItem4");
    removeEntry("1TestItem5");
    
    removeEntry("2TestItem2");
    removeEntry("2TestItem3");
    
    removeEntry("3TestItem4");
    removeEntry("3TestItem5");
    
    // test group
    QSharedPointer<CaEntry> testGroup = createGroup("TestGroup","testfolder");
    
    // test entries
    QList< QSharedPointer<CaEntry> > entryList;
    entryList << createItem("1TestItem1","testitem");
    entryList << createItem("1TestItem2","testitem");
    entryList << createItem("1TestItem3","testitem");
    
    entryList << createItem("2TestItem1","testitem");
    
    entryList << createItem("3TestItem1","testitem");
    entryList << createItem("3TestItem2","testitem");
    entryList << createItem("3TestItem3","testitem");
    
    // entries for inserting into sorted order - notice the names
    entryList << createItem("0TestItem1","testitem");
    entryList << createItem("0TestItem2","testitem");
        
    entryList << createItem("1TestItem4","testitem");
    entryList << createItem("1TestItem5","testitem");
    
    entryList << createItem("2TestItem2","testitem");
    entryList << createItem("2TestItem3","testitem");
    
    entryList << createItem("3TestItem4","testitem");
    entryList << createItem("3TestItem5","testitem");

    // create a model to test
    CaQuery query;
    query.setParentId(testGroup->id());
    CaItemModel model(query, NULL);
    model.setAutoUpdate(true);
    
    // create row insertion signal spyes;
    qRegisterMetaType<QModelIndex>("QModelIndex");
    QSignalSpy rowsAboutToBeInsertedSpy(
                &model, SIGNAL(rowsAboutToBeInserted(QModelIndex,int,int)));
    QSignalSpy rowsInsertedSpy(
                &model, SIGNAL(rowsInserted(QModelIndex,int,int)));
    QSignalSpy resetSpy(
                &model, SIGNAL(modelReset()));
    QList<QVariant> spyArguments;
    
// ***[1]*** test adding 3 entries to an empty collection
    service->appendEntriesToGroup(*testGroup, entryList.mid(0, 3));
    QTest::qWait(50);
    
    QCOMPARE(rowsAboutToBeInsertedSpy.count(), 1);
    spyArguments = rowsAboutToBeInsertedSpy.takeFirst();
    // added 3 entries to the beginning of the group
    // first row in the signal should be 0 and the last row 2
    QVERIFY(spyArguments.at(1).toInt() == 0);
    QVERIFY(spyArguments.at(2).toInt() == 2);
    
    QCOMPARE(rowsInsertedSpy.count(), 1);
    spyArguments = rowsInsertedSpy.takeFirst();
    QVERIFY(spyArguments.at(1).toInt() == 0);
    QVERIFY(spyArguments.at(2).toInt() == 2);
    
// ***[2]*** add 1 entry to a collection already containing items
    service->appendEntryToGroup(*testGroup, *entryList[3]);
    QTest::qWait(50);
    
    QCOMPARE(resetSpy.count(), 1);
    
// ***[5]*** rearrange items
    model.setSort(DefaultSortAttribute);
    
    QSignalSpy layoutAboutToBeChangedSpy(&model, SIGNAL(layoutAboutToBeChanged()));
    QSignalSpy layoutChangedSpy(&model, SIGNAL(layoutChanged()));
    
    QList<int> idList;
    QSharedPointer<CaEntry> entry;
    foreach(entry, entryList) {
        idList << entry->id();
    }
    // swap the first and last element to trigger a layout update
    idList.swap(0, idList.count() - 1);

    service->customSort(testGroup->id(), idList);
    QTest::qWait(50);
    
    QCOMPARE(layoutAboutToBeChangedSpy.count(), 1);
    QCOMPARE(layoutChangedSpy.count(), 1);
   
    
    removeEntry("1TestItem1");
    removeEntry("1TestItem2");
    removeEntry("1TestItem3");
    removeEntry("2TestItem1");
    removeEntry("3TestItem1");
    removeEntry("3TestItem2");
    removeEntry("3TestItem3");
    removeEntry("0TestItem1");
    removeEntry("0TestItem2");
    removeEntry("1TestItem4");
    removeEntry("1TestItem5");
    removeEntry("2TestItem2");
    removeEntry("2TestItem3");
    removeEntry("3TestItem4");
    removeEntry("3TestItem5");
    removeEntry("TestGroup");
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::TestCaItemModelEmptySignal()
{
	QSharedPointer<CaService> service = CaService::instance();
	
	// ensure that entries are not present in a storage
	removeEntry("TestGroup_EmptySignal");
	removeEntry("TestItem1");
	removeEntry("TestItem2");
    // test group
    QSharedPointer<CaEntry> testGroup = createGroup("TestGroup_EmptySignal","testfolder");
    
    // test entries
    QSharedPointer<CaEntry> entry1 = createItem("TestItem1","testitem");
    QSharedPointer<CaEntry> entry2 = createItem("TestItem2","testitem");

    // create a model to test
    CaQuery query;
    query.setParentId(testGroup->id());
    CaItemModel model(query, NULL);
     
    // create signal spyes;
    //qRegisterMetaType<QModelIndex>("QModelIndex");
    QSignalSpy emptySignalSpy(
                &model, SIGNAL(empty(bool)));
    QList<QVariant> spyArguments;
     
	//test
    service->appendEntryToGroup(*testGroup.data(), *entry1.data());
    QTest::qWait(50);    
    QCOMPARE(emptySignalSpy.count(),1);
    
    spyArguments = emptySignalSpy.takeAt(0);
    QCOMPARE(spyArguments.at(0).toBool(), false);
    spyArguments.clear();
    emptySignalSpy.clear();
    
    service->appendEntryToGroup(*testGroup.data(), *entry2.data());
    QTest::qWait(50);    
    QCOMPARE(emptySignalSpy.count(),0);
	removeEntry("TestItem1");
    QTest::qWait(50);    
    QCOMPARE(emptySignalSpy.count(),0);
	removeEntry("TestItem2");
    QTest::qWait(50);    
    QCOMPARE(emptySignalSpy.count(),1);

    spyArguments = emptySignalSpy.takeAt(0);
    QCOMPARE(spyArguments.at(0).toBool(), true);

    
    //cleanup
	removeEntry("TestGroup_EmptySignal");
}

// ---------------------------------------------------------------------------
// UTILS
// ---------------------------------------------------------------------------
//
QSharedPointer<CaEntry> TestCaClient::createGroup(const QString &groupName, const QString &typeName)
{
    CaEntry item(GroupEntryRole);
    item.setText(groupName);
    item.setEntryTypeName(typeName);
    QSharedPointer<CaService> service = CaService::instance();
    return service->createEntry(item);
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
QSharedPointer<CaEntry> TestCaClient::createItem(const QString &itemName, const QString &description,
                                  const QString &typeName, EntryFlags flags)
{
    CaEntry item(ItemEntryRole);
    item.setText(itemName);
    item.setDescription(description);
    item.setEntryTypeName(typeName);
    item.setFlags(flags);
    QSharedPointer<CaService> service = CaService::instance();
    return service->createEntry(item);
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
QSharedPointer<CaEntry> TestCaClient::createItem(const QString &itemName, const QString &typeName)
{
    CaEntry item(ItemEntryRole);
    item.setText(itemName);
    item.setEntryTypeName(typeName);
    QSharedPointer<CaService> service = CaService::instance();
    return service->createEntry(item);
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::addItemToGroup(int groupId, int itemId)
{
    QSharedPointer<CaService> service = CaService::instance();
    service->appendEntryToGroup(groupId, itemId) ;
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::removeItemFromGroup(int groupId, int itemId)
{
    QSharedPointer<CaService> service = CaService::instance();
    service->removeEntryFromGroup(groupId, itemId) ;
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
void TestCaClient::removeEntry(int entryId)
{
    QSharedPointer<CaService> service = CaService::instance();
    service->removeEntry(entryId);
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
bool TestCaClient::removeEntry(const QString &entryName)
{
    bool found(false);
    QSharedPointer<CaService> service = CaService::instance();
    CaQuery query;
    QList< QSharedPointer<CaEntry> > entries = service->getEntries(query);
    foreach(QSharedPointer<CaEntry> entry, entries) {
        if (entry->text() == entryName) {
            service->removeEntry(*entry);
            found = true;
        }
    }
    return found;
}

// ---------------------------------------------------------------------------
// ---------------------------------------------------------------------------
//
QString TestCaClient::itemName(const CaItemModel &model, int row)
{
    return model.data(model.index(row),CaItemModel::TextRole).toString();
}