example/diameter/launcher/testing/TestStep.hpp

   1 // ANNA - Anna is Not Nothingness Anymore                                                         //
   2 //                                                                                                //
   3 // (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
   4 //                                                                                                //
   5 // See project site at http://redmine.teslayout.com/projects/anna-suite                           //
   6 // See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //
   7
   8
   9 #ifndef example_diameter_launcher_TestStep_hpp
  10 #define example_diameter_launcher_TestStep_hpp
  11
  12 // Standard
  13 #include <string>
  14 #include <vector>
  15 #include <thread>
  16
  17 // Project
  18 #include <anna/core/DataBlock.hpp>
  19 #include <anna/xml/Node.hpp>
  20 #include <anna/diameter/codec/Message.hpp>
  21
  22 // Process
  23 #include <TestCondition.hpp>
  24
  25
  26
  27
  28 namespace anna {
  29   class Millisecond;
  30
  31   namespace xml {
  32     class Node;
  33   }
  34   namespace diameter {
  35     namespace codec {
  36       class Message;
  37     }
  38     namespace comm {
  39       class ClientSession;
  40       class ServerSession;
  41     }
  42   }
  43 }
  44
  45 class TestCase;
  46 class TestTimer;
  47 class RealmNode;
  48
  49 class TestStep {
  50
  51     int a_number; // step number used for xml (informational)
  52     anna::Millisecond a_beginTimestamp; // unix time
  53     anna::Millisecond a_endTimestamp; // unix time
  54
  55     void setBeginTimestamp(const anna::Millisecond &t) throw() { a_beginTimestamp = t; }
  56     const anna::Millisecond &getBeginTimestamp() const throw() { return a_beginTimestamp; }
  57     void setEndTimestamp(const anna::Millisecond &t) throw() { a_endTimestamp = t; }
  58     const anna::Millisecond &getEndTimestamp() const throw() { return a_endTimestamp; }
  59
  60     void initialize(TestCase *testCase);
  61
  62   public:
  63     struct Type { enum _v { Unconfigured, Timeout, Sendxml2e, Sendxml2c, Delay, Wait, Cmd }; };
  64     static const char* asText(const Type::_v type) throw();
  65
  66     TestStep(TestCase *testCase) : a_message(true), a_messageCodec(NULL) { initialize(testCase); }
  67     virtual ~TestStep() {;}
  68
  69     // setter & getters
  70     const Type::_v &getType() const throw() { return a_type; }
  71     const int &getNumber() const throw() { return a_number; }
  72     bool isCompleted() const throw() { return a_completed; }
  73
  74     bool execute() throw();
  75     void complete() throw();
  76     void reset() throw();
  77     void next() throw();
  78     virtual anna::xml::Node* asXML(anna::xml::Node* parent) throw();
  79     std::string asXMLString() throw();
  80
  81   protected:
  82     TestCase *a_testCase;
  83     bool a_completed;
  84     Type::_v a_type;
  85
  86     // Message (not for all step types)
  87     anna::DataBlock a_message;
  88     anna::diameter::codec::Message *a_messageCodec; // used as helper and for traffic logs
  89     bool decodeMessage() throw();
  90
  91     virtual bool do_execute() throw() = 0; // returns true if next step must be executed
  92     virtual void do_complete() throw() = 0; // end of transaction (delay/timeout expired, wait condition fulfilled, sending done)
  93                                             // In all cases, the next step will be executed except 'timeout' which is asynchronous
  94                                             //  and will move to the next step just after timer creation (no complete waited)
  95     virtual void do_reset() throw() = 0;
  96 };
  97
  98
  99 class TestStepTimeout : public TestStep {
 100
 101     anna::Millisecond a_timeout;
 102     TestTimer *a_timer; // just in case i would need to cancel
 103
 104   public:
 105     TestStepTimeout(TestCase *testCase) : TestStep(testCase), a_timeout(0), a_timer(NULL) { a_type = Type::Timeout; }
 106
 107     // setter & getters
 108     void setTimeout(const anna::Millisecond &t) throw() { a_timeout = t; }
 109     const anna::Millisecond &getTimeout() const throw() { return a_timeout; }
 110
 111     // virtuals
 112     bool do_execute() throw();
 113     void do_complete() throw(); // timeout reached, test case failed
 114     void do_reset() throw();
 115     anna::xml::Node* asXML(anna::xml::Node* parent) throw();
 116 };
 117
 118
 119 class TestStepSendxml : public TestStep {
 120
 121   protected:
 122     // possible end points:
 123     RealmNode *a_realmNode;
 124
 125     // Step number reference ('wait for request' step)
 126     int a_waitForRequestStepNumber;
 127
 128     // Expired ?
 129     bool a_expired; // a_endTimestamp will be the expiration reception timestamp
 130
 131   public:
 132     TestStepSendxml(TestCase *testCase) : TestStep(testCase),
 133       a_expired(false),
 134       a_realmNode(NULL),
 135       a_waitForRequestStepNumber(-1) {;}
 136     ~TestStepSendxml() {;}
 137
 138     // setter & getters
 139     void setRealmNode(RealmNode *realm) throw() { a_realmNode = realm; }
 140     RealmNode *getRealmNode() const throw() { return a_realmNode; }
 141     void setWaitForRequestStepNumber(int stepNumber) throw() { a_waitForRequestStepNumber = stepNumber; }
 142     int getWaitForRequestStepNumber() const throw() { return a_waitForRequestStepNumber; }
 143     void setMsgDataBlock(const anna::DataBlock &db) throw() { a_message = db; }
 144     const anna::DataBlock &getMsgDataBlock() const throw() { return a_message; }
 145
 146     // virtuals
 147     bool do_execute() throw();
 148     void do_complete() throw() {;}
 149     void do_reset() throw();
 150     anna::xml::Node* asXML(anna::xml::Node* parent) throw();
 151 };
 152
 153 class TestStepSendxml2e : public TestStepSendxml {
 154   public:
 155     TestStepSendxml2e(TestCase *testCase) : TestStepSendxml(testCase) { a_type = Type::Sendxml2e; }
 156 };
 157
 158 class TestStepSendxml2c : public TestStepSendxml {
 159   public:
 160     TestStepSendxml2c(TestCase *testCase) : TestStepSendxml(testCase) { a_type = Type::Sendxml2c; }
 161 };
 162
 163
 164 class TestStepDelay : public TestStep {
 165     anna::Millisecond a_delay;
 166     TestTimer *a_timer; // just in case i would need to cancel
 167
 168   public:
 169     TestStepDelay(TestCase *testCase) : TestStep(testCase), a_delay(0), a_timer(NULL) { a_type = Type::Delay; }
 170
 171     // setter & getters
 172     void setDelay(const anna::Millisecond &d) throw() { a_delay = d; }
 173     const anna::Millisecond &getDelay() const throw() { return a_delay; }
 174
 175     // virtuals
 176     bool do_execute() throw();
 177     void do_complete() throw(); // delay reached
 178     void do_reset() throw();
 179     anna::xml::Node* asXML(anna::xml::Node* parent) throw();
 180 };
 181
 182
 183 class TestStepWait : public TestStep {
 184
 185     TestCondition a_condition;
 186     anna::diameter::comm::ClientSession *a_clientSession;
 187     anna::diameter::comm::ServerSession *a_serverSession;
 188
 189   public:
 190     TestStepWait(TestCase *testCase) : TestStep(testCase) {
 191       a_type = Type::Wait;
 192       a_clientSession = NULL;
 193       a_serverSession = NULL;
 194     }
 195     ~TestStepWait() {;}
 196
 197     // setter & getters
 198     void setCondition(bool fromEntity,
 199                         const std::string &code, const std::string &bitR, const std::string &hopByHop, const std::string &applicationId,
 200                         const std::string &sessionId, const std::string &resultCode,
 201                         const std::string &msisdn, const std::string &imsi, const std::string &serviceContextId) throw();
 202     void setCondition(bool fromEntity, const std::string &regexp) throw();
 203
 204     void setClientSession(anna::diameter::comm::ClientSession *cs) throw() { a_clientSession = cs; }
 205     void setServerSession(anna::diameter::comm::ServerSession *ss) throw() { a_serverSession = ss; }
 206     anna::diameter::comm::ClientSession *getClientSession() const throw() { return a_clientSession; }
 207     anna::diameter::comm::ServerSession *getServerSession() const throw() { return a_serverSession; }
 208
 209     const TestCondition &getCondition() const throw() { return a_condition; }
 210     //void setMsgDataBlock(const anna::DataBlock &db) throw() { a_message = db; }
 211     bool fulfilled(const anna::DataBlock &db/*, bool matchSessionId = true*/) throw();
 212     const anna::DataBlock &getMsgDataBlock() const throw() { return a_message; }
 213
 214
 215     // virtuals
 216     bool do_execute() throw(); // this will be executed when test case starts (at least we could measure the time until condition is fulfilled)
 217     void do_complete() throw(); // condition fulfilled
 218     void do_reset() throw();
 219     anna::xml::Node* asXML(anna::xml::Node* parent) throw();
 220 };
 221
 222
 223 class TestStepCmd : public TestStep {
 224
 225   std::string a_script;
 226   std::string a_parameters;
 227   std::thread a_thread;
 228   bool a_threadRunning;
 229   bool a_threadDeprecated;
 230   int a_resultCode;
 231   std::string a_errorMsg;
 232   //std::string a_output; // for POPEN
 233
 234   public:
 235     TestStepCmd(TestCase *testCase) : TestStep(testCase), a_threadRunning(false), a_threadDeprecated(false), a_resultCode(-2)/*, a_output("")*/, a_errorMsg("") { a_type = Type::Cmd; }
 236
 237     // setter & getters
 238     void setThreadRunning(bool running) throw() { a_threadRunning = running; }
 239     //bool getThreadRunning() const throw() { return a_threadRunning; }
 240     //void setThreadDeprecated(bool deprecated) throw() { a_threadDeprecated = deprecated; }
 241     //bool getThreadDeprecated() const throw() { return a_threadDeprecated; }
 242
 243     void setResultCode(int rc) throw() { a_resultCode = rc; }
 244     int getResultCode() const throw() { return a_resultCode; }
 245     void setErrorMsg(const std::string &em) throw() { a_errorMsg = em; }
 246     const std::string &getErrorMsg() const throw() { return a_errorMsg; }
 247     //void appendOutput(const std::string &output) throw() { a_output += output; }
 248     //const std::string &getOutput() const throw() { return a_output; }
 249
 250     void setScript(const std::string &script) throw() { a_script = script; }
 251     const std::string &getScript() const throw() { return a_script; }
 252     void setParameters(const std::string &params) throw() { a_parameters = params; }
 253     const std::string &getParameters() const throw() { return a_parameters; }
 254
 255     // virtuals
 256     bool do_execute() throw();
 257     void do_complete() throw();
 258     void do_reset() throw();
 259     anna::xml::Node* asXML(anna::xml::Node* parent) throw();
 260 };
 261
 262
 263 #endif