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:

    15 *

    16 */

    17 #include "t_afstorageproxy.h"

    18 

    19 #include <QtTest/QtTest>

    20 #include <QPainter>

    21 #include <XQConversions>

    22 

    23 #include <afstorageglobals.h>

    24 #include <afentry.h>

    25 

    26 #include "afstorageclient.h"

    27 #include "afstorageproxy.h"

    28 #include "afserializer.h"

    29 

    30 namespace {

    31     const int KApplicationId = 42;

    32     

    33     const char KActivityId[] = "TestActivity";

    34     const char KImagePath[] = "SomeFakePath";

    35 }

    36 

    37 void TestAfStorageProxy::init()

    38 {

    39     mProxy = new AfStorageProxy();

    40 }

    41 

    42 void TestAfStorageProxy::cleanup()

    43 {

    44     delete mProxy;

    45     mProxy = NULL;

    46 }

    47 

    48 void TestAfStorageProxy::testSaveActivityDataSerialization()

    49 {    

    50     // check that data and metadata are properly serialized

    51     QVariant data("Data");

    52     QVariantHash metaData;

    53     QString someKey("SomeKey");

    54     QVariant someValue("SomeValue");

    55     metaData.insert(someKey, someValue);

    56     

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

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

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

    60     

    61     CAfEntry *entry = CAfStorageClient::lastCallEntry;

    62     QVERIFY(entry);

    63     

    64     QVariantHash deserializedMetaData;

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

    66     QVERIFY(deserializedMetaData.contains(someKey));

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

    68 

    69     QVariantHash deserializedData;

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

    71     QVERIFY(deserializedData.contains(ActivityDataKeyword));

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

    73 }

    74 

    75 void TestAfStorageProxy::testSaveActivityFlags()

    76 {   

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

    78     {

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

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

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

    82         

    83         CAfEntry *entry = CAfStorageClient::lastCallEntry;

    84         QVERIFY(entry);

    85         

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

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

    88         CAfStorageClient::clearLastCallInfo();

    89     }

    90  

    91     // test persistency flag is properly set

    92     {

    93         QVariantHash metaData;

    94         metaData.insert(ActivityPersistence, true);

    95     

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

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

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

    99         

   100         CAfEntry *entry = CAfStorageClient::lastCallEntry;

   101         QVERIFY(entry);

   102         

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

   104         CAfStorageClient::clearLastCallInfo();

   105     } 

   106  

   107     // test visibility flag is properly set

   108     {

   109         QVariantHash metaData;

   110         metaData.insert(ActivityVisibility, false);

   111     

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

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

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

   115         

   116         CAfEntry *entry = CAfStorageClient::lastCallEntry;

   117         QVERIFY(entry);

   118         

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

   120         CAfStorageClient::clearLastCallInfo();

   121     } 

   122 }

   123 

   124 void TestAfStorageProxy::testSaveActivityScreenshotHandle()

   125 {   

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

   127     {

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

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

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

   131         

   132         QCOMPARE(CAfStorageClient::lastCallImageHandle, -1);

   133         CAfStorageClient::clearLastCallInfo();

   134     }

   135  

   136     // proper handle is sent for non-null pixmap

   137     {

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

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

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

   141         

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

   143         CAfStorageClient::clearLastCallInfo();

   144     }

   145 }

   146 

   147 void TestAfStorageProxy::testDeprecatedAddAndUpdateMethods()

   148 {

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

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

   151     // removed soon.

   152     

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

   154     

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

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

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

   158     

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

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

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

   162 }

   163 

   164 void TestAfStorageProxy::testRemoveActivity()

   165 {

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

   167     mProxy->removeActivity(KApplicationId, KActivityId);    

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

   169     

   170     CAfEntry *entry = CAfStorageClient::lastCallEntry;

   171     QVERIFY(entry);

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

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

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

   175 }

   176 

   177 void TestAfStorageProxy::testRemoveApplicationActivities()

   178 {

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

   180     mProxy->removeApplicationActivities(KApplicationId);    

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

   182     

   183     CAfEntry *entry = CAfStorageClient::lastCallEntry;

   184     QVERIFY(entry);

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

   186 }

   187 

   188 void TestAfStorageProxy::testWaitActivity()

   189 {

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

   191     

   192     CAfStorageClient::expectedReturnCode = KErrCancel;

   193     mProxy->waitActivity();

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

   195     

   196     CAfStorageClient::lastMethodCalled = CAfStorageClient::NoCall;

   197     CAfStorageClient::expectedReturnCode = KErrNone;

   198     mProxy->waitActivity();

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

   200 }

   201 

   202 void TestAfStorageProxy::testLaunchActivity()

   203 {

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

   205     mProxy->launchActivity(KApplicationId, KActivityId);        

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

   207     

   208     CAfEntry *entry = CAfStorageClient::lastCallEntry;

   209     QVERIFY(entry);

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

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

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

   213 }

   214 

   215 void TestAfStorageProxy::testGetThumbnail()

   216 {

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

   218     

   219     CAfStorageClient::expectedReturnCode = KErrNone;

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

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

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

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

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

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

   226     QVERIFY(CAfStorageClient::lastCallUserData == this);

   227     

   228     CAfStorageClient::expectedReturnCode = KErrNone;

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

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

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

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

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

   234     QVERIFY(CAfStorageClient::lastCallUserData == this);

   235     

   236     CAfStorageClient::expectedReturnCode = KErrAccessDenied;

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

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

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

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

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

   242     QVERIFY(CAfStorageClient::lastCallUserData == this);

   243     

   244 }

   245     

   246 void TestAfStorageProxy::testNotifyDataChange()

   247 {

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

   249     

   250     CAfStorageClient::expectedReturnCode = KErrCancel;

   251     mProxy->notifyDataChange();

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

   253     

   254     CAfStorageClient::lastMethodCalled = CAfStorageClient::NoCall;

   255     CAfStorageClient::expectedReturnCode = KErrNone;

   256     mProxy->notifyDataChange();

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

   258 }

   259 

   260 // ---------------------------------------------------------------------------

   261 void TestAfStorageProxy::testActivities()

   262 {

   263     mProxy->removeApplicationActivities(KApplicationId);

   264     

   265     QList< QVariantHash > result;

   266     QVERIFY(mProxy->activities(result));

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

   268     

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

   270     QVERIFY(mProxy->activities(result));

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

   272 }

   273 

   274 // ---------------------------------------------------------------------------

   275 void TestAfStorageProxy::testApplicationActivities()

   276 {

   277     mProxy->removeApplicationActivities(KApplicationId);

   278     

   279     QStringList result;

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

   281     QCOMPARE(result.count(), 0);

   282     

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

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

   285     QCOMPARE(result.count(), 1);

   286 }

   287 

   288 // ---------------------------------------------------------------------------

   289 void TestAfStorageProxy::testActivityData()

   290 {

   291     mProxy->removeApplicationActivities(KApplicationId);

   292     

   293     QVariant result;

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

   295     

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

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

   298     QCOMPARE(result, QVariant(KApplicationId));

   299 }

   300 

   301 void TestAfStorageProxy::testActivityMetaData()

   302 {

   303     QVariantHash result;

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

   305     

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

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

   308 }

   309 

   310 // ---------------------------------------------------------------------------

   311 //  helper methods

   312 // ---------------------------------------------------------------------------

   313 //

   314 QPixmap TestAfStorageProxy::generateNonNullScreenshot()

   315 {

   316     QPixmap screenshot(10, 10);    

   317     {

   318         QPainter painter(&screenshot);

   319         painter.setBrush(Qt::black);

   320         painter.drawRect(screenshot.rect());

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

   322         painter.drawEllipse(screenshot.rect());

   323     }

   324     return screenshot;

   325 }

   326 

   327 QTEST_MAIN(TestAfStorageProxy)