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