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

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