activityfw/activityserviceplugin/tsrc/t_afstorageproxy/src/t_afstorageproxy.cpp
changeset 117 c63ee96dbe5f
equal deleted inserted replaced
115:3ab5c078b490 117:c63ee96dbe5f
       
     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)