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