+TEST_F(ResourceObjectHandlingRequestTest, SeparateResponseIsSlowResponse)
+{
+ server->setGetRequestHandler(
+ [](const RCSRequest&, RCSResourceAttributes&) -> RCSGetResponse
+ {
+ return RCSGetResponse::separate();
+ }
+ );
+
+ ASSERT_EQ(OC_EH_SLOW, handler(createRequest()));
+}
+
+TEST_F(ResourceObjectHandlingRequestTest, SetMethodOfSeparateResponseInvokesSendResponse)
+{
+ RCSRequest aRequest;
+ server->setGetRequestHandler(
+ [&aRequest](const RCSRequest& request, RCSResourceAttributes&) -> RCSGetResponse
+ {
+ aRequest = request;
+ return RCSGetResponse::separate();
+ }
+ );
+ handler(createRequest(OC_REST_GET));
+
+ mocks.ExpectCallFunc(OCPlatform::sendResponse).Return(OC_STACK_OK);
+
+ RCSSeparateResponse(aRequest).set();
+}
+
+TEST_F(ResourceObjectHandlingRequestTest, SetMethodOfSeparateResponseThrowsIfTheResourceIsDestroyed)
+{
+ RCSRequest aRequest;
+ server->setGetRequestHandler(
+ [&aRequest](const RCSRequest& request, RCSResourceAttributes&) -> RCSGetResponse
+ {
+ aRequest = request;
+ return RCSGetResponse::separate();
+ }
+ );
+ handler(createRequest(OC_REST_GET));
+
+ RCSSeparateResponse resp(aRequest);
+
+ server.reset();
+
+ EXPECT_THROW(resp.set(), RCSBadRequestException);
+}
+
+static bool checkResponse(const OCRepresentation& ocRep, const RCSResourceAttributes& rcsAttr,
+ const std::vector<std::string>& interfaces,
+ const std::vector<std::string>& resourceTypes, const std::string& resourceUri)
+{
+ return resourceUri == ocRep.getUri() &&
+ interfaces == ocRep.getResourceInterfaces() &&
+ resourceTypes == ocRep.getResourceTypes() &&
+ rcsAttr == ResourceAttributesConverter::fromOCRepresentation(ocRep);
+}
+
+static bool compareResponse(const OCRepresentation& ocRep1, const OCRepresentation& ocRep2)
+{
+ return ocRep1.getUri() == ocRep2.getUri() &&
+ ocRep1.getResourceInterfaces() == ocRep2.getResourceInterfaces() &&
+ ocRep1.getResourceTypes() == ocRep2.getResourceTypes() &&
+ ResourceAttributesConverter::fromOCRepresentation(ocRep1) ==
+ ResourceAttributesConverter::fromOCRepresentation(ocRep2);
+}
+
+class ResourceObjectInterfaceHandlerTest: public ResourceObjectHandlingRequestTest
+{
+public:
+ void initServer(vector<string> interfaces,
+ const std::string& defaultInterface = BASELINE_INTERFACE)
+ {
+ auto initBuilder = RCSResourceObject::Builder(RESOURCE_URI, RESOURCE_TYPE,
+ BASELINE_INTERFACE);
+
+ for(const auto& itf : interfaces)
+ {
+ initBuilder.addInterface(itf);
+ }
+
+ RCSResourceAttributes rcsAttr;
+ rcsAttr[KEY] = 2;
+ initBuilder.setAttributes(rcsAttr);
+ initBuilder.setDefaultInterface(defaultInterface);
+
+ server = initBuilder.build();
+ server->setAutoNotifyPolicy(RCSResourceObject::AutoNotifyPolicy::NEVER);
+ server->setSetRequestHandlerPolicy(RCSResourceObject::SetRequestHandlerPolicy::ACCEPTANCE);
+ }
+
+protected:
+
+ void SetUp()
+ {
+ TestWithMock::SetUp();
+
+ initMocks();
+ }
+
+ void initMocks()
+ {
+ ResourceObjectHandlingRequestTest::initMocks();
+
+ mocks.OnCallFunc(OCPlatform::bindInterfaceToResource).Return(OC_STACK_OK);
+ }
+};
+
+TEST_F(ResourceObjectInterfaceHandlerTest, GetResponseForBaselineContainsAllPropertiesOfServer)
+{
+ initServer({BASELINE_INTERFACE});
+
+ OCRepresentation ocRep;
+
+ mocks.ExpectCallFunc(OCPlatform::sendResponse).Match(
+ [=](const shared_ptr<OCResourceResponse> response)
+ {
+ RCSResourceObject::LockGuard guard{ server };
+
+ return checkResponse(response->getResourceRepresentation(),
+ server->getAttributes(), server->getInterfaces(), server->getTypes(),
+ server->getUri());
+
+ }
+ ).Return(OC_STACK_OK);
+
+ handler(createRequest(OC_REST_GET, ocRep, BASELINE_INTERFACE));
+}
+
+TEST_F(ResourceObjectInterfaceHandlerTest, SetResponseForActuatorContainsOnlyRequestedAttributes)
+{
+ initServer({ACTUATOR_INTERFACE});
+
+ OCRepresentation ocRep;
+ ocRep[KEY] = VALUE;
+
+ mocks.ExpectCallFunc(OCPlatform::sendResponse).Match(
+ [&ocRep](const shared_ptr<OCResourceResponse> response)
+ {
+ return checkResponse(response->getResourceRepresentation(),
+ ResourceAttributesConverter::fromOCRepresentation(ocRep), {}, {}, "");
+ }
+ ).Return(OC_STACK_OK);
+
+ handler(createRequest(OC_REST_POST, ocRep, ACTUATOR_INTERFACE));
+}
+
+TEST_F(ResourceObjectInterfaceHandlerTest, SetResponseForBaselineContainsAppliedAttributes)
+{
+ initServer({BASELINE_INTERFACE});
+
+ OCRepresentation ocRep;
+ ocRep["NEWKEY"] = std::string("NEWVALUE");
+
+ mocks.ExpectCallFunc(OCPlatform::sendResponse).Match(
+ [=](const shared_ptr<OCResourceResponse> response)
+ {
+ RCSResourceObject::LockGuard guard{ server };
+
+ return checkResponse(response->getResourceRepresentation(),
+ server->getAttributes(), server->getInterfaces(), server->getTypes(),
+ server->getUri());
+ }
+ ).Return(OC_STACK_OK);
+
+ handler(createRequest(OC_REST_POST, ocRep, BASELINE_INTERFACE));
+}
+
+TEST_F(ResourceObjectInterfaceHandlerTest, GetResponseForCustomEqualsResponseForDefault)
+{
+ initServer({CUSTOM_INTERFACE});
+
+ OCRepresentation ocRep;
+ OCRepresentation repArray[2];
+ int cnt = 0;
+
+ mocks.OnCallFunc(OCPlatform::sendResponse).Do(
+ [&repArray, &cnt](const shared_ptr<OCResourceResponse> response)
+ {
+ repArray[cnt++] = response->getResourceRepresentation();
+ return OC_STACK_OK;
+ }
+ );
+
+ handler(createRequest(OC_REST_GET, ocRep, CUSTOM_INTERFACE));
+ handler(createRequest(OC_REST_GET, ocRep, server->getDefaultInterface()));
+
+ EXPECT_EQ(cnt, 2);
+ EXPECT_TRUE(compareResponse(repArray[0], repArray[1]));
+}
+
+TEST_F(ResourceObjectInterfaceHandlerTest, SetRequestForSensorGotNoHandler)
+{
+ initServer({SENSOR_INTERFACE});
+
+ OCRepresentation ocRep;
+ ocRep[KEY] = VALUE;
+
+ EXPECT_EQ(OC_EH_ERROR, handler(createRequest(OC_REST_POST, ocRep, SENSOR_INTERFACE)));
+}
+
+TEST_F(ResourceObjectInterfaceHandlerTest, ThrowIfDefaultInterfaceIsInvalid)
+{
+ auto builder = RCSResourceObject::Builder(RESOURCE_URI, RESOURCE_TYPE, BASELINE_INTERFACE);
+
+ ASSERT_THROW(builder.setDefaultInterface(ACTUATOR_INTERFACE), RCSBadRequestException);
+}
+
+TEST_F(ResourceObjectInterfaceHandlerTest, SettingDefaultInterfaceEqualsGetDefaultInterface)
+{
+ initServer({SENSOR_INTERFACE}, BASELINE_INTERFACE);
+
+ EXPECT_EQ(BASELINE_INTERFACE, server->getDefaultInterface());
+}
+
+