/*

* 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);