service/resource-container/unittests/ResourceContainerTest.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 #if defined(__linux__)
  22 #include <unistd.h>
  23 #endif
  24
  25 #include <string>
  26 #include <map>
  27 #include <vector>
  28 #include <memory>
  29 #include <algorithm>
  30
  31 #include <UnitTestHelper.h>
  32
  33 #include <gtest/gtest.h>
  34 #include <HippoMocks/hippomocks.h>
  35
  36 #include "Configuration.h"
  37 #include "BundleActivator.h"
  38 #include "BundleResource.h"
  39 #include "RCSResourceContainer.h"
  40 #include "ResourceContainerBundleAPI.h"
  41 #include "ResourceContainerImpl.h"
  42 #include "RemoteResourceUnit.h"
  43
  44 #include "RCSResourceObject.h"
  45 #include "RCSRemoteResourceObject.h"
  46 #include "SoftSensorResource.h"
  47
  48 #include "ResourceContainerTestSimulator.h"
  49
  50 using namespace std;
  51 using namespace testing;
  52 using namespace OIC::Service;
  53
  54 #define MAX_PATH 2048
  55
  56 string CONFIG_FILE = "ResourceContainerTestConfig.xml";
  57
  58 void getCurrentPath(std::string *pPath)
  59 {
  60     char buffer[MAX_PATH];
  61
  62 #if defined(__linux__)
  63     char *strPath = NULL;
  64     int length = readlink("/proc/self/exe", buffer, MAX_PATH - 1);
  65
  66     if (length != -1)
  67     {
  68         buffer[length] = '\0';
  69         strPath = strrchr(buffer, '/');
  70
  71         if (strPath != NULL)
  72             *strPath = '\0';
  73     }
  74 #endif
  75     pPath->append(buffer);
  76 }
  77
  78 template<typename Derived, typename Base, typename Del>
  79 std::unique_ptr<Derived, Del>
  80 static_unique_ptr_cast( std::unique_ptr<Base, Del>&& p )
  81 {
  82     auto d = static_cast<Derived *>(p.release());
  83     return std::unique_ptr<Derived, Del>(d, std::move(p.get_deleter()));
  84 }
  85
  86 template<typename Derived, typename Base, typename Del>
  87 std::unique_ptr<Derived, Del>
  88 dynamic_unique_ptr_cast( std::unique_ptr<Base, Del>&& p )
  89 {
  90     if(Derived *result = dynamic_cast<Derived *>(p.get())) {
  91         p.release();
  92         return std::unique_ptr<Derived, Del>(result, std::move(p.get_deleter()));
  93     }
  94     return std::unique_ptr<Derived, Del>(nullptr, p.get_deleter());
  95 }
  96
  97 /*Fake bundle resource class for testing*/
  98 class TestBundleResource: public BundleResource
  99 {
 100     public:
 101         virtual void initAttributes() { }
 102
 103         virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr,
 104                                                 const std::map< std::string, std::string > &queryParams)
 105         {
 106             (void)queryParams;
 107             BundleResource::setAttributes(attr);
 108         }
 109
 110         virtual RCSResourceAttributes handleGetAttributesRequest(const
 111                 std::map< std::string, std::string > &queryParams)
 112         {
 113             (void)queryParams;
 114             return BundleResource::getAttributes();
 115         }
 116 };
 117
 118 /*Fake bundle resource class for testing*/
 119 class TestBundleResourceWithAttrs: public BundleResource
 120 {
 121     public:
 122         virtual void initAttributes() {
 123             setAttribute("attrib1", RCSResourceAttributes::Value("test"));
 124             setAttribute("attrib2", RCSResourceAttributes::Value(1));
 125             setAttribute("attrib3", RCSResourceAttributes::Value(true));
 126         }
 127
 128         virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr,
 129                                                 const std::map< std::string, std::string > &queryParams)
 130         {
 131             (void)queryParams;
 132             BundleResource::setAttributes(attr);
 133         }
 134
 135         virtual RCSResourceAttributes handleGetAttributesRequest(const
 136                 std::map< std::string, std::string > &queryParams)
 137         {
 138             (void)queryParams;
 139             return BundleResource::getAttributes();
 140         }
 141 };
 142
 143
 144 /*Fake bundle resource class for testing*/
 145 class TestSoftSensorResource: public SoftSensorResource
 146 {
 147     public:
 148         virtual void initAttributes() {
 149             SoftSensorResource::initAttributes();
 150         }
 151
 152         virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr,
 153                                                 const std::map< std::string, std::string > &queryParams)
 154         {
 155             (void)queryParams;
 156             BundleResource::setAttributes(attr);
 157         }
 158
 159         virtual RCSResourceAttributes handleGetAttributesRequest(const
 160                  std::map< std::string, std::string > &queryParams)
 161         {
 162             (void)queryParams;
 163             return BundleResource::getAttributes();
 164         }
 165
 166         virtual void executeLogic(){
 167
 168         }
 169
 170         virtual void onUpdatedInputResource(
 171                 std::string, std::vector<OIC::Service::RCSResourceAttributes::Value>){
 172
 173         }
 174 };
 175
 176 class ResourceContainerTest: public TestWithMock
 177 {
 178
 179     public:
 180         RCSResourceContainer *m_pResourceContainer;
 181         std::string m_strConfigPath;
 182
 183     protected:
 184         void SetUp()
 185         {
 186             TestWithMock::SetUp();
 187             m_pResourceContainer = RCSResourceContainer::getInstance();
 188             getCurrentPath(&m_strConfigPath);
 189             m_strConfigPath.append("/");
 190             m_strConfigPath.append(CONFIG_FILE);
 191         }
 192 };
 193
 194 TEST_F(ResourceContainerTest, TestBundleResource)
 195 {
 196     TestBundleResourceWithAttrs testResource;
 197     testResource.initAttributes();
 198
 199     // check if initAttributes worked
 200     EXPECT_STREQ("\"test\"", testResource.getAttribute("attrib1").toString().c_str());
 201
 202     std::list<string> attrNames = testResource.getAttributeNames();
 203     ASSERT_TRUE(std::find(attrNames.begin(), attrNames.end(), "attrib1") != attrNames.end());
 204
 205     ASSERT_FALSE(testResource.getAttributes().contains("attrib4"));
 206
 207     testResource.getAttributeNames();
 208
 209     RCSResourceAttributes fullAttributes;
 210     const std::map< std::string, std::string > queryParams = {};
 211
 212     fullAttributes["attrib1"] = "test";
 213     fullAttributes["attrib2"] = 1;
 214     fullAttributes["attrib3"] = true;
 215
 216     testResource.setAttributes(fullAttributes);
 217
 218     ASSERT_TRUE(testResource.getAttributes().contains("attrib1"));
 219
 220     fullAttributes["attrib1"] = "test2";
 221     fullAttributes["attrib2"] = 2;
 222     fullAttributes["attrib3"] = false;
 223
 224     testResource.handleSetAttributesRequest(fullAttributes, queryParams);
 225
 226     EXPECT_EQ((unsigned int) 3, testResource.getAttributeNames().size());
 227
 228     EXPECT_EQ((unsigned int) 3, testResource.handleGetAttributesRequest(queryParams).size());
 229     std::string testString = "test";
 230     testResource.setAttribute("attrib1", RCSResourceAttributes::Value(testString), false);
 231
 232     testResource.setAttributes(fullAttributes, false);
 233
 234     EXPECT_STREQ("\"test2\"", testResource.getAttribute("attrib1").toString().c_str());
 235     EXPECT_EQ(2, testResource.getAttribute("attrib2"));
 236
 237     testResource.setAttribute("attrib1", RCSResourceAttributes::Value("test"));
 238     EXPECT_STREQ("\"test\"", testResource.getAttribute("attrib1").toString().c_str());
 239     EXPECT_EQ(2, testResource.getAttribute("attrib2"));
 240 }
 241
 242 TEST_F(ResourceContainerTest, TestSoftSensorResource)
 243 {
 244     TestSoftSensorResource softSensorResource;
 245     softSensorResource.initAttributes();
 246     EXPECT_EQ((unsigned int) 0, softSensorResource.getAttributeNames().size());
 247 }
 248
 249
 250 TEST_F(ResourceContainerTest, BundleRegisteredWhenContainerStartedWithValidConfigFile)
 251 {
 252     m_pResourceContainer->startContainer(m_strConfigPath);
 253     EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
 254     EXPECT_STREQ("oic.bundle.test",
 255                  (*m_pResourceContainer->listBundles().begin())->getID().c_str());
 256     EXPECT_STREQ("libTestBundle.so",
 257                  (*m_pResourceContainer->listBundles().begin())->getPath().c_str());
 258     EXPECT_STREQ("1.0.0", (*m_pResourceContainer->listBundles().begin())->getVersion().c_str());
 259     m_pResourceContainer->stopContainer();
 260 }
 261
 262 TEST_F(ResourceContainerTest, BundleLoadedWhenContainerStartedWithValidConfigFile)
 263 {
 264     m_pResourceContainer->startContainer(m_strConfigPath);
 265
 266     EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
 267     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 268     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 269     EXPECT_TRUE( firstInternal->isLoaded() );
 270     EXPECT_NE(nullptr,
 271                 firstInternal->getBundleHandle());
 272
 273     m_pResourceContainer->stopContainer();
 274 }
 275
 276 TEST_F(ResourceContainerTest, BundleActivatedWhenContainerStartedWithValidConfigFile)
 277 {
 278     m_pResourceContainer->startContainer(m_strConfigPath);
 279
 280     EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
 281     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 282     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 283     EXPECT_TRUE(firstInternal->isActivated());
 284     EXPECT_NE(nullptr,firstInternal->getBundleActivator());
 285
 286     m_pResourceContainer->stopContainer();
 287 }
 288
 289 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithInvalidConfigFile)
 290 {
 291     m_pResourceContainer->startContainer("invalidConfig");
 292
 293     EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
 294 }
 295
 296 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithEmptyConfigFile)
 297 {
 298     m_pResourceContainer->startContainer("");
 299
 300     EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
 301 }
 302
 303 TEST_F(ResourceContainerTest, BundleUnregisteredWhenContainerStopped)
 304 {
 305     m_pResourceContainer->startContainer(m_strConfigPath);
 306     m_pResourceContainer->stopContainer();
 307
 308     EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
 309 }
 310
 311 TEST_F(ResourceContainerTest, BundleStoppedWithStartBundleAPI)
 312 {
 313     m_pResourceContainer->startContainer(m_strConfigPath);
 314     m_pResourceContainer->stopBundle("oic.bundle.test");
 315
 316     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 317     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 318     EXPECT_FALSE(firstInternal->isActivated());
 319
 320     m_pResourceContainer->stopContainer();
 321 }
 322
 323 TEST_F(ResourceContainerTest, BundleStartedWithStartBundleAPI)
 324 {
 325     m_pResourceContainer->startContainer(m_strConfigPath);
 326     m_pResourceContainer->stopBundle("oic.bundle.test");
 327     m_pResourceContainer->startBundle("oic.bundle.test");
 328     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 329     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 330     EXPECT_TRUE(firstInternal->isActivated());
 331
 332     m_pResourceContainer->stopContainer();
 333 }
 334
 335 TEST_F(ResourceContainerTest, AddNewSoBundleToContainer)
 336 {
 337     std::map<string, string> bundleParams;
 338     std::list<std::unique_ptr<RCSBundleInfo>> bundles;
 339
 340     bundles = m_pResourceContainer->listBundles();
 341     m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
 342
 343     EXPECT_EQ(bundles.size() + 1, m_pResourceContainer->listBundles().size());
 344     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 345     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 346     EXPECT_TRUE(firstInternal->isLoaded());
 347 }
 348
 349 TEST_F(ResourceContainerTest, RemoveSoBundleFromContainer)
 350 {
 351     std::map<string, string> bundleParams;
 352     std::list<std::unique_ptr<RCSBundleInfo>> bundles;
 353
 354     bundles = m_pResourceContainer->listBundles();
 355     m_pResourceContainer->removeBundle("oic.bundle.test");
 356
 357     EXPECT_EQ(bundles.size() - 1, m_pResourceContainer->listBundles().size());
 358 }
 359
 360 TEST_F(ResourceContainerTest, AddBundleAlreadyRegistered)
 361 {
 362     std::map<string, string> bundleParams;
 363     std::list<std::unique_ptr<RCSBundleInfo> > bundles;
 364
 365     m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
 366     bundles = m_pResourceContainer->listBundles();
 367     m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test",  bundleParams);
 368
 369     EXPECT_EQ(bundles.size(), m_pResourceContainer->listBundles().size());
 370 }
 371
 372 TEST_F(ResourceContainerTest, AddAndRemoveSoBundleResource)
 373 {
 374     std::list<string> resources;
 375     std::map<string, string> resourceParams;
 376     resourceParams["resourceType"] = "container.test";
 377
 378     m_pResourceContainer->startContainer(m_strConfigPath);
 379     resources = m_pResourceContainer->listBundleResources("oic.bundle.test");
 380
 381     m_pResourceContainer->addResourceConfig("oic.bundle.test", "/test_resource", resourceParams);
 382
 383     EXPECT_EQ(resources.size() + 1,
 384               m_pResourceContainer->listBundleResources("oic.bundle.test").size());
 385
 386     m_pResourceContainer->removeResourceConfig("oic.bundle.test", "/test_resource");
 387
 388     EXPECT_EQ(resources.size(), m_pResourceContainer->listBundleResources("oic.bundle.test").size());
 389
 390     m_pResourceContainer->stopContainer();
 391 }
 392
 393 TEST_F(ResourceContainerTest, TryAddingSoBundleResourceToNotRegisteredBundle)
 394 {
 395     std::map<string, string> resourceParams;
 396
 397     mocks.NeverCallFunc(ResourceContainerImpl::buildResourceObject);
 398
 399     m_pResourceContainer->addResourceConfig("unvalidBundleId", "", resourceParams);
 400 }
 401
 402 class ResourceContainerBundleAPITest: public TestWithMock
 403 {
 404
 405     public:
 406         RCSResourceObject *m_pResourceObject;
 407         ResourceContainerBundleAPI *m_pResourceContainer;
 408         BundleResource::Ptr m_pBundleResource;
 409         std::string m_strConfigPath;
 410
 411     protected:
 412         void SetUp()
 413         {
 414             TestWithMock::SetUp();
 415             m_pResourceObject = mocks.Mock<RCSResourceObject>();
 416             m_pResourceContainer = ResourceContainerBundleAPI::getInstance();
 417
 418             getCurrentPath(&m_strConfigPath);
 419             m_strConfigPath.append("/");
 420             m_strConfigPath.append(CONFIG_FILE);
 421
 422             m_pBundleResource = std::make_shared< TestBundleResource >();
 423             m_pBundleResource->m_bundleId = "oic.bundle.test";
 424             m_pBundleResource->m_uri = "/test_resource";
 425             m_pBundleResource->m_resourceType = "container.test";
 426             m_pBundleResource->m_interface = "oic.if.baseline";
 427         }
 428 };
 429
 430 TEST_F(ResourceContainerBundleAPITest, ResourceServerCreatedWhenRegisterResourceCalled)
 431 {
 432     m_pBundleResource = std::make_shared< TestBundleResource >();
 433     m_pBundleResource->m_bundleId = "oic.bundle.test";
 434     m_pBundleResource->m_uri = "/test_resource/test";
 435     m_pBundleResource->m_resourceType = "container.test";
 436     m_pBundleResource->m_interface = "oic.if.baseline";
 437
 438     mocks.ExpectCallFunc(ResourceContainerImpl::buildResourceObject).With(m_pBundleResource->m_uri,
 439             m_pBundleResource->m_resourceType, m_pBundleResource->m_interface).Return(nullptr);
 440
 441     m_pResourceContainer->registerResource(m_pBundleResource);
 442 }
 443
 444 TEST_F(ResourceContainerBundleAPITest, RequestHandlerForResourceServerSetWhenRegisterResourceCalled)
 445 {
 446     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 447         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 448     {}));
 449
 450     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
 451     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
 452
 453     m_pResourceContainer->registerResource(m_pBundleResource);
 454
 455     m_pResourceContainer->unregisterResource(m_pBundleResource);
 456 }
 457
 458 TEST_F(ResourceContainerBundleAPITest, BundleResourceUnregisteredWhenUnregisterResourceCalled)
 459 {
 460     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 461         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 462     {}));
 463
 464     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
 465     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
 466
 467     m_pResourceContainer->registerResource(m_pBundleResource);
 468     m_pResourceContainer->unregisterResource(m_pBundleResource);
 469
 470     EXPECT_EQ((unsigned int) 0,
 471               ((ResourceContainerImpl *)m_pResourceContainer)->listBundleResources(
 472                   m_pBundleResource->m_bundleId).size());
 473 }
 474
 475 TEST_F(ResourceContainerBundleAPITest,
 476        ServerNotifiesToObserversWhenNotificationReceivedFromResource)
 477 {
 478     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 479         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 480     {}));
 481
 482     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
 483     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
 484
 485     m_pResourceContainer->registerResource(m_pBundleResource);
 486
 487     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::notify);
 488
 489     m_pResourceContainer->onNotificationReceived(m_pBundleResource->m_uri);
 490
 491     m_pResourceContainer->unregisterResource(m_pBundleResource);
 492 }
 493
 494 TEST_F(ResourceContainerBundleAPITest, BundleConfigurationParsedWithValidBundleId)
 495 {
 496     configInfo bundle;
 497     map< string, string > results;
 498
 499     ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
 500     m_pResourceContainer->getBundleConfiguration("oic.bundle.test", &bundle);
 501
 502     results = *bundle.begin();
 503
 504     EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
 505     EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
 506     EXPECT_STREQ("1.0.0", results["version"].c_str());
 507
 508     ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
 509 }
 510
 511 TEST_F(ResourceContainerBundleAPITest, BundleResourceConfigurationListParsed)
 512 {
 513     vector< resourceInfo > resourceConfig;
 514     resourceInfo result;
 515
 516     ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
 517     m_pResourceContainer->getResourceConfiguration("oic.bundle.test", &resourceConfig);
 518
 519     result = *resourceConfig.begin();
 520
 521     EXPECT_STREQ("test_resource", result.name.c_str());
 522     EXPECT_STREQ("container.test", result.resourceType.c_str());
 523
 524     ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
 525 }
 526
 527 class ResourceContainerImplTest: public TestWithMock
 528 {
 529
 530     public:
 531         ResourceContainerImpl *m_pResourceContainer;
 532         shared_ptr<BundleInfoInternal> m_pBundleInfo;
 533
 534     protected:
 535         void SetUp()
 536         {
 537             TestWithMock::SetUp();
 538             m_pResourceContainer = ResourceContainerImpl::getImplInstance();
 539             m_pBundleInfo = std::make_shared<BundleInfoInternal>();
 540         }
 541
 542         void TearDown()
 543         {
 544             m_pBundleInfo.reset();
 545         }
 546 };
 547
 548
 549 /* Test for Configuration */
 550 TEST(ConfigurationTest, ConfigFileLoadedWithValidPath)
 551 {
 552     std::string strConfigPath;
 553     getCurrentPath(&strConfigPath);
 554     strConfigPath.append("/");
 555     strConfigPath.append(CONFIG_FILE);
 556
 557     Configuration *config = new Configuration(strConfigPath);
 558
 559     EXPECT_TRUE(config->isLoaded());
 560
 561     delete config;
 562 }
 563
 564 TEST(ConfigurationTest, ConfigFileNotLoadedWithInvalidPath)
 565 {
 566     Configuration *config = new Configuration("InvalidPath");
 567
 568     EXPECT_FALSE(config->isLoaded());
 569
 570     delete config;
 571 }
 572
 573 TEST(ConfigurationTest, BundleConfigurationListParsed)
 574 {
 575     std::string strConfigPath;
 576     getCurrentPath(&strConfigPath);
 577     strConfigPath.append("/");
 578     strConfigPath.append(CONFIG_FILE);
 579
 580     Configuration *config = new Configuration(strConfigPath);
 581
 582     configInfo bundles;
 583     map< string, string > results;
 584
 585     config->getConfiguredBundles(&bundles);
 586
 587     results = *bundles.begin();
 588
 589     EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
 590     EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
 591     EXPECT_STREQ("1.0.0", results["version"].c_str());
 592
 593     delete config;
 594 }
 595
 596 TEST(ConfigurationTest, BundleConfigurationParsedWithValidBundleId)
 597 {
 598     std::string strConfigPath;
 599     getCurrentPath(&strConfigPath);
 600     strConfigPath.append("/");
 601     strConfigPath.append(CONFIG_FILE);
 602
 603     Configuration *config = new Configuration(strConfigPath);
 604
 605     configInfo bundle;
 606     map< string, string > results;
 607
 608     config->getBundleConfiguration("oic.bundle.test", &bundle);
 609
 610     results = *bundle.begin();
 611
 612     EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
 613     EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
 614     EXPECT_STREQ("1.0.0", results["version"].c_str());
 615
 616     delete config;
 617 }
 618
 619 TEST(ConfigurationTest, BundleConfigurationNotParsedWithInvalidBundleId)
 620 {
 621     std::string strConfigPath;
 622     getCurrentPath(&strConfigPath);
 623     strConfigPath.append("/");
 624     strConfigPath.append(CONFIG_FILE);
 625
 626     Configuration *config = new Configuration(strConfigPath);
 627
 628     configInfo bundles;
 629     config->getBundleConfiguration("test", &bundles);
 630
 631     EXPECT_TRUE(bundles.empty());
 632
 633     delete config;
 634 }
 635
 636 TEST(ConfigurationTest, BundleResourceConfigurationListParsed)
 637 {
 638     std::string strConfigPath;
 639     getCurrentPath(&strConfigPath);
 640     strConfigPath.append("/");
 641     strConfigPath.append(CONFIG_FILE);
 642
 643     Configuration *config = new Configuration(strConfigPath);
 644
 645     vector< resourceInfo > resourceConfig;
 646     resourceInfo result;
 647
 648     config->getResourceConfiguration("oic.bundle.test", &resourceConfig);
 649
 650     result = *resourceConfig.begin();
 651
 652     EXPECT_STREQ("test_resource", result.name.c_str());
 653     EXPECT_STREQ("container.test", result.resourceType.c_str());
 654
 655     delete config;
 656 }
 657
 658 TEST(ConfigurationTest, BundleResourceConfigurationNotParsedWithInvalidBundleId)
 659 {
 660     std::string strConfigPath;
 661     getCurrentPath(&strConfigPath);
 662     strConfigPath.append("/");
 663     strConfigPath.append(CONFIG_FILE);
 664
 665     Configuration *config = new Configuration(strConfigPath);
 666
 667     configInfo bundles;
 668     vector< resourceInfo > resourceConfig;
 669     config->getResourceConfiguration("test", &resourceConfig);
 670
 671     EXPECT_TRUE(bundles.empty());
 672
 673     delete config;
 674 }
 675
 676 class DiscoverResourceUnitTest: public TestWithMock
 677 {
 678     private:
 679         typedef std::function<void(const std::string attributeName,
 680                                    std::vector<RCSResourceAttributes::Value> values)>
 681         UpdatedCB;
 682     public:
 683         ResourceContainerTestSimulator::Ptr testObject;
 684         DiscoverResourceUnit::Ptr m_pDiscoverResourceUnit;
 685         std::string m_bundleId;
 686         UpdatedCB m_updatedCB;
 687
 688     protected:
 689         void SetUp()
 690         {
 691             TestWithMock::SetUp();
 692
 693             testObject = std::make_shared<ResourceContainerTestSimulator>();
 694             testObject->createResource();
 695             m_bundleId = "/a/TempHumSensor/Container";
 696             m_pDiscoverResourceUnit = std::make_shared< DiscoverResourceUnit >( m_bundleId );
 697             m_updatedCB = ([](const std::string, std::vector< RCSResourceAttributes::Value >) { });
 698         }
 699
 700         void TearDown()
 701         {
 702             m_pDiscoverResourceUnit.reset();
 703             testObject.reset();
 704             TestWithMock::TearDown();
 705         }
 706 };
 707
 708 TEST_F(DiscoverResourceUnitTest, startDiscover)
 709 {
 710     std::string type = "resource.container";
 711     std::string attributeName = "TestResourceContainer";
 712
 713     m_pDiscoverResourceUnit->startDiscover(
 714         DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
 715
 716     std::chrono::milliseconds interval(ResourceContainerTestSimulator::DEFAULT_WAITTIME);
 717     std::this_thread::sleep_for(interval);
 718 }
 719
 720 TEST_F(DiscoverResourceUnitTest, onUpdateCalled)
 721 {
 722     std::string type = "resource.container";
 723     std::string attributeName = "TestResourceContainer";
 724
 725     m_pDiscoverResourceUnit->startDiscover(
 726         DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
 727
 728     std::chrono::milliseconds interval(ResourceContainerTestSimulator::DEFAULT_WAITTIME);
 729     std::this_thread::sleep_for(interval);
 730
 731     testObject->ChangeAttributeValue();
 732 }
 733
 734 namespace
 735 {
 736     void onCacheCB(const RCSResourceAttributes &) { }
 737 }
 738
 739 class RemoteResourceUnitTest: public TestWithMock
 740 {
 741     private:
 742         typedef std::function<void(RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr)>
 743         UpdatedCBFromServer;
 744
 745     public:
 746         ResourceContainerTestSimulator::Ptr testObject;
 747         RemoteResourceUnit::Ptr m_pRemoteResourceUnit;
 748         RCSRemoteResourceObject::Ptr m_pRCSRemoteResourceObject;
 749         UpdatedCBFromServer m_updatedCBFromServer;
 750
 751     protected:
 752         void SetUp()
 753         {
 754             TestWithMock::SetUp();
 755             testObject = std::make_shared<ResourceContainerTestSimulator>();
 756             testObject->defaultRunSimulator();
 757             m_pRCSRemoteResourceObject = testObject->getRemoteResource();
 758             m_updatedCBFromServer = ([](RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr) {});
 759         }
 760
 761         void TearDown()
 762         {
 763             m_pRCSRemoteResourceObject.reset();
 764             testObject.reset();
 765             TestWithMock::TearDown();
 766         }
 767 };
 768
 769 TEST_F(RemoteResourceUnitTest, createRemoteResourceInfo)
 770 {
 771     EXPECT_NE(nullptr, m_pRemoteResourceUnit->createRemoteResourceInfo(m_pRCSRemoteResourceObject,
 772               m_updatedCBFromServer));
 773 }
 774
 775 TEST_F(RemoteResourceUnitTest, getRemoteResourceObject)
 776 {
 777     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 778                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 779     EXPECT_EQ(m_pRCSRemoteResourceObject, ptr->getRemoteResourceObject());
 780 }
 781
 782 TEST_F(RemoteResourceUnitTest, getRemoteResourceUri)
 783 {
 784     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 785                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 786     EXPECT_NE("", ptr->getRemoteResourceUri());
 787 }
 788
 789 TEST_F(RemoteResourceUnitTest, startCaching)
 790 {
 791     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 792                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 793     ptr->startCaching();
 794 }
 795
 796 TEST_F(RemoteResourceUnitTest, startMonitoring)
 797 {
 798     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 799                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 800     ptr->startMonitoring();
 801 }
 802
 803 TEST_F(RemoteResourceUnitTest, onCacheCBCalled)
 804 {
 805     bool isCalled = false;
 806     mocks.ExpectCallFunc(onCacheCB).Do(
 807         [this, &isCalled](const RCSResourceAttributes &)
 808     {
 809         isCalled = true;
 810     });
 811     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfoWithCacheCB(
 812                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer, onCacheCB);
 813     ptr->startCaching();
 814     testObject->ChangeAttributeValue();
 815     EXPECT_TRUE(isCalled);
 816 }