service/resource-encapsulation/unittests/ResourceClient_Test.cpp

   1 #define private public
   2 #include <gtest/gtest.h>
   3 #include <iostream>
   4 #include "ResourceClient.h"
   5 #include "RCSResourceObject.h"
   6 #include "OCPlatform.h"
   7
   8 #define RESOURCEURI "/a/TemperatureSensor"
   9 #define RESOURCETYPE "Resource.Hosting"
  10 #define RESOURCEINTERFACE "oic.if.baseline"
  11
  12 using namespace OIC::Service;
  13 using namespace OC;
  14
  15 bool cbresult = false;
  16 std::string uri = "/oic/res?rt=Resource.Hosting";
  17 std::shared_ptr<RemoteResourceObject> object;
  18 DiscoveryManager *manager = DiscoveryManager::getInstance();
  19 ResourceState receivedResourceState;
  20 RCSResourceAttributes receivedResourceAttributes;
  21 RCSResourceObject::Ptr server;
  22
  23 void createResource()
  24 {
  25     server = RCSResourceObject::Builder(RESOURCEURI, RESOURCETYPE,
  26                                      RESOURCEINTERFACE).setDiscoverable(true).setObservable(true).build();
  27     std::cout << "Resource created successfully " << std::endl;
  28     server->setAttribute("Temperature", 0);
  29     PlatformConfig config
  30     {
  31         OC::ServiceType::InProc, ModeType::Client, "0.0.0.0", 0, OC::QualityOfService::LowQos
  32     };
  33     OCPlatform::Configure(config);
  34 }
  35
  36 void destroyResource()
  37 {
  38     server = NULL;
  39 }
  40
  41 //Callbacks
  42 void onRemoteAttrReceived(const RCSResourceAttributes &attributes)
  43 {
  44     cbresult = true;
  45     receivedResourceAttributes = attributes;
  46 }
  47
  48 void onResourceDiscoveredCallback(std::shared_ptr<RemoteResourceObject> receivedObject)
  49 {
  50     std::cout << "Resource discovered" << std::endl;
  51     object = receivedObject;
  52     std::cout << object->getUri() << std::endl;
  53     std::cout << "Resource discovered exited" << std::endl;
  54     EXPECT_TRUE(object != NULL);
  55 }
  56
  57 void onResourceStateChanged(ResourceState state)
  58 {
  59     receivedResourceState = state;
  60 }
  61
  62 void onCacheUpdated(const RCSResourceAttributes attribute)
  63 {
  64     receivedResourceAttributes = attribute;
  65 }
  66
  67 void OnRemoteAttributesSetCallback(const RCSResourceAttributes &attributes)
  68 {
  69     cbresult = true;
  70 }
  71
  72 //Send valid call to discover resource
  73 TEST(ResourceClientTest, testDiscoverResourcePass)
  74 {
  75     createResource();
  76     DiscoveryManager *instance = DiscoveryManager::getInstance();
  77     cbresult = false;
  78
  79     instance->discoverResource("", uri, CT_DEFAULT, &onResourceDiscoveredCallback);
  80     sleep(2);
  81     EXPECT_TRUE(object != NULL);
  82     destroyResource();
  83 }
  84
  85 //Get remote attributes when callback is valid
  86 TEST(ResourceClientTest, testGetRemoteAttributesPass)
  87 {
  88     createResource();
  89     sleep(2);
  90     cbresult = false;
  91     object->getRemoteAttributes(&onRemoteAttrReceived);
  92     sleep(2);
  93
  94     EXPECT_TRUE(cbresult);
  95     destroyResource();
  96 }
  97
  98 //Set remote attributes when callback is valid
  99 TEST(ResourceClientTest, testSetRemoteAttributesPass)
 100 {
 101     createResource();
 102     sleep(2);
 103
 104     cbresult = false;
 105     object->getRemoteAttributes(&onRemoteAttrReceived);
 106     sleep(2);
 107     RCSResourceAttributes::const_iterator iter = receivedResourceAttributes.begin();
 108     for (unsigned int i = 0; i < receivedResourceAttributes.size(); ++i)
 109     {
 110         if ( iter->key() == "Temperature")
 111         {
 112             std::cout << "It is there" << std::endl;
 113             receivedResourceAttributes["Temperature"]  = 100;
 114             object->setRemoteAttributes(receivedResourceAttributes, &OnRemoteAttributesSetCallback);
 115         }
 116         ++iter;
 117     }
 118     sleep(2);
 119     EXPECT_TRUE(cbresult);
 120     destroyResource();
 121 }
 122
 123 //Check value of isMonitoring
 124 TEST(ResourceClientTest, testIsMonitoring)
 125 {
 126     createResource();
 127     manager->DiscoveryManager::discoverResource("", uri, CT_DEFAULT, &onResourceDiscoveredCallback);
 128     sleep(1);
 129     destroyResource();
 130     EXPECT_FALSE(object->isMonitoring());
 131 }
 132
 133 //Check value of isCaching
 134 TEST(ResourceClientTest, testIsCaching)
 135 {
 136     createResource();
 137     destroyResource();
 138     EXPECT_FALSE(object->isCaching());
 139 }
 140
 141 TEST(ResourceClientTest, testIsObservable)
 142 {
 143     createResource();
 144     destroyResource();
 145     EXPECT_TRUE(object->isObservable());
 146 }
 147
 148 //Check value of startMonitoring for NULL callback
 149 TEST(ResourceClientTest, testStartMonitoringFail)
 150 {
 151     createResource();
 152     object->m_monitoringFlag = false;
 153     object->startMonitoring(NULL);
 154     EXPECT_TRUE(object->m_monitoringFlag);
 155     object->stopMonitoring();
 156     destroyResource();
 157 }
 158
 159 //Check value of startMonitoring for valid callback
 160 TEST(ResourceClientTest, testStartMonitoringPass)
 161 {
 162     createResource();
 163     object->startMonitoring(&onResourceStateChanged);
 164     EXPECT_TRUE(object->m_monitoringFlag);
 165     object->stopMonitoring();
 166     destroyResource();
 167 }
 168
 169 //Stop Monitoring when Monitoring is true
 170 TEST(ResourceClientTest, testStopMonitoring)
 171 {
 172     createResource();
 173     object->startMonitoring(&onResourceStateChanged);
 174     object->stopMonitoring();
 175     EXPECT_FALSE(object->m_monitoringFlag);
 176     object->startMonitoring(&onResourceStateChanged);
 177     destroyResource();
 178 }
 179
 180 //Get state of resource
 181 TEST(ResourceClientTest, testGetStatePass)
 182 {
 183     createResource();
 184     ResourceState result = object->getState();
 185     EXPECT_TRUE(result >= ResourceState::NOT_MONITORING && result <= ResourceState::DESTROYED);
 186     destroyResource();
 187 }
 188
 189 //Cache ID is not zero
 190 TEST(ResourceClientTest, testStartCachingPass)
 191 {
 192     createResource();
 193     object->m_cachingFlag = false;
 194     object->startCaching();
 195     EXPECT_TRUE(object->m_cachingFlag);
 196     destroyResource();
 197 }
 198
 199 TEST(ResourceClientTest, testStopCaching)
 200 {
 201     createResource();
 202     object->m_cachingFlag = false;
 203     object->startCaching();
 204     object->stopCaching();
 205     EXPECT_FALSE(object->m_cachingFlag);
 206     destroyResource();
 207 }
 208
 209 TEST(ResourceClientTest, testRefreshCache)
 210 {
 211     createResource();
 212     object->m_cachingFlag = false;
 213     object->startCaching();
 214     object->refreshCache();
 215     EXPECT_TRUE(object->getResourceCacheState() == CacheState::UPDATING);
 216     destroyResource();
 217 }
 218
 219 //Callback for start caching is valid
 220 TEST(ResourceClientTest, testStartCachingCbPass)
 221 {
 222     createResource();
 223     object->m_cachingFlag = false;
 224     object->startCaching(&onCacheUpdated);
 225     EXPECT_TRUE(object->m_cachingFlag);
 226     destroyResource();
 227 }
 228
 229 //Callback for start caching is NULL
 230 TEST(ResourceClientTest, testStartCachingCbFail)
 231 {
 232     createResource();
 233     object->m_cachingFlag = false;
 234     object->startCaching(NULL);
 235     EXPECT_TRUE(object->m_cachingFlag);
 236     destroyResource();
 237 }
 238
 239 //Get resource state
 240 TEST(ResourceClientTest, testGetResourceCacheState)
 241 {
 242     createResource();
 243     CacheState result = object->getResourceCacheState();
 244     EXPECT_TRUE(result >= CacheState::READY && result <= CacheState::NONE);
 245     destroyResource();
 246 }
 247
 248 //Get cached attributes
 249 TEST(ResourceClientTest, testGetCachedAttributesWithoutCallback)
 250 {
 251     createResource();
 252     RCSResourceAttributes result = object->getCachedAttributes();
 253     EXPECT_TRUE(result.empty());
 254     destroyResource();
 255 }
 256
 257 //Check with invalid attribute value
 258 TEST(ResourceClientTest, testGetCachedAttributeWithInvalidAttribute)
 259 {
 260     createResource();
 261     RCSResourceAttributes::Value result = object->getCachedAttribute("");
 262     EXPECT_TRUE(result == nullptr);
 263     destroyResource();
 264 }
 265
 266 //Get remote attributes when callback is NULL
 267 TEST(ResourceClientTest, testGetRemoteAttributesFail)
 268 {
 269     createResource();
 270     cbresult = false;
 271     object->getRemoteAttributes(NULL);
 272     EXPECT_FALSE(cbresult);
 273     destroyResource();
 274 }
 275
 276 TEST(ResourceClientTest, testGetUri)
 277 {
 278     createResource();
 279     std::string result = object->getUri();
 280     EXPECT_TRUE(!result.empty());
 281     destroyResource();
 282 }
 283
 284 TEST(ResourceClientTest, testGetAddress)
 285 {
 286     createResource();
 287     std::string result = object->getAddress();
 288     EXPECT_TRUE(!result.empty());
 289     destroyResource();
 290 }
 291
 292 TEST(ResourceClientTest, testGetTypes)
 293 {
 294     createResource();
 295     std::vector < std::string > result = object->getTypes();
 296     EXPECT_TRUE(result.size() != 0);
 297     destroyResource();
 298 }
 299
 300 TEST(ResourceClientTest, testGetInterfaces)
 301 {
 302     createResource();
 303     std::vector < std::string > result = object->getInterfaces();
 304     EXPECT_TRUE(result.size() != 0);
 305     destroyResource();
 306 }
 307
 308 //Check with valid attribute value
 309 TEST(ResourceClientTest, testGetCachedAttribute)
 310 {
 311     createResource();
 312     RCSResourceAttributes::Value result = object->getCachedAttribute("Temperature");
 313     EXPECT_TRUE(result != nullptr);
 314     destroyResource();
 315 }
 316
 317 //Test getting instance of DiscoveryManager
 318 TEST(ResourceClientTest, testGetInstance)
 319 {
 320     createResource();
 321     DiscoveryManager *instance = DiscoveryManager::getInstance();
 322     EXPECT_TRUE(instance != NULL);
 323     destroyResource();
 324 }
 325
 326 //Send empty resource URI
 327 TEST(ResourceClientTest, testDiscoverResourceEmptyResource)
 328 {
 329     createResource();
 330     DiscoveryManager *instance = DiscoveryManager::getInstance();
 331     EXPECT_THROW(instance->discoverResource("", "", CT_DEFAULT, &onResourceDiscoveredCallback),
 332                  InvalidParameterException);
 333     destroyResource();
 334 }
 335
 336 //Send NULL callback
 337 TEST(ResourceClientTest, testDiscoverResourceEmptyCallback)
 338 {
 339     createResource();
 340     DiscoveryManager *instance = DiscoveryManager::getInstance();
 341     EXPECT_THROW(instance->discoverResource("", uri, CT_DEFAULT, NULL), InvalidParameterException);
 342     destroyResource();
 343     object->stopMonitoring();
 344 }
 345
 346 //Send invalid RCSResourceAttributes object to function
 347 TEST(ResourceClientTest, testSetRemoteAttributesInvalidAttributes)
 348 {
 349     createResource();
 350     cbresult = false;
 351     RCSResourceAttributes attr;
 352     //object->getRemoteAttributes(&onRemoteAttrReceived);
 353     object->setRemoteAttributes(attr, &OnRemoteAttributesSetCallback);
 354     EXPECT_FALSE(cbresult);
 355     destroyResource();
 356 }