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__)
27 #include <UnitTestHelper.h>
29 #include <gtest/gtest.h>
30 #include <HippoMocks/hippomocks.h>
32 #include "RCSResourceContainer.h"
33 #include "ResourceContainerImpl.h"
34 #include "SoftSensorResource.h"
36 #include "RCSResourceObject.h"
37 #include "RCSRemoteResourceObject.h"
39 #include "ResourceContainerTestSimulator.h"
42 using namespace testing;
43 using namespace OIC::Service;
47 string CONFIG_FILE = "ResourceContainerTestConfig.xml";
49 void getCurrentPath(std::string *pPath)
51 char buffer[MAX_PATH];
53 #if defined(__linux__)
55 int length = readlink("/proc/self/exe", buffer, MAX_PATH - 1);
59 buffer[length] = '\0';
60 strPath = strrchr(buffer, '/');
68 pPath->append(buffer);
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 )
75 auto d = static_cast<Derived *>(p.release());
76 return std::unique_ptr<Derived, Del>(d, std::move(p.get_deleter()));
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 )
83 if(Derived *result = dynamic_cast<Derived *>(p.get())) {
85 return std::unique_ptr<Derived, Del>(result, std::move(p.get_deleter()));
87 return std::unique_ptr<Derived, Del>(nullptr, p.get_deleter());
90 /*Fake bundle resource class for testing*/
91 class TestBundleResource: public BundleResource
94 virtual void initAttributes()
98 virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr,
99 const std::map< std::string, std::string > &queryParams)
102 BundleResource::setAttributes(attr);
105 virtual RCSResourceAttributes handleGetAttributesRequest(const
106 std::map< std::string, std::string > &queryParams)
109 return BundleResource::getAttributes();
113 /*Fake bundle resource class for testing*/
114 class TestBundleResourceWithAttrs: public BundleResource
117 virtual void initAttributes()
119 setAttribute("attrib1", RCSResourceAttributes::Value("test"));
120 setAttribute("attrib2", RCSResourceAttributes::Value(1));
121 setAttribute("attrib3", RCSResourceAttributes::Value(true));
124 virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr,
125 const std::map< std::string, std::string > &queryParams)
128 BundleResource::setAttributes(attr);
131 virtual RCSResourceAttributes handleGetAttributesRequest(const
132 std::map< std::string, std::string > &queryParams)
135 return BundleResource::getAttributes();
140 /*Fake bundle resource class for testing*/
141 class TestSoftSensorResource: public SoftSensorResource
144 virtual void initAttributes()
146 SoftSensorResource::initAttributes();
149 virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr,
150 const std::map< std::string, std::string > &queryParams)
153 BundleResource::setAttributes(attr);
156 virtual RCSResourceAttributes handleGetAttributesRequest(const
157 std::map< std::string, std::string > &queryParams)
160 return BundleResource::getAttributes();
163 virtual void executeLogic()
167 virtual void onUpdatedInputResource(
168 std::string, std::vector<OIC::Service::RCSResourceAttributes::Value>)
173 class ResourceContainerTest: public TestWithMock
177 RCSResourceContainer *m_pResourceContainer;
178 std::string m_strConfigPath;
183 TestWithMock::SetUp();
184 m_pResourceContainer = RCSResourceContainer::getInstance();
185 getCurrentPath(&m_strConfigPath);
186 m_strConfigPath.append("/");
187 m_strConfigPath.append(CONFIG_FILE);
191 TEST_F(ResourceContainerTest, TestBundleResource)
193 TestBundleResourceWithAttrs testResource;
194 testResource.initAttributes();
196 // check if initAttributes worked
197 EXPECT_STREQ("\"test\"", testResource.getAttribute("attrib1").toString().c_str());
199 std::list<string> attrNames = testResource.getAttributeNames();
200 ASSERT_TRUE(std::find(attrNames.begin(), attrNames.end(), "attrib1") != attrNames.end());
202 ASSERT_FALSE(testResource.getAttributes().contains("attrib4"));
204 testResource.getAttributeNames();
206 RCSResourceAttributes fullAttributes;
207 const std::map< std::string, std::string > queryParams = {};
209 fullAttributes["attrib1"] = "test";
210 fullAttributes["attrib2"] = 1;
211 fullAttributes["attrib3"] = true;
213 testResource.setAttributes(fullAttributes);
215 ASSERT_TRUE(testResource.getAttributes().contains("attrib1"));
217 fullAttributes["attrib1"] = "test2";
218 fullAttributes["attrib2"] = 2;
219 fullAttributes["attrib3"] = false;
221 testResource.handleSetAttributesRequest(fullAttributes, queryParams);
223 EXPECT_EQ((unsigned int) 3, testResource.getAttributeNames().size());
225 EXPECT_EQ((unsigned int) 3, testResource.handleGetAttributesRequest(queryParams).size());
226 std::string testString = "test";
227 testResource.setAttribute("attrib1", RCSResourceAttributes::Value(testString), false);
229 testResource.setAttributes(fullAttributes, false);
231 EXPECT_STREQ("\"test2\"", testResource.getAttribute("attrib1").toString().c_str());
232 EXPECT_EQ(2, testResource.getAttribute("attrib2"));
234 testResource.setAttribute("attrib1", RCSResourceAttributes::Value("test"));
235 EXPECT_STREQ("\"test\"", testResource.getAttribute("attrib1").toString().c_str());
236 EXPECT_EQ(2, testResource.getAttribute("attrib2"));
239 TEST_F(ResourceContainerTest, TestSoftSensorResource)
241 TestSoftSensorResource softSensorResource;
242 softSensorResource.initAttributes();
243 EXPECT_EQ((unsigned int) 0, softSensorResource.getAttributeNames().size());
247 TEST_F(ResourceContainerTest, BundleRegisteredWhenContainerStartedWithValidConfigFile)
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();
259 TEST_F(ResourceContainerTest, BundleLoadedWhenContainerStartedWithValidConfigFile)
261 m_pResourceContainer->startContainer(m_strConfigPath);
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() );
268 firstInternal->getBundleHandle());
270 m_pResourceContainer->stopContainer();
273 TEST_F(ResourceContainerTest, BundleActivatedWhenContainerStartedWithValidConfigFile)
275 m_pResourceContainer->startContainer(m_strConfigPath);
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());
283 m_pResourceContainer->stopContainer();
286 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithInvalidConfigFile)
288 m_pResourceContainer->startContainer("invalidConfig");
290 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
293 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithEmptyConfigFile)
295 m_pResourceContainer->startContainer("");
297 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
300 TEST_F(ResourceContainerTest, BundleUnregisteredWhenContainerStopped)
302 m_pResourceContainer->startContainer(m_strConfigPath);
303 m_pResourceContainer->stopContainer();
305 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
308 TEST_F(ResourceContainerTest, BundleStoppedWithStartBundleAPI)
310 m_pResourceContainer->startContainer(m_strConfigPath);
311 m_pResourceContainer->stopBundle("oic.bundle.test");
313 unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
314 unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
315 EXPECT_FALSE(firstInternal->isActivated());
317 m_pResourceContainer->stopContainer();
320 TEST_F(ResourceContainerTest, BundleStartedWithStartBundleAPI)
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());
329 m_pResourceContainer->stopContainer();
332 TEST_F(ResourceContainerTest, AddNewSoBundleToContainer)
334 std::map<string, string> bundleParams;
335 std::list<std::unique_ptr<RCSBundleInfo>> bundles;
337 bundles = m_pResourceContainer->listBundles();
338 m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
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());
346 TEST_F(ResourceContainerTest, RemoveSoBundleFromContainer)
348 std::map<string, string> bundleParams;
349 std::list<std::unique_ptr<RCSBundleInfo>> bundles;
351 bundles = m_pResourceContainer->listBundles();
352 m_pResourceContainer->removeBundle("oic.bundle.test");
354 EXPECT_EQ(bundles.size() - 1, m_pResourceContainer->listBundles().size());
357 TEST_F(ResourceContainerTest, AddBundleAlreadyRegistered)
359 std::map<string, string> bundleParams;
360 std::list<std::unique_ptr<RCSBundleInfo> > bundles;
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);
366 EXPECT_EQ(bundles.size(), m_pResourceContainer->listBundles().size());
369 TEST_F(ResourceContainerTest, AddAndRemoveSoBundleResource)
371 std::list<string> resources;
372 std::map<string, string> resourceParams;
373 resourceParams["resourceType"] = "container.test";
375 m_pResourceContainer->startContainer(m_strConfigPath);
376 resources = m_pResourceContainer->listBundleResources("oic.bundle.test");
378 m_pResourceContainer->addResourceConfig("oic.bundle.test", "/test_resource", resourceParams);
380 EXPECT_EQ(resources.size() + 1,
381 m_pResourceContainer->listBundleResources("oic.bundle.test").size());
383 m_pResourceContainer->removeResourceConfig("oic.bundle.test", "/test_resource");
385 EXPECT_EQ(resources.size(), m_pResourceContainer->listBundleResources("oic.bundle.test").size());
387 m_pResourceContainer->stopContainer();
390 TEST_F(ResourceContainerTest, TryAddingSoBundleResourceToNotRegisteredBundle)
392 std::map<string, string> resourceParams;
394 mocks.NeverCallFunc(ResourceContainerImpl::buildResourceObject);
396 m_pResourceContainer->addResourceConfig("unvalidBundleId", "", resourceParams);
399 class ResourceContainerBundleAPITest: public TestWithMock
403 RCSResourceObject *m_pResourceObject;
404 ResourceContainerBundleAPI *m_pResourceContainer;
405 BundleResource::Ptr m_pBundleResource;
406 std::string m_strConfigPath;
411 TestWithMock::SetUp();
412 m_pResourceObject = mocks.Mock<RCSResourceObject>();
413 m_pResourceContainer = ResourceContainerBundleAPI::getInstance();
415 getCurrentPath(&m_strConfigPath);
416 m_strConfigPath.append("/");
417 m_strConfigPath.append(CONFIG_FILE);
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";
427 TEST_F(ResourceContainerBundleAPITest, ResourceServerCreatedWhenRegisterResourceCalled)
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";
435 mocks.ExpectCallFunc(ResourceContainerImpl::buildResourceObject).With(m_pBundleResource->m_uri,
436 m_pBundleResource->m_resourceType, m_pBundleResource->m_interface).Return(nullptr);
438 m_pResourceContainer->registerResource(m_pBundleResource);
441 TEST_F(ResourceContainerBundleAPITest, RequestHandlerForResourceServerSetWhenRegisterResourceCalled)
443 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
444 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
448 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
449 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
451 m_pResourceContainer->registerResource(m_pBundleResource);
453 m_pResourceContainer->unregisterResource(m_pBundleResource);
456 TEST_F(ResourceContainerBundleAPITest, BundleResourceUnregisteredWhenUnregisterResourceCalled)
458 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
459 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
463 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
464 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
466 m_pResourceContainer->registerResource(m_pBundleResource);
467 m_pResourceContainer->unregisterResource(m_pBundleResource);
469 EXPECT_EQ((unsigned int) 0,
470 ((ResourceContainerImpl *)m_pResourceContainer)->listBundleResources(
471 m_pBundleResource->m_bundleId).size());
474 TEST_F(ResourceContainerBundleAPITest,
475 ServerNotifiesToObserversWhenNotificationReceivedFromResource)
477 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
478 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
482 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
483 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
485 m_pResourceContainer->registerResource(m_pBundleResource);
487 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::notify);
489 m_pResourceContainer->onNotificationReceived(m_pBundleResource->m_uri);
491 m_pResourceContainer->unregisterResource(m_pBundleResource);
494 TEST_F(ResourceContainerBundleAPITest, BundleConfigurationParsedWithValidBundleId)
497 map< string, string > results;
499 ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
500 m_pResourceContainer->getBundleConfiguration("oic.bundle.test", &bundle);
502 results = *bundle.begin();
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());
508 ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
511 TEST_F(ResourceContainerBundleAPITest, BundleResourceConfigurationListParsed)
513 vector< resourceInfo > resourceConfig;
516 ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
517 m_pResourceContainer->getResourceConfiguration("oic.bundle.test", &resourceConfig);
519 result = *resourceConfig.begin();
521 EXPECT_STREQ("test_resource", result.name.c_str());
522 EXPECT_STREQ("container.test", result.resourceType.c_str());
524 ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
527 class ResourceContainerImplTest: public TestWithMock
531 ResourceContainerImpl *m_pResourceContainer;
532 shared_ptr<BundleInfoInternal> m_pBundleInfo;
537 TestWithMock::SetUp();
538 m_pResourceContainer = ResourceContainerImpl::getImplInstance();
539 m_pBundleInfo = std::make_shared<BundleInfoInternal>();
544 m_pBundleInfo.reset();
549 /* Test for Configuration */
550 TEST(ConfigurationTest, ConfigFileLoadedWithValidPath)
552 std::string strConfigPath;
553 getCurrentPath(&strConfigPath);
554 strConfigPath.append("/");
555 strConfigPath.append(CONFIG_FILE);
557 Configuration *config = new Configuration(strConfigPath);
559 EXPECT_TRUE(config->isLoaded());
564 TEST(ConfigurationTest, ConfigFileNotLoadedWithInvalidPath)
566 Configuration *config = new Configuration("InvalidPath");
568 EXPECT_FALSE(config->isLoaded());
573 TEST(ConfigurationTest, BundleConfigurationListParsed)
575 std::string strConfigPath;
576 getCurrentPath(&strConfigPath);
577 strConfigPath.append("/");
578 strConfigPath.append(CONFIG_FILE);
580 Configuration *config = new Configuration(strConfigPath);
583 map< string, string > results;
585 config->getConfiguredBundles(&bundles);
587 results = *bundles.begin();
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());
596 TEST(ConfigurationTest, BundleConfigurationParsedWithValidBundleId)
598 std::string strConfigPath;
599 getCurrentPath(&strConfigPath);
600 strConfigPath.append("/");
601 strConfigPath.append(CONFIG_FILE);
603 Configuration *config = new Configuration(strConfigPath);
606 map< string, string > results;
608 config->getBundleConfiguration("oic.bundle.test", &bundle);
610 results = *bundle.begin();
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());
619 TEST(ConfigurationTest, BundleConfigurationNotParsedWithInvalidBundleId)
621 std::string strConfigPath;
622 getCurrentPath(&strConfigPath);
623 strConfigPath.append("/");
624 strConfigPath.append(CONFIG_FILE);
626 Configuration *config = new Configuration(strConfigPath);
629 config->getBundleConfiguration("test", &bundles);
631 EXPECT_TRUE(bundles.empty());
636 TEST(ConfigurationTest, BundleResourceConfigurationListParsed)
638 std::string strConfigPath;
639 getCurrentPath(&strConfigPath);
640 strConfigPath.append("/");
641 strConfigPath.append(CONFIG_FILE);
643 Configuration *config = new Configuration(strConfigPath);
645 vector< resourceInfo > resourceConfig;
648 config->getResourceConfiguration("oic.bundle.test", &resourceConfig);
650 result = *resourceConfig.begin();
652 EXPECT_STREQ("test_resource", result.name.c_str());
653 EXPECT_STREQ("container.test", result.resourceType.c_str());
658 TEST(ConfigurationTest, BundleResourceConfigurationNotParsedWithInvalidBundleId)
660 std::string strConfigPath;
661 getCurrentPath(&strConfigPath);
662 strConfigPath.append("/");
663 strConfigPath.append(CONFIG_FILE);
665 Configuration *config = new Configuration(strConfigPath);
668 vector< resourceInfo > resourceConfig;
669 config->getResourceConfiguration("test", &resourceConfig);
671 EXPECT_TRUE(bundles.empty());
676 class DiscoverResourceUnitTest: public TestWithMock
679 typedef std::function<void(const std::string attributeName,
680 std::vector<RCSResourceAttributes::Value> values)>
683 ResourceContainerTestSimulator::Ptr testObject;
684 DiscoverResourceUnit::Ptr m_pDiscoverResourceUnit;
685 std::string m_bundleId;
686 UpdatedCB m_updatedCB;
691 TestWithMock::SetUp();
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 >)
704 m_pDiscoverResourceUnit.reset();
706 TestWithMock::TearDown();
710 TEST_F(DiscoverResourceUnitTest, startDiscover)
712 std::string type = "resource.container";
713 std::string attributeName = "TestResourceContainer";
715 m_pDiscoverResourceUnit->startDiscover(
716 DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
718 std::chrono::milliseconds interval(ResourceContainerTestSimulator::DEFAULT_WAITTIME);
719 std::this_thread::sleep_for(interval);
722 TEST_F(DiscoverResourceUnitTest, onUpdateCalled)
724 std::string type = "resource.container";
725 std::string attributeName = "TestResourceContainer";
727 m_pDiscoverResourceUnit->startDiscover(
728 DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
730 std::chrono::milliseconds interval(ResourceContainerTestSimulator::DEFAULT_WAITTIME);
731 std::this_thread::sleep_for(interval);
733 testObject->ChangeAttributeValue();
738 void onCacheCB(const RCSResourceAttributes &)
743 class RemoteResourceUnitTest: public TestWithMock
746 typedef std::function<void(RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr)>
750 ResourceContainerTestSimulator::Ptr testObject;
751 RemoteResourceUnit::Ptr m_pRemoteResourceUnit;
752 RCSRemoteResourceObject::Ptr m_pRCSRemoteResourceObject;
753 UpdatedCBFromServer m_updatedCBFromServer;
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)
769 m_pRCSRemoteResourceObject.reset();
771 TestWithMock::TearDown();
775 TEST_F(RemoteResourceUnitTest, createRemoteResourceInfo)
777 EXPECT_NE(nullptr, m_pRemoteResourceUnit->createRemoteResourceInfo(m_pRCSRemoteResourceObject,
778 m_updatedCBFromServer));
781 TEST_F(RemoteResourceUnitTest, getRemoteResourceObject)
783 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
784 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
785 EXPECT_EQ(m_pRCSRemoteResourceObject, ptr->getRemoteResourceObject());
788 TEST_F(RemoteResourceUnitTest, getRemoteResourceUri)
790 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
791 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
792 EXPECT_NE("", ptr->getRemoteResourceUri());
795 TEST_F(RemoteResourceUnitTest, startCaching)
797 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
798 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
802 TEST_F(RemoteResourceUnitTest, startMonitoring)
804 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
805 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
806 ptr->startMonitoring();
810 TEST_F(RemoteResourceUnitTest, DISABLED_onCacheCBCalled)
812 TEST_F(RemoteResourceUnitTest, onCacheCBCalled)
815 bool isCalled = false;
816 mocks.ExpectCallFunc(onCacheCB).Do(
817 [this, &isCalled](const RCSResourceAttributes &)
821 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfoWithCacheCB(
822 m_pRCSRemoteResourceObject, m_updatedCBFromServer, onCacheCB);
824 testObject->ChangeAttributeValue();
825 EXPECT_TRUE(isCalled);