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