Initial commit

Lts/Services/Messaging/ModuleTests/msg_tests.cpp

@@ -0,0 +1,441 @@
+/**
+  * 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
+