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__)
31 #include <UnitTestHelper.h>
33 #include <gtest/gtest.h>
34 #include <HippoMocks/hippomocks.h>
36 #include "Configuration.h"
37 #include "BundleActivator.h"
38 #include "BundleResource.h"
39 #include "RCSResourceContainer.h"
40 #include "ResourceContainerBundleAPI.h"
41 #include "ResourceContainerImpl.h"
42 #include "RemoteResourceUnit.h"
44 #include "RCSResourceObject.h"
45 #include "RCSRemoteResourceObject.h"
46 #include "SoftSensorResource.h"
48 #include "ResourceContainerTestSimulator.h"
51 using namespace testing;
52 using namespace OIC::Service;
56 string CONFIG_FILE = "ResourceContainerTestConfig.xml";
58 void getCurrentPath(std::string *pPath)
60 char buffer[MAX_PATH];
62 #if defined(__linux__)
64 int length = readlink("/proc/self/exe", buffer, MAX_PATH - 1);
68 buffer[length] = '\0';
69 strPath = strrchr(buffer, '/');
75 pPath->append(buffer);
78 template<typename Derived, typename Base, typename Del>
79 std::unique_ptr<Derived, Del>
80 static_unique_ptr_cast( std::unique_ptr<Base, Del>&& p )
82 auto d = static_cast<Derived *>(p.release());
83 return std::unique_ptr<Derived, Del>(d, std::move(p.get_deleter()));
86 template<typename Derived, typename Base, typename Del>
87 std::unique_ptr<Derived, Del>
88 dynamic_unique_ptr_cast( std::unique_ptr<Base, Del>&& p )
90 if(Derived *result = dynamic_cast<Derived *>(p.get())) {
92 return std::unique_ptr<Derived, Del>(result, std::move(p.get_deleter()));
94 return std::unique_ptr<Derived, Del>(nullptr, p.get_deleter());
97 /*Fake bundle resource class for testing*/
98 class TestBundleResource: public BundleResource
101 virtual void initAttributes() { }
103 virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr)
105 BundleResource::setAttributes(attr);
108 virtual RCSResourceAttributes handleGetAttributesRequest()
110 return BundleResource::getAttributes();
114 /*Fake bundle resource class for testing*/
115 class TestBundleResourceWithAttrs: public BundleResource
118 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)
126 BundleResource::setAttributes(attr);
129 virtual RCSResourceAttributes handleGetAttributesRequest()
131 return BundleResource::getAttributes();
136 /*Fake bundle resource class for testing*/
137 class TestSoftSensorResource: public SoftSensorResource
140 virtual void initAttributes() {
141 SoftSensorResource::initAttributes();
144 virtual void handleSetAttributesRequest(const RCSResourceAttributes &attr)
146 BundleResource::setAttributes(attr);
149 virtual RCSResourceAttributes handleGetAttributesRequest()
151 return BundleResource::getAttributes();
154 virtual void executeLogic(){
158 virtual void onUpdatedInputResource(
159 std::string, std::vector<OIC::Service::RCSResourceAttributes::Value>){
164 class ResourceContainerTest: public TestWithMock
168 RCSResourceContainer *m_pResourceContainer;
169 std::string m_strConfigPath;
174 TestWithMock::SetUp();
175 m_pResourceContainer = RCSResourceContainer::getInstance();
176 getCurrentPath(&m_strConfigPath);
177 m_strConfigPath.append("/");
178 m_strConfigPath.append(CONFIG_FILE);
182 TEST_F(ResourceContainerTest, TestBundleResource)
184 TestBundleResourceWithAttrs testResource;
185 testResource.initAttributes();
187 // check if initAttributes worked
188 EXPECT_STREQ("\"test\"", testResource.getAttribute("attrib1").toString().c_str());
190 std::list<string> attrNames = testResource.getAttributeNames();
191 ASSERT_TRUE(std::find(attrNames.begin(), attrNames.end(), "attrib1") != attrNames.end());
193 ASSERT_FALSE(testResource.getAttributes().contains("attrib4"));
195 testResource.getAttributeNames();
197 RCSResourceAttributes fullAttributes;
199 fullAttributes["attrib1"] = "test";
200 fullAttributes["attrib2"] = 1;
201 fullAttributes["attrib3"] = true;
203 testResource.setAttributes(fullAttributes);
205 ASSERT_TRUE(testResource.getAttributes().contains("attrib1"));
207 fullAttributes["attrib1"] = "test2";
208 fullAttributes["attrib2"] = 2;
209 fullAttributes["attrib3"] = false;
211 testResource.handleSetAttributesRequest(fullAttributes);
213 EXPECT_EQ((unsigned int) 3, testResource.getAttributeNames().size());
215 EXPECT_EQ((unsigned int) 3, testResource.handleGetAttributesRequest().size());
216 std::string testString = "test";
217 testResource.setAttribute("attrib1", RCSResourceAttributes::Value(testString), false);
219 testResource.setAttributes(fullAttributes, false);
221 EXPECT_STREQ("\"test2\"", testResource.getAttribute("attrib1").toString().c_str());
222 EXPECT_EQ(2, testResource.getAttribute("attrib2"));
224 testResource.setAttribute("attrib1", RCSResourceAttributes::Value("test"));
225 EXPECT_STREQ("\"test\"", testResource.getAttribute("attrib1").toString().c_str());
226 EXPECT_EQ(2, testResource.getAttribute("attrib2"));
229 TEST_F(ResourceContainerTest, TestSoftSensorResource)
231 TestSoftSensorResource softSensorResource;
232 softSensorResource.initAttributes();
233 EXPECT_EQ((unsigned int) 0, softSensorResource.getAttributeNames().size());
237 TEST_F(ResourceContainerTest, BundleRegisteredWhenContainerStartedWithValidConfigFile)
239 m_pResourceContainer->startContainer(m_strConfigPath);
240 EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
241 EXPECT_STREQ("oic.bundle.test",
242 (*m_pResourceContainer->listBundles().begin())->getID().c_str());
243 EXPECT_STREQ("libTestBundle.so",
244 (*m_pResourceContainer->listBundles().begin())->getPath().c_str());
245 EXPECT_STREQ("1.0.0", (*m_pResourceContainer->listBundles().begin())->getVersion().c_str());
246 m_pResourceContainer->stopContainer();
249 TEST_F(ResourceContainerTest, BundleLoadedWhenContainerStartedWithValidConfigFile)
251 m_pResourceContainer->startContainer(m_strConfigPath);
253 EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
254 unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
255 unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
256 EXPECT_TRUE( firstInternal->isLoaded() );
258 firstInternal->getBundleHandle());
260 m_pResourceContainer->stopContainer();
263 TEST_F(ResourceContainerTest, BundleActivatedWhenContainerStartedWithValidConfigFile)
265 m_pResourceContainer->startContainer(m_strConfigPath);
267 EXPECT_GT(m_pResourceContainer->listBundles().size(), (unsigned int) 0);
268 unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
269 unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
270 EXPECT_TRUE(firstInternal->isActivated());
271 EXPECT_NE(nullptr,firstInternal->getBundleActivator());
273 m_pResourceContainer->stopContainer();
276 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithInvalidConfigFile)
278 m_pResourceContainer->startContainer("invalidConfig");
280 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
283 TEST_F(ResourceContainerTest, BundleNotRegisteredWhenContainerStartedWithEmptyConfigFile)
285 m_pResourceContainer->startContainer("");
287 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
290 TEST_F(ResourceContainerTest, BundleUnregisteredWhenContainerStopped)
292 m_pResourceContainer->startContainer(m_strConfigPath);
293 m_pResourceContainer->stopContainer();
295 EXPECT_EQ((unsigned int) 0, m_pResourceContainer->listBundles().size());
298 TEST_F(ResourceContainerTest, BundleStoppedWithStartBundleAPI)
300 m_pResourceContainer->startContainer(m_strConfigPath);
301 m_pResourceContainer->stopBundle("oic.bundle.test");
303 unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
304 unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
305 EXPECT_FALSE(firstInternal->isActivated());
307 m_pResourceContainer->stopContainer();
310 TEST_F(ResourceContainerTest, BundleStartedWithStartBundleAPI)
312 m_pResourceContainer->startContainer(m_strConfigPath);
313 m_pResourceContainer->stopBundle("oic.bundle.test");
314 m_pResourceContainer->startBundle("oic.bundle.test");
315 unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
316 unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
317 EXPECT_TRUE(firstInternal->isActivated());
319 m_pResourceContainer->stopContainer();
322 TEST_F(ResourceContainerTest, AddNewSoBundleToContainer)
324 std::map<string, string> bundleParams;
325 std::list<std::unique_ptr<RCSBundleInfo>> bundles;
327 bundles = m_pResourceContainer->listBundles();
328 m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
330 EXPECT_EQ(bundles.size() + 1, m_pResourceContainer->listBundles().size());
331 unique_ptr<RCSBundleInfo> first = std::move(*m_pResourceContainer->listBundles().begin());
332 unique_ptr<BundleInfoInternal> firstInternal((BundleInfoInternal*)first.release());
333 EXPECT_TRUE(firstInternal->isLoaded());
336 TEST_F(ResourceContainerTest, RemoveSoBundleFromContainer)
338 std::map<string, string> bundleParams;
339 std::list<std::unique_ptr<RCSBundleInfo>> bundles;
341 bundles = m_pResourceContainer->listBundles();
342 m_pResourceContainer->removeBundle("oic.bundle.test");
344 EXPECT_EQ(bundles.size() - 1, m_pResourceContainer->listBundles().size());
347 TEST_F(ResourceContainerTest, AddBundleAlreadyRegistered)
349 std::map<string, string> bundleParams;
350 std::list<std::unique_ptr<RCSBundleInfo> > bundles;
352 m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
353 bundles = m_pResourceContainer->listBundles();
354 m_pResourceContainer->addBundle("oic.bundle.test", "", "libTestBundle.so", "test", bundleParams);
356 EXPECT_EQ(bundles.size(), m_pResourceContainer->listBundles().size());
359 TEST_F(ResourceContainerTest, AddAndRemoveSoBundleResource)
361 std::list<string> resources;
362 std::map<string, string> resourceParams;
363 resourceParams["resourceType"] = "container.test";
365 m_pResourceContainer->startContainer(m_strConfigPath);
366 resources = m_pResourceContainer->listBundleResources("oic.bundle.test");
368 m_pResourceContainer->addResourceConfig("oic.bundle.test", "/test_resource", resourceParams);
370 EXPECT_EQ(resources.size() + 1,
371 m_pResourceContainer->listBundleResources("oic.bundle.test").size());
373 m_pResourceContainer->removeResourceConfig("oic.bundle.test", "/test_resource");
375 EXPECT_EQ(resources.size(), m_pResourceContainer->listBundleResources("oic.bundle.test").size());
377 m_pResourceContainer->stopContainer();
380 TEST_F(ResourceContainerTest, TryAddingSoBundleResourceToNotRegisteredBundle)
382 std::map<string, string> resourceParams;
384 mocks.NeverCallFunc(ResourceContainerImpl::buildResourceObject);
386 m_pResourceContainer->addResourceConfig("unvalidBundleId", "", resourceParams);
389 class ResourceContainerBundleAPITest: public TestWithMock
393 RCSResourceObject *m_pResourceObject;
394 ResourceContainerBundleAPI *m_pResourceContainer;
395 BundleResource::Ptr m_pBundleResource;
396 std::string m_strConfigPath;
401 TestWithMock::SetUp();
402 m_pResourceObject = mocks.Mock<RCSResourceObject>();
403 m_pResourceContainer = ResourceContainerBundleAPI::getInstance();
405 getCurrentPath(&m_strConfigPath);
406 m_strConfigPath.append("/");
407 m_strConfigPath.append(CONFIG_FILE);
409 m_pBundleResource = std::make_shared< TestBundleResource >();
410 m_pBundleResource->m_bundleId = "oic.bundle.test";
411 m_pBundleResource->m_uri = "/test_resource";
412 m_pBundleResource->m_resourceType = "container.test";
413 m_pBundleResource->m_interface = "oic.if.baseline";
417 TEST_F(ResourceContainerBundleAPITest, ResourceServerCreatedWhenRegisterResourceCalled)
419 m_pBundleResource = std::make_shared< TestBundleResource >();
420 m_pBundleResource->m_bundleId = "oic.bundle.test";
421 m_pBundleResource->m_uri = "/test_resource/test";
422 m_pBundleResource->m_resourceType = "container.test";
423 m_pBundleResource->m_interface = "oic.if.baseline";
425 mocks.ExpectCallFunc(ResourceContainerImpl::buildResourceObject).With(m_pBundleResource->m_uri,
426 m_pBundleResource->m_resourceType, m_pBundleResource->m_interface).Return(nullptr);
428 m_pResourceContainer->registerResource(m_pBundleResource);
431 TEST_F(ResourceContainerBundleAPITest, RequestHandlerForResourceServerSetWhenRegisterResourceCalled)
433 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
434 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
437 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
438 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
440 m_pResourceContainer->registerResource(m_pBundleResource);
442 m_pResourceContainer->unregisterResource(m_pBundleResource);
445 TEST_F(ResourceContainerBundleAPITest, BundleResourceUnregisteredWhenUnregisterResourceCalled)
447 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
448 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
451 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
452 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
454 m_pResourceContainer->registerResource(m_pBundleResource);
455 m_pResourceContainer->unregisterResource(m_pBundleResource);
457 EXPECT_EQ((unsigned int) 0,
458 ((ResourceContainerImpl *)m_pResourceContainer)->listBundleResources(
459 m_pBundleResource->m_bundleId).size());
462 TEST_F(ResourceContainerBundleAPITest,
463 ServerNotifiesToObserversWhenNotificationReceivedFromResource)
465 mocks.OnCallFunc(ResourceContainerImpl::buildResourceObject).Return(
466 RCSResourceObject::Ptr(m_pResourceObject, [](RCSResourceObject *)
469 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setGetRequestHandler);
470 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::setSetRequestHandler);
472 m_pResourceContainer->registerResource(m_pBundleResource);
474 mocks.ExpectCall(m_pResourceObject, RCSResourceObject::notify);
476 m_pResourceContainer->onNotificationReceived(m_pBundleResource->m_uri);
478 m_pResourceContainer->unregisterResource(m_pBundleResource);
481 TEST_F(ResourceContainerBundleAPITest, BundleConfigurationParsedWithValidBundleId)
484 map< string, string > results;
486 ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
487 m_pResourceContainer->getBundleConfiguration("oic.bundle.test", &bundle);
489 results = *bundle.begin();
491 EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
492 EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
493 EXPECT_STREQ("1.0.0", results["version"].c_str());
495 ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
498 TEST_F(ResourceContainerBundleAPITest, BundleResourceConfigurationListParsed)
500 vector< resourceInfo > resourceConfig;
503 ((ResourceContainerImpl *)m_pResourceContainer)->startContainer(m_strConfigPath);
504 m_pResourceContainer->getResourceConfiguration("oic.bundle.test", &resourceConfig);
506 result = *resourceConfig.begin();
508 EXPECT_STREQ("test_resource", result.name.c_str());
509 EXPECT_STREQ("container.test", result.resourceType.c_str());
511 ((ResourceContainerImpl *)m_pResourceContainer)->stopContainer();
514 class ResourceContainerImplTest: public TestWithMock
518 ResourceContainerImpl *m_pResourceContainer;
519 shared_ptr<BundleInfoInternal> m_pBundleInfo;
524 TestWithMock::SetUp();
525 m_pResourceContainer = ResourceContainerImpl::getImplInstance();
526 m_pBundleInfo = std::make_shared<BundleInfoInternal>();
531 m_pBundleInfo.reset();
536 /* Test for Configuration */
537 TEST(ConfigurationTest, ConfigFileLoadedWithValidPath)
539 std::string strConfigPath;
540 getCurrentPath(&strConfigPath);
541 strConfigPath.append("/");
542 strConfigPath.append(CONFIG_FILE);
544 Configuration *config = new Configuration(strConfigPath);
546 EXPECT_TRUE(config->isLoaded());
551 TEST(ConfigurationTest, ConfigFileNotLoadedWithInvalidPath)
553 Configuration *config = new Configuration("InvalidPath");
555 EXPECT_FALSE(config->isLoaded());
560 TEST(ConfigurationTest, BundleConfigurationListParsed)
562 std::string strConfigPath;
563 getCurrentPath(&strConfigPath);
564 strConfigPath.append("/");
565 strConfigPath.append(CONFIG_FILE);
567 Configuration *config = new Configuration(strConfigPath);
570 map< string, string > results;
572 config->getConfiguredBundles(&bundles);
574 results = *bundles.begin();
576 EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
577 EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
578 EXPECT_STREQ("1.0.0", results["version"].c_str());
583 TEST(ConfigurationTest, BundleConfigurationParsedWithValidBundleId)
585 std::string strConfigPath;
586 getCurrentPath(&strConfigPath);
587 strConfigPath.append("/");
588 strConfigPath.append(CONFIG_FILE);
590 Configuration *config = new Configuration(strConfigPath);
593 map< string, string > results;
595 config->getBundleConfiguration("oic.bundle.test", &bundle);
597 results = *bundle.begin();
599 EXPECT_STREQ("oic.bundle.test", results["id"].c_str());
600 EXPECT_STREQ("libTestBundle.so", results["path"].c_str());
601 EXPECT_STREQ("1.0.0", results["version"].c_str());
606 TEST(ConfigurationTest, BundleConfigurationNotParsedWithInvalidBundleId)
608 std::string strConfigPath;
609 getCurrentPath(&strConfigPath);
610 strConfigPath.append("/");
611 strConfigPath.append(CONFIG_FILE);
613 Configuration *config = new Configuration(strConfigPath);
616 config->getBundleConfiguration("test", &bundles);
618 EXPECT_TRUE(bundles.empty());
623 TEST(ConfigurationTest, BundleResourceConfigurationListParsed)
625 std::string strConfigPath;
626 getCurrentPath(&strConfigPath);
627 strConfigPath.append("/");
628 strConfigPath.append(CONFIG_FILE);
630 Configuration *config = new Configuration(strConfigPath);
632 vector< resourceInfo > resourceConfig;
635 config->getResourceConfiguration("oic.bundle.test", &resourceConfig);
637 result = *resourceConfig.begin();
639 EXPECT_STREQ("test_resource", result.name.c_str());
640 EXPECT_STREQ("container.test", result.resourceType.c_str());
645 TEST(ConfigurationTest, BundleResourceConfigurationNotParsedWithInvalidBundleId)
647 std::string strConfigPath;
648 getCurrentPath(&strConfigPath);
649 strConfigPath.append("/");
650 strConfigPath.append(CONFIG_FILE);
652 Configuration *config = new Configuration(strConfigPath);
655 vector< resourceInfo > resourceConfig;
656 config->getResourceConfiguration("test", &resourceConfig);
658 EXPECT_TRUE(bundles.empty());
663 class DiscoverResourceUnitTest: public TestWithMock
666 typedef std::function<void(const std::string attributeName,
667 std::vector<RCSResourceAttributes::Value> values)>
670 ResourceContainerTestSimulator::Ptr testObject;
671 DiscoverResourceUnit::Ptr m_pDiscoverResourceUnit;
672 std::string m_bundleId;
673 UpdatedCB m_updatedCB;
678 TestWithMock::SetUp();
680 testObject = std::make_shared<ResourceContainerTestSimulator>();
681 testObject->createResource();
682 m_bundleId = "/a/TempHumSensor/Container";
683 m_pDiscoverResourceUnit = std::make_shared< DiscoverResourceUnit >( m_bundleId );
684 m_updatedCB = ([](const std::string, std::vector< RCSResourceAttributes::Value >) { });
689 m_pDiscoverResourceUnit.reset();
691 TestWithMock::TearDown();
695 TEST_F(DiscoverResourceUnitTest, startDiscover)
697 std::string type = "Resource.Container";
698 std::string attributeName = "TestResourceContainer";
700 m_pDiscoverResourceUnit->startDiscover(
701 DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
703 std::chrono::milliseconds interval(400);
704 std::this_thread::sleep_for(interval);
707 TEST_F(DiscoverResourceUnitTest, onUpdateCalled)
709 std::string type = "Resource.Container";
710 std::string attributeName = "TestResourceContainer";
712 m_pDiscoverResourceUnit->startDiscover(
713 DiscoverResourceUnit::DiscoverResourceInfo("", type, attributeName), m_updatedCB);
715 std::chrono::milliseconds interval(400);
716 std::this_thread::sleep_for(interval);
718 testObject->ChangeAttributeValue();
724 void onCacheCB(const RCSResourceAttributes &) { }
727 class RemoteResourceUnitTest: public TestWithMock
730 typedef std::function<void(RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr)>
734 ResourceContainerTestSimulator::Ptr testObject;
735 RemoteResourceUnit::Ptr m_pRemoteResourceUnit;
736 RCSRemoteResourceObject::Ptr m_pRCSRemoteResourceObject;
737 UpdatedCBFromServer m_updatedCBFromServer;
742 TestWithMock::SetUp();
743 testObject = std::make_shared<ResourceContainerTestSimulator>();
744 testObject->defaultRunSimulator();
745 m_pRCSRemoteResourceObject = testObject->getRemoteResource();
746 m_updatedCBFromServer = ([](RemoteResourceUnit::UPDATE_MSG, RCSRemoteResourceObject::Ptr) {});
751 m_pRCSRemoteResourceObject.reset();
753 TestWithMock::TearDown();
757 TEST_F(RemoteResourceUnitTest, createRemoteResourceInfo)
759 EXPECT_NE(nullptr, m_pRemoteResourceUnit->createRemoteResourceInfo(m_pRCSRemoteResourceObject,
760 m_updatedCBFromServer));
763 TEST_F(RemoteResourceUnitTest, getRemoteResourceObject)
765 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
766 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
767 EXPECT_EQ(m_pRCSRemoteResourceObject, ptr->getRemoteResourceObject());
770 TEST_F(RemoteResourceUnitTest, getRemoteResourceUri)
772 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
773 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
774 EXPECT_NE("", ptr->getRemoteResourceUri());
777 TEST_F(RemoteResourceUnitTest, startCaching)
779 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
780 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
784 TEST_F(RemoteResourceUnitTest, startMonitoring)
786 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfo(
787 m_pRCSRemoteResourceObject, m_updatedCBFromServer);
788 ptr->startMonitoring();
791 TEST_F(RemoteResourceUnitTest, onCacheCBCalled)
793 bool isCalled = false;
794 mocks.ExpectCallFunc(onCacheCB).Do(
795 [this, &isCalled](const RCSResourceAttributes &)
799 RemoteResourceUnit::Ptr ptr = m_pRemoteResourceUnit->createRemoteResourceInfoWithCacheCB(
800 m_pRCSRemoteResourceObject, m_updatedCBFromServer, onCacheCB);
802 testObject->ChangeAttributeValue();
803 EXPECT_TRUE(isCalled);