TestStep.hpp

Go to the documentation of this file.

// ANNA - Anna is Not Nothingness Anymore                                                         //
//                                                                                                //
// (c) Copyright 2005-2015 Eduardo Ramos Testillano & Francisco Ruiz Rayo                         //
//                                                                                                //
// See project site at http://redmine.teslayout.com/projects/anna-suite                           //
// See accompanying file LICENSE or copy at http://www.teslayout.com/projects/public/anna.LICENSE //


#ifndef anna_testing_TestStep_hpp
#define anna_testing_TestStep_hpp

// Standard
#include <string>
#include <vector>
#include <thread>
#include <atomic>

// Project
#include <anna/core/DataBlock.hpp>
#include <anna/testing/TestDiameterCondition.hpp>
#include <anna/core/util/Millisecond.hpp>


namespace anna {
  class Millisecond;

  namespace xml {
    class Node;
  }
  namespace diameter {
    namespace codec {
      class Message;
    }
    namespace comm {
      class OriginHost;
      class ClientSession;
      class ServerSession;
    }
  }

namespace testing {

class TestCase;
class TestTimer;

class TestStep {

    int a_number; // step number used for xml (informational)
    anna::Millisecond a_beginTimestamp; // unix time
    anna::Millisecond a_endTimestamp; // unix time
    bool a_executed; // used for interactive mode in order to not repeat a execution step if before completing, the user add interactive amount

    void setBeginTimestamp(const anna::Millisecond &t) { a_beginTimestamp = t; }
    const anna::Millisecond &getBeginTimestamp() const { return a_beginTimestamp; }
    void setEndTimestamp(const anna::Millisecond &t) { a_endTimestamp = t; }
    const anna::Millisecond &getEndTimestamp() const { return a_endTimestamp; }

    void initialize(TestCase *testCase);

  public:
    struct Type { enum _v { Unconfigured, Timeout, Sendxml2e, Sendxml2c, Delay, Wait, Cmd, IpLimit }; };
    static const char* asText(const Type::_v type) ;

    TestStep(TestCase *testCase) : a_message(true), a_messageCodec(NULL), a_executed(false) { initialize(testCase); }
    virtual ~TestStep() {;}

    // setter & getters
    const Type::_v &getType() const { return a_type; }
    const int &getNumber() const { return a_number; }
    bool isCompleted() const { return a_completed; }
    anna::Millisecond getLapseMs() const { return a_endTimestamp - a_beginTimestamp; }

    bool execute() ;
    void complete() ;
    void reset() ;
    void next() ;
    virtual anna::xml::Node* asXML(anna::xml::Node* parent) ;
    std::string asXMLString() ;

  protected:
    TestCase *a_testCase;
    bool a_completed;
    Type::_v a_type;

    // Message (not for all step types)
    anna::DataBlock a_message;
    anna::diameter::codec::Message *a_messageCodec; // used as helper and for traffic logs
    bool decodeMessage(bool trust = false) ; // If trust=true: decoding the previously encoded message (sendxml sentences).
                                                    // The only error would be validation ones, and we are going to ignore them here.

    virtual bool do_execute()  = 0; // returns true if next step must be executed
    virtual void do_complete()  = 0; // end of transaction (delay/timeout expired, wait condition fulfilled, sending done)
                                            // In all cases, the next step will be executed except 'timeout' which is asynchronous
                                            //  and will move to the next step just after timer creation (no complete waited)
    virtual void do_reset()  = 0;
};


class TestStepTimeout : public TestStep {

    anna::Millisecond a_timeout;
    TestTimer *a_timer; // just in case i would need to cancel

  public:
    TestStepTimeout(TestCase *testCase) : TestStep(testCase), a_timeout(0), a_timer(NULL) { a_type = Type::Timeout; }
    ~TestStepTimeout() { do_reset(); }

    // setter & getters
    void setTimeout(const anna::Millisecond &t) { a_timeout = t; }
    const anna::Millisecond &getTimeout() const { return a_timeout; }

    // virtuals
    bool do_execute() ;
    void do_complete() ; // timeout reached, test case failed
    void do_reset() ;
    void cancelTimer() ;
    anna::xml::Node* asXML(anna::xml::Node* parent) ;
};


class TestStepSendDiameterXml : public TestStep {

  protected:
    // possible end points:
    anna::diameter::comm::OriginHost *a_originHost;

    // Step number reference ('wait for request' step)
    int a_waitForRequestStepNumber;

    // Expired ?
    bool a_expired; // a_endTimestamp will be the expiration reception timestamp

  public:
    TestStepSendDiameterXml(TestCase *testCase) : TestStep(testCase),
      a_expired(false),
      a_originHost(NULL),
      a_waitForRequestStepNumber(-1) {;}
    ~TestStepSendDiameterXml() { do_reset(); }

    // setter & getters
    void setOriginHost(anna::diameter::comm::OriginHost *host) { a_originHost = host; }
    anna::diameter::comm::OriginHost *getOriginHost() const { return a_originHost; }
    void setWaitForRequestStepNumber(int stepNumber) { a_waitForRequestStepNumber = stepNumber; }
    int getWaitForRequestStepNumber() const { return a_waitForRequestStepNumber; }
    void setMsgDataBlock(const anna::DataBlock &db) { a_message = db; }
    const anna::DataBlock &getMsgDataBlock() const { return a_message; }

    // virtuals
    bool do_execute() ;
    void do_complete() {;}
    void do_reset() ;
    anna::xml::Node* asXML(anna::xml::Node* parent) ;
};

class TestStepSendDiameterXml2e : public TestStepSendDiameterXml {
  public:
    TestStepSendDiameterXml2e(TestCase *testCase) : TestStepSendDiameterXml(testCase) { a_type = Type::Sendxml2e; }
};

class TestStepSendDiameterXml2c : public TestStepSendDiameterXml {
  public:
    TestStepSendDiameterXml2c(TestCase *testCase) : TestStepSendDiameterXml(testCase) { a_type = Type::Sendxml2c; }
};


class TestStepDelay : public TestStep {
    anna::Millisecond a_delay;
    TestTimer *a_timer; // just in case i would need to cancel

  public:
    TestStepDelay(TestCase *testCase) : TestStep(testCase), a_delay(0), a_timer(NULL) { a_type = Type::Delay; }
    ~TestStepDelay() { do_reset(); }

    // setter & getters
    void setDelay(const anna::Millisecond &d) { a_delay = d; }
    const anna::Millisecond &getDelay() const { return a_delay; }

    // virtuals
    bool do_execute() ;
    void do_complete() ; // delay reached
    void do_reset() ;
    void cancelTimer() ;
    anna::xml::Node* asXML(anna::xml::Node* parent) ;
};


class TestStepWaitDiameter : public TestStep {

    TestDiameterCondition a_condition;
    anna::diameter::comm::ClientSession *a_clientSession;
    anna::diameter::comm::ServerSession *a_serverSession;

  public:
    TestStepWaitDiameter(TestCase *testCase) : TestStep(testCase) {
      a_type = Type::Wait;
      a_clientSession = NULL;
      a_serverSession = NULL;
    }
    ~TestStepWaitDiameter() { do_reset(); }

    // setter & getters
    void setCondition(bool fromEntity,
                        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) ;
    void setConditionRegexpXml(bool fromEntity, const std::string &regexp) ;
    void setConditionRegexpHex(bool fromEntity, const std::string &regexp) ;

    void setClientSession(anna::diameter::comm::ClientSession *cs) { a_clientSession = cs; }
    void setServerSession(anna::diameter::comm::ServerSession *ss) { a_serverSession = ss; }
    anna::diameter::comm::ClientSession *getClientSession() const { return a_clientSession; }
    anna::diameter::comm::ServerSession *getServerSession() const { return a_serverSession; }

    const TestDiameterCondition &getCondition() const { return a_condition; }
    //void setMsgDataBlock(const anna::DataBlock &db) { a_message = db; }
    bool fulfilled(const anna::DataBlock &db/*, bool matchSessionId = true*/) ;
    const anna::DataBlock &getMsgDataBlock() const { return a_message; }


    // virtuals
    bool do_execute() ; // this will be executed when test case starts (at least we could measure the time until condition is fulfilled)
    void do_complete() ; // condition fulfilled
    void do_reset() ;
    anna::xml::Node* asXML(anna::xml::Node* parent) ;
};


class TestStepCmd : public TestStep {

  std::string a_script;
  std::thread a_thread;
  std::atomic<bool> a_threadRunning;
  bool a_threadDeprecated;
  int a_resultCode;
  std::string a_errorMsg;
  //std::string a_output; // for POPEN

  pid_t a_childPid;

  public:
    TestStepCmd(TestCase *testCase) : TestStep(testCase), a_threadRunning(false), a_threadDeprecated(false), a_resultCode(-2)/*, a_output("")*/, a_errorMsg(""), a_childPid(-1) { a_type = Type::Cmd; }
    ~TestStepCmd() { do_reset(); }

    // setter & getters
    void setThreadRunning() { a_threadRunning = true; }
    void setThreadNotRunning() { a_threadRunning = false; }
    bool threadRunning() const { return a_threadRunning; }
    bool threadNotRunning() const { return !a_threadRunning; }

    void setResultCode(int rc) { a_resultCode = rc; }
    int getResultCode() const { return a_resultCode; }
    void setErrorMsg(const std::string &em) { a_errorMsg = em; }
    const std::string &getErrorMsg() const { return a_errorMsg; }
    //void appendOutput(const std::string &output) { a_output += output; }
    //const std::string &getOutput() const { return a_output; }
    void setChildPid(pid_t pid) { a_childPid = pid; }
    const pid_t &getChildPid() const { return a_childPid; }

    void setScript(const std::string &script) { a_script = script; }
    const std::string &getScript() const { return a_script; }

    // virtuals
    bool do_execute() ;
    void do_complete() ;
    void do_reset() ;
    anna::xml::Node* asXML(anna::xml::Node* parent) ;
};


class TestStepIpLimit : public TestStep {

    unsigned int a_ipLimit;

  public:
    TestStepIpLimit(TestCase *testCase) : TestStep(testCase), a_ipLimit(1) { a_type = Type::IpLimit; }
    ~TestStepIpLimit() { do_reset(); }

    // setter & getters
    void setIpLimit(unsigned int limit) { a_ipLimit = limit; }
    unsigned int getIpLimit() const { return a_ipLimit; }

    // virtuals
    bool do_execute() ;
    void do_complete() ;
    void do_reset() {;}
    anna::xml::Node* asXML(anna::xml::Node* parent) ;
};

}
}

#endif