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