//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
#include "UnitTestHelper.h"
+
+#include "OCResource.h"
+
#include "RCSRemoteResourceObject.h"
#include "RCSDiscoveryManager.h"
#include "RCSResourceObject.h"
-#include "PrimitiveResource.h"
-#include <condition_variable>
+#include "RCSAddress.h"
+#include "RCSRequest.h"
+#include <condition_variable>
#include <mutex>
using namespace OIC::Service;
using namespace OC;
constexpr char RESOURCEURI[]{ "/a/TemperatureSensor" };
-constexpr char RESOURCETYPE[]{ "Resource.Hosting" };
+constexpr char RESOURCETYPE[]{ "resource.type" };
constexpr char RESOURCEINTERFACE[]{ "oic.if.baseline" };
constexpr char ATTR_KEY[]{ "Temperature" };
constexpr int DEFAULT_WAITING_TIME_IN_MILLIS = 3000;
-void getRemoteAttributesCallback(const RCSResourceAttributes&) {}
-void setRemoteAttributesCallback(const RCSResourceAttributes&) {}
+void getRemoteAttributesCallback(const RCSResourceAttributes&, int) {}
+void setRemoteAttributesCallback(const RCSResourceAttributes&, int) {}
+void setRemoteRepresentationCallback(const HeaderOpts&, const RCSRepresentation&, int) {}
void resourceStateChanged(ResourceState) { }
-void cacheUpdatedCallback(const RCSResourceAttributes&) {}
+void cacheUpdatedCallback(const RCSResourceAttributes&, int) {}
class RemoteResourceObjectTest: public TestWithMock
{
public:
RCSResourceObject::Ptr server;
RCSRemoteResourceObject::Ptr object;
- std::shared_ptr< bool > finished;
public:
void Proceed()
{
TestWithMock::SetUp();
- finished = std::make_shared< bool >(false);
-
CreateResource();
WaitUntilDiscovered();
+
+ ASSERT_NE(object, nullptr);
}
void TearDown()
// This method is to make sure objects disposed.
WaitForPtrBeingUnique();
-
- *finished = true;
}
private:
server->setAttribute(ATTR_KEY, ATTR_VALUE);
}
- bool checkObject()
- {
- std::lock_guard<std::mutex> lock{ mutexForObject };
- return object == nullptr;
- }
-
void WaitUntilDiscovered()
{
- while (checkObject())
+ for (int i=0; i<10 && !object; ++i)
{
- const std::string uri = "/oic/res";
- const std::string type = "Resource.Hosting";
- RCSDiscoveryManager::getInstance()->discoverResourceByType(RCSAddress::multicast(),
- uri, type, std::bind(resourceDiscovered, this, finished,
- std::placeholders::_1));
+ auto discoveryTask = RCSDiscoveryManager::getInstance()->discoverResourceByType(
+ RCSAddress::multicast(), RESOURCETYPE,
+ std::bind(&RemoteResourceObjectTest::resourceDiscovered, this,
+ std::placeholders::_1));
Wait(1000);
+ discoveryTask->cancel();
}
}
}
}
- // This callback is to protect crash from crashes caused by delayed callbacks
- static void resourceDiscovered(RemoteResourceObjectTest* test,
- std::shared_ptr< bool > finished, RCSRemoteResourceObject::Ptr resourceObject)
+ void resourceDiscovered(RCSRemoteResourceObject::Ptr resourceObject)
{
- if (*finished) return;
-
- {
- std::lock_guard< std::mutex > lock{ test->mutexForObject };
-
- if (test->object) return;
+ object = resourceObject;
- test->object = resourceObject;
- }
-
- test->Proceed();
+ Proceed();
}
private:
std::condition_variable cond;
std::mutex mutex;
- std::mutex mutexForObject;
};
TEST_F(RemoteResourceObjectTest, GetRemoteAttributesDoesNotAllowEmptyFunction)
{
- ASSERT_THROW(object->getRemoteAttributes({ }), InvalidParameterException);
+ ASSERT_THROW(object->getRemoteAttributes({ }), RCSInvalidParameterException);
}
TEST_F(RemoteResourceObjectTest, GetRemoteAttributesGetsAttributesOfServer)
{
mocks.ExpectCallFunc(getRemoteAttributesCallback).Match(
- [this](const RCSResourceAttributes& attrs)
+ [this](const RCSResourceAttributes& attrs, int)
{
RCSResourceObject::LockGuard lock{ server };
return attrs == server->getAttributes();
}
- ).Do([this](const RCSResourceAttributes&){ Proceed(); });
+ ).Do([this](const RCSResourceAttributes&, int){ Proceed(); });
object->getRemoteAttributes(getRemoteAttributesCallback);
TEST_F(RemoteResourceObjectTest, SetRemoteAttributesDoesNotAllowEmptyFunction)
{
- ASSERT_THROW(object->setRemoteAttributes({ }, { }), InvalidParameterException);
+ ASSERT_THROW(object->setRemoteAttributes({ }, { }), RCSInvalidParameterException);
}
TEST_F(RemoteResourceObjectTest, SetRemoteAttributesSetsAttributesOfServer)
newAttrs[ATTR_KEY] = newValue;
mocks.ExpectCallFunc(setRemoteAttributesCallback).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
object->setRemoteAttributes(newAttrs, setRemoteAttributesCallback);
Wait();
- ASSERT_EQ(newValue, server->getAttributeValue(ATTR_KEY));
+ ASSERT_EQ(newValue, server->getAttributeValue(ATTR_KEY).get<int>());
+}
+
+TEST_F(RemoteResourceObjectTest, SetRemoteRepresentationDoesNotAllowEmptyFunction)
+{
+ RCSQueryParams queryParams;
+ RCSRepresentation rcsRep;
+ ASSERT_THROW(object->set(queryParams, rcsRep, {}), RCSInvalidParameterException);
+}
+
+TEST_F(RemoteResourceObjectTest, SetRemoteRepresentationSetsRepresentationOfServer)
+{
+ RCSRepresentation rcsRep;
+ RCSQueryParams queryParams;
+ constexpr int newValue = ATTR_VALUE + 1;
+ RCSResourceAttributes newAttrs;
+ newAttrs[ATTR_KEY] = newValue;
+
+ rcsRep.setAttributes(newAttrs);
+
+ mocks.ExpectCallFunc(setRemoteRepresentationCallback).
+ Do([this](const HeaderOpts&, const RCSRepresentation&, int){ Proceed(); });
+
+ object->set(queryParams, rcsRep, setRemoteRepresentationCallback);
+ Wait();
+
+ ASSERT_EQ(newValue, server->getAttributeValue(ATTR_KEY).get<int>());
+}
+
+TEST_F(RemoteResourceObjectTest, QueryParamsForGetWillBePassedToBase)
+{
+ class CustomHandler
+ {
+ public:
+ virtual RCSGetResponse handle(const RCSRequest&, RCSResourceAttributes&) = 0;
+ virtual ~CustomHandler() {}
+ };
+
+ constexpr char PARAM_KEY[] { "aKey" };
+ constexpr char VALUE[] { "value" };
+
+ object->get(RCSQueryParams().setResourceInterface(RESOURCEINTERFACE).setResourceType(RESOURCETYPE).
+ put(PARAM_KEY, VALUE),
+ [](const HeaderOpts&, const RCSRepresentation&, int){});
+
+ auto mockHandler = mocks.Mock< CustomHandler >();
+
+ mocks.ExpectCall(mockHandler, CustomHandler::handle).
+ Match([](const RCSRequest& request, RCSResourceAttributes&)
+ {
+ return request.getInterface() == RESOURCEINTERFACE &&
+ request.getQueryParams().at(PARAM_KEY) == VALUE;
+ }
+ ).
+ Do([this](const RCSRequest&, RCSResourceAttributes&)
+ {
+ Proceed();
+ return RCSGetResponse::defaultAction();
+ }
+ );
+
+ server->setGetRequestHandler(std::bind(&CustomHandler::handle, mockHandler,
+ std::placeholders::_1, std::placeholders::_2));
+
+ Wait();
}
TEST_F(RemoteResourceObjectTest, MonitoringIsNotStartedByDefault)
TEST_F(RemoteResourceObjectTest, StartMonitoringThrowsIfFunctionIsEmpty)
{
- ASSERT_THROW(object->startMonitoring({ }), InvalidParameterException);
+ ASSERT_THROW(object->startMonitoring({ }), RCSInvalidParameterException);
}
TEST_F(RemoteResourceObjectTest, IsMonitoringReturnsTrueAfterStartMonitoring)
{
object->startMonitoring(resourceStateChanged);
- ASSERT_THROW(object->startMonitoring(resourceStateChanged), BadRequestException);
+ ASSERT_THROW(object->startMonitoring(resourceStateChanged), RCSBadRequestException);
}
TEST_F(RemoteResourceObjectTest, DefaultStateIsNone)
{
object->startCaching(cacheUpdatedCallback);
- ASSERT_THROW(object->startCaching(), BadRequestException);
+ ASSERT_THROW(object->startCaching(), RCSBadRequestException);
}
TEST_F(RemoteResourceObjectTest, DefaultCacheStateIsNone)
TEST_F(RemoteResourceObjectTest, CacheStateIsReadyAfterCacheUpdated)
{
mocks.ExpectCallFunc(cacheUpdatedCallback).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
object->startCaching(cacheUpdatedCallback);
Wait();
TEST_F(RemoteResourceObjectTest, IsCachedAvailableReturnsTrueWhenCacheIsReady)
{
mocks.ExpectCallFunc(cacheUpdatedCallback).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
object->startCaching(cacheUpdatedCallback);
Wait();
TEST_F(RemoteResourceObjectTest, DISABLED_CacheUpdatedCallbackBeCalledWheneverCacheUpdated)
{
mocks.OnCallFunc(cacheUpdatedCallback).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
object->startCaching(cacheUpdatedCallback);
Wait();
mocks.ExpectCallFunc(cacheUpdatedCallback).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
server->setAttribute(ATTR_KEY, ATTR_VALUE + 1);
constexpr int newValue = ATTR_VALUE + 1;
mocks.OnCallFunc(cacheUpdatedCallback).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
object->startCaching(cacheUpdatedCallback);
Wait();
mocks.ExpectCallFunc(cacheUpdatedCallback).
- Match([this](const RCSResourceAttributes& attrs){
+ Match([this](const RCSResourceAttributes& attrs, int){
return attrs.at(ATTR_KEY) == newValue;
}).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
server->setAttribute(ATTR_KEY, newValue);
TEST_F(RemoteResourceObjectTest, GetCachedAttributesThrowsIfCachingIsNotStarted)
{
- ASSERT_THROW(object->getCachedAttributes(), BadRequestException);
+ ASSERT_THROW(object->getCachedAttributes(), RCSBadRequestException);
}
TEST_F(RemoteResourceObjectTest, CachedAttributesHasSameAttributesWithServer)
{
mocks.OnCallFunc(cacheUpdatedCallback).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
object->startCaching(cacheUpdatedCallback);
Wait();
TEST_F(RemoteResourceObjectTest, GetCachedAttributeThrowsIfCachingIsNotStarted)
{
- ASSERT_THROW(object->getCachedAttribute(ATTR_KEY), BadRequestException);
+ ASSERT_THROW(object->getCachedAttribute(ATTR_KEY), RCSBadRequestException);
}
TEST_F(RemoteResourceObjectTest, GetCachedAttributeThrowsIfKeyIsInvalid)
{
mocks.OnCallFunc(cacheUpdatedCallback).
- Do([this](const RCSResourceAttributes&){ Proceed(); });
+ Do([this](const RCSResourceAttributes&, int){ Proceed(); });
object->startCaching(cacheUpdatedCallback);
Wait();
- ASSERT_THROW(object->getCachedAttribute(""), InvalidKeyException);
+ ASSERT_THROW(object->getCachedAttribute(""), RCSInvalidKeyException);
}
TEST_F(RemoteResourceObjectTest, HasSameUriWithServer)
EXPECT_EQ(RESOURCEINTERFACE, object->getInterfaces()[0]);
}
+TEST_F(RemoteResourceObjectTest, GetValidOCResourceTest)
+{
+ std::shared_ptr<OC::OCResource> ocRes = RCSRemoteResourceObject::toOCResource(object);
+
+ EXPECT_NE(nullptr, ocRes);
+
+ EXPECT_EQ(RESOURCEURI, ocRes->uri());
+}
+
projects / platform / upstream / iotivity.git / blobdiff