service/resource-encapsulation/src/resourceCache/unittests/DataCacheTest.cpp

   1 //******************************************************************
   2 //
   3 // Copyright 2015 Samsung Electronics All Rights Reserved.
   4 //
   5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
   6 //
   7 // Licensed under the Apache License, Version 2.0 (the "License");
   8 // you may not use this file except in compliance with the License.
   9 // You may obtain a copy of the License at
  10 //
  11 //      http://www.apache.org/licenses/LICENSE-2.0
  12 //
  13 // Unless required by applicable law or agreed to in writing, software
  14 // distributed under the License is distributed on an "AS IS" BASIS,
  15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 // See the License for the specific language governing permissions and
  17 // limitations under the License.
  18 //
  19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
  20
  21 #include <iostream>
  22 #include <gtest/gtest.h>
  23 #include <HippoMocks/hippomocks.h>
  24
  25 #include "ResourceCacheManager.h"
  26 #include "DataCache.h"
  27 #include "RCSResourceAttributes.h"
  28 #include "ResponseStatement.h"
  29 #include "UnitTestHelper.h"
  30
  31 using namespace OIC::Service;
  32
  33 class DataCacheTest : public TestWithMock
  34 {
  35     public:
  36         typedef std::function <
  37         void(const OIC::Service::HeaderOptions &, const OIC::Service::ResponseStatement &,
  38              int) > GetCallback;
  39
  40         typedef std::function <
  41         void(const OIC::Service::HeaderOptions &, const OIC::Service::ResponseStatement &, int,
  42              int) > ObserveCallback;
  43     public:
  44         std::shared_ptr<DataCache> cacheHandler;
  45         PrimitiveResource::Ptr pResource;
  46         CacheCB cb;
  47         CacheID id;
  48
  49     protected:
  50         virtual void SetUp()
  51         {
  52             TestWithMock::SetUp();
  53             pResource = PrimitiveResource::Ptr(mocks.Mock< PrimitiveResource >(),
  54                                                [](PrimitiveResource *)
  55                                                {
  56
  57                                                });
  58
  59             mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(false);
  60             cacheHandler.reset(new DataCache());
  61             cb = ([](std::shared_ptr<PrimitiveResource >,
  62                     const RCSResourceAttributes &, int) -> OCStackResult
  63                     {
  64                         return OC_STACK_OK;
  65                     });
  66         }
  67
  68         virtual void TearDown()
  69         {
  70             cacheHandler.reset();
  71             pResource.reset();
  72             TestWithMock::TearDown();
  73         }
  74 };
  75
  76 TEST_F(DataCacheTest, initializeDataCache_normalCase)
  77 {
  78
  79     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
  80     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
  81     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
  82     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
  83
  84     cacheHandler->initializeDataCache(pResource);
  85 }
  86
  87 TEST_F(DataCacheTest, initializeDataCache_normalCaseObservable)
  88 {
  89
  90     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
  91         [](GetCallback callback)
  92     {
  93         OIC::Service::HeaderOptions hos;
  94
  95         OIC::Service::RCSResourceAttributes attr;
  96         OIC::Service::ResponseStatement rep(attr);
  97         callback(hos, rep, OC_STACK_OK);
  98         return;
  99     }
 100     );
 101     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 102     mocks.OnCall(pResource.get(), PrimitiveResource::requestObserve).Do(
 103         [](ObserveCallback callback)
 104     {
 105         OIC::Service::HeaderOptions hos;
 106         OIC::Service::RCSResourceAttributes attr;
 107         OIC::Service::ResponseStatement rep(attr);
 108         int seq = 0;
 109         callback(hos, rep, OC_STACK_OK, seq);
 110         return;
 111     }
 112     );
 113     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 114
 115     cacheHandler->initializeDataCache(pResource);
 116 }
 117
 118 TEST_F(DataCacheTest, initializeDataCache_normalCaseNonObservable)
 119 {
 120
 121     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
 122         [](GetCallback callback)
 123     {
 124         OIC::Service::HeaderOptions hos;
 125
 126         OIC::Service::RCSResourceAttributes attr;
 127         OIC::Service::ResponseStatement rep(attr);
 128         callback(hos, rep, OC_STACK_OK);
 129         return;
 130     }
 131     );
 132     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(false);
 133     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 134
 135     cacheHandler->initializeDataCache(pResource);
 136
 137     sleep(3);
 138 }
 139
 140 TEST_F(DataCacheTest, initializeDataCache_normalCaseTimeOut)
 141 {
 142
 143     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 144     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 145     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 146     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 147
 148     cacheHandler->initializeDataCache(pResource);
 149
 150     sleep(3);
 151 }
 152
 153 TEST_F(DataCacheTest, addSubscriber_normalCase)
 154 {
 155
 156     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 157     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 158     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 159     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 160
 161     cacheHandler->initializeDataCache(pResource);
 162     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 163     long reportTime = 1l;
 164
 165     ASSERT_NE(cacheHandler->addSubscriber(cb, rf, reportTime), 0);
 166 }
 167
 168 TEST_F(DataCacheTest, deleteSubsciber_normalCase)
 169 {
 170
 171     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 172     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 173     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 174     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 175
 176     cacheHandler->initializeDataCache(pResource);
 177
 178     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 179     long reportTime = 1l;
 180
 181     id = cacheHandler->addSubscriber(cb, rf, reportTime);
 182
 183     ASSERT_NE(cacheHandler->deleteSubscriber(id), 0);
 184 }
 185
 186 TEST_F(DataCacheTest, getCacheState_normalCase)
 187 {
 188
 189     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 190     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 191     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 192     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 193
 194     cacheHandler->initializeDataCache(pResource);
 195
 196     ASSERT_EQ(cacheHandler->getCacheState(), CACHE_STATE::READY_YET);
 197 }
 198
 199 TEST_F(DataCacheTest, getCachedData_normalCase)
 200 {
 201
 202     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 203     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 204     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 205     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 206
 207     cacheHandler->initializeDataCache(pResource);
 208
 209     ASSERT_EQ(cacheHandler->getCachedData(), RCSResourceAttributes());
 210 }
 211
 212 TEST_F(DataCacheTest, getPrimitiveResource_normalCase)
 213 {
 214
 215     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 216     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 217     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 218     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 219
 220     cacheHandler->initializeDataCache(pResource);
 221
 222     ASSERT_EQ(cacheHandler->getPrimitiveResource(), pResource);
 223 }
 224
 225 TEST_F(DataCacheTest, requestGet_normalCase)
 226 {
 227
 228     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 229     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 230     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 231     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 232     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 233
 234     cacheHandler->initializeDataCache(pResource);
 235
 236     cacheHandler->requestGet();
 237 }
 238
 239 TEST_F(DataCacheTest, isEmptySubscriber_normalCase)
 240 {
 241
 242     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 243     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 244     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 245     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 246
 247     cacheHandler->initializeDataCache(pResource);
 248
 249     ASSERT_EQ(cacheHandler->isEmptySubscriber(), true);
 250 }
 251
 252 TEST_F(DataCacheTest, requestGet_normalCasetest)
 253 {
 254
 255     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 256     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 257     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 258     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
 259         [](GetCallback callback)
 260     {
 261         OIC::Service::HeaderOptions hos;
 262         OIC::Service::RCSResourceAttributes attr;
 263         OIC::Service::ResponseStatement rep(attr);
 264         callback(hos, rep, OC_STACK_OK);
 265         return;
 266     });
 267     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 268
 269     cacheHandler->initializeDataCache(pResource);
 270
 271     cacheHandler->requestGet();
 272 }