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