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