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