service/resource-encapsulation/unittests/ResourceClient_Test.cpp

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