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