TestCase.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_TestCase_hpp
#define anna_testing_TestCase_hpp

// Standard
#include <string>
#include <vector>
#include <map>

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

// Diameter-specific
#include <anna/diameter/defines.hpp>
#include <anna/testing/TestDiameterCondition.hpp>


namespace anna {
  class Millisecond;

  namespace xml {
    class Node;
  }
  namespace diameter {
    namespace comm {
      class OriginHost;
    }
  }

namespace testing {

  class TestStep;
  class TestStepWaitDiameter;
class TestCase {

  void assertInitialized() const noexcept(false);
  void assertMessage(const anna::DataBlock &db, bool toEntity, std::string &key1, std::string &key2) noexcept(false);

public:

  // Debug summary:
  class DebugSummary {

    typedef struct {
      anna::Millisecond Timestamp;
      std::string Hint;
    } event_t;

    std::vector<event_t> a_events;
  public:
    void addHint(const std::string &hint) ;
    void clear() ;
    int events() const { return a_events.size(); }
    anna::xml::Node* asXML(anna::xml::Node* parent) const ;
    std::string asString() const ;
  };

  TestCase(unsigned int id, const std::string &description = "");
  ~TestCase();

  struct State { enum _v { Initialized, InProgress, Failed, Success }; };
  static const char* asText(const State::_v state) ;
  const State::_v &getState() const { return a_state; }
  const anna::Millisecond &getStartTimestamp() const { return a_startTimestamp; }
  const anna::Millisecond &getFinishTimestamp() const { return a_finishTimestamp; }
  anna::Millisecond getLapseMs() const ;
  anna::Millisecond getProcessingTimeMs() const ;
  void addDebugSummaryHint(const std::string &hint) { a_debugSummary.addHint(hint); }
  void setState(const State::_v &state) ;
  bool isFinished() const { return (getState() == State::Failed || getState() == State::Success); }
  bool inProgress() const { return (getState() == State::InProgress); }
  bool isFailed() const { return (getState() == State::Failed); }
  bool isSuccess() const { return (getState() == State::Success); }
  bool hasSameCondition(const TestDiameterCondition &condition) const ;
  const DebugSummary & getDebugSummary() const { return a_debugSummary; }

  // Interactivity:
  void makeInteractive(bool yes = true) { a_interactiveAmount = (yes ? 0:-1); }
  void addInteractiveAmount(unsigned int amount) {
    if (a_interactiveAmount == -1) makeInteractive();
    if (amount == 0) return;
    a_interactiveAmount += amount;
    process();
  }
  int interactiveAmount() const { return a_interactiveAmount; }
  void interactiveExecution() { a_interactiveAmount --; }

  // Step type & information
  void addTimeout(const anna::Millisecond &timeout) noexcept(false);
  void addDelay(const anna::Millisecond &delay) noexcept(false);
  void addWaitDiameter(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) noexcept(false);
  void addCommand(const std::string &cmd) noexcept(false);
  void addIpLimit(unsigned int ipLimit) noexcept(false);

  // Diameter-specifc
  void addSendDiameterXml2e(const anna::DataBlock &db, anna::diameter::comm::OriginHost *host, int stepNumber) noexcept(false);
  void addSendDiameterXml2c(const anna::DataBlock &db, anna::diameter::comm::OriginHost *host, int stepNumber) noexcept(false);
  void addWaitDiameterAnswer(bool fromEntity, int stepNumber) noexcept(false);
  void addWaitDiameterRegexpHex(bool fromEntity, const std::string &regexp) noexcept(false);
  void addWaitDiameterRegexpXml(bool fromEntity, const std::string &regexp) noexcept(false);


  // Process:
  void nextStep() { a_stepsIt++; }
  bool done() ;
  bool process() ; // false to stop

  // Reset test case and underlaying information (steps context)
  bool reset(bool hard /* hard reset includes in-progress test cases */) ;

  // Check for clear (destroy steps)
  bool safeToClear(); // false if something pending (running threads steps)

  // getters
  const unsigned int &getId() const { return a_id; }
  const std::string &getKey1() const { return a_key1; }
  const std::string &getKey2() const { return a_key2; }
  const std::string &getDescription() const { return a_description; }

  // setters
  void setDescription(const std::string &description) { a_description = description; }

  //helpers
  int steps() const { return a_steps.size(); }
  void addStep(TestStep *step) { a_steps.push_back(step); }

  TestStepWaitDiameter *searchNextWaitConditionFulfilled(const anna::DataBlock &message, bool waitFromEntity) ;
      // When a message arrives, we identify the test case by mean the Session-Id. Then, from the current step iterator (included),
      //  we search for a fulfilling condition for that message. The first found, is 'completed' and then breaks the search.
  const TestStep *getStep(int stepNumber) const ;

  anna::xml::Node* asXML(anna::xml::Node* parent) const ;
  std::string asXMLString() const ;


private:
  // private members:
  unsigned int a_id;
  std::string a_key1;
  std::string a_key2;
  std::string a_description;
  std::vector<TestStep*> a_steps;
  std::vector<TestStep*>::const_iterator a_stepsIt;
  std::map<anna::diameter::HopByHop, TestStep*> a_hopByHops; // for wait-answer
  State::_v a_state;
  anna::Millisecond a_startTimestamp;
  anna::Millisecond a_finishTimestamp;
  DebugSummary a_debugSummary; // used when a test case has failed, uncovered message conditions, and any other hint.
  int a_interactiveAmount;

  friend class TestStep;
};

}
}

#endif