// Process
#include <EventOperation.hpp>
#include <Launcher.hpp>
+#include <Procedure.hpp>
+#include <MyDiameterEngine.hpp>
+#include <MyLocalServer.hpp>
+#include <anna/testing/TestManager.hpp>
+
+// Standard
+#include <fstream>
+#include <unistd.h> // chdir
// Project
#include <anna/diameter.comm/OriginHost.hpp>
-
-
-//// Standard
-//#include <sstream> // std::istringstream
-//#include <iostream> // std::cout
-//#include <math.h> // ceil
-//#include <climits>
-#include <unistd.h> // chdir
-//#include <stdio.h>
-//
-//// Project
#include <anna/json/functions.hpp>
#include <anna/diameter/codec/Message.hpp>
-//#include <anna/timex/Engine.hpp>
-//#include <anna/statistics/Engine.hpp>
-//#include <anna/diameter/codec/functions.hpp>
-//#include <anna/diameter/codec/Engine.hpp>
-//#include <anna/diameter/codec/EngineManager.hpp>
-//#include <anna/http/Transport.hpp>
-//#include <anna/diameter/stack/Engine.hpp>
-//#include <anna/diameter/helpers/base/functions.hpp>
-//#include <anna/time/functions.hpp>
-//#include <anna/diameter.comm/ApplicationMessageOamModule.hpp>
-//#include <anna/testing/defines.hpp>
+#include <anna/diameter/helpers/base/functions.hpp>
+#include <anna/time/functions.hpp>
+#include <anna/core/functions.hpp>
#include <anna/xml/xml.hpp>
-//#include <anna/diameter.comm/OriginHost.hpp>
-//#include <anna/diameter.comm/OriginHostManager.hpp>
-//
-//// Process
-//#include <Launcher.hpp>
-//#include <Procedure.hpp>
-//#include <EventOperation.hpp>
-#include <MyDiameterEngine.hpp>
-#include <MyLocalServer.hpp>
-//#include <anna/testing/TestManager.hpp>
-//#include <anna/testing/TestCase.hpp>
+#include <anna/diameter.comm/Message.hpp>
/////////////////////
/////////////////////
// Flow operations //
/////////////////////
-bool EventOperation::sendmsg2e(std::string &response, const std::string & diameterJson) {
+bool EventOperation::sendmsg_hex_2e(std::string &response, const std::string & diameterJson_or_Hex, bool msg_or_hex) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::diameter::codec::Message codecMsg; // auxiliary codec message
+ bool success;
+ anna::diameter::comm::Message *msg;
+ if(msg_or_hex) {
+ std::string diameterXml = anna::json::functions::json2xml(diameterJson_or_Hex, success);
+ if (!success) {
+ response += "json to xml failed, unable to send message !";
+ return false;
+ }
+ codecMsg.loadXMLString(diameterXml);
+ try {
+ my_app.updateOperatedOriginHostWithMessage(codecMsg);
+ msg = my_app.getOperatedHost()->createCommMessage();
+ msg->clearBody();
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid operated host";
+ return false;
+ }
+ try { codecMsg.valid(); } catch(anna::RuntimeException &ex) { ex.trace(); } // at least we need to see validation errors although it will continue sending (see validation mode configured in launcher)
+ msg->setBody(codecMsg.code());
+ } else {
+ // Get DataBlock from hex content:
+ anna::DataBlock db_aux(true);
+ std::string hexString = diameterJson_or_Hex;
+ hexString.erase(std::remove(hexString.begin(), hexString.end(), ':'), hexString.end());
+ LOGDEBUG(
+ std::string msg = "Hex string (remove colons if exists): ";
+ msg += hexString;
+ anna::Logger::debug(msg, ANNA_FILE_LOCATION);
+ );
+ anna::functions::fromHexString(hexString, db_aux); // could launch exception
+ try {
+ my_app.updateOperatedOriginHostWithMessage(db_aux);
+ msg = my_app.getOperatedHost()->createCommMessage();
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid operated host";
+ return false;
+ }
+ msg->setBody(db_aux);
+ try { if(my_app.getOperatedHost()->logEnabled()) codecMsg.decode(db_aux); } catch(anna::RuntimeException &ex) { ex.trace(); }
+ }
+ success = my_app.getOperatedEntity()->send(msg);
+ my_app.getOperatedHost()->releaseCommMessage(msg);
- return true; // OK
-}
-
-bool EventOperation::sendmsg2c(std::string &response, const std::string & diameterJson) {
-
- Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
-
+ // Detailed log:
+ if(my_app.getOperatedHost()->logEnabled()) {
+ anna::diameter::comm::Server *usedServer = my_app.getOperatedEntity()->getLastUsedResource();
+ anna::diameter::comm::ClientSession *usedClientSession = usedServer ? usedServer->getLastUsedResource() : NULL;
+ std::string detail = usedClientSession ? usedClientSession->asString() : "[null client session]"; // shouldn't happen
+ my_app.getOperatedHost()->writeLogFile(codecMsg, (success ? "sent2e" : "send2eError"), detail);
+ }
- return true; // OK
+ response = "Operation processed"; // could be failed
+ return success;
}
-bool EventOperation::answermsg2e(std::string &response, const std::string & diameterJson) {
+bool EventOperation::sendmsg_hex_2c(std::string &response, const std::string & diameterJson_or_Hex, bool msg_or_hex) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::diameter::codec::Message codecMsg; // auxiliary codec message
+ bool success;
+ anna::diameter::comm::Message *msg;
+ if(msg_or_hex) {
+ std::string diameterXml = anna::json::functions::json2xml(diameterJson_or_Hex, success);
+ if (!success) {
+ response += "json to xml failed, unable to send message !";
+ return false;
+ }
+ codecMsg.loadXMLString(diameterXml);
+ try {
+ my_app.updateOperatedOriginHostWithMessage(codecMsg);
+ msg = my_app.getOperatedHost()->createCommMessage();
+ msg->clearBody();
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid operated host";
+ return false;
+ }
+ try { codecMsg.valid(); } catch(anna::RuntimeException &ex) { ex.trace(); } // at least we need to see validation errors although it will continue sending (see validation mode configured in launcher)
+ msg->setBody(codecMsg.code());
+ } else {
+ // Get DataBlock from hex content:
+ anna::DataBlock db_aux(true);
+ std::string hexString = diameterJson_or_Hex;
+ hexString.erase(std::remove(hexString.begin(), hexString.end(), ':'), hexString.end());
+ LOGDEBUG(
+ std::string msg = "Hex string (remove colons if exists): ";
+ msg += hexString;
+ anna::Logger::debug(msg, ANNA_FILE_LOCATION);
+ );
+ anna::functions::fromHexString(hexString, db_aux); // could launch exception
+ try {
+ my_app.updateOperatedOriginHostWithMessage(db_aux);
+ msg = my_app.getOperatedHost()->createCommMessage();
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid operated host";
+ return false;
+ }
+ msg->setBody(db_aux);
+ try { if(my_app.getOperatedHost()->logEnabled()) codecMsg.decode(db_aux); } catch(anna::RuntimeException &ex) { ex.trace(); }
+ }
+ success = my_app.getOperatedServer()->send(msg);
+ my_app.getOperatedHost()->releaseCommMessage(msg);
- return true; // OK
-}
-
-bool EventOperation::answermsg2c(std::string &response, const std::string & diameterJson) {
-
- Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
-
+ // Detailed log:
+ if(my_app.getOperatedHost()->logEnabled()) {
+ anna::diameter::comm::ServerSession *usedServerSession = my_app.getOperatedServer()->getLastUsedResource();
+ std::string detail = usedServerSession ? usedServerSession->asString() : "[null server session]"; // shouldn't happen
+ my_app.getOperatedHost()->writeLogFile(codecMsg, (success ? "sent2c" : "send2cError"), detail);
+ }
- return true; // OK
+ response = "Operation processed"; // could be failed
+ return success;
}
-bool EventOperation::answermsg2e_action(std::string &response, const std::string & action) {
+bool EventOperation::answermsg_action_2e(std::string &response, const std::string & diameterJson_or_action, bool msg_or_action) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::diameter::codec::Message codecMsg; // auxiliary codec message
+ anna::diameter::codec::Message *message;
+ bool success;
+ if (msg_or_action) {
+ std::string diameterXml = anna::json::functions::json2xml(diameterJson_or_action, success);
+ if (!success) {
+ response += "json to xml failed, unable to send message !";
+ return false;
+ }
+ codecMsg.loadXMLString(diameterXml);
+ try {
+ my_app.updateOperatedOriginHostWithMessage(codecMsg);
+ message = my_app.getOperatedHost()->getCodecEngine()->createMessage(diameterXml, false /* is xml string */); // loads xml again, lesser of two evils
+ LOGDEBUG(anna::Logger::debug(message->asXMLString(), ANNA_FILE_LOCATION));
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid operated host";
+ return false;
+ }
- return true; // OK
-}
-
-bool EventOperation::answermsg2c_action(std::string &response, const std::string & action) {
-
- Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ if(message->isRequest()) {
+ response += "cannot program diameter requests. Answer type must be provided";
+ return false;
+ }
+ int code = message->getId().first;
+ LOGDEBUG(anna::Logger::debug("Adding a new programed 'answer to entity' to the FIFO queue corresponding to its message code ...", ANNA_FILE_LOCATION));
+ response = "Added 'answer to entity' to the FIFO queue corresponding to its message code";
+ my_app.getOperatedHost()->getReactingAnswers()->addMessage(code, message);
+ }
+ else { // action
+
+ if(diameterJson_or_action == "list") { // programmed answers FIFO's to stdout
+ response = anna::functions::encodeBase64(my_app.getOperatedHost()->getReactingAnswers()->asString("ANSWERS TO ENTITY"));
+ } else if (diameterJson_or_action == "rotate") {
+ my_app.getOperatedHost()->getReactingAnswers()->rotate(true);
+ response = "rotate";
+ } else if (diameterJson_or_action == "exhaust") {
+ my_app.getOperatedHost()->getReactingAnswers()->rotate(false);
+ response = "exhaust";
+ } else if (diameterJson_or_action == "clear") {
+ my_app.getOperatedHost()->getReactingAnswers()->clear();
+ response = "clear";
+ } else if (diameterJson_or_action == "dump") {
+ my_app.getOperatedHost()->getReactingAnswers()->dump("programmed_answer");
+ response = "dump";
+ }
+ }
return true; // OK
}
-bool EventOperation::sendhex2e(std::string &response, const std::string & diameterHex) {
+bool EventOperation::answermsg_action_2c(std::string &response, const std::string & diameterJson_or_action, bool msg_or_action) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::diameter::codec::Message codecMsg; // auxiliary codec message
+ anna::diameter::codec::Message *message;
+ bool success;
+ if (msg_or_action) {
+ std::string diameterXml = anna::json::functions::json2xml(diameterJson_or_action, success);
+ if (!success) {
+ response += "json to xml failed, unable to send message !";
+ return false;
+ }
+ codecMsg.loadXMLString(diameterXml);
+ try {
+ my_app.updateOperatedOriginHostWithMessage(codecMsg);
+ message = my_app.getOperatedHost()->getCodecEngine()->createMessage(diameterXml, false /* is xml string */); // loads xml again, lesser of two evils
+ LOGDEBUG(anna::Logger::debug(message->asXMLString(), ANNA_FILE_LOCATION));
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid operated host";
+ return false;
+ }
- return true; // OK
-}
-
-bool EventOperation::sendhex2c(std::string &response, const std::string & diameterHex) {
-
- Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ if(message->isRequest()) {
+ response += "cannot program diameter requests. Answer type must be provided";
+ return false;
+ }
+ int code = message->getId().first;
+ LOGDEBUG(anna::Logger::debug("Adding a new programed 'answer to client' to the FIFO queue corresponding to its message code ...", ANNA_FILE_LOCATION));
+ my_app.getOperatedHost()->getReactingAnswers()->addMessage(code, message);
+ response = "Added 'answer to client' to the FIFO queue corresponding to its message code";
+ }
+ else { // action
+
+ if(diameterJson_or_action == "list") { // programmed answers FIFO's to stdout
+ response = anna::functions::encodeBase64(my_app.getOperatedHost()->getReactingAnswers()->asString("ANSWERS TO CLIENT"));
+ } else if (diameterJson_or_action == "rotate") {
+ my_app.getOperatedHost()->getReactingAnswers()->rotate(true);
+ response = "rotate";
+ } else if (diameterJson_or_action == "exhaust") {
+ my_app.getOperatedHost()->getReactingAnswers()->rotate(false);
+ response = "exhaust";
+ } else if (diameterJson_or_action == "clear") {
+ my_app.getOperatedHost()->getReactingAnswers()->clear();
+ response = "clear";
+ } else if (diameterJson_or_action == "dump") {
+ my_app.getOperatedHost()->getReactingAnswers()->dump("programmed_answer");
+ response = "dump";
+ }
+ }
return true; // OK
}
-
/////////////////
// FSM testing //
/////////////////
bool EventOperation::test_id__description(std::string &response, unsigned int id, const std::string & description) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ try {
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ tc->setDescription(description);
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid ip-limit";
+ return false;
+ }
return true; // OK
}
bool EventOperation::test_id__ip_limit(std::string &response, unsigned int id, int amount) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ try {
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ tc->addIpLimit(amount);
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid ip-limit";
+ return false;
+ }
return true; // OK
}
bool EventOperation::test_id__timeout(std::string &response, unsigned int id, int msecs) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ try {
+ anna::Millisecond timeout = my_app.checkTimeMeasure("Test case timeout", anna::functions::asString(msecs));
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ tc->addTimeout(timeout);
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid timeout";
+ return false;
+ }
return true; // OK
}
-bool EventOperation::test_id__sendmsg2e(std::string &response, unsigned int id, const std::string & diameterJson, int stepNumber) {
+bool EventOperation::test_id__sendmsg2e_2c(std::string &response, unsigned int id, bool _2e_or_2c, const std::string & diameterJson, int stepNumber) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ bool success;
+ std::string diameterXml = anna::json::functions::json2xml(diameterJson, success);
+ if (!success) {
+ response += "json to xml failed, unable to load message !";
+ return false;
+ }
+ anna::diameter::codec::Message codecMsg; // auxiliary codec message
+ codecMsg.loadXMLString(diameterXml);
+ LOGWARNING(
+ if (!codecMsg.isRequest() && (stepNumber == -1))
+ anna::Logger::warning("Step number has not been provided. Take into account that this answer message will be sent 'as is' and sequence information could be wrong at the remote peer", ANNA_FILE_LOCATION);
+ );
- return true; // OK
-}
-
-bool EventOperation::test_id__sendmsg2c(std::string &response, unsigned int id, const std::string & diameterJson, int stepNumber) {
-
- Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
-
-
+ try {
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ my_app.updateOperatedOriginHostWithMessage(codecMsg);
+ if (_2e_or_2c)
+ tc->addSendDiameterXml2e(codecMsg.code(), my_app.getOperatedHost(), stepNumber);
+ else
+ tc->addSendDiameterXml2c(codecMsg.code(), my_app.getOperatedHost(), stepNumber);
+
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "failed";
+ return false;
+ }
return true; // OK
}
bool EventOperation::test_id__delay(std::string &response, unsigned int id, int msecs) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ try {
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ anna::Millisecond delay = ((msecs == 0 /* special case */) ? (anna::Millisecond)0 : my_app.checkTimeMeasure("Test case delay step", anna::functions::asString(msecs)));
+ tc->addDelay(delay); // creates / reuses
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "invalid delay";
+ return false;
+ }
return true; // OK
}
bool EventOperation::test_id__sh_command(std::string &response, unsigned int id, const std::string & script) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
-
- return true; // OK
-}
-
-bool EventOperation::test_id__waitfe_hex(std::string &response, unsigned int id, const std::string & hex, bool strict) {
-
- Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
-
-
+ try {
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ tc->addCommand(script); // creates / reuses
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "failed";
+ return false;
+ }
return true; // OK
}
-bool EventOperation::test_id__waitfc_hex(std::string &response, unsigned int id, const std::string & hex, bool strict) {
+bool EventOperation::test_id__waitfefc_hex(std::string &response, unsigned int id, bool fe_or_fc, const std::string & hex, bool strict) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ // Get DataBlock from hex content:
+ anna::DataBlock db_aux(true);
+ std::string hexString = hex;
+ hexString.erase(std::remove(hexString.begin(), hexString.end(), ':'), hexString.end());
+ LOGDEBUG(
+ std::string msg = "Hex string (remove colons if exists): ";
+ msg += hexString;
+ anna::Logger::debug(msg, ANNA_FILE_LOCATION);
+ );
+
+ std::string regexp;
+ try {
+ anna::functions::fromHexString(hexString, db_aux); // could launch exception
+ regexp = anna::functions::asHexString(db_aux);
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "failed";
+ return false;
+ }
+ // optional 'full':
+ if(!strict) {
+ //// If request, we will ignore sequence data:
+ //if (anna::diameter::codec::functions::requestBit(db_aux))
+ regexp.replace (24, 16, "[0-9A-Fa-f]{16}");
- return true; // OK
-}
-
-bool EventOperation::test_id__waitfe_msg(std::string &response, unsigned int id, const std::string & diameterJson, bool strict) {
-
- Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
-
+ regexp.insert(0, "^");
+ regexp += "$";
+ }
+ try {
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ tc->addWaitDiameterRegexpHex(fe_or_fc, regexp);
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "failed";
+ return false;
+ }
return true; // OK
}
-bool EventOperation::test_id__waitfc_msg(std::string &response, unsigned int id, const std::string & diameterJson, bool strict) {
+bool EventOperation::test_id__waitfefc_msg(std::string &response, unsigned int id, bool fe_or_fc, const std::string & diameterJson, bool strict) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ bool success;
+ std::string diameterXml = anna::json::functions::json2xml(diameterJson, success);
+ if (!success) {
+ response += "json to xml failed, unable to load message !";
+ return false;
+ }
+ try {
+ anna::diameter::codec::Message codecMsg; // auxiliary codec message
+ codecMsg.loadXMLString(diameterXml);
+ std::string regexp = codecMsg.asXMLString(true /* normalization */);
+
+ // Now we must insert regular expressions in hop-by-hop, end-to-end and Origin-State-Id:
+
+ // optional 'full':
+ if(!strict) {
+ std::string::size_type pos, pos_1, pos_2;
+
+ pos = regexp.find("end-to-end-id=", 0u);
+ if (pos != std::string::npos) {
+ pos = regexp.find("\"", pos);
+ pos_1 = pos;
+ pos = regexp.find("\"", pos+1);
+ pos_2 = pos;
+ regexp.replace(pos_1 + 1, pos_2 - pos_1 - 1, "[0-9]+");
+ }
- return true; // OK
-}
-
-bool EventOperation::test_id__waitfe(std::string &response, unsigned int id, const std::string & condition) {
+ pos = regexp.find("hop-by-hop-id=", 0u);
+ if (pos != std::string::npos) {
+ pos = regexp.find("\"", pos);
+ pos_1 = pos;
+ pos = regexp.find("\"", pos+1);
+ pos_2 = pos;
+ regexp.replace(pos_1 + 1, pos_2 - pos_1 - 1, "[0-9]+");
+ }
- Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ // For this representation: <avp name="Origin-State-Id" data="1428633668"/>
+ //pos = regexp.find("Origin-State-Id", 0u);
+ //pos = regexp.find("\"", pos);
+ //pos = regexp.find("\"", pos+1);
+ //pos_1 = pos;
+ //pos = regexp.find("\"", pos+1);
+ //pos_2 = pos;
+ //regexp.replace(pos_1 + 1, pos_2 - pos_1 - 1, "[0-9]+");
+ // But we have this one: <avp data="1428633668" name="Origin-State-Id"/>
+ pos = regexp.find("Origin-State-Id", 0u);
+ if (pos != std::string::npos) {
+ pos = regexp.rfind("\"", pos);
+ pos = regexp.rfind("\"", pos-1);
+ pos = regexp.rfind("\"", pos-1);
+ pos_1 = pos;
+ pos = regexp.find("\"", pos+1);
+ pos_2 = pos;
+ regexp.replace(pos_1 + 1, pos_2 - pos_1 - 1, "[0-9]+");
+ }
+ //regexp.insert(0, "^");
+ //regexp += "$";
+ }
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ tc->addWaitDiameterRegexpXml(fe_or_fc, regexp);
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "failed";
+ return false;
+ }
return true; // OK
}
-bool EventOperation::test_id__waitfc(std::string &response, unsigned int id, const std::string & condition) {
+bool EventOperation::test_id__waitfefc(std::string &response, unsigned int id, bool fe_or_fc,
+ const std::string & code,
+ const std::string & bitR,
+ const std::string & hopByHop,
+ const std::string & applicationId,
+ const std::string & sessionId,
+ const std::string & resultCode,
+ const std::string & msisdn,
+ const std::string & imsi,
+ const std::string & serviceContextId) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ try { // [code]|[bitR]|[hopByHop]|[applicationId]|[sessionId]|[resultCode]|[msisdn]|[imsi]|[serviceContextId]
+ anna::testing::TestCase *tc = testManager.getTestCase(id); // creates / reuses
+ tc->addWaitDiameter(fe_or_fc, code, bitR, hopByHop, applicationId, sessionId, resultCode, msisdn, imsi, serviceContextId);
+ response = std::to_string(tc->getId());
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += "failed";
+ return false;
+ }
return true; // OK
}
bool EventOperation::test__ttps(std::string &response, int amount) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ bool success = testManager.configureTTPS(amount);
+ if (success) {
+ response = "Assigned new test launch rate to ";
+ response += anna::functions::asString(amount);
+ response += " events per second";
+ }
+ else {
+ response += "unable to configure the test rate provided";
+ }
-
- return true; // OK
+ return success; // OK
}
bool EventOperation::test__next(std::string &response, int syncAmount) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+
+ if (syncAmount < 1) {
+ response += "the parameter 'sync-amount' must be a positive integer value";
+ return false;
+ }
+ bool success = testManager.execTestCases(syncAmount);
+ response = (success ? "P" : "Not completely p" /* completed cycle and no repeats, rare case */);
+ response += "rocessed ";
+ response += anna::functions::asString(syncAmount);
+ response += ((syncAmount > 1) ? " test cases synchronously" : " test case");
- return true; // OK
+ return success;
}
bool EventOperation::test__ip_limit(std::string &response, int amount) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ if (amount > -2) {
+ testManager.setInProgressLimit(amount);
+ response = "New in-progress limit: ";
+ response += (amount != -1) ? anna::functions::asString(amount) : "[no limit]";
+ }
+ else {
+ response = "In-progress limit amount: ";
+ int limit = testManager.getInProgressLimit();
+ response += (limit != -1) ? anna::functions::asString(limit) : "[no limit]";
+ response += "; currently there are ";
+ response += anna::functions::asString(testManager.getInProgressCount());
+ response += " test cases running";
+ }
return true; // OK
}
bool EventOperation::test__goto(std::string &response, int id) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ bool success = testManager.gotoTestCase(id);
+ if (success) {
+ response = "Position updated for id provided (";
+ }
+ else {
+ response += "cannot found test id (";
+ }
+ response += anna::functions::asString(id);
+ response += ")";
- return true; // OK
+ return success;
}
bool EventOperation::test__run(std::string &response, int id) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ bool success = testManager.runTestCase(id);
+ if (success) {
+ response = "Test executed for id provided (";
+ }
+ else {
+ response += "cannot found test id (";
+ }
+ response += anna::functions::asString(id);
+ response += ")";
- return true; // OK
+ return success;
}
bool EventOperation::test__look(std::string &response, int id) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ anna::testing::TestCase *testCase = testManager.findTestCase(id);
+ if (!testCase) {
+ if (id == -1) {
+ response += "no current test case detected (testing started ?)";
+ }
+ else {
+ response += "cannot found test id (";
+ response += anna::functions::asString(id);
+ response += ")";
+ }
+ return false;
+ }
+
+ if (a_http)
+ response = anna::functions::encodeBase64(testCase->asXMLString());
+ else
+ response = testCase->asXMLString();
return true; // OK
}
bool EventOperation::test__state(std::string &response, int id) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ anna::testing::TestCase *testCase = testManager.findTestCase(id);
+ if (!testCase) {
+ if (id == -1) {
+ response += "no current test case detected (testing started ?)";
+ }
+ else {
+ response += "cannot found test id (";
+ response += anna::functions::asString(id);
+ response += ")";
+ }
+ return false;
+ }
- return true; // OK
+ response = anna::testing::TestCase::asText(testCase->getState());
+ return testCase->isSuccess();
}
bool EventOperation::test__interact(std::string &response, int amount, unsigned int id) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ if (amount < -1) {
+ response += "interactive amount must be -1 (to disable interactive mode) or a positive number.";
+ return false;
+ }
+ anna::testing::TestCase *testCase = testManager.findTestCase(id);
+ if (testCase) {
+ if (amount == -1) {
+ testCase->makeInteractive(false);
+ response = "Interactive mode disabled";
+ }
+ else {
+ testCase->addInteractiveAmount(amount);
+ response = "Added interactive amount of ";
+ response += anna::functions::asString(amount);
+ response += " units";
+ if (amount == 0) response += " (0: freezing a non-interactive testcase, no effect on already interactive)";
+ }
+ response += " for test case id ";
+ response += anna::functions::asString(id);
+ }
+ else {
+ response += "cannot found test id (";
+ response += anna::functions::asString(id);
+ response += ")";
+ return false;
+ }
return true; // OK
}
-bool EventOperation::test__reset(std::string &response, bool soft_hard, unsigned int id) {
+bool EventOperation::test__reset(std::string &response, bool soft_hard, int id) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
-
-
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+
+ anna::testing::TestCase *testCase = ((id != -1) ? testManager.findTestCase(id) : NULL);
+ if (testCase) {
+ bool done = testCase->reset(!soft_hard);
+ response = "Test ";
+ response += (soft_hard ? "soft":"hard");
+ response += " reset for id ";
+ response += anna::functions::asString(id);
+ response += done ? ": done": ": not done";
+ }
+ else {
+ if (id == -1) {
+ bool anyReset = testManager.resetPool(!soft_hard);
+ response = (soft_hard ? "Soft":"Hard");
+ response += " reset have been sent to all programmed tests: "; response += anyReset ? "some/all have been reset" : "nothing was reset";
+ }
+ else {
+ response += "cannot found test id (";
+ response += anna::functions::asString(id);
+ response += ")";
+ return false;
+ }
+ }
return true; // OK
}
bool EventOperation::test__repeats(std::string &response, int amount) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ if (amount < 0) amount = -1;
+ testManager.setPoolRepeats(amount);
+ std::string nolimit = (amount != -1) ? "":" [no limit]";
+ response = anna::functions::asString("Pool repeats: %d%s (current cycle: %d)", amount, nolimit.c_str(), testManager.getPoolCycle());
return true; // OK
}
bool EventOperation::test__auto_reset(std::string &response, bool soft_hard) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ testManager.setAutoResetHard(!soft_hard);
+ response = anna::functions::asString("Auto-reset configured to '%s'", (soft_hard ? "soft":"hard"));
return true; // OK
}
bool EventOperation::test__initialized(std::string &response) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ response = anna::functions::asString("%lu", testManager.getInitializedCount());
return true; // OK
}
bool EventOperation::test__finished(std::string &response) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ response = anna::functions::asString("%lu", testManager.getFinishedCount());
return true; // OK
}
-bool EventOperation::test__clear(std::string &response) {
+bool EventOperation::test__clear(std::string &response, int id) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ if (id == -1) {
+ return testManager.clearPool(response);
+ }
+ if (!testManager.findTestCase(id)) {
+ response += "cannot found test id (";
+ response += anna::functions::asString(id);
+ response += ")";
+ return false;
+ }
- return true; // OK
+ return testManager.clearTestCase(response, id);
}
bool EventOperation::test__junit(std::string &response, const std::string & targetFile) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+ std::ofstream out;
+ out.open(targetFile.c_str());
+ if(out.is_open() == false) {
+ response += "error opening '";
+ response += targetFile;
+ response += "'";
+ return false;
+ }
+
+ out << testManager.junitAsXMLString() << std::endl;
+ out.close();
+
+ response = "Junit report written on '";
+ response += targetFile;
+ response += "'";
return true; // OK
}
bool EventOperation::test__summary_counts(std::string &response) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ response = anna::functions::encodeBase64(testManager.summaryCounts());
return true; // OK
}
bool EventOperation::test__summary_states(std::string &response) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ response = anna::functions::encodeBase64(testManager.summaryStates());
return true; // OK
}
bool EventOperation::test__summary(std::string &response) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ response = anna::functions::encodeBase64(testManager.asXMLString());
return true; // OK
}
bool EventOperation::test__report(std::string &response, const std::string & state, bool enable) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+
+ std::string _state = state;
+
+ if(_state == "initialized")
+ testManager.setDumpInitializedReports(enable);
+ else if(_state == "in-progress")
+ testManager.setDumpInProgressReports(enable);
+ else if(_state == "failed")
+ testManager.setDumpFailedReports(enable);
+ else if(_state == "success")
+ testManager.setDumpSuccessReports(enable);
+ else if(_state == "all") {
+ _state = "any";
+ testManager.setDumpAllReports(enable);
+ }
+ else if(_state == "none") {
+ enable = !enable;
+ _state = "any";
+ testManager.setDumpAllReports(enable);
+ }
+ else {
+ response += "invalid state (allowed: initialized|in-progress|failed|success|[all]|none)";
+ return false;
+ }
-
+ response = (enable ? "Report enabled " : "Report disabled ");
+ response += "for tests in '";
+ response += _state;
+ response += "' state";
return true; // OK
}
bool EventOperation::test__report_hex(std::string &response, bool enable) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
-
+ testManager.setDumpHex(enable);
+ response = (testManager.getDumpHex() ? "Report includes hexadecimal messages" : "Report excludes hexadecimal messages");
return true; // OK
}
bool EventOperation::test__dump_stdout(std::string &response, bool enable) {
Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+ anna::testing::TestManager &testManager = anna::testing::TestManager::instantiate();
+
+ testManager.setDumpStdout(enable);
+ response = (testManager.getDumpStdout() ? "Test manager dumps progress into stdout" : "Test manager does not dump progress into stdout");
+
+ return true; // OK
+}
+bool EventOperation::test__dynamic(std::string &response, const nlohmann::json &arguments) {
+ Launcher& my_app = static_cast <Launcher&>(anna::app::functions::getApp());
+
+ Procedure p(&my_app);
+ try {
+ p.execute(arguments, response);
+ }
+ catch(anna::RuntimeException &ex) {
+ ex.trace();
+ response += ex.asString();
+ return false;
+ }
return true; // OK
}
projects / anna.git / blobdiff