/*

* 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:

*

*/

#include "t_afstorageproxy.h"

#include <QtTest/QtTest>

#include <QPainter>

#include <XQConversions>

#include <afstorageglobals.h>

#include <afentry.h>

#include "afstorageclient.h"

#include "afstorageproxy.h"

#include "afserializer.h"

namespace {

    const int KApplicationId = 42;

    const char KActivityId[] = "TestActivity";

    const char KImagePath[] = "SomeFakePath";

}

void TestAfStorageProxy::init()

{

    mProxy = new AfStorageProxy();

}

void TestAfStorageProxy::cleanup()

{

    delete mProxy;

    mProxy = NULL;

}

void TestAfStorageProxy::testSaveActivityDataSerialization()

{    

    // check that data and metadata are properly serialized

    QVariant data("Data");

    QVariantHash metaData;

    QString someKey("SomeKey");

    QVariant someValue("SomeValue");

    metaData.insert(someKey, someValue);

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

    mProxy->saveActivity(KApplicationId, KActivityId, data, metaData, QPixmap());

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);

    CAfEntry *entry = CAfStorageClient::lastCallEntry;

    QVERIFY(entry);

    QVariantHash deserializedMetaData;

    deserializedMetaData << entry->Data(CAfEntry::Public);

    QVERIFY(deserializedMetaData.contains(someKey));

    QCOMPARE(deserializedMetaData.value(someKey), someValue);    

    QVariantHash deserializedData;

    deserializedData << entry->Data(CAfEntry::Private);

    QVERIFY(deserializedData.contains(ActivityDataKeyword));

    QCOMPARE(deserializedData.value(ActivityDataKeyword), data);    

}

void TestAfStorageProxy::testSaveActivityFlags()

{   

    // test that activities are visible and non-persistent by default

    {

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), QPixmap());

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);

        CAfEntry *entry = CAfStorageClient::lastCallEntry;

        QVERIFY(entry);

        QVERIFY(!(entry->Flags() & CAfEntry::Persistent));

        QVERIFY(!(entry->Flags() & CAfEntry::Invisible));

        CAfStorageClient::clearLastCallInfo();

    }

    // test persistency flag is properly set

    {

        QVariantHash metaData;

        metaData.insert(ActivityPersistence, true);

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), metaData, QPixmap());

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);

        CAfEntry *entry = CAfStorageClient::lastCallEntry;

        QVERIFY(entry);

        QVERIFY(entry->Flags() & CAfEntry::Persistent);

        CAfStorageClient::clearLastCallInfo();

    } 

    // test visibility flag is properly set

    {

        QVariantHash metaData;

        metaData.insert(ActivityVisibility, false);

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), metaData, QPixmap());

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);

        CAfEntry *entry = CAfStorageClient::lastCallEntry;

        QVERIFY(entry);

        QVERIFY(entry->Flags() & CAfEntry::Invisible);

        CAfStorageClient::clearLastCallInfo();

    } 

}

void TestAfStorageProxy::testSaveActivityScreenshotHandle()

{   

    // in case of null pixmap -1 handle will be sent to server

    {

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), QPixmap());

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);

        QCOMPARE(CAfStorageClient::lastCallImageHandle, -1);

        CAfStorageClient::clearLastCallInfo();

    }

    // proper handle is sent for non-null pixmap

    {

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

        mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());

        QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::SaveActivityMethod);

        QVERIFY(CAfStorageClient::lastCallImageHandle != -1);

        CAfStorageClient::clearLastCallInfo();

    }

}

void TestAfStorageProxy::testDeprecatedAddAndUpdateMethods()

{

    // we don't test those methods thoroughly, because a) it's basically the

    // same code as saveActivity b) those methods are deprecated and will be

    // removed soon.

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

    mProxy->addActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), QPixmap());    

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::AddActivityMethod);

    mProxy->addActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());

    mProxy->updateActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), QPixmap());

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::UpdateActivityMethod);

    mProxy->updateActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());

}

void TestAfStorageProxy::testRemoveActivity()

{

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

    mProxy->removeActivity(KApplicationId, KActivityId);    

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::RemoveActivityMethod);

    CAfEntry *entry = CAfStorageClient::lastCallEntry;

    QVERIFY(entry);

    QCOMPARE(entry->ApplicationId(), KApplicationId);

    QScopedPointer<HBufC> activityIdAsDesc(XQConversions::qStringToS60Desc(QString(KActivityId)));

    QVERIFY(entry->ActivityId().Compare(*activityIdAsDesc.data()) == 0);

}

void TestAfStorageProxy::testRemoveApplicationActivities()

{

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

    mProxy->removeApplicationActivities(KApplicationId);    

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::RemoveApplicationActivitiesMethod);

    CAfEntry *entry = CAfStorageClient::lastCallEntry;

    QVERIFY(entry);

    QCOMPARE(entry->ApplicationId(), KApplicationId);

}

void TestAfStorageProxy::testWaitActivity()

{

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

    CAfStorageClient::expectedReturnCode = KErrCancel;

    mProxy->waitActivity();

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::WaitActivityMethod);

    CAfStorageClient::lastMethodCalled = CAfStorageClient::NoCall;

    CAfStorageClient::expectedReturnCode = KErrNone;

    mProxy->waitActivity();

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::WaitActivityMethod);

}

void TestAfStorageProxy::testLaunchActivity()

{

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

    mProxy->launchActivity(KApplicationId, KActivityId);        

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::LaunchActivityMethod);

    CAfEntry *entry = CAfStorageClient::lastCallEntry;

    QVERIFY(entry);

    QCOMPARE(entry->ApplicationId(), KApplicationId);

    QScopedPointer<HBufC> activityIdAsDesc(XQConversions::qStringToS60Desc(QString(KActivityId)));

    QVERIFY(entry->ActivityId().Compare(*activityIdAsDesc.data()) == 0);

}

void TestAfStorageProxy::testGetThumbnail()

{

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

    CAfStorageClient::expectedReturnCode = KErrNone;

    mProxy->getThumbnail(QSize(100, 50), QString(KImagePath), this);

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::GetThumbnailMethod);

    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iWidth, 100);

    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iHeight, 50);

    QScopedPointer<HBufC> pathAsDesc(XQConversions::qStringToS60Desc(QString(KImagePath)));

    QVERIFY(CAfStorageClient::lastCallThumbnailPath->Compare(*pathAsDesc.data()) == 0);

    QVERIFY(CAfStorageClient::lastCallUserData == this);

    CAfStorageClient::expectedReturnCode = KErrNone;

    mProxy->getThumbnail(QSize(0, 0), QString(KImagePath), this);

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::GetThumbnailMethod);

    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iWidth, 0);

    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iHeight,0);

    QVERIFY(CAfStorageClient::lastCallThumbnailPath->Compare(*pathAsDesc.data()) == 0);

    QVERIFY(CAfStorageClient::lastCallUserData == this);

    CAfStorageClient::expectedReturnCode = KErrAccessDenied;

    mProxy->getThumbnail(QSize(100, 50), QString(KImagePath), this);

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::GetThumbnailMethod);

    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iWidth, 100);

    QCOMPARE(CAfStorageClient::lastCallThumbnailSize.iHeight,50);

    QVERIFY(CAfStorageClient::lastCallThumbnailPath->Compare(*pathAsDesc.data()) == 0);

    QVERIFY(CAfStorageClient::lastCallUserData == this);

}

void TestAfStorageProxy::testNotifyDataChange()

{

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NoCall);

    CAfStorageClient::expectedReturnCode = KErrCancel;

    mProxy->notifyDataChange();

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NotifyDataChangeMethod);

    CAfStorageClient::lastMethodCalled = CAfStorageClient::NoCall;

    CAfStorageClient::expectedReturnCode = KErrNone;

    mProxy->notifyDataChange();

    QCOMPARE(CAfStorageClient::lastMethodCalled, CAfStorageClient::NotifyDataChangeMethod);

}

// ---------------------------------------------------------------------------

void TestAfStorageProxy::testActivities()

{

    mProxy->removeApplicationActivities(KApplicationId);

    QList< QVariantHash > result;

    QVERIFY(mProxy->activities(result));

    QVERIFY(result.count() >= 0);

    mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());

    QVERIFY(mProxy->activities(result));

    QVERIFY(result.count() > 0);

}

// ---------------------------------------------------------------------------

void TestAfStorageProxy::testApplicationActivities()

{

    mProxy->removeApplicationActivities(KApplicationId);

    QStringList result;

    QVERIFY(mProxy->applicationActivities(result, KApplicationId));

    QCOMPARE(result.count(), 0);

    mProxy->saveActivity(KApplicationId, KActivityId, QVariant(), QVariantHash(), generateNonNullScreenshot());

    QVERIFY(mProxy->applicationActivities(result, KApplicationId));

    QCOMPARE(result.count(), 1);

}

// ---------------------------------------------------------------------------

void TestAfStorageProxy::testActivityData()

{

    mProxy->removeApplicationActivities(KApplicationId);

    QVariant result;

    QVERIFY(!mProxy->activityData(result, KApplicationId, KActivityId));

    mProxy->saveActivity(KApplicationId, KActivityId, QVariant(KApplicationId), QVariantHash(), generateNonNullScreenshot());

    QVERIFY(mProxy->activityData(result, KApplicationId, KActivityId));

    QCOMPARE(result, QVariant(KApplicationId));

}

void TestAfStorageProxy::testActivityMetaData()

{

    QVariantHash result;

    QVERIFY(!mProxy->activityMetaData(result, KApplicationId, KActivityId));

    mProxy->saveActivity(KApplicationId, KActivityId, QVariant(KApplicationId), QVariantHash(), generateNonNullScreenshot());

    QVERIFY(mProxy->activityMetaData(result, KApplicationId, KActivityId));

}

// ---------------------------------------------------------------------------

//  helper methods

// ---------------------------------------------------------------------------

//

QPixmap TestAfStorageProxy::generateNonNullScreenshot()

{

    QPixmap screenshot(10, 10);    

    {

        QPainter painter(&screenshot);

        painter.setBrush(Qt::black);

        painter.drawRect(screenshot.rect());

        painter.setBrush(QColor::fromHsv(0, 255, 255));

        painter.drawEllipse(screenshot.rect());

    }

    return screenshot;

}

QTEST_MAIN(TestAfStorageProxy)