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         }
 310 };
 311
 312 TEST_F(ResourceContainerBundleAPITest, ResourceServerCreatedWhenRegisterResourceCalled)
 313 {
 314     m_pBundleResource = std::make_shared< TestBundleResource >();
 315     m_pBundleResource->m_bundleId = "oic.bundle.test";
 316     m_pBundleResource->m_uri = "/test_resource/test";
 317     m_pBundleResource->m_resourceType = "container.test";
 318
 319     mocks.ExpectCallFunc(ResourceContainerImpl::buildResourceObject).With(m_pBundleResource->m_uri,
 320             m_pBundleResource->m_resourceType, m_pBundleResource->m_interface).Return(nullptr);
 321
 322     m_pResourceContainer->registerResource(m_pBundleResource);
 323 }
 324
 325 TEST_F(ResourceContainerBundleAPITest, RequestHandlerForResourceServerSetWhenRegisterResourceCalled)
 326 {
 327     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 328         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 329     {}));
 330
 331     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
 332     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
 333
 334     m_pResourceContainer->registerResource(m_pBundleResource);
 335
 336     m_pResourceContainer->unregisterResource(m_pBundleResource);
 337 }
 338
 339 TEST_F(ResourceContainerBundleAPITest, BundleResourceUnregisteredWhenUnregisterResourceCalled)
 340 {
 341     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 342         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 343     {}));
 344
 345     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
 346     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
 347
 348     m_pResourceContainer->registerResource(m_pBundleResource);
 349     m_pResourceContainer->unregisterResource(m_pBundleResource);
 350
 351     EXPECT_EQ((unsigned int) 0,
 352               ((ResourceContainerImpl *)m_pResourceContainer)->listBundleResources(
 353                   m_pBundleResource->m_bundleId).size());
 354 }
 355
 356 TEST_F(ResourceContainerBundleAPITest,
 357        ServerNotifiesToObserversWhenNotificationReceivedFromResource)
 358 {
 359     mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
 360         RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
 361     {}));
 362
 363     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
 364     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
 365
 366     m_pResourceContainer->registerResource(m_pBundleResource);
 367
 368     mocks.ExpectCall(m_pResourceObject, RCSResourceObject::notify);
 369
 370     m_pResourceContainer->onNotificationReceived(m_pBundleResource->m_uri);
 371
 372     m_pResourceContainer->unregisterResource(m_pBundleResource);
 373 }
 374
 375 TEST_F(ResourceContainerBundleAPITest, BundleConfigurationParsedWithValidBundleId)
 376 {
 377     configInfo bundle;
 378     map< string, string > results;
 379
 380     ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
 381     m_pResourceContainer->getBundleConfiguration("oic.bundle.test", &bundle);
 382
 383     results = *bundle.begin();
 384
 385     EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
 386     EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
 387     EXPECT_STREQ("1.0.0", results["version"].c_str());
 388
 389     ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
 390 }
 391
 392 TEST_F(ResourceContainerBundleAPITest, BundleResourceConfigurationListParsed)
 393 {
 394     vector< resourceInfo > resourceConfig;
 395     resourceInfo result;
 396
 397     ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
 398     m_pResourceContainer->getResourceConfiguration("oic.bundle.test", &resourceConfig);
 399
 400     result = *resourceConfig.begin();
 401
 402     EXPECT_STREQ("test_resource", result.name.c_str());
 403     EXPECT_STREQ("container.test", result.resourceType.c_str());
 404
 405     ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
 406 }
 407
 408 class ResourceContainerImplTest: public TestWithMock
 409 {
 410
 411     public:
 412         ResourceContainerImpl *m_pResourceContainer;
 413         BundleInfoInternal *m_pBundleInfo;
 414
 415     protected:
 416         void SetUp()
 417         {
 418             TestWithMock::SetUp();
 419             m_pResourceContainer = ResourceContainerImpl::getImplInstance();
 420             m_pBundleInfo = new BundleInfoInternal();
 421         }
 422
 423         void TearDown()
 424         {
 425             delete m_pBundleInfo;
 426         }
 427 };
 428
 429 TEST_F(ResourceContainerImplTest, SoBundleLoadedWhenRegisteredWithRegisterBundleAPI)
 430 {
 431     m_pBundleInfo->setPath("libTestBundle.so");
 432     m_pBundleInfo->setActivatorName("test");
 433     m_pBundleInfo->setVersion("1.0");
 434     m_pBundleInfo->setLibraryPath(".");
 435     m_pBundleInfo->setID("oic.bundle.test");
 436
 437     m_pResourceContainer->registerBundle(m_pBundleInfo);
 438
 439     EXPECT_NE(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleHandle());
 440 }
 441
 442 #if (JAVA_SUPPORT_TEST)
 443 TEST_F(ResourceContainerImplTest, JavaBundleLoadedWhenRegisteredWithRegisterBundleAPIWrongPath)
 444 {
 445     m_pBundleInfo->setPath("wrong_path.jar");
 446     m_pBundleInfo->setActivatorName("org/iotivity/bundle/hue/HueBundleActivator");
 447     m_pBundleInfo->setLibraryPath("../.");
 448     m_pBundleInfo->setVersion("1.0");
 449     m_pBundleInfo->setID("oic.bundle.java.test");
 450
 451     m_pResourceContainer->registerBundle(m_pBundleInfo);
 452     EXPECT_FALSE(((BundleInfoInternal *)m_pBundleInfo)->isLoaded());
 453 }
 454
 455 TEST_F(ResourceContainerImplTest, JavaBundleTest)
 456 {
 457     m_pBundleInfo->setPath("TestBundleJava/hue-0.1-jar-with-dependencies.jar");
 458     m_pBundleInfo->setActivatorName("org/iotivity/bundle/hue/HueBundleActivator");
 459     m_pBundleInfo->setLibraryPath("../.");
 460     m_pBundleInfo->setVersion("1.0");
 461     m_pBundleInfo->setID("oic.bundle.java.test");
 462
 463     m_pResourceContainer->registerBundle(m_pBundleInfo);
 464     EXPECT_TRUE(((BundleInfoInternal *)m_pBundleInfo)->isLoaded());
 465
 466     m_pResourceContainer->activateBundle(m_pBundleInfo);
 467     EXPECT_TRUE(((BundleInfoInternal *) m_pBundleInfo)->isActivated());
 468
 469     m_pResourceContainer->deactivateBundle(m_pBundleInfo);
 470     EXPECT_FALSE(((BundleInfoInternal *) m_pBundleInfo)->isActivated());
 471 }
 472 #endif
 473
 474 TEST_F(ResourceContainerImplTest, BundleNotRegisteredIfBundlePathIsInvalid)
 475 {
 476     m_pBundleInfo->setPath("");
 477     m_pBundleInfo->setVersion("1.0");
 478     m_pBundleInfo->setLibraryPath("../.");
 479     m_pBundleInfo->setID("oic.bundle.test");
 480
 481     m_pResourceContainer->registerBundle(m_pBundleInfo);
 482
 483     EXPECT_EQ(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleHandle());
 484
 485 }
 486
 487 TEST_F(ResourceContainerImplTest, SoBundleActivatedWithValidBundleInfo)
 488 {
 489     m_pBundleInfo->setPath("libTestBundle.so");
 490     m_pBundleInfo->setVersion("1.0");
 491     m_pBundleInfo->setActivatorName("test");
 492     m_pBundleInfo->setLibraryPath("../.");
 493     m_pBundleInfo->setID("oic.bundle.test");
 494
 495     m_pResourceContainer->registerBundle(m_pBundleInfo);
 496     m_pResourceContainer->activateBundle(m_pBundleInfo);
 497
 498     EXPECT_NE(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleActivator());
 499 }
 500
 501 TEST_F(ResourceContainerImplTest, BundleNotActivatedWhenNotRegistered)
 502 {
 503     m_pBundleInfo->setPath("libTestBundle.so");
 504     m_pBundleInfo->setActivatorName("test");
 505     m_pBundleInfo->setVersion("1.0");
 506     m_pBundleInfo->setLibraryPath("../.");
 507     m_pBundleInfo->setID("oic.bundle.test");
 508
 509     m_pResourceContainer->activateBundle(m_pBundleInfo);
 510
 511     EXPECT_EQ(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleActivator());
 512 }
 513
 514 TEST_F(ResourceContainerImplTest, SoBundleActivatedWithBundleID)
 515 {
 516     m_pBundleInfo->setPath("libTestBundle.so");
 517     m_pBundleInfo->setVersion("1.0");
 518     m_pBundleInfo->setLibraryPath("../.");
 519     m_pBundleInfo->setActivatorName("test");
 520     m_pBundleInfo->setID("oic.bundle.test");
 521
 522     m_pResourceContainer->registerBundle(m_pBundleInfo);
 523     m_pResourceContainer->activateBundle(m_pBundleInfo->getID());
 524
 525     EXPECT_NE(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleActivator());
 526     EXPECT_TRUE(((BundleInfoInternal *)m_pBundleInfo)->isActivated());
 527 }
 528
 529 TEST_F(ResourceContainerImplTest, BundleDeactivatedWithBundleInfo)
 530 {
 531     m_pBundleInfo->setPath("libTestBundle.so");
 532     m_pBundleInfo->setVersion("1.0");
 533     m_pBundleInfo->setLibraryPath("../.");
 534     m_pBundleInfo->setActivatorName("test");
 535     m_pBundleInfo->setID("oic.bundle.test");
 536
 537     m_pResourceContainer->registerBundle(m_pBundleInfo);
 538     m_pResourceContainer->activateBundle(m_pBundleInfo);
 539     m_pResourceContainer->deactivateBundle(m_pBundleInfo);
 540
 541     EXPECT_NE(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleDeactivator());
 542     EXPECT_FALSE(((BundleInfoInternal *)m_pBundleInfo)->isActivated());
 543 }
 544
 545 TEST_F(ResourceContainerImplTest, BundleDeactivatedWithBundleInfoJava)
 546 {
 547     m_pBundleInfo->setPath("TestBundle/hue-0.1-jar-with-dependencies.jar");
 548     m_pBundleInfo->setActivatorName("org/iotivity/bundle/hue/HueBundleActivator");
 549     m_pBundleInfo->setLibraryPath("../.");
 550     m_pBundleInfo->setVersion("1.0");
 551     m_pBundleInfo->setID("oic.bundle.java.test");
 552
 553     m_pResourceContainer->registerBundle(m_pBundleInfo);
 554     m_pResourceContainer->activateBundle(m_pBundleInfo);
 555     m_pResourceContainer->deactivateBundle(m_pBundleInfo);
 556     EXPECT_FALSE(((BundleInfoInternal *) m_pBundleInfo)->isActivated());
 557 }
 558
 559 TEST_F(ResourceContainerImplTest, SoBundleDeactivatedWithBundleID)
 560 {
 561     m_pBundleInfo->setPath("libTestBundle.so");
 562     m_pBundleInfo->setVersion("1.0");
 563     m_pBundleInfo->setLibraryPath("../.");
 564     m_pBundleInfo->setActivatorName("test");
 565     m_pBundleInfo->setID("oic.bundle.test");
 566
 567     m_pResourceContainer->registerBundle(m_pBundleInfo);
 568     m_pResourceContainer->activateBundle(m_pBundleInfo);
 569
 570     m_pResourceContainer->deactivateBundle(m_pBundleInfo->getID());
 571
 572     EXPECT_FALSE(((BundleInfoInternal *)m_pBundleInfo)->isActivated());
 573 }
 574
 575
 576 /* Test for Configuration */
 577 TEST(ConfigurationTest, ConfigFileLoadedWithValidPath)
 578 {
 579     std::string strConfigPath;
 580     getCurrentPath(&strConfigPath);
 581     strConfigPath.append("/");
 582     strConfigPath.append(CONFIG_FILE);
 583
 584     Configuration *config = new Configuration(strConfigPath);
 585
 586     EXPECT_TRUE(config->isLoaded());
 587
 588     delete config;
 589 }
 590
 591 TEST(ConfigurationTest, ConfigFileNotLoadedWithInvalidPath)
 592 {
 593     Configuration *config = new Configuration("InvalidPath");
 594
 595     EXPECT_FALSE(config->isLoaded());
 596
 597     delete config;
 598 }
 599
 600 TEST(ConfigurationTest, BundleConfigurationListParsed)
 601 {
 602     std::string strConfigPath;
 603     getCurrentPath(&strConfigPath);
 604     strConfigPath.append("/");
 605     strConfigPath.append(CONFIG_FILE);
 606
 607     Configuration *config = new Configuration(strConfigPath);
 608
 609     configInfo bundles;
 610     map< string, string > results;
 611
 612     config->getConfiguredBundles(&bundles);
 613
 614     results = *bundles.begin();
 615
 616     EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
 617     EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
 618     EXPECT_STREQ("1.0.0", results["version"].c_str());
 619
 620     delete config;
 621 }
 622
 623 TEST(ConfigurationTest, BundleConfigurationParsedWithValidBundleId)
 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     configInfo bundle;
 633     map< string, string > results;
 634
 635     config->getBundleConfiguration("oic.bundle.test", &bundle);
 636
 637     results = *bundle.begin();
 638
 639     EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
 640     EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
 641     EXPECT_STREQ("1.0.0", results["version"].c_str());
 642
 643     delete config;
 644 }
 645
 646 TEST(ConfigurationTest, BundleConfigurationNotParsedWithInvalidBundleId)
 647 {
 648     std::string strConfigPath;
 649     getCurrentPath(&strConfigPath);
 650     strConfigPath.append("/");
 651     strConfigPath.append(CONFIG_FILE);
 652
 653     Configuration *config = new Configuration(strConfigPath);
 654
 655     configInfo bundles;
 656     config->getBundleConfiguration("test", &bundles);
 657
 658     EXPECT_TRUE(bundles.empty());
 659
 660     delete config;
 661 }
 662
 663 TEST(ConfigurationTest, BundleResourceConfigurationListParsed)
 664 {
 665     std::string strConfigPath;
 666     getCurrentPath(&strConfigPath);
 667     strConfigPath.append("/");
 668     strConfigPath.append(CONFIG_FILE);
 669
 670     Configuration *config = new Configuration(strConfigPath);
 671
 672     vector< resourceInfo > resourceConfig;
 673     resourceInfo result;
 674
 675     config->getResourceConfiguration("oic.bundle.test", &resourceConfig);
 676
 677     result = *resourceConfig.begin();
 678
 679     EXPECT_STREQ("test_resource", result.name.c_str());
 680     EXPECT_STREQ("container.test", result.resourceType.c_str());
 681
 682     delete config;
 683 }
 684
 685 TEST(ConfigurationTest, BundleResourceConfigurationNotParsedWithInvalidBundleId)
 686 {
 687     std::string strConfigPath;
 688     getCurrentPath(&strConfigPath);
 689     strConfigPath.append("/");
 690     strConfigPath.append(CONFIG_FILE);
 691
 692     Configuration *config = new Configuration(strConfigPath);
 693
 694     configInfo bundles;
 695     vector< resourceInfo > resourceConfig;
 696     config->getResourceConfiguration("test", &resourceConfig);
 697
 698     EXPECT_TRUE(bundles.empty());
 699
 700     delete config;
 701 }
 702
 703 class DiscoverResourceUnitTest: public TestWithMock
 704 {
 705     private:
 706         typedef std::function<void(const std::string attributeName,
 707                                    std::vector<RCSResourceAttributes::Value> values)>
 708         UpdatedCB;
 709     public:
 710         ResourceContainerTestSimulator::Ptr testObject;
 711         DiscoverResourceUnit::Ptr m_pDiscoverResourceUnit;
 712         std::string m_bundleId;
 713         UpdatedCB m_updatedCB;
 714
 715     protected:
 716         void SetUp()
 717         {
 718             TestWithMock::SetUp();
 719
 720             testObject = std::make_shared<ResourceContainerTestSimulator>();
 721             testObject->createResource();
 722             m_bundleId = "/a/TempHumSensor/Container";
 723             m_pDiscoverResourceUnit = std::make_shared< DiscoverResourceUnit >( m_bundleId );
 724             m_updatedCB = ([](const std::string, std::vector< RCSResourceAttributes::Value >) { });
 725         }
 726
 727         void TearDown()
 728         {
 729             m_pDiscoverResourceUnit.reset();
 730             testObject.reset();
 731             TestWithMock::TearDown();
 732         }
 733 };
 734
 735 TEST_F(DiscoverResourceUnitTest, startDiscover)
 736 {
 737     std::string type = "Resource.Container";
 738     std::string attributeName = "TestResourceContainer";
 739
 740     m_pDiscoverResourceUnit->startDiscover(
 741         DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
 742
 743     std::chrono::milliseconds interval(400);
 744     std::this_thread::sleep_for(interval);
 745 }
 746
 747 TEST_F(DiscoverResourceUnitTest, onUpdateCalled)
 748 {
 749     std::string type = "Resource.Container";
 750     std::string attributeName = "TestResourceContainer";
 751
 752     m_pDiscoverResourceUnit->startDiscover(
 753         DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
 754
 755     std::chrono::milliseconds interval(400);
 756     std::this_thread::sleep_for(interval);
 757
 758     testObject->ChangeAttributeValue();
 759
 760 }
 761
 762 namespace
 763 {
 764     void onCacheCB(const RCSResourceAttributes &) { }
 765 }
 766
 767 class RemoteResourceUnitTest: public TestWithMock
 768 {
 769     private:
 770         typedef std::function<void(RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr)>
 771         UpdatedCBFromServer;
 772
 773     public:
 774         ResourceContainerTestSimulator::Ptr testObject;
 775         RemoteResourceUnit::Ptr m_pRemoteResourceUnit;
 776         RCSRemoteResourceObject::Ptr m_pRCSRemoteResourceObject;
 777         UpdatedCBFromServer m_updatedCBFromServer;
 778
 779     protected:
 780         void SetUp()
 781         {
 782             TestWithMock::SetUp();
 783
 784             testObject = std::make_shared<ResourceContainerTestSimulator>();
 785             testObject->defaultRunSimulator();
 786             m_pRCSRemoteResourceObject = testObject->getRemoteResource();
 787             m_updatedCBFromServer = ([](RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr) {});
 788         }
 789
 790         void TearDown()
 791         {
 792             m_pRCSRemoteResourceObject.reset();
 793             testObject.reset();
 794             TestWithMock::TearDown();
 795         }
 796 };
 797
 798 TEST_F(RemoteResourceUnitTest, createRemoteResourceInfo)
 799 {
 800     EXPECT_NE(nullptr, m_pRemoteResourceUnit->createRemoteResourceInfo(m_pRCSRemoteResourceObject,
 801               m_updatedCBFromServer));
 802 }
 803
 804 TEST_F(RemoteResourceUnitTest, getRemoteResourceObject)
 805 {
 806     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 807                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 808     EXPECT_EQ(m_pRCSRemoteResourceObject, ptr->getRemoteResourceObject());
 809 }
 810
 811 TEST_F(RemoteResourceUnitTest, getRemoteResourceUri)
 812 {
 813     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 814                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 815     EXPECT_NE("", ptr->getRemoteResourceUri());
 816 }
 817
 818 TEST_F(RemoteResourceUnitTest, startCaching)
 819 {
 820     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 821                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 822     ptr->startCaching();
 823 }
 824
 825 TEST_F(RemoteResourceUnitTest, startMonitoring)
 826 {
 827     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
 828                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer);
 829     ptr->startMonitoring();
 830 }
 831
 832 TEST_F(RemoteResourceUnitTest, onCacheCBCalled)
 833 {
 834     bool isCalled = false;
 835     mocks.ExpectCallFunc(onCacheCB).Do(
 836         [this, &isCalled](const RCSResourceAttributes &)
 837     {
 838         isCalled = true;
 839     });
 840     RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfoWithCacheCB(
 841                                       m_pRCSRemoteResourceObject, m_updatedCBFromServer, onCacheCB);
 842     ptr->startCaching();
 843     testObject->ChangeAttributeValue();
 844     EXPECT_TRUE(isCalled);
 845 }