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