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 <algorithm>
  26
  27 #include <UnitTestHelper.h>
  28
  29 #include <gtest/gtest.h>
  30 #include <HippoMocks/hippomocks.h>
  31
  32 #include "RCSResourceContainer.h"
  33 #include "ResourceContainerImpl.h"
  34 #include "SoftSensorResource.h"
  35
  36 #include "RCSResourceObject.h"
  37 #include "RCSRemoteResourceObject.h"
  38
  39 #include "ResourceContainerTestSimulator.h"
  40
  41 using namespace std;
  42 using namespace testing;
  43 using namespace OIC::Service;
  44
  45 #define MAX_PATH 2048
  46
  47 string CONFIG_FILE = "ResourceContainerTestConfig.xml";
  48
  49 void getCurrentPath(std::string *pPath)
  50 {
  51     char buffer[MAX_PATH] = {0,};
  52
  53 #if defined(__linux__)
  54     char *strPath = NULL;
  55     int length = readlink("/proc/self/exe", buffer, MAX_PATH - 1);
  56
  57     if (length != -1)
  58     {
  59         buffer[length] = '\0';
  60         strPath = strrchr(buffer, '/');
  61
  62         if (strPath != NULL)
  63         {
  64             *strPath = '\0';
  65         }
  66     }
  67 #endif
  68     pPath->append(buffer);
  69 }
  70
  71 template<typename Derived, typename Base, typename Del>
  72 std::unique_ptr<Derived, Del>
  73 static_unique_ptr_cast( std::unique_ptr<Base, Del>&& p )
  74 {
  75     auto d = static_cast<Derived *>(p.release());
  76     return std::unique_ptr<Derived, Del>(d, std::move(p.get_deleter()));
  77 }
  78
  79 template<typename Derived, typename Base, typename Del>
  80 std::unique_ptr<Derived, Del>
  81 dynamic_unique_ptr_cast( std::unique_ptr<Base, Del>&& p )
  82 {
  83     if(Derived *result = dynamic_cast<Derived *>(p.get())) {
  84         p.release();
  85         return std::unique_ptr<Derived, Del>(result, std::move(p.get_deleter()));
  86     }
  87     return std::unique_ptr<Derived, Del>(nullptr, p.get_deleter());
  88 }
  89
  90 /*Fake bundle resource class for testing*/
  91 class TestBundleResource: public BundleResource
  92 {
  93     public:
  94         virtual void initAttributes()
  95         {
  96         }
  97
  98         virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr,
  99                                                 const std::map< std::string, std::string > &queryParams)
 100         {
 101             (void)queryParams;
 102             BundleResource::setAttributes(attr);
 103         }
 104
 105         virtual RCSResourceAttributes handleGetAttributesRequest(const
 106                 std::map< std::string, std::string > &queryParams)
 107         {
 108             (void)queryParams;
 109             return BundleResource::getAttributes();
 110         }
 111 };
 112
 113 /*Fake bundle resource class for testing*/
 114 class TestBundleResourceWithAttrs: public BundleResource
 115 {
 116     public:
 117         virtual void initAttributes()
 118         {
 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                                                 const std::map< std::string, std::string > &queryParams)
 126         {
 127             (void)queryParams;
 128             BundleResource::setAttributes(attr);
 129         }
 130
 131         virtual RCSResourceAttributes handleGetAttributesRequest(const
 132                 std::map< std::string, std::string > &queryParams)
 133         {
 134             (void)queryParams;
 135             return BundleResource::getAttributes();
 136         }
 137 };
 138
 139
 140 /*Fake bundle resource class for testing*/
 141 class TestSoftSensorResource: public SoftSensorResource
 142 {
 143     public:
 144         virtual void initAttributes()
 145         {
 146             SoftSensorResource::initAttributes();
 147         }
 148
 149         virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr,
 150                                                 const std::map< std::string, std::string > &queryParams)
 151         {
 152             (void)queryParams;
 153             BundleResource::setAttributes(attr);
 154         }
 155
 156         virtual RCSResourceAttributes handleGetAttributesRequest(const
 157                  std::map< std::string, std::string > &queryParams)
 158         {
 159             (void)queryParams;
 160             return BundleResource::getAttributes();
 161         }
 162
 163         virtual void executeLogic()
 164         {
 165         }
 166
 167         virtual void onUpdatedInputResource(
 168                 std::string, std::vector<OIC::Service::RCSResourceAttributes::Value>)
 169         {
 170         }
 171 };
 172
 173 class ResourceContainerTest: public TestWithMock
 174 {
 175
 176     public:
 177         RCSResourceContainer *m_pResourceContainer;
 178         std::string m_strConfigPath;
 179
 180     protected:
 181         void SetUp()
 182         {
 183             TestWithMock::SetUp();
 184             m_pResourceContainer = RCSResourceContainer::getInstance();
 185             getCurrentPath(&m_strConfigPath);
 186             m_strConfigPath.append("/");
 187             m_strConfigPath.append(CONFIG_FILE);
 188         }
 189 };
 190
 191 TEST_F(ResourceContainerTest, TestBundleResource)
 192 {
 193     TestBundleResourceWithAttrs testResource;
 194     testResource.initAttributes();
 195
 196     // check if initAttributes worked
 197     EXPECT_STREQ("\"test\"", testResource.getAttribute("attrib1").toString().c_str());
 198
 199     std::list<string> attrNames = testResource.getAttributeNames();
 200     ASSERT_TRUE(std::find(attrNames.begin(), attrNames.end(), "attrib1") != attrNames.end());
 201
 202     ASSERT_FALSE(testResource.getAttributes().contains("attrib4"));
 203
 204     testResource.getAttributeNames();
 205
 206     RCSResourceAttributes fullAttributes;
 207     const std::map< std::string, std::string > queryParams = {};
 208
 209     fullAttributes["attrib1"] = "test";
 210     fullAttributes["attrib2"] = 1;
 211     fullAttributes["attrib3"] = true;
 212
 213     testResource.setAttributes(fullAttributes);
 214
 215     ASSERT_TRUE(testResource.getAttributes().contains("attrib1"));
 216
 217     fullAttributes["attrib1"] = "test2";
 218     fullAttributes["attrib2"] = 2;
 219     fullAttributes["attrib3"] = false;
 220
 221     testResource.handleSetAttributesRequest(fullAttributes, queryParams);
 222
 223     EXPECT_EQ((unsigned int) 3, testResource.getAttributeNames().size());
 224
 225     EXPECT_EQ((unsigned int) 3, testResource.handleGetAttributesRequest(queryParams).size());
 226     std::string testString = "test";
 227     testResource.setAttribute("attrib1", RCSResourceAttributes::Value(testString), false);
 228
 229     testResource.setAttributes(fullAttributes, false);
 230
 231     EXPECT_STREQ("\"test2\"", testResource.getAttribute("attrib1").toString().c_str());
 232     EXPECT_EQ(2, testResource.getAttribute("attrib2"));
 233
 234     testResource.setAttribute("attrib1", RCSResourceAttributes::Value("test"));
 235     EXPECT_STREQ("\"test\"", testResource.getAttribute("attrib1").toString().c_str());
 236     EXPECT_EQ(2, testResource.getAttribute("attrib2"));
 237 }
 238
 239 TEST_F(ResourceContainerTest, TestSoftSensorResource)
 240 {
 241     TestSoftSensorResource softSensorResource;
 242     softSensorResource.initAttributes();
 243     EXPECT_EQ((unsigned int) 0, softSensorResource.getAttributeNames().size());
 244 }
 245
 246
 247 TEST_F(ResourceContainerTest, BundleRegisteredWhenContainerStartedWithValidConfigFile)
 248 {
 249     m_pResourceContainer->startContainer(m_strConfigPath);
 250     EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
 251     EXPECT_STREQ("oic.bundle.test",
 252                  (*m_pResourceContainer->listBundles().begin())->getID().c_str());
 253     EXPECT_STREQ("libTestBundle.so",
 254                  (*m_pResourceContainer->listBundles().begin())->getPath().c_str());
 255     EXPECT_STREQ("1.0.0", (*m_pResourceContainer->listBundles().begin())->getVersion().c_str());
 256     m_pResourceContainer->stopContainer();
 257 }
 258
 259 TEST_F(ResourceContainerTest, BundleLoadedWhenContainerStartedWithValidConfigFile)
 260 {
 261     m_pResourceContainer->startContainer(m_strConfigPath);
 262
 263     EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
 264     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 265     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 266     EXPECT_TRUE( firstInternal->isLoaded() );
 267     EXPECT_NE(nullptr,
 268                 firstInternal->getBundleHandle());
 269
 270     m_pResourceContainer->stopContainer();
 271 }
 272
 273 TEST_F(ResourceContainerTest, BundleActivatedWhenContainerStartedWithValidConfigFile)
 274 {
 275     m_pResourceContainer->startContainer(m_strConfigPath);
 276
 277     EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
 278     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 279     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 280     EXPECT_TRUE(firstInternal->isActivated());
 281     EXPECT_NE(nullptr,firstInternal->getBundleActivator());
 282
 283     m_pResourceContainer->stopContainer();
 284 }
 285
 286 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithInvalidConfigFile)
 287 {
 288     m_pResourceContainer->startContainer("invalidConfig");
 289
 290     EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
 291 }
 292
 293 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithEmptyConfigFile)
 294 {
 295     m_pResourceContainer->startContainer("");
 296
 297     EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
 298 }
 299
 300 TEST_F(ResourceContainerTest, BundleUnregisteredWhenContainerStopped)
 301 {
 302     m_pResourceContainer->startContainer(m_strConfigPath);
 303     m_pResourceContainer->stopContainer();
 304
 305     EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
 306 }
 307
 308 TEST_F(ResourceContainerTest, BundleStoppedWithStartBundleAPI)
 309 {
 310     m_pResourceContainer->startContainer(m_strConfigPath);
 311     m_pResourceContainer->stopBundle("oic.bundle.test");
 312
 313     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 314     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 315     EXPECT_FALSE(firstInternal->isActivated());
 316
 317     m_pResourceContainer->stopContainer();
 318 }
 319
 320 TEST_F(ResourceContainerTest, BundleStartedWithStartBundleAPI)
 321 {
 322     m_pResourceContainer->startContainer(m_strConfigPath);
 323     m_pResourceContainer->stopBundle("oic.bundle.test");
 324     m_pResourceContainer->startBundle("oic.bundle.test");
 325     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 326     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 327     EXPECT_TRUE(firstInternal->isActivated());
 328
 329     m_pResourceContainer->stopContainer();
 330 }
 331
 332 TEST_F(ResourceContainerTest, AddNewSoBundleToContainer)
 333 {
 334     std::map<string, string> bundleParams;
 335     std::list<std::unique_ptr<RCSBundleInfo>> bundles;
 336
 337     bundles = m_pResourceContainer->listBundles();
 338     m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
 339
 340     EXPECT_EQ(bundles.size() + 1, m_pResourceContainer->listBundles().size());
 341     unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
 342     unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
 343     EXPECT_TRUE(firstInternal->isLoaded());
 344 }
 345
 346 TEST_F(ResourceContainerTest, RemoveSoBundleFromContainer)
 347 {
 348     std::map<string, string> bundleParams;
 349     std::list<std::unique_ptr<RCSBundleInfo>> bundles;
 350
 351     bundles = m_pResourceContainer->listBundles();
 352     m_pResourceContainer->removeBundle("oic.bundle.test");
 353
 354     EXPECT_EQ(bundles.size() - 1, m_pResourceContainer->listBundles().size());
 355 }
 356
 357 TEST_F(ResourceContainerTest, AddBundleAlreadyRegistered)
 358 {
 359     std::map<string, string> bundleParams;
 360     std::list<std::unique_ptr<RCSBundleInfo> > bundles;
 361
 362     m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
 363     bundles = m_pResourceContainer->listBundles();
 364     m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test",  bundleParams);
 365
 366     EXPECT_EQ(bundles.size(), m_pResourceContainer->listBundles().size());
 367 }
 368
 369 TEST_F(ResourceContainerTest, AddAndRemoveSoBundleResource)
 370 {
 371     std::list<string> resources;
 372     std::map<string, string> resourceParams;
 373     resourceParams["resourceType"] = "container.test";
 374
 375     m_pResourceContainer->startContainer(m_strConfigPath);
 376     resources = m_pResourceContainer->listBundleResources("oic.bundle.test");
 377
 378     m_pResourceContainer->addResourceConfig("oic.bundle.test", "/test_resource", resourceParams);
 379
 380     EXPECT_EQ(resources.size() + 1,
 381               m_pResourceContainer->listBundleResources("oic.bundle.test").size());
 382
 383     m_pResourceContainer->removeResourceConfig("oic.bundle.test", "/test_resource");
 384
 385     EXPECT_EQ(resources.size(), m_pResourceContainer->listBundleResources("oic.bundle.test").size());
 386
 387     m_pResourceContainer->stopContainer();
 388 }
 389
 390 TEST_F(ResourceContainerTest, TryAddingSoBundleResourceToNotRegisteredBundle)
 391 {
 392     std::map<string, string> resourceParams;
 393
 394     mocks.NeverCallFunc(ResourceContainerImpl::buildResourceObject);
 395
 396     m_pResourceContainer->addResourceConfig("unvalidBundleId", "", resourceParams);
 397 }
 398
 399 class ResourceContainerBundleAPITest: public TestWithMock
 400 {
 401
 402     public:
 403         RCSResourceObject *m_pResourceObject;
 404         ResourceContainerBundleAPI *m_pResourceContainer;
 405         BundleResource::Ptr m_pBundleResource;
 406         std::string m_strConfigPath;
 407
 408     protected:
 409         void SetUp()
 410         {
 411             TestWithMock::SetUp();
 412             m_pResourceObject = mocks.Mock<RCSResourceObject>();
 413             m_pResourceContainer = ResourceContainerBundleAPI::getInstance();
 414
 415             getCurrentPath(&m_strConfigPath);
 416             m_strConfigPath.append("/");
 417             m_strConfigPath.append(CONFIG_FILE);
 418
 419             m_pBundleResource = std::make_shared< TestBundleResource >();
 420             m_pBundleResource->m_bundleId = "oic.bundle.test";
 421             m_pBundleResource->m_uri = "/test_resource";
 422             m_pBundleResource->m_resourceType = "container.test";
 423             m_pBundleResource->m_interface = "oic.if.baseline";
 424         }
 425 };
 426
 427 TEST_F(ResourceContainerBundleAPITest, ResourceServerCreatedWhenRegisterResourceCalled)
 428 {
 429     m_pBundleResource = std::make_shared< TestBundleResource >();
 430     m_pBundleResource->m_bundleId = "oic.bundle.test";
 431     m_pBundleResource->m_uri = "/test_resource/test";
 432     m_pBundleResource->m_resourceType = "container.test";
 433     m_pBundleResource->m_interface = "oic.if.baseline";
 434
 435     mocks.ExpectCallFunc(ResourceContainerImpl::buildResourceObject).With(m_pBundleResource->m_uri,
 436             m_pBundleResource->m_resourceType, m_pBundleResource->m_interface).Return(nullptr);
 437
 438     m_pResourceContainer->registerResource(m_pBundleResource);
 439 }
 440
 441 TEST_F(ResourceContainerBundleAPITest, RequestHandlerForResourceServerSetWhenRegisterResourceCalled)
 442 {
 443     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 444         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 445         {
 446         }));
 447
 448     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
 449     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
 450
 451     m_pResourceContainer->registerResource(m_pBundleResource);
 452
 453     m_pResourceContainer->unregisterResource(m_pBundleResource);
 454 }
 455
 456 TEST_F(ResourceContainerBundleAPITest, BundleResourceUnregisteredWhenUnregisterResourceCalled)
 457 {
 458     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 459         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 460         {
 461         }));
 462
 463     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
 464     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
 465
 466     m_pResourceContainer->registerResource(m_pBundleResource);
 467     m_pResourceContainer->unregisterResource(m_pBundleResource);
 468
 469     EXPECT_EQ((unsigned int) 0,
 470               ((ResourceContainerImpl *)m_pResourceContainer)->listBundleResources(
 471                   m_pBundleResource->m_bundleId).size());
 472 }
 473
 474 TEST_F(ResourceContainerBundleAPITest,
 475        ServerNotifiesToObserversWhenNotificationReceivedFromResource)
 476 {
 477     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 478         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 479         {
 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         }
 701
 702         void TearDown()
 703         {
 704             m_pDiscoverResourceUnit.reset();
 705             testObject.reset();
 706             TestWithMock::TearDown();
 707         }
 708 };
 709
 710 TEST_F(DiscoverResourceUnitTest, startDiscover)
 711 {
 712     std::string type = "resource.container";
 713     std::string attributeName = "TestResourceContainer";
 714
 715     m_pDiscoverResourceUnit->startDiscover(
 716         DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
 717
 718     std::chrono::milliseconds interval(ResourceContainerTestSimulator::DEFAULT_WAITTIME);
 719     std::this_thread::sleep_for(interval);
 720 }
 721
 722 TEST_F(DiscoverResourceUnitTest, onUpdateCalled)
 723 {
 724     std::string type = "resource.container";
 725     std::string attributeName = "TestResourceContainer";
 726
 727     m_pDiscoverResourceUnit->startDiscover(
 728         DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
 729
 730     std::chrono::milliseconds interval(ResourceContainerTestSimulator::DEFAULT_WAITTIME);
 731     std::this_thread::sleep_for(interval);
 732
 733     testObject->ChangeAttributeValue();
 734 }
 735
 736 namespace
 737 {
 738     void onCacheCB(const RCSResourceAttributes &, int)
 739     {
 740     }
 741 }
 742
 743 class RemoteResourceUnitTest: public TestWithMock
 744 {
 745     private:
 746         typedef std::function<void(RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr)>
 747         UpdatedCBFromServer;
 748
 749     public:
 750         ResourceContainerTestSimulator::Ptr testObject;
 751         RemoteResourceUnit::Ptr m_pRemoteResourceUnit;
 752         RCSRemoteResourceObject::Ptr m_pRCSRemoteResourceObject;
 753         UpdatedCBFromServer m_updatedCBFromServer;
 754
 755     protected:
 756         void SetUp()
 757         {
 758             TestWithMock::SetUp();
 759             testObject = std::make_shared<ResourceContainerTestSimulator>();
 760             testObject->defaultRunSimulator();
 761             m_pRCSRemoteResourceObject = testObject->getRemoteResource();
 762             m_updatedCBFromServer = ([](RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr)
 763                 {
 764                 });
 765         }
 766
 767         void TearDown()
 768         {
 769             m_pRCSRemoteResourceObject.reset();
 770             testObject.reset();
 771             TestWithMock::TearDown();
 772         }
 773 };
 774
 775 TEST_F(RemoteResourceUnitTest, createRemoteResourceInfo)
 776 {
 777     EXPECT_NE(nullptr, m_pRemoteResourceUnit->createRemoteResourceInfo(m_pRCSRemoteResourceObject,
 778               m_updatedCBFromServer));
 779 }
 780
 781 TEST_F(RemoteResourceUnitTest, getRemoteResourceObject)
 782 {
 783     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 784                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 785     EXPECT_EQ(m_pRCSRemoteResourceObject, ptr->getRemoteResourceObject());
 786 }
 787
 788 TEST_F(RemoteResourceUnitTest, getRemoteResourceUri)
 789 {
 790     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 791                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 792     EXPECT_NE("", ptr->getRemoteResourceUri());
 793 }
 794
 795 TEST_F(RemoteResourceUnitTest, startCaching)
 796 {
 797     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 798                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 799     ptr->startCaching();
 800 }
 801
 802 TEST_F(RemoteResourceUnitTest, startMonitoring)
 803 {
 804     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 805                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 806     ptr->startMonitoring();
 807 }
 808
 809 #ifdef SECURED
 810 TEST_F(RemoteResourceUnitTest, DISABLED_onCacheCBCalled)
 811 #else
 812 TEST_F(RemoteResourceUnitTest, onCacheCBCalled)
 813 #endif
 814 {
 815     bool isCalled = false;
 816     mocks.ExpectCallFunc(onCacheCB).Do(
 817         [this, &isCalled](const RCSResourceAttributes &, int)
 818     {
 819         isCalled = true;
 820     });
 821     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfoWithCacheCB(
 822                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer, onCacheCB);
 823     ptr->startCaching();
 824     testObject->ChangeAttributeValue();
 825     EXPECT_TRUE(isCalled);
 826 }