/* ****************************************************************************
*
* json_ok -
*/
TEST(RegisterProviderRequest, json_ok)
{
ParseData reqData;
const char* inFile1 = "ngsi9.registerProviderRequest.noRegistrationId.valid.json";
const char* inFile2 = "ngsi9.registerProviderRequest.ok.valid.json";
const char* outFile1 = "ngsi9.registerProviderRequestRendered.noRegistrationId.valid.json";
const char* outFile2 = "ngsi9.registerProviderRequest.noMetdataName.valid.json";
const char* outFile3 = "ngsi9.registerProviderRequest.predetectedError.valid.json";
const char* outFile4 = "ngsi9.registerProviderRequestRendered.ok.valid.json";
std::string result;
std::string rendered;
std::string checked;
ConnectionInfo ci("", "POST", "1.1");
// 1. Normal registerProviderRequest
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile1)) << "Error getting test data from '" << inFile1 << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFile1)) << "Error getting test data from '" << outFile1 << "'";
result = jsonTreat(testBuf, &ci, &reqData, ContextEntitiesByEntityId, "registerProviderRequest", NULL);
EXPECT_EQ("OK", result) << "this test should be OK";
rendered = reqData.rpr.res.render("");
EXPECT_STREQ(expectedBuf, rendered.c_str());
// 2. Destroying metadata to provoke an error
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFile2)) << "Error getting test data from '" << outFile2 << "'";
reqData.rpr.res.metadataVector[0]->name = "";
checked = reqData.rpr.res.check(&ci, DiscoverContextAvailability, "", "", 0);
EXPECT_STREQ(expectedBuf, checked.c_str());
// 3. sending a 'predetected error' to the check function
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFile3)) << "Error getting test data from '" << outFile3 << "'";
checked = reqData.rpr.res.check(&ci, DiscoverContextAvailability, "", "forced predetectedError", 0);
EXPECT_STREQ(expectedBuf, checked.c_str());
// Just for coverage
reqData.rpr.res.release();
// 4. Second file
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile2)) << "Error getting test data from '" << inFile2 << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFile4)) << "Error getting test data from '" << outFile4 << "'";
result = jsonTreat(testBuf, &ci, &reqData, ContextEntitiesByEntityId, "registerProviderRequest", NULL);
EXPECT_EQ("OK", result);
rendered = reqData.rpr.res.render("");
EXPECT_STREQ(expectedBuf, rendered.c_str());
}
/* ****************************************************************************
*
* ok_json -
*/
TEST(UpdateContextRequest, ok_json)
{
ParseData reqData;
ConnectionInfo ci("", "POST", "1.1");
const char* infile = "ngsi10.updateContext.ok.valid.json";
utInit();
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
ci.inFormat = JSON;
ci.outFormat = JSON;
lmTraceLevelSet(LmtDump, true);
std::string result = jsonTreat(testBuf, &ci, &reqData, UpdateContext, "updateContextRequest", NULL);
lmTraceLevelSet(LmtDump, false);
EXPECT_EQ("OK", result);
//
// With the data obtained, render, present and release methods are exercised
//
UpdateContextRequest* upcrP = &reqData.upcr.res;
upcrP->present(""); // No output
upcrP->release();
utExit();
}
/* ****************************************************************************
*
* ok_json -
*/
TEST(SubscribeContextRequest, ok_json)
{
ParseData parseData;
ConnectionInfo ci("", "POST", "1.1");
const char* infile = "ngsi10.subscribeContextRequest.ok.valid.json";
utInit();
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
ci.inFormat = JSON;
ci.outFormat = JSON;
lmTraceLevelSet(LmtDump, true);
std::string result = jsonTreat(testBuf, &ci, &parseData, SubscribeContext, "subscribeContextRequest", NULL);
EXPECT_EQ("OK", result);
lmTraceLevelSet(LmtDump, false);
//
// With the data obtained, render, present and release methods are exercised
//
SubscribeContextRequest* scrP = &parseData.scr.res;
const char* outfile = "ngsi10.subscribeContextRequest_ok.expected.valid.json";
scrP->present(""); // No output
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile << "'";
std::string out = scrP->render(SubscribeContext, JSON, "");
EXPECT_STREQ(expectedBuf, out.c_str());
scrP->release();
utExit();
}
/* ****************************************************************************
*
* payloadParse -
*/
std::string payloadParse(ConnectionInfo* ciP, ParseData* parseDataP, RestService* service, XmlRequest** reqPP, JsonRequest** jsonPP)
{
std::string result = "NONE";
LM_T(LmtParsedPayload, ("parsing data for service '%s'. Method: '%s'", requestType(service->request), ciP->method.c_str()));
LM_T(LmtParsedPayload, ("outFormat: %s", formatToString(ciP->outFormat)));
if (ciP->inFormat == XML)
{
LM_T(LmtParsedPayload, ("Calling xmlTreat for service request %d, payloadWord '%s'", service->request, service->payloadWord.c_str()));
result = xmlTreat(ciP->payload, ciP, parseDataP, service->request, service->payloadWord, reqPP);
}
else if (ciP->inFormat == JSON)
result = jsonTreat(ciP->payload, ciP, parseDataP, service->request, service->payloadWord, jsonPP);
else
{
LM_W(("Bad Input (payload mime-type is neither JSON nor XML)"));
return "Bad inFormat";
}
LM_T(LmtParsedPayload, ("result: '%s'", result.c_str()));
LM_T(LmtParsedPayload, ("outFormat: %s", formatToString(ciP->outFormat)));
if (result != "OK")
{
restReply(ciP, result);
}
return result;
}
/* ****************************************************************************
*
* ok_json -
*/
TEST(NotifyContextAvailabilityRequest, ok_json)
{
ParseData parseData;
const char* fileName = "ngsi9.notifyContextAvailabilityRequest.ok2.valid.json";
ConnectionInfo ci("", "POST", "1.1");
std::string out;
utInit();
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), fileName)) << "Error getting test data from '" << fileName << "'";
lmTraceLevelSet(LmtDump, true);
out = jsonTreat(testBuf, &ci, &parseData, NotifyContextAvailability, "notifyContextAvailabilityRequest", NULL);
EXPECT_EQ("OK", out);
lmTraceLevelSet(LmtDump, false);
NotifyContextAvailabilityRequest* ncarP = &parseData.ncar.res;
const char* outfile = "ngsi9.notifyContextAvailabilityRequest.ok.valid.json";
out = ncarP->render(NotifyContext, JSON, "");
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile << "'";
EXPECT_STREQ(expectedBuf, out.c_str());
ncarP->release();
utExit();
}
/* ****************************************************************************
*
* badSubscriptionId_json -
*/
TEST(UnsubscribeContextAvailabilityRequest, badSubscriptionId_json)
{
ParseData reqData;
ConnectionInfo ci("", "POST", "1.1");
const char* infile = "ngsi9.unsubscribeContextAvailabilityRequest.badSubscriptionId.invalid.json";
const char* outfile = "ngsi9.unsubscribeContextAvailabilityResponse.badSubscriptionId.valid.json";
utInit();
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile << "'";
ci.inFormat = JSON;
ci.outFormat = JSON;
lmTraceLevelSet(LmtDump, true);
std::string out = jsonTreat(testBuf, &ci, &reqData, UnsubscribeContextAvailability, "unsubscribeContextAvailabilityRequest", NULL);
EXPECT_STREQ(expectedBuf, out.c_str());
lmTraceLevelSet(LmtDump, false);
UnsubscribeContextAvailabilityRequest* ucarP = &reqData.ucar.res;
ucarP->release();
utExit();
}
/* ****************************************************************************
*
* json_ok -
*/
TEST(NotifyContextRequest, json_ok)
{
ParseData reqData;
ConnectionInfo ci("", "POST", "1.1");
NotifyContextRequest* ncrP = &reqData.ncr.res;
const char* infile = "notifyContextRequest_ok.json";
const char* outfile = "ngsi10.notifyContextRequest_ok.expected1.valid.json";
std::string rendered;
utInit();
ci.outMimeType = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
ci.inMimeType = JSON;
ci.outMimeType = JSON;
lmTraceLevelSet(LmtDump, true);
std::string result = jsonTreat(testBuf, &ci, &reqData, NotifyContext, NULL);
EXPECT_EQ("OK", result);
lmTraceLevelSet(LmtDump, false);
//
// With the data obtained, render, present and release methods are exercised
//
std::vector<std::string> emptyV;
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile << "'";
rendered = ncrP->toJsonV1(false, emptyV, false, emptyV);
EXPECT_STREQ(expectedBuf, rendered.c_str());
ncrP->release();
utExit();
}
/* ****************************************************************************
*
* updateTwoStringsJson -
*/
TEST(compoundValue, updateTwoStringsJson)
{
ParseData reqData;
const char* inFile = "ngsi10.updateContextRequest.updateTwoStrings.valid.json";
ConnectionInfo ci("/ngsi10/updateContext", "POST", "1.1");
ContextAttribute* caP;
orion::CompoundValueNode* cvnRootP;
orion::CompoundValueNode* childP;
RestService restService = { UpdateContext, 2, { "ngsi10", "updateContext" }, NULL };
utInit();
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
ci.inMimeType = JSON;
ci.outMimeType = JSON;
ci.restServiceP = &restService;
std::string result = jsonTreat(testBuf, &ci, &reqData, UpdateContext, NULL);
EXPECT_STREQ("OK", result.c_str());
caP = reqData.upcr.res.entityVector[0]->attributeVector[0];
EXPECT_TRUE(caP != NULL);
EXPECT_TRUE(caP->compoundValueP != NULL);
// Get root of compound value
cvnRootP = caP->compoundValueP;
// The root should be a struct in this test case
EXPECT_EQ(orion::ValueTypeObject, cvnRootP->valueType);
// The root should have exactly two children
EXPECT_EQ(2, cvnRootP->childV.size());
// child 1
childP = cvnRootP->childV[0];
EXPECT_EQ("s1", childP->name);
EXPECT_EQ(orion::ValueTypeString, childP->valueType);
EXPECT_EQ("STRING", childP->stringValue);
EXPECT_EQ(0, childP->childV.size());
// child 2
childP = cvnRootP->childV[1];
EXPECT_EQ("s2", childP->name);
EXPECT_EQ(orion::ValueTypeString, childP->valueType);
EXPECT_EQ("STRING", childP->stringValue);
EXPECT_EQ(0, childP->childV.size());
utExit();
}
/* ****************************************************************************
*
* json_overwriteEntityIdType -
*/
TEST(RegisterContextRequest, json_overwriteEntityIdType)
{
ParseData parseData;
const char* inFile = "ngsi9.registerContextRequest.overwriteEntityIdType.invalid.json";
ConnectionInfo ci("", "POST", "1.1");
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
std::string result = jsonTreat(testBuf, &ci, &parseData, RegisterContext, "registerContextRequest", NULL);
EXPECT_EQ("OK", result) << "error at overwriting EntityIdType";
}
/* ****************************************************************************
*
* parseError_json -
*/
TEST(DiscoverContextAvailabilityRequest, parseError_json)
{
ParseData reqData;
const char* inFile = "ngsi9.discoverContextAvailabilityRequest.parseError.invalid.json";
ConnectionInfo ci("", "POST", "1.1");
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
std::string result = jsonTreat(testBuf, &ci, &reqData, DiscoverContextAvailability, "discoverContextAvailabilityRequest", NULL);
EXPECT_NE("OK", result) << "Parse Error not detected";
}
/* ****************************************************************************
*
* updateContextValueVectorFiveItemsJson -
*/
TEST(compoundValue, updateContextValueVectorFiveItemsJson)
{
ParseData reqData;
const char* inFile = "ngsi10.updateContextRequest.updateContextValueVectorFiveItems.valid.json";
ConnectionInfo ci("/ngsi10/updateContext", "POST", "1.1");
ContextAttribute* caP;
orion::CompoundValueNode* cvnRootP;
orion::CompoundValueNode* childP;
RestService restService = { UpdateContext, 2, { "ngsi10", "updateContext" }, NULL };
utInit();
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
ci.inMimeType = JSON;
ci.outMimeType = JSON;
ci.restServiceP = &restService;
std::string result = jsonTreat(testBuf, &ci, &reqData, UpdateContext, NULL);
EXPECT_STREQ("OK", result.c_str());
caP = reqData.upcr.res.entityVector[0]->attributeVector[0];
EXPECT_TRUE(caP != NULL);
EXPECT_TRUE(caP->compoundValueP != NULL);
// Get root of compound value
cvnRootP = caP->compoundValueP;
// The root should be a 'vector' in this test case
EXPECT_EQ(orion::ValueTypeVector, cvnRootP->valueType);
// The root should have five children
EXPECT_EQ(5, cvnRootP->childV.size());
// Child 1-5
std::string value[] = { "1", "2", "3", "4", "5" };
for (unsigned int childIx = 0; childIx < 5; ++childIx)
{
childP = cvnRootP->childV[childIx];
EXPECT_EQ("item", childP->name);
EXPECT_EQ(orion::ValueTypeString, childP->valueType);
EXPECT_EQ(value[childIx], childP->stringValue);
EXPECT_EQ(0, childP->childV.size());
}
utExit();
}
/* ****************************************************************************
*
* json_reregistration -
*/
TEST(RegisterContextRequest, json_reregistration)
{
ParseData parseData;
const char* inFile = "ngsi9.registerContextRequest.reregistration.valid.json";
const char* expect = "OK";
ConnectionInfo ci("", "POST", "1.1");
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
std::string result = jsonTreat(testBuf, &ci, &parseData, RegisterContext, "registerContextRequest", NULL);
EXPECT_EQ(expect, result);
}
/* ****************************************************************************
*
* json_entityIdWithIsPatternTrue -
*/
TEST(RegisterContextRequest, json_entityIdWithIsPatternTrue)
{
ParseData parseData;
const char* inFile = "ngsi9.registerContextRequest.entityIdWithIsPatternTrue.valid.json";
const char* expect = "OK";
ConnectionInfo ci("", "POST", "1.1");
ci.inMimeType = JSON;
ci.outMimeType = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
std::string result = jsonTreat(testBuf, &ci, &parseData, RegisterContext, "registerContextRequest", NULL);
EXPECT_EQ(expect, result) << "entityIdWithIsPatternTrue error";
}
/* ****************************************************************************
*
* payloadParse -
*/
std::string payloadParse
(
ConnectionInfo* ciP,
ParseData* parseDataP,
RestService* service,
JsonRequest** jsonPP,
JsonDelayedRelease* jsonReleaseP,
std::vector<std::string>& compV
)
{
std::string result = "NONE";
LM_T(LmtParsedPayload, ("parsing data for service '%s'. Method: '%s'", requestType(service->request), ciP->method.c_str()));
LM_T(LmtParsedPayload, ("outFormat: %s", formatToString(ciP->outFormat)));
ciP->requestType = service->request;
if (ciP->inFormat == JSON)
{
if (compV[0] == "v2")
{
result = jsonRequestTreat(ciP, parseDataP, service->request, jsonReleaseP, compV);
}
else
{
result = jsonTreat(ciP->payload, ciP, parseDataP, service->request, service->payloadWord, jsonPP);
}
}
else if (ciP->inFormat == TEXT)
{
result = textRequestTreat(ciP, parseDataP, service->request);
}
else
{
alarmMgr.badInput(clientIp, "payload mime-type is not JSON");
return "Bad inFormat";
}
LM_T(LmtParsedPayload, ("result: '%s'", result.c_str()));
LM_T(LmtParsedPayload, ("outFormat: %s", formatToString(ciP->outFormat)));
if (result != "OK")
{
restReply(ciP, result);
}
return result;
}
/* ****************************************************************************
*
* jsonTreat -
*/
TEST(jsonRequest, jsonTreat)
{
ConnectionInfo ci("/ngsi9/registerContext", "POST", "1.1");
ParseData parseData;
std::string out;
const char* outfile1 = "orion.jsonRequest.jsonTreat.valid.json";
utInit();
ci.outFormat = JSON;
out = jsonTreat("", &ci, &parseData, InvalidRequest, "no_payload", NULL);
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile1)) << "Error getting test data from '" << outfile1 << "'";
EXPECT_STREQ(expectedBuf, out.c_str());
utExit();
}
/* ****************************************************************************
*
* json_badContextRegistrationAttributeIsDomain -
*/
TEST(RegisterContextRequest, json_badContextRegistrationAttributeIsDomain)
{
ParseData parseData;
const char* inFile = "ngsi9.registerContextRequest.badContextRegistrationAttributeIsDomain.invalid.json";
const char* outFile = "ngsi9.registerContextResponse.badContextRegistrationAttributeIsDomain.valid.json";
ConnectionInfo ci("", "POST", "1.1");
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFile)) << "Error getting test data from '" << outFile << "'";
std::string result = jsonTreat(testBuf, &ci, &parseData, RegisterContext, "registerContextRequest", NULL);
EXPECT_STREQ(expectedBuf, result.c_str());
}
/* ****************************************************************************
*
* emptyAttributeName_json -
*/
TEST(DiscoverContextAvailabilityRequest, emptyAttributeName_json)
{
ParseData reqData;
const char* inFile = "ngsi9.discoverContextAvailabilityRequest.emptyAttributeName.invalid.json";
const char* outFile = "ngsi9.discoverContextAvailabilityResponse.emptyAttributeName.valid.json";
ConnectionInfo ci("", "POST", "1.1");
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFile)) << "Error getting test data from '" << outFile << "'";
std::string result = jsonTreat(testBuf, &ci, &reqData, DiscoverContextAvailability, "discoverContextAvailabilityRequest", NULL);
EXPECT_STREQ(expectedBuf, result.c_str());
}
/* ****************************************************************************
*
* ok_json -
*/
TEST(DiscoverContextAvailabilityRequest, ok_json)
{
ParseData reqData;
const char* inFile = "ngsi9.discoverContextAvailabilityRequest.ok2.valid.json";
ConnectionInfo ci("", "POST", "1.1");
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
lmTraceLevelSet(LmtDump, true);
std::string result = jsonTreat(testBuf, &ci, &reqData, DiscoverContextAvailability, "discoverContextAvailabilityRequest", NULL);
EXPECT_EQ("OK", result) << "this test should be OK";
lmTraceLevelSet(LmtDump, false);
}
/* ****************************************************************************
*
* json_badIsPattern -
*/
TEST(SubscribeContextAvailabilityRequest, json_badIsPattern)
{
ParseData reqData;
const char* infile = "ngsi9.subscribeContextAvailabilityRequest.badIsPattern.invalid.json";
ConnectionInfo ci("", "POST", "1.1");
utInit();
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
std::string result = jsonTreat(testBuf, &ci, &reqData, SubscribeContextAvailability, "subscribeContextAvailabilityRequest", NULL);
EXPECT_EQ("OK", result);
utExit();
}
/* ****************************************************************************
*
* scopeGeolocationPolygonInvertedJson -
*/
TEST(SubscribeContextRequest, scopeGeolocationPolygonInvertedJson)
{
ParseData parseData;
const char* inFile = "ngsi10.subscribeContextRequest.polygonInverted.postponed.json";
ConnectionInfo ci("/ngsi10/subscribeContext", "POST", "1.1");
std::string result;
utInit();
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
result = jsonTreat(testBuf, &ci, &parseData, SubscribeContext, "subscribeContextRequest", NULL);
EXPECT_STREQ("OK", result.c_str());
utExit();
}
/* ****************************************************************************
*
* updateNoCompoundValue -
*/
TEST(compoundValue, updateNoCompoundValue)
{
ParseData reqData;
const char* inFileJson = "ngsi10.updateContextRequest.updateNoCompoundValue.valid.json";
ConnectionInfo ci("/ngsi10/updateContext", "POST", "1.1");
ContextAttribute* caP;
std::string result;
utInit();
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFileJson)) << "Error getting test data from '" << inFileJson << "'";
ci.inMimeType = JSON;
result = jsonTreat(testBuf, &ci, &reqData, UpdateContext, NULL);
EXPECT_STREQ("OK", result.c_str());
caP = reqData.upcr.res.entityVector[0]->attributeVector[0];
EXPECT_EQ("1", caP->stringValue);
utExit();
}
/* ****************************************************************************
*
* emptyAttributeExpression_json -
*/
TEST(QueryContextRequest, emptyAttributeExpression_json)
{
ParseData parseData;
ConnectionInfo ci("", "POST", "1.1");
const char* infile = "ngsi10.queryContextRequest.emptyAttributeExpression.invalid.json";
const char* outfile = "ngsi10.queryContextResponse.emptyAttributeExpression.valid.json";
utInit();
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile << "'";
std::string out = jsonTreat(testBuf, &ci, &parseData, QueryContext, "queryContextRequest", NULL);
EXPECT_STREQ(expectedBuf, out.c_str());
utExit();
}
/* ****************************************************************************
*
* json_badDuration -
*/
TEST(SubscribeContextAvailabilityRequest, json_badDuration)
{
ParseData reqData;
const char* infile = "ngsi9.subscribeContextAvailabilityRequest.badDuration.invalid.json";
const char* outfile = "ngsi9.subscribeContextAvailabilityResponse.badDuration.valid.json";
ConnectionInfo ci("", "POST", "1.1");
utInit();
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile << "'";
std::string out = jsonTreat(testBuf, &ci, &reqData, SubscribeContextAvailability, "subscribeContextAvailabilityRequest", NULL);
EXPECT_STREQ(expectedBuf, out.c_str());
utExit();
}
/* ****************************************************************************
*
* json_badIsPattern -
*/
TEST(NotifyContextRequest, json_badIsPattern)
{
ParseData reqData;
ConnectionInfo ci("", "POST", "1.1");
const char* infile = "ngsi10.notifyContextRequest.badIsPattern.invalid.json";
const char* outfile = "ngsi10.notifyContextResponse.badIsPattern.valid.json";
utInit();
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile << "'";
ci.inMimeType = JSON;
ci.outMimeType = JSON;
std::string out = jsonTreat(testBuf, &ci, &reqData, NotifyContext, NULL);
EXPECT_STREQ(expectedBuf, out.c_str());
utExit();
}
/* ****************************************************************************
*
* scopeGeolocationCircleZeroRadiusJson -
*/
TEST(SubscribeContextRequest, scopeGeolocationCircleZeroRadiusJson)
{
ParseData reqData;
const char* inFile = "ngsi10.subscribeContextRequest.circleZeroRadius.postponed.json";
const char* outFile = "ngsi10.subscribeContextResponse.circleZeroRadius.valid.json";
ConnectionInfo ci("/ngsi10/subscribeContext", "POST", "1.1");
std::string result;
utInit();
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFile)) << "Error getting test data from '" << outFile << "'";
result = jsonTreat(testBuf, &ci, &reqData, SubscribeContext, "subscribeContextRequest", NULL);
EXPECT_STREQ(expectedBuf, result.c_str());
utExit();
}
/* ****************************************************************************
*
* json_invalidIsPattern -
*/
TEST(UpdateContextAvailabilitySubscriptionRequest, json_invalidIsPattern)
{
ParseData reqData;
const char* infile = "updateContextAvailabilitySubscriptionRequest_invalidIsPattern.json";
const char* outfile = "ngsi9.updateContextAvailabilitySubscriptionResponse.invalidIsPattern.valid.json";
ConnectionInfo ci("", "POST", "1.1");
utInit();
ci.inMimeType = JSON;
ci.outMimeType = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile << "'";
std::string out = jsonTreat(testBuf, &ci, &reqData, UpdateContextAvailabilitySubscription, NULL);
EXPECT_STREQ(expectedBuf, out.c_str());
utExit();
}
/* ****************************************************************************
*
* badIsPattern_json -
*/
TEST(UpdateContextRequest, badIsPattern_json)
{
ParseData parseData;
ConnectionInfo ci("", "POST", "1.1");
const char* infile = "ngsi10.updateContextRequest.badIsPattern.invalid.json";
const char* outfile = "ngsi10.updateContextResponse.badIsPattern.invalid.json";
JsonRequest* reqP;
utInit();
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile)) << "Error getting test data from '" << outfile;
std::string out = jsonTreat(testBuf, &ci, &parseData, UpdateContext, "updateContextRequest", &reqP);
EXPECT_STREQ(expectedBuf, out.c_str());
reqP->release(&parseData);
utExit();
}
/* ****************************************************************************
*
* json_ok -
*/
TEST(UpdateContextAvailabilitySubscriptionRequest, json_ok)
{
ConnectionInfo ci("", "POST", "1.1");
ParseData parseData;
const char* infile = "ngsi9.updateContextAvailabilitySubscriptionRequest.ok.valid.json";
const char* outfile1 = "ngsi9.updateContextAvailabilitySubscriptionRequest.expected1.valid.json";
const char* outfile2 = "ngsi9.updateContextAvailabilitySubscriptionRequest.expected2.valid.json";
const char* outfile3 = "ngsi9.updateContextAvailabilitySubscriptionRequest.expected3.valid.json";
std::string out;
utInit();
ci.inMimeType = JSON;
ci.outMimeType = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), infile)) << "Error getting test data from '" << infile << "'";
lmTraceLevelSet(LmtDump, true);
out = jsonTreat(testBuf, &ci, &parseData, UpdateContextAvailabilitySubscription, NULL);
lmTraceLevelSet(LmtDump, false);
EXPECT_EQ("OK", out) << "this test should be OK";
UpdateContextAvailabilitySubscriptionRequest* ucasP = &parseData.ucas.res;
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile1)) << "Error getting test data from '" << outfile1 << "'";
out = ucasP->toJsonV1();
EXPECT_STREQ(expectedBuf, out.c_str());
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile2)) << "Error getting test data from '" << outfile2 << "'";
out = ucasP->check("predetected error", 0);
EXPECT_STREQ(expectedBuf, out.c_str());
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile3)) << "Error getting test data from '" << outfile3 << "'";
ucasP->duration.set("eeeee");
out = ucasP->check("", 0);
EXPECT_STREQ(expectedBuf, out.c_str());
utExit();
}
/* ****************************************************************************
*
* updateUnknownPath -
*/
TEST(compoundValue, updateUnknownPath)
{
ParseData reqData;
const char* inFileJson = "ngsi10.updateContextRequest.updateUnknownPath.invalid.json";
const char* outFileJson = "ngsi10.updateContextResponse.updateUnknownPath.valid.json";
ConnectionInfo ciJson("/ngsi10/updateContext", "POST", "1.1");
std::string result;
RestService restService = { UpdateContext, 2, { "ngsi10", "updateContext" }, NULL };
utInit();
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFileJson)) << "Error getting test data from '" << inFileJson << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFileJson)) << "Error getting test data from '" << outFileJson << "'";
ciJson.inMimeType = JSON;
ciJson.outMimeType = JSON;
ciJson.restServiceP = &restService;
result = jsonTreat(testBuf, &ciJson, &reqData, UpdateContext, NULL);
EXPECT_STREQ(expectedBuf, result.c_str());
utExit();
}
/* ****************************************************************************
*
* json_ok -
*/
TEST(RegisterContextRequest, json_ok)
{
ParseData parseData;
const char* inFile = "ngsi9.registerContextRequest.ok.valid.json";
const char* outFile = "ngsi9.registerContextRequestRendered.ok.valid.json";
RegisterContextRequest* rcrP = &parseData.rcr.res;
ConnectionInfo ci("", "POST", "1.1");
JsonRequest* reqP;
std::string out;
ci.inFormat = JSON;
ci.outFormat = JSON;
EXPECT_EQ("OK", testDataFromFile(testBuf, sizeof(testBuf), inFile)) << "Error getting test data from '" << inFile << "'";
EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outFile)) << "Error getting test data from '" << outFile << "'";
std::string result = jsonTreat(testBuf, &ci, &parseData, RegisterContext, "registerContextRequest", &reqP);
EXPECT_EQ("OK", result) << "this test should be OK";
out = rcrP->render(RegisterContext, JSON, "");
EXPECT_STREQ(expectedBuf, out.c_str());
reqP->release(&parseData);
}
