qt5-legatus-legacy/Lts/Services/Messaging/ModuleTests/msg_tests.cpp

/**
  * Msg Function Topic Module Test
  * $Id$
  * $HeadURL$
  * $Author$
  */

#include "msg_tests.h"

#include <nglapplication/nglcoreapplication.h>
#include <LtsCommandLineParser/LtsCommandLineParser.h>
#include <QTimer>
#include <QDateTime>

#include <Messaging/msg_ftc.h>

/* ----------------------------------------------------------------------------------
 * HOW TO RUN THE TESTS
 * ----------------------------------------------------------------------------------
 *  0. Preconditions:
 *  Start with an empty database (BUILD)
 *     make db
 *
 * Preconditions:
 * For test 1, 2, 3:
 * - User 1,2,3 in DB
 *
 * For test 4 and 5:
 * - exercise with Observer/Controller ( ppm.ppm_equipment_type = 20 )equipmentNumber 2500, 2501
 * - empty table msg.msg_message_operator_data
 *
 * Please start in order 1, 2, 3, ...
 *
 *  Start services: (SV)
 *     ./bin/svcMessaging &
 *  -t 1 = CreateOperatorMessage
 *  -t 2 = SetIsRead
 *  -t 3 = SetDeleted
 *  -t 4 = Send to Tetra
 *  -t 5 = receive from Tetra
 */

namespace Messaging
{

MsgTests::MsgTests(QObject *parent)
  : QObject(parent)
  , m_testId(0)
  , m_bTestsSuccessful(true)
  , m_messageCount(0)
  , m_msgIdSendMessage(1) // Result from last test
  , m_msgIdRecvMessage(3) // Result from last test
  , m_numberMessages(3)   // Result from last test
  , m_testStep(TestCase::CreateOperator)
  , m_logger(getLogger("MsgTests"))
{}

MsgTests::~MsgTests()
{}

bool MsgTests::init(int domainId, int testId)
{
  INFO_LOG(m_logger) << "init begin";

  m_testId = testId;

  m_ddsConnector.reset(new DDSConnector::DdsConnector(domainId, IDL::PartitionType::Any));
  if (!m_ddsConnector->init())
    return false;
  m_ddsConnector->initPublisherSubscriber();

  m_ftc = Messaging::Interface::Ftc::create(m_ddsConnector);
  bool bRet = m_ftc->enableAll();

  m_dtc = Messaging::Interface::Dtc::create(m_ddsConnector);
  bRet &= m_dtc->enableAll();

  return bRet;
} // init

void MsgTests::startTest()
{
  INFO_LOG(m_logger) << "startTest m_testId=" << m_testId;
  if (m_testId <= 1) // CreateOperatorMessage
  {
    m_testStep = TestCase::CreateOperator;
    QTimer::singleShot(0, this, &MsgTests::tryCreateOperatorMessage);
  }
  else if (m_testId == 2) // SetIsRead
  {
    m_testStep = TestCase::SetIsRead;
    MsgTests::markMessageAsRead();
  }
  else if (m_testId == 3) // SetDeleted
  {
    m_testStep = TestCase::SetDeleted;
    MsgTests::markMessageAsDeleted();
  }
  else if (m_testId == 4) // send to TETRA
  {
    m_testStep = TestCase::SendToTetra;
    QTimer::singleShot(0, this, &MsgTests::tryCreateOperatorMessage);
  }
  else if (m_testId == 5) // receive from TETRA
  {
    m_testStep = TestCase::ReceiveFromTetra;
    QTimer::singleShot(0, this, &MsgTests::tryCreateOperatorMessage);
  }
} // startTest

void MsgTests::tryCreateOperatorMessage()
{
  INFO_LOG(m_logger) << "trying to send createRequest Operator Message";
  Messaging::AddressType receiverType;
  Messaging::AddressType senderType;

  std::vector<int32_t> recipientIds;
  int32_t sender = 3;
  std::string subject = "subject Operator";
  recipientIds.resize(2);
  int exerciseId = 42;
  switch (m_testStep)
  {
  case TestCase::CreateOperator:
  {
    receiverType = Messaging::AddressType_def::type::Operator;
    senderType = Messaging::AddressType_def::type::Operator;
    m_expectedMessage = "msg Operator: " + QDateTime::currentDateTimeUtc().toString().toStdString();
    recipientIds[0] = 1;
    recipientIds[1] = 2;
    break;
  }
  case TestCase::SendToTetra:
  {
    receiverType = Messaging::AddressType_def::type::ObserverController;
    senderType = Messaging::AddressType_def::type::Operator;
    m_expectedMessage = "msg to OC: " + QDateTime::currentDateTimeUtc().toString().toStdString();
    recipientIds[0] = 57; // Participant id for eq-number 2500
    recipientIds[1] = 58; // Participant id for eq-number 2501
    break;
  }
  case TestCase::ReceiveFromTetra:
  {
    receiverType = Messaging::AddressType_def::type::Operator;
    senderType = Messaging::AddressType_def::type::ObserverController;
    m_expectedMessage = "msg from OC: " + QDateTime::currentDateTimeUtc().toString().toStdString();
    sender = 2500;
    recipientIds[0] = 1;
    recipientIds[1] = 2;
    break;
  }
  default:
    return;
  }


  if (!m_ftc->createOperatorMessageRequest(CreateOperatorMessageRequest(recipientIds, exerciseId, sender, subject, m_expectedMessage, senderType, receiverType), this))
  {
    ERROR_LOG(m_logger) << "Error requesting create data";
    failExit();
  }
} // tryCreateOperatorMessage

void MsgTests::checkMessageOnDdsAfterCreate()
{
  // read from dds, check if data is as expected
  m_messageCount = 0;

  m_dtc->waitForHistoricalDataOperatorMessage();
  const QMap<int, Messaging::OperatorMessage> messages = m_dtc->operatorMessages();
  for (const auto &om : messages)
  {
    INFO_LOG(m_logger) << "checkMessageOnDdsAfterCreate om.id = " << om.id();

    if (om.message() == m_expectedMessage)
    {
      DEBUG_LOG(m_logger) << "senderId: " << om.senderId() << ", recipientId: " << om.recipientId();
      if (om.senderId() != 0 && om.recipientId() == 0)
      {
        m_msgIdSendMessage = om.id();
        DEBUG_LOG(m_logger) << "m_msgIdSendMessage=" << m_msgIdSendMessage;
        ++m_messageCount;
      }

      if (om.senderId() != 0 && om.recipientId() != 0)
      {
        m_msgIdRecvMessage = om.id();
        DEBUG_LOG(m_logger) << "m_msgIdRecvMessage=" << m_msgIdRecvMessage;
        ++m_messageCount;
      }
    }
    // msg count == 3 -> one for sender, two for receiver
    if (m_messageCount == 3)
    {
      INFO_LOG(m_logger) << "Success: receiving messages - got: " << m_messageCount << " expected: 3";
      ExitSuccess();
      return;
    }
  }

  if (m_testStep == TestCase::ReceiveFromTetra || m_testStep == TestCase::SendToTetra)
  {
    ExitSuccess();
    return;
  }

  ERROR_LOG(m_logger) << "Error receiving messages - got: " << m_messageCount << " expected: 3";
  failExit();
} // checkMessageOnDdsAfterCreate

void MsgTests::checkMessageOnDdsAfterModify()
{
  // read from dds, check if data is as expected
  int isRead = 0;
  INFO_LOG(m_logger) << "checkMessageOnDdsAfterModify";
  m_dtc->waitForHistoricalDataOperatorMessage();
  const QMap<int, Messaging::OperatorMessage> messages = m_dtc->operatorMessages();
  switch (m_testStep)
  {
  case TestCase::SetIsRead:
  {
    for (const auto &om : messages)
    {
      DEBUG_LOG(m_logger) << "om.id()=" << om.id() << " om.isRead()=" << om.isRead();
      if (om.id() == m_msgIdRecvMessage && om.isRead() == true)
        ++isRead;
    }
    if (isRead == 1)
    {
      INFO_LOG(m_logger) << "modify messages isRead = TRUE: Success ";
      ExitSuccess();
      return;
    }

    ERROR_LOG(m_logger) << "Error modify messages - got: " << isRead << " expected: 1";
    failExit();
    break;
  }
  case TestCase::SetDeleted:
  {
    // Message removed from DDS

    DEBUG_LOG(m_logger) << "m_numberMessages= " << m_numberMessages << " messages.size()= " << messages.size();
    if (m_numberMessages > messages.size())
    {
      INFO_LOG(m_logger) << "modify messages isDeleted = TRUE: Success ";
      ExitSuccess();
      return;
    }


    ERROR_LOG(m_logger) << "Error modify messages - got: " << messages.size() << " expected less than " << m_numberMessages;
    failExit();
    break;
  }
  case TestCase::SendToTetra:
  {
    DEBUG_LOG(m_logger) << "SendToTetra reply m_numberMessages= " << m_numberMessages << " messages.size()= " << messages.size();
    ExitSuccess();
    break;
  }
  case TestCase::ReceiveFromTetra:
  {
    DEBUG_LOG(m_logger) << "ReceiveFromTetra reply m_numberMessages= " << m_numberMessages << " messages.size()= " << messages.size();
    ExitSuccess();
    break;
  }
  default:
  {
    INFO_LOG(m_logger) << "Nothing to do in this TestCase";
  }
  }
} // checkMessageOnDdsAfterModify

void MsgTests::checkMessageOnDdsAfterDelete()
{
  // read from dds, check if data is as expected
  int isDeleted = 0;
  INFO_LOG(m_logger) << "checkMessageOnDdsAfterModify";
  m_dtc->waitForHistoricalDataOperatorMessage();
  const QMap<int, Messaging::OperatorMessage> messages = m_dtc->operatorMessages();
  for (const auto &om : messages)
  {
    if (om.id() == m_msgIdRecvMessage && om.isDeleted() == true)
      ++isDeleted;
  }
  if (isDeleted == 1)
  {
    INFO_LOG(m_logger) << "modify messages delete: Success ";
    return;
  }


  ERROR_LOG(m_logger) << "Error modify messages - got: " << isDeleted << " expected: 1";
  failExit();
} // checkMessageOnDdsAfterDelete

void MsgTests::markMessageAsRead()
{
  INFO_LOG(m_logger) << "trying to mark Message as read m_msgIdRecvMessage =" << m_msgIdRecvMessage;

  int32_t id = m_msgIdRecvMessage;
  bool isRead = true;
  bool isSend = false;
  bool isDeleted = false;

  if (!m_ftc->modifyOperatorMessageRequest(ModifyOperatorMessageRequest(id, isRead, isSend, isDeleted), this))
  {
    ERROR_LOG(m_logger) << "Error mark Message as read";
    failExit();
  }
} // markMessageAsRead

void MsgTests::markMessageAsDeleted()
{
  INFO_LOG(m_logger) << "trying to mark Message as deleted m_msgIdRecvMessage =" << m_msgIdRecvMessage;

  int32_t id = m_msgIdRecvMessage;
  bool isRead = true;
  bool isSend = false;
  bool isDeleted = true;

  m_dtc->waitForHistoricalDataOperatorMessage();
  DEBUG_LOG(m_logger) << "m_numberMessages =" << m_numberMessages;

  if (!m_ftc->modifyOperatorMessageRequest(ModifyOperatorMessageRequest(id, isRead, isSend, isDeleted), this))
  {
    ERROR_LOG(m_logger) << "Error mark Message as deleted";
    failExit();
  }
} // markMessageAsDeleted

void MsgTests::onCreateOperatorMessageReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "onCreateOperatorMessageReply, error = " << replyObject.error();
  if (replyObject.error())
  {
    ERROR_LOG(m_logger) << "Error creating new message - aborting";
    failExit();
  }
  else
  {
    switch (m_testStep)
    {
    case TestCase::CreateOperator:
    case TestCase::SendToTetra:
    case TestCase::ReceiveFromTetra:
      // 1s - wait until data is delivered
      QTimer::singleShot(1000, this, &MsgTests::checkMessageOnDdsAfterCreate);
      break;
    default:
      INFO_LOG(m_logger) << "Nothing to do in this Case";
    }
  }
} // onCreateOperatorMessageReply

void MsgTests::onModifyOperatorMessageReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "onModifyOperatorMessageReply, error = " << replyObject.error();
  if (replyObject.error())
  {
    ERROR_LOG(m_logger) << "Error modify message - aborting";
    failExit();
  }
  else
  {
    // 1s - wait until data is delivered
    QTimer::singleShot(1000, this, &MsgTests::checkMessageOnDdsAfterModify);
  }
} // onModifyOperatorMessageReply

/*
void MsgTests::onSendEquipmentMessageReply(const Core::FunctionReplyObject &replyObject)
{
  INFO_LOG(m_logger) << "************** onSendEquipmentMessageReply TODO isRead = TRUE setzen: id = **********************";
}

*/
void MsgTests::failExit()
{
  m_bTestsSuccessful = false;
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
} // failExit

void MsgTests::ExitSuccess()
{
  DEBUG_LOG(m_logger) << "SUCCESS";
  m_bTestsSuccessful = true;
  QTimer::singleShot(0, qApp, &QCoreApplication::quit);
} // ExitSuccess

}
// ------------------------------------------------------------------
class CmdLineParser : public LtsCommandLineParser::LtsCommandLineParser
{
public:
  CmdLineParser()
    : LtsCommandLineParser()
  {
    addOption({ QStringList() << QLatin1String("t") << QLatin1String("testId")
                , QLatin1String("TestId.")
                , QLatin1String("Default: 0 (all tests)")
                , QLatin1String("0")
              });

  }

  int testId() const         { return isSet(QLatin1String("t")) ? value(QLatin1String("t")).toInt() : -1; }
};

// ------------------------------------------------------------------
int main(int argc, char **argv)
{
  NGLCoreApplication app(argc, argv);
  app.createLogger("MSG", 0);

  CmdLineParser options;
  if (!options.init())
    return -1;

  int iRet = -1;
  {
    std::unique_ptr<Messaging::MsgTests> msgTests(new Messaging::MsgTests);

    if (!msgTests->init(options.domainId(), options.testId()))
      return iRet;

    msgTests->startTest();

    STARTUP_LOG(app.baseLogger());

    app.exec();

    iRet = msgTests->testsSuccessful() ? 0 : 1;

    SHUTDOWN_LOG(app.baseLogger());
  }

  return iRet;
} // main