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 >,
  50                     const RCSResourceAttributes &, int) -> OCStackResult
  51                     {
  52                         return OC_STACK_OK;
  53                     });
  54         }
  55
  56         virtual void TearDown()
  57         {
  58             pResource.reset();
  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     CACHE_METHOD cm = CACHE_METHOD::ITERATED_GET;
  69     long reportTime = 20l;
  70
  71     ASSERT_THROW(cacheInstance->requestResourceCache(NULL, func, cm, rf, reportTime),
  72                  RCSInvalidParameterException);
  73 }
  74
  75 TEST_F(ResourceCacheManagerTest, requestResourceCache_cacheCBIsNULL)
  76 {
  77
  78     CacheCB func = NULL;
  79     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
  80     CACHE_METHOD cm = CACHE_METHOD::ITERATED_GET;
  81     long reportTime = 20l;
  82
  83     ASSERT_THROW(cacheInstance->requestResourceCache(pResource, func, cm, rf, reportTime),
  84                  RCSInvalidParameterException);
  85 }
  86
  87 TEST_F(ResourceCacheManagerTest, requestResourceCache_reportTimeIsNULL)
  88 {
  89
  90     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
  91     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
  92     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
  93     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
  94
  95     CacheCB func = cb;
  96     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
  97     CACHE_METHOD cm = CACHE_METHOD::ITERATED_GET;
  98
  99     id = cacheInstance->requestResourceCache(pResource, func, cm, rf);
 100     cacheInstance->cancelResourceCache(id);
 101
 102     ASSERT_NE(id, 0);
 103
 104 }
 105
 106 TEST_F(ResourceCacheManagerTest, requestResourceCache_normalCase)
 107 {
 108
 109     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 110     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 111     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 112     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 113
 114     CacheCB func = cb;
 115     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 116     CACHE_METHOD cm = CACHE_METHOD::ITERATED_GET;
 117     long reportTime = 20l;
 118
 119     id = cacheInstance->requestResourceCache(pResource, func, cm, rf, reportTime);
 120     cacheInstance->cancelResourceCache(id);
 121
 122     ASSERT_NE(id, 0);
 123 }
 124
 125 TEST_F(ResourceCacheManagerTest, cancelResourceCache_cacheIDIsZero)
 126 {
 127
 128     ASSERT_THROW(cacheInstance->cancelResourceCache(0),
 129                  RCSInvalidParameterException);
 130 }
 131
 132 TEST_F(ResourceCacheManagerTest, cancelResourceCache_normalCase)
 133 {
 134
 135     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestGet);
 136     mocks.ExpectCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 137     mocks.ExpectCall(pResource.get(), PrimitiveResource::requestObserve);
 138     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 139
 140     CacheCB func = cb;
 141     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 142     CACHE_METHOD cm = CACHE_METHOD::ITERATED_GET;
 143     long reportTime = 20l;
 144
 145     id = cacheInstance->requestResourceCache(pResource, func, cm, rf, reportTime);
 146
 147     cacheInstance->cancelResourceCache(id);
 148 }
 149
 150 TEST_F(ResourceCacheManagerTest, updateResourceCacheCacheID_cacheIDIsZero)
 151 {
 152
 153     ASSERT_THROW(cacheInstance->updateResourceCache(0),
 154                  RCSInvalidParameterException);
 155 }
 156
 157 TEST_F(ResourceCacheManagerTest, updateResourceCacheCacheID_cacheIsNULL)
 158 {
 159
 160     ASSERT_THROW(cacheInstance->updateResourceCache(id),
 161                  RCSInvalidParameterException);
 162 }
 163
 164 TEST_F(ResourceCacheManagerTest, updateResourceCacheCacheID_normalCase)
 165 {
 166
 167     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet);
 168     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 169     mocks.OnCall(pResource.get(), PrimitiveResource::requestObserve);
 170     mocks.OnCall(pResource.get(), PrimitiveResource::getUri).Return("testUri");
 171     mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return("testHost");
 172     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 173
 174     CacheCB func = cb;
 175     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 176     CACHE_METHOD cm = CACHE_METHOD::ITERATED_GET;
 177     long reportTime = 20l;
 178
 179     id = cacheInstance->requestResourceCache(pResource, func, cm, rf, reportTime);
 180
 181     cacheInstance->updateResourceCache(id);
 182
 183     cacheInstance->cancelResourceCache(id);
 184 }
 185
 186 TEST_F(ResourceCacheManagerTest, getCachedDataCachID_resourceIsNULL)
 187 {
 188
 189     ASSERT_THROW(cacheInstance->getCachedData(0), RCSInvalidParameterException);
 190 }
 191
 192 TEST_F(ResourceCacheManagerTest, getCachedDataCachID_handlerIsNULL)
 193 {
 194
 195     ASSERT_THROW(cacheInstance->getCachedData(id), RCSInvalidParameterException);
 196 }
 197
 198 TEST_F(ResourceCacheManagerTest, getResourceCacheStateCacheID_cacheIDIsZero)
 199 {
 200
 201     ASSERT_THROW(cacheInstance->getResourceCacheState(0),
 202                  RCSInvalidParameterException);
 203 }
 204
 205 TEST_F(ResourceCacheManagerTest, getResourceCacheStateCacheID_handlerIsNULL)
 206 {
 207
 208     id = 1;
 209     ASSERT_EQ(cacheInstance->getResourceCacheState(id), CACHE_STATE::NONE);
 210 }
 211
 212 TEST_F(ResourceCacheManagerTest, getResourceCacheStateCacheID_normalCase)
 213 {
 214
 215     mocks.OnCall(pResource.get(), PrimitiveResource::requestGet);
 216     mocks.OnCall(pResource.get(), PrimitiveResource::isObservable).Return(true);
 217     mocks.OnCall(pResource.get(), PrimitiveResource::requestObserve);
 218     mocks.OnCall(pResource.get(), PrimitiveResource::getUri).Return("testUri");
 219     mocks.OnCall(pResource.get(), PrimitiveResource::getHost).Return("testHost");
 220     mocks.OnCall(pResource.get(), PrimitiveResource::cancelObserve);
 221
 222     CacheCB func = cb;
 223     REPORT_FREQUENCY rf = REPORT_FREQUENCY::UPTODATE;
 224     CACHE_METHOD cm = CACHE_METHOD::ITERATED_GET;
 225     long reportTime = 20l;
 226
 227     id = cacheInstance->requestResourceCache(pResource, func, cm, rf, reportTime);
 228     CACHE_STATE state = cacheInstance->getResourceCacheState(id);
 229
 230     cacheInstance->cancelResourceCache(id);
 231
 232     ASSERT_EQ(state, CACHE_STATE::READY_YET);
 233 }