1 //******************************************************************
3 // Copyright 2015 Samsung Electronics All Rights Reserved.
5 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
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
11 // http://www.apache.org/licenses/LICENSE-2.0
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.
19 //-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
21 #if defined(__linux__)
30 #include <UnitTestHelper.h>
32 #include <gtest/gtest.h>
33 #include <HippoMocks/hippomocks.h>
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"
43 #include "RCSResourceObject.h"
44 #include "RCSRemoteResourceObject.h"
46 #include "ResourceContainerTestSimulator.h"
49 using namespace testing;
50 using namespace OIC::Service;
54 string CONFIG_FILE = "ResourceContainerTestConfig.xml";
56 void getCurrentPath(std::string *pPath)
58 char buffer[MAX_PATH];
60 #if defined(__linux__)
62 int length = readlink("/proc/self/exe", buffer, MAX_PATH - 1);
66 buffer[length] = '\0';
67 strPath = strrchr(buffer, '/');
73 pPath->append(buffer);
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 )
80 auto d = static_cast<Derived *>(p.release());
81 return std::unique_ptr<Derived, Del>(d, std::move(p.get_deleter()));
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 )
88 if(Derived *result = dynamic_cast<Derived *>(p.get())) {
90 return std::unique_ptr<Derived, Del>(result, std::move(p.get_deleter()));
92 return std::unique_ptr<Derived, Del>(nullptr, p.get_deleter());
95 /*Fake bundle resource class for testing*/
96 class TestBundleResource: public BundleResource
99 virtual void initAttributes() { }
101 virtual void handleSetAttributesRequest(RCSResourceAttributes &attr)
103 BundleResource::setAttributes(attr);
106 virtual RCSResourceAttributes &handleGetAttributesRequest()
108 return BundleResource::getAttributes();
112 class ResourceContainerTest: public TestWithMock
116 RCSResourceContainer *m_pResourceContainer;
117 std::string m_strConfigPath;
122 TestWithMock::SetUp();
123 m_pResourceContainer = RCSResourceContainer::getInstance();
124 getCurrentPath(&m_strConfigPath);
125 m_strConfigPath.append("/");
126 m_strConfigPath.append(CONFIG_FILE);
130 TEST_F(ResourceContainerTest, BundleRegisteredWhenContainerStartedWithValidConfigFile)
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());
141 cout << "Now stopping container." << endl;
142 m_pResourceContainer->stopContainer();
145 TEST_F(ResourceContainerTest, BundleLoadedWhenContainerStartedWithValidConfigFile)
147 m_pResourceContainer->startContainer(m_strConfigPath);
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() );
154 firstInternal->getBundleHandle());
156 m_pResourceContainer->stopContainer();
159 TEST_F(ResourceContainerTest, BundleActivatedWhenContainerStartedWithValidConfigFile)
161 m_pResourceContainer->startContainer(m_strConfigPath);
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());
169 m_pResourceContainer->stopContainer();
172 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithInvalidConfigFile)
174 m_pResourceContainer->startContainer("invalidConfig");
176 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
179 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithEmptyConfigFile)
181 m_pResourceContainer->startContainer("");
183 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
186 TEST_F(ResourceContainerTest, BundleUnregisteredWhenContainerStopped)
188 m_pResourceContainer->startContainer(m_strConfigPath);
189 m_pResourceContainer->stopContainer();
191 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
194 TEST_F(ResourceContainerTest, BundleStoppedWithStartBundleAPI)
196 m_pResourceContainer->startContainer(m_strConfigPath);
197 m_pResourceContainer->stopBundle("oic.bundle.test");
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());
203 m_pResourceContainer->stopContainer();
206 TEST_F(ResourceContainerTest, BundleStartedWithStartBundleAPI)
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());
215 m_pResourceContainer->stopContainer();
218 TEST_F(ResourceContainerTest, AddNewSoBundleToContainer)
220 std::map<string, string> bundleParams;
221 std::list<std::unique_ptr<RCSBundleInfo>> bundles;
223 bundles = m_pResourceContainer->listBundles();
224 m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
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());
232 TEST_F(ResourceContainerTest, RemoveSoBundleFromContainer)
234 std::map<string, string> bundleParams;
235 std::list<std::unique_ptr<RCSBundleInfo>> bundles;
237 bundles = m_pResourceContainer->listBundles();
238 m_pResourceContainer->removeBundle("oic.bundle.test");
240 EXPECT_EQ(bundles.size() - 1, m_pResourceContainer->listBundles().size());
243 TEST_F(ResourceContainerTest, AddBundleAlreadyRegistered)
245 std::map<string, string> bundleParams;
246 std::list<std::unique_ptr<RCSBundleInfo> > bundles;
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);
252 EXPECT_EQ(bundles.size(), m_pResourceContainer->listBundles().size());
255 TEST_F(ResourceContainerTest, AddAndRemoveSoBundleResource)
257 std::list<string> resources;
258 std::map<string, string> resourceParams;
259 resourceParams["resourceType"] = "container.test";
261 m_pResourceContainer->startContainer(m_strConfigPath);
262 resources = m_pResourceContainer->listBundleResources("oic.bundle.test");
264 m_pResourceContainer->addResourceConfig("oic.bundle.test", "/test_resource", resourceParams);
266 EXPECT_EQ(resources.size() + 1,
267 m_pResourceContainer->listBundleResources("oic.bundle.test").size());
269 m_pResourceContainer->removeResourceConfig("oic.bundle.test", "/test_resource");
271 EXPECT_EQ(resources.size(), m_pResourceContainer->listBundleResources("oic.bundle.test").size());
273 m_pResourceContainer->stopContainer();
276 TEST_F(ResourceContainerTest, TryAddingSoBundleResourceToNotRegisteredBundle)
278 std::map<string, string> resourceParams;
280 mocks.NeverCallFunc(ResourceContainerImpl::buildResourceObject);
282 m_pResourceContainer->addResourceConfig("unvalidBundleId", "", resourceParams);
285 class ResourceContainerBundleAPITest: public TestWithMock
289 RCSResourceObject *m_pResourceObject;
290 ResourceContainerBundleAPI *m_pResourceContainer;
291 BundleResource::Ptr m_pBundleResource;
292 std::string m_strConfigPath;
297 TestWithMock::SetUp();
298 m_pResourceObject = mocks.Mock<RCSResourceObject>();
299 m_pResourceContainer = ResourceContainerBundleAPI::getInstance();
301 getCurrentPath(&m_strConfigPath);
302 m_strConfigPath.append("/");
303 m_strConfigPath.append(CONFIG_FILE);
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";
312 TEST_F(ResourceContainerBundleAPITest, ResourceServerCreatedWhenRegisterResourceCalled)
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";
319 mocks.ExpectCallFunc(ResourceContainerImpl::buildResourceObject).With(m_pBundleResource->m_uri,
320 m_pBundleResource->m_resourceType).Return(nullptr);
322 m_pResourceContainer->registerResource(m_pBundleResource);
325 TEST_F(ResourceContainerBundleAPITest, RequestHandlerForResourceServerSetWhenRegisterResourceCalled)
327 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
328 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
331 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
332 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
334 m_pResourceContainer->registerResource(m_pBundleResource);
336 m_pResourceContainer->unregisterResource(m_pBundleResource);
339 TEST_F(ResourceContainerBundleAPITest, BundleResourceUnregisteredWhenUnregisterResourceCalled)
341 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
342 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
345 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
346 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
348 m_pResourceContainer->registerResource(m_pBundleResource);
349 m_pResourceContainer->unregisterResource(m_pBundleResource);
351 EXPECT_EQ((unsigned int) 0,
352 ((ResourceContainerImpl *)m_pResourceContainer)->listBundleResources(
353 m_pBundleResource->m_bundleId).size());
356 TEST_F(ResourceContainerBundleAPITest,
357 ServerNotifiesToObserversWhenNotificationReceivedFromResource)
359 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
360 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
363 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
364 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
366 m_pResourceContainer->registerResource(m_pBundleResource);
368 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::notify);
370 m_pResourceContainer->onNotificationReceived(m_pBundleResource->m_uri);
372 m_pResourceContainer->unregisterResource(m_pBundleResource);
375 TEST_F(ResourceContainerBundleAPITest, BundleConfigurationParsedWithValidBundleId)
378 map< string, string > results;
380 ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
381 m_pResourceContainer->getBundleConfiguration("oic.bundle.test", &bundle);
383 results = *bundle.begin();
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());
389 ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
392 TEST_F(ResourceContainerBundleAPITest, BundleResourceConfigurationListParsed)
394 vector< resourceInfo > resourceConfig;
397 ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
398 m_pResourceContainer->getResourceConfiguration("oic.bundle.test", &resourceConfig);
400 result = *resourceConfig.begin();
402 EXPECT_STREQ("test_resource", result.name.c_str());
403 EXPECT_STREQ("container.test", result.resourceType.c_str());
405 ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
408 class ResourceContainerImplTest: public TestWithMock
412 ResourceContainerImpl *m_pResourceContainer;
413 BundleInfoInternal *m_pBundleInfo;
418 TestWithMock::SetUp();
419 m_pResourceContainer = ResourceContainerImpl::getImplInstance();
420 m_pBundleInfo = new BundleInfoInternal();
425 delete m_pBundleInfo;
429 TEST_F(ResourceContainerImplTest, SoBundleLoadedWhenRegisteredWithRegisterBundleAPI)
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");
437 m_pResourceContainer->registerBundle(m_pBundleInfo);
439 EXPECT_NE(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleHandle());
442 #if (JAVA_SUPPORT_TEST)
443 TEST_F(ResourceContainerImplTest, JavaBundleLoadedWhenRegisteredWithRegisterBundleAPIWrongPath)
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");
451 m_pResourceContainer->registerBundle(m_pBundleInfo);
452 EXPECT_FALSE(((BundleInfoInternal *)m_pBundleInfo)->isLoaded());
455 TEST_F(ResourceContainerImplTest, JavaBundleTest)
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");
463 m_pResourceContainer->registerBundle(m_pBundleInfo);
464 EXPECT_TRUE(((BundleInfoInternal *)m_pBundleInfo)->isLoaded());
466 m_pResourceContainer->activateBundle(m_pBundleInfo);
467 EXPECT_TRUE(((BundleInfoInternal *) m_pBundleInfo)->isActivated());
469 m_pResourceContainer->deactivateBundle(m_pBundleInfo);
470 EXPECT_FALSE(((BundleInfoInternal *) m_pBundleInfo)->isActivated());
474 TEST_F(ResourceContainerImplTest, BundleNotRegisteredIfBundlePathIsInvalid)
476 m_pBundleInfo->setPath("");
477 m_pBundleInfo->setVersion("1.0");
478 m_pBundleInfo->setLibraryPath("../.");
479 m_pBundleInfo->setID("oic.bundle.test");
481 m_pResourceContainer->registerBundle(m_pBundleInfo);
483 EXPECT_EQ(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleHandle());
487 TEST_F(ResourceContainerImplTest, SoBundleActivatedWithValidBundleInfo)
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");
495 m_pResourceContainer->registerBundle(m_pBundleInfo);
496 m_pResourceContainer->activateBundle(m_pBundleInfo);
498 EXPECT_NE(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleActivator());
501 TEST_F(ResourceContainerImplTest, BundleNotActivatedWhenNotRegistered)
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");
509 m_pResourceContainer->activateBundle(m_pBundleInfo);
511 EXPECT_EQ(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleActivator());
514 TEST_F(ResourceContainerImplTest, SoBundleActivatedWithBundleID)
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");
522 m_pResourceContainer->registerBundle(m_pBundleInfo);
523 m_pResourceContainer->activateBundle(m_pBundleInfo->getID());
525 EXPECT_NE(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleActivator());
526 EXPECT_TRUE(((BundleInfoInternal *)m_pBundleInfo)->isActivated());
529 TEST_F(ResourceContainerImplTest, BundleDeactivatedWithBundleInfo)
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");
537 m_pResourceContainer->registerBundle(m_pBundleInfo);
538 m_pResourceContainer->activateBundle(m_pBundleInfo);
539 m_pResourceContainer->deactivateBundle(m_pBundleInfo);
541 EXPECT_NE(nullptr, ((BundleInfoInternal *)m_pBundleInfo)->getBundleDeactivator());
542 EXPECT_FALSE(((BundleInfoInternal *)m_pBundleInfo)->isActivated());
545 TEST_F(ResourceContainerImplTest, BundleDeactivatedWithBundleInfoJava)
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");
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());
559 TEST_F(ResourceContainerImplTest, SoBundleDeactivatedWithBundleID)
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");
567 m_pResourceContainer->registerBundle(m_pBundleInfo);
568 m_pResourceContainer->activateBundle(m_pBundleInfo);
570 m_pResourceContainer->deactivateBundle(m_pBundleInfo->getID());
572 EXPECT_FALSE(((BundleInfoInternal *)m_pBundleInfo)->isActivated());
576 /* Test for Configuration */
577 TEST(ConfigurationTest, ConfigFileLoadedWithValidPath)
579 std::string strConfigPath;
580 getCurrentPath(&strConfigPath);
581 strConfigPath.append("/");
582 strConfigPath.append(CONFIG_FILE);
584 Configuration *config = new Configuration(strConfigPath);
586 EXPECT_TRUE(config->isLoaded());
591 TEST(ConfigurationTest, ConfigFileNotLoadedWithInvalidPath)
593 Configuration *config = new Configuration("InvalidPath");
595 EXPECT_FALSE(config->isLoaded());
600 TEST(ConfigurationTest, BundleConfigurationListParsed)
602 std::string strConfigPath;
603 getCurrentPath(&strConfigPath);
604 strConfigPath.append("/");
605 strConfigPath.append(CONFIG_FILE);
607 Configuration *config = new Configuration(strConfigPath);
610 map< string, string > results;
612 config->getConfiguredBundles(&bundles);
614 results = *bundles.begin();
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());
623 TEST(ConfigurationTest, BundleConfigurationParsedWithValidBundleId)
625 std::string strConfigPath;
626 getCurrentPath(&strConfigPath);
627 strConfigPath.append("/");
628 strConfigPath.append(CONFIG_FILE);
630 Configuration *config = new Configuration(strConfigPath);
633 map< string, string > results;
635 config->getBundleConfiguration("oic.bundle.test", &bundle);
637 results = *bundle.begin();
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());
646 TEST(ConfigurationTest, BundleConfigurationNotParsedWithInvalidBundleId)
648 std::string strConfigPath;
649 getCurrentPath(&strConfigPath);
650 strConfigPath.append("/");
651 strConfigPath.append(CONFIG_FILE);
653 Configuration *config = new Configuration(strConfigPath);
656 config->getBundleConfiguration("test", &bundles);
658 EXPECT_TRUE(bundles.empty());
663 TEST(ConfigurationTest, BundleResourceConfigurationListParsed)
665 std::string strConfigPath;
666 getCurrentPath(&strConfigPath);
667 strConfigPath.append("/");
668 strConfigPath.append(CONFIG_FILE);
670 Configuration *config = new Configuration(strConfigPath);
672 vector< resourceInfo > resourceConfig;
675 config->getResourceConfiguration("oic.bundle.test", &resourceConfig);
677 result = *resourceConfig.begin();
679 EXPECT_STREQ("test_resource", result.name.c_str());
680 EXPECT_STREQ("container.test", result.resourceType.c_str());
685 TEST(ConfigurationTest, BundleResourceConfigurationNotParsedWithInvalidBundleId)
687 std::string strConfigPath;
688 getCurrentPath(&strConfigPath);
689 strConfigPath.append("/");
690 strConfigPath.append(CONFIG_FILE);
692 Configuration *config = new Configuration(strConfigPath);
695 vector< resourceInfo > resourceConfig;
696 config->getResourceConfiguration("test", &resourceConfig);
698 EXPECT_TRUE(bundles.empty());
705 void discoverdCB(RCSRemoteResourceObject::Ptr);
706 void onUpdate(RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr);
709 class DiscoverResourceUnitTest: public TestWithMock
712 typedef std::function<void(const std::string attributeName,
713 std::vector<RCSResourceAttributes::Value> values)>
716 ResourceContainerTestSimulator::Ptr testObject;
717 DiscoverResourceUnit::Ptr m_pDiscoverResourceUnit;
718 std::string m_bundleId;
719 UpdatedCB m_updatedCB;
724 TestWithMock::SetUp();
726 testObject = std::make_shared<ResourceContainerTestSimulator>();
727 testObject->createResource();
728 m_bundleId = "/a/TempHumSensor/Container";
729 m_pDiscoverResourceUnit = std::make_shared< DiscoverResourceUnit >( m_bundleId );
730 m_updatedCB = ([](const std::string, std::vector< RCSResourceAttributes::Value >) { });
735 m_pDiscoverResourceUnit.reset();
737 TestWithMock::TearDown();
741 TEST_F(DiscoverResourceUnitTest, startDiscover)
743 std::string type = "Resource.Container";
744 std::string attributeName = "TestResourceContainer";
746 m_pDiscoverResourceUnit->startDiscover(
747 DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
749 std::chrono::milliseconds interval(400);
750 std::this_thread::sleep_for(interval);
753 TEST_F(DiscoverResourceUnitTest, onUpdateCalled)
755 std::string type = "Resource.Container";
756 std::string attributeName = "TestResourceContainer";
758 m_pDiscoverResourceUnit->startDiscover(
759 DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
761 std::chrono::milliseconds interval(400);
762 std::this_thread::sleep_for(interval);
764 testObject->ChangeAttributeValue();
770 void onStateCB(ResourceState) { }
771 void onCacheCB(const RCSResourceAttributes &) { }
774 class RemoteResourceUnitTest: public TestWithMock
777 typedef std::function<void(RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr)>
781 ResourceContainerTestSimulator::Ptr testObject;
782 RemoteResourceUnit::Ptr m_pRemoteResourceUnit;
783 RCSRemoteResourceObject::Ptr m_pRCSRemoteResourceObject;
784 UpdatedCBFromServer m_updatedCBFromServer;
789 TestWithMock::SetUp();
791 testObject = std::make_shared<ResourceContainerTestSimulator>();
792 testObject->defaultRunSimulator();
793 m_pRCSRemoteResourceObject = testObject->getRemoteResource();
794 m_updatedCBFromServer = ([](RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr) {});
799 m_pRCSRemoteResourceObject.reset();
801 TestWithMock::TearDown();
805 TEST_F(RemoteResourceUnitTest, createRemoteResourceInfo)
807 EXPECT_NE(nullptr, m_pRemoteResourceUnit->createRemoteResourceInfo(m_pRCSRemoteResourceObject,
808 m_updatedCBFromServer));
811 TEST_F(RemoteResourceUnitTest, getRemoteResourceObject)
813 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
814 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
815 EXPECT_EQ(m_pRCSRemoteResourceObject, ptr->getRemoteResourceObject());
818 TEST_F(RemoteResourceUnitTest, getRemoteResourceUri)
820 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
821 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
822 EXPECT_NE("", ptr->getRemoteResourceUri());
825 TEST_F(RemoteResourceUnitTest, startCaching)
827 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
828 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
832 TEST_F(RemoteResourceUnitTest, startMonitoring)
834 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
835 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
836 ptr->startMonitoring();
839 TEST_F(RemoteResourceUnitTest, onCacheCBCalled)
841 bool isCalled = false;
842 mocks.ExpectCallFunc(onCacheCB).Do(
843 [this, &isCalled](const RCSResourceAttributes &)
847 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfoWithCacheCB(
848 m_pRCSRemoteResourceObject, m_updatedCBFromServer, onCacheCB);
850 testObject->ChangeAttributeValue();
851 EXPECT_TRUE(isCalled);