/*
* 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();
}