service/resource-encapsulation/src/resourceCache/unittests/ResourceCacheTest.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 "UnitTestHelper.h"
  27
  28 using namespace OIC::Service;
  29
  30 class ResourceCacheManagerTest : public TestWithMock
  31 {
  32     public:
  33         ResourceCacheManager *cacheInstance;
  34         PrimitiveResource::Ptr pResource;
  35         CacheCB cb;
  36         CacheID id;
  37
  38     protected:
  39         virtual void SetUp()
  40         {
  41             TestWithMock::SetUp();
  42             cacheInstance = ResourceCacheManager::getInstance();
  43             pResource = PrimitiveResource::Ptr(mocks.Mock< PrimitiveResource >(), [](PrimitiveResource *) {});
  44             cb = ([](std::shared_ptr<PrimitiveResource >, const RCSResourceAttributes &)->OCStackResult {return OC_STACK_OK;});
  45         }
  46
  47         virtual void TearDown()
  48         {
  49             TestWithMock::TearDown();
  50         }
  51 };
  52
  53 TEST_F(ResourceCacheManagerTest, requestResourceCache_resourceIsNULL)
  54 {
  55
  56     CacheCB func = cb;
  57     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
  58     long reportTime = 20l;
  59
  60     ASSERT_THROW(cacheInstance->requestResourceCache(NULL, func, rf, reportTime),
  61                  ResourceCacheManager::InvalidParameterException);
  62 }
  63
  64 TEST_F(ResourceCacheManagerTest, requestResourceCache_cacheCBIsNULL)
  65 {
  66
  67     CacheCB func = NULL;
  68     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
  69     long reportTime = 20l;
  70
  71     ASSERT_THROW(cacheInstance->requestResourceCache(pResource, func, rf, reportTime),
  72                  ResourceCacheManager::InvalidParameterException);
  73 }
  74
  75 TEST_F(ResourceCacheManagerTest, requestResourceCache_reportTimeIsNULL)
  76 {
  77
  78     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
  79     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
  80     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
  81     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
  82
  83     CacheCB func = cb;
  84     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
  85
  86     id = cacheInstance->requestResourceCache(pResource, func, rf);
  87     cacheInstance->cancelResourceCache(id);
  88
  89     ASSERT_NE(id, 0);
  90
  91 }
  92
  93 TEST_F(ResourceCacheManagerTest, requestResourceCache_normalCase)
  94 {
  95
  96     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
  97     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
  98     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
  99     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 100
 101     CacheCB func = cb;
 102     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 103     long reportTime = 20l;
 104
 105     id = cacheInstance->requestResourceCache(pResource, func, rf, reportTime);
 106     cacheInstance->cancelResourceCache(id);
 107
 108     ASSERT_NE(id, 0);
 109 }
 110
 111 TEST_F(ResourceCacheManagerTest, cancelResourceCache_cacheIDIsZero)
 112 {
 113
 114     ASSERT_THROW(cacheInstance->cancelResourceCache(0),
 115                  ResourceCacheManager::InvalidParameterException);
 116 }
 117
 118 TEST_F(ResourceCacheManagerTest, cancelResourceCache_normalCase)
 119 {
 120
 121     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 122     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 123     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 124     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 125
 126     CacheCB func = cb;
 127     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 128     long reportTime = 20l;
 129
 130     id = cacheInstance->requestResourceCache(pResource, func, rf, reportTime);
 131
 132     cacheInstance->cancelResourceCache(id);
 133 }
 134
 135 TEST_F(ResourceCacheManagerTest, updateResourceCachePrimitiveResource_resourceIsNULL)
 136 {
 137
 138     pResource = NULL;
 139
 140     ASSERT_THROW(cacheInstance->updateResourceCache(pResource),
 141                  ResourceCacheManager::InvalidParameterException);
 142 }
 143
 144 TEST_F(ResourceCacheManagerTest, updateResourceCachePrimitiveResource_cacheIsNULL)
 145 {
 146
 147     ASSERT_THROW(cacheInstance->updateResourceCache(pResource),
 148                  ResourceCacheManager::InvalidParameterException);
 149 }
 150
 151 TEST_F(ResourceCacheManagerTest, updateResourceCachePrimitiveResource_normalCase)
 152 {
 153
 154     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet);
 155     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 156     mocks.OnCall(pResource.get(), PrimitiveResource::requestObserve);
 157     mocks.OnCall(pResource.get(), PrimitiveResource::getUri).Return("testUri");
 158     mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return("testHost");
 159     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 160
 161     CacheCB func = cb;
 162     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 163     long reportTime = 20l;
 164
 165     id = cacheInstance->requestResourceCache(pResource, func, rf, reportTime);
 166
 167     cacheInstance->updateResourceCache(pResource);
 168
 169     cacheInstance->cancelResourceCache(id);
 170 }
 171
 172 TEST_F(ResourceCacheManagerTest, updateResourceCacheCacheID_cacheIDIsZero)
 173 {
 174
 175     ASSERT_THROW(cacheInstance->updateResourceCache(0),
 176                  ResourceCacheManager::InvalidParameterException);
 177 }
 178
 179 TEST_F(ResourceCacheManagerTest, updateResourceCacheCacheID_cacheIsNULL)
 180 {
 181
 182     ASSERT_THROW(cacheInstance->updateResourceCache(id),
 183                  ResourceCacheManager::InvalidParameterException);
 184 }
 185
 186 TEST_F(ResourceCacheManagerTest, updateResourceCacheCacheID_normalCase)
 187 {
 188
 189     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet);
 190     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 191     mocks.OnCall(pResource.get(), PrimitiveResource::requestObserve);
 192     mocks.OnCall(pResource.get(), PrimitiveResource::getUri).Return("testUri");
 193     mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return("testHost");
 194     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 195
 196     CacheCB func = cb;
 197     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 198     long reportTime = 20l;
 199
 200     id = cacheInstance->requestResourceCache(pResource, func, rf, reportTime);
 201
 202     cacheInstance->updateResourceCache(id);
 203
 204     cacheInstance->cancelResourceCache(id);
 205 }
 206
 207 TEST_F(ResourceCacheManagerTest, getCachedDataPrimitiveResource_resourceIsNULL)
 208 {
 209
 210     pResource = NULL;
 211
 212     ASSERT_THROW(cacheInstance->getCachedData(pResource),
 213                  ResourceCacheManager::InvalidParameterException);
 214 }
 215
 216 TEST_F(ResourceCacheManagerTest, getCachedDataPrimitiveResource_handlerIsNULL)
 217 {
 218
 219     ASSERT_THROW(cacheInstance->getCachedData(pResource),
 220                  ResourceCacheManager::InvalidParameterException);
 221 }
 222
 223 TEST_F(ResourceCacheManagerTest, getCachedDataCachID_resourceIsNULL)
 224 {
 225
 226     ASSERT_THROW(cacheInstance->getCachedData(0), ResourceCacheManager::InvalidParameterException);
 227 }
 228
 229 TEST_F(ResourceCacheManagerTest, getCachedDataCachID_handlerIsNULL)
 230 {
 231
 232     ASSERT_THROW(cacheInstance->getCachedData(id), ResourceCacheManager::InvalidParameterException);
 233 }
 234
 235 TEST_F(ResourceCacheManagerTest, getResourceCacheStatePrimitiveResource_resourceIsNULL)
 236 {
 237
 238     pResource = NULL;
 239
 240     ASSERT_THROW(cacheInstance->getResourceCacheState(pResource),
 241                  ResourceCacheManager::InvalidParameterException);
 242 }
 243
 244 TEST_F(ResourceCacheManagerTest, getResourceCacheStatePrimitiveResource_handlerIsNULL)
 245 {
 246
 247     ASSERT_EQ(cacheInstance->getResourceCacheState(pResource), CACHE_STATE::NONE);
 248 }
 249
 250 TEST_F(ResourceCacheManagerTest, getResourceCacheStatePrimitiveResource_normalCase)
 251 {
 252
 253     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet);
 254     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 255     mocks.OnCall(pResource.get(), PrimitiveResource::requestObserve);
 256     mocks.OnCall(pResource.get(), PrimitiveResource::getUri).Return("testUri");
 257     mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return("testHost");
 258     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 259
 260     CacheCB func = cb;
 261     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 262     long reportTime = 20l;
 263
 264     id = cacheInstance->requestResourceCache(pResource, func, rf, reportTime);
 265     CACHE_STATE state = cacheInstance->getResourceCacheState(pResource);
 266
 267     cacheInstance->cancelResourceCache(id);
 268
 269     ASSERT_EQ(state, CACHE_STATE::READY_YET);
 270 }
 271
 272 TEST_F(ResourceCacheManagerTest, getResourceCacheStateCacheID_cacheIDIsZero)
 273 {
 274
 275     ASSERT_THROW(cacheInstance->getResourceCacheState(0),
 276                  ResourceCacheManager::InvalidParameterException);
 277 }
 278
 279 TEST_F(ResourceCacheManagerTest, getResourceCacheStateCacheID_handlerIsNULL)
 280 {
 281
 282     ASSERT_EQ(cacheInstance->getResourceCacheState(id), CACHE_STATE::NONE);
 283 }
 284
 285 TEST_F(ResourceCacheManagerTest, getResourceCacheStateCacheID_normalCase)
 286 {
 287
 288     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet);
 289     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 290     mocks.OnCall(pResource.get(), PrimitiveResource::requestObserve);
 291     mocks.OnCall(pResource.get(), PrimitiveResource::getUri).Return("testUri");
 292     mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return("testHost");
 293     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 294
 295     CacheCB func = cb;
 296     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 297     long reportTime = 20l;
 298
 299     id = cacheInstance->requestResourceCache(pResource, func, rf, reportTime);
 300     CACHE_STATE state = cacheInstance->getResourceCacheState(id);
 301
 302     cacheInstance->cancelResourceCache(id);
 303
 304     ASSERT_EQ(state, CACHE_STATE::READY_YET);
 305 }