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 >(), [](PrimitiveResource *) {});
  54             cacheHandler.reset(new DataCache());
  55             cb = ([](std::shared_ptr<PrimitiveResource >, const RCSResourceAttributes &)->OCStackResult {return OC_STACK_OK;});
  56         }
  57
  58         virtual void TearDown()
  59         {
  60             cacheHandler.reset();
  61             pResource.reset();
  62             TestWithMock::TearDown();
  63         }
  64 };
  65
  66 TEST_F(DataCacheTest, initializeDataCache_normalCase)
  67 {
  68
  69     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
  70     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
  71     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
  72     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
  73
  74     cacheHandler->initializeDataCache(pResource);
  75 }
  76
  77 TEST_F(DataCacheTest, initializeDataCache_normalCaseObservable)
  78 {
  79
  80     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
  81         [](GetCallback callback)
  82     {
  83         OIC::Service::HeaderOptions hos;
  84
  85         OIC::Service::RCSResourceAttributes attr;
  86         OIC::Service::ResponseStatement rep(attr);
  87         callback(hos, rep, OC_STACK_OK);
  88         return;
  89     }
  90     );
  91     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
  92     mocks.OnCall(pResource.get(), PrimitiveResource::requestObserve).Do(
  93         [](ObserveCallback callback)
  94     {
  95         OIC::Service::HeaderOptions hos;
  96         OIC::Service::RCSResourceAttributes attr;
  97         OIC::Service::ResponseStatement rep(attr);
  98         int seq;
  99         callback(hos, rep, OC_STACK_OK, seq);
 100         return;
 101     }
 102     );
 103     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 104
 105     cacheHandler->initializeDataCache(pResource);
 106 }
 107
 108 TEST_F(DataCacheTest, initializeDataCache_normalCaseNonObservable)
 109 {
 110
 111     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
 112         [](GetCallback callback)
 113     {
 114         OIC::Service::HeaderOptions hos;
 115
 116         OIC::Service::RCSResourceAttributes attr;
 117         OIC::Service::ResponseStatement rep(attr);
 118         callback(hos, rep, OC_STACK_OK);
 119         return;
 120     }
 121     );
 122     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(false);
 123     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 124
 125     cacheHandler->initializeDataCache(pResource);
 126
 127     sleep(3);
 128 }
 129
 130 TEST_F(DataCacheTest, initializeDataCache_normalCaseTimeOut)
 131 {
 132
 133     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 134     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 135     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 136     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 137
 138     cacheHandler->initializeDataCache(pResource);
 139
 140     sleep(3);
 141 }
 142
 143 TEST_F(DataCacheTest, addSubscriber_normalCase)
 144 {
 145
 146     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 147     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 148     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 149     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 150
 151     cacheHandler->initializeDataCache(pResource);
 152     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 153     long reportTime = 1l;
 154
 155     ASSERT_NE(cacheHandler->addSubscriber(cb, rf, reportTime), 0);
 156 }
 157
 158 TEST_F(DataCacheTest, deleteSubsciber_normalCase)
 159 {
 160
 161     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 162     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 163     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 164     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 165
 166     cacheHandler->initializeDataCache(pResource);
 167
 168     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 169     long reportTime = 1l;
 170
 171     id = cacheHandler->addSubscriber(cb, rf, reportTime);
 172
 173     ASSERT_NE(cacheHandler->deleteSubscriber(id), 0);
 174 }
 175
 176 TEST_F(DataCacheTest, getCacheState_normalCase)
 177 {
 178
 179     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 180     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 181     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 182     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 183
 184     cacheHandler->initializeDataCache(pResource);
 185
 186     ASSERT_EQ(cacheHandler->getCacheState(), CACHE_STATE::READY_YET);
 187 }
 188
 189 TEST_F(DataCacheTest, getCachedData_normalCase)
 190 {
 191
 192     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 193     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 194     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 195     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 196
 197     cacheHandler->initializeDataCache(pResource);
 198
 199     ASSERT_EQ(cacheHandler->getCachedData(), RCSResourceAttributes());
 200 }
 201
 202 TEST_F(DataCacheTest, getPrimitiveResource_normalCase)
 203 {
 204
 205     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 206     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 207     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 208     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 209
 210     cacheHandler->initializeDataCache(pResource);
 211
 212     ASSERT_EQ(cacheHandler->getPrimitiveResource(), pResource);
 213 }
 214
 215 TEST_F(DataCacheTest, requestGet_normalCase)
 216 {
 217
 218     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 219     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 220     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 221     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 222     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 223
 224     cacheHandler->initializeDataCache(pResource);
 225
 226     cacheHandler->requestGet();
 227 }
 228
 229 TEST_F(DataCacheTest, isEmptySubscriber_normalCase)
 230 {
 231
 232     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 233     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 234     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 235     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 236
 237     cacheHandler->initializeDataCache(pResource);
 238
 239     ASSERT_EQ(cacheHandler->isEmptySubscriber(), true);
 240 }
 241
 242 TEST_F(DataCacheTest, requestGet_normalCasetest)
 243 {
 244
 245     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 246     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 247     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 248     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet).Do(
 249         [](GetCallback callback)
 250     {
 251         OIC::Service::HeaderOptions hos;
 252         OIC::Service::RCSResourceAttributes attr;
 253         OIC::Service::ResponseStatement rep(attr);
 254         callback(hos, rep, OC_STACK_OK);
 255         return;
 256     });
 257     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 258
 259     cacheHandler->initializeDataCache(pResource);
 260
 261     cacheHandler->requestGet();
 262 }