DRCEFunctionalTests.cpp

Go to the documentation of this file.

#include <gtest/gtest.h>

#include "DRCEProtocolsTest.hpp"
#include "DRCEActionTypesTest.hpp"
#include "DRCERequestLocalShellTest.hpp"
#include "DRCEFunctionalObjectTest.hpp"
#include "DRCETaskThreadingModeTest.hpp"
#include "DRCETaskRequestsTest.hpp"
#include "DRCETaskThreadingModeTest.hpp"
#include "DRCETaskRequestTerminate.hpp"
#include "DRCETaskRequestSetExecute.hpp"
#include "DRCEStressTest.hpp"
#include "DRCECleanupTest.hpp"

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(DRCEProtocolsTest, testResultDataSerializator)
{
  HCE::drce::tests::DRCEProtocolsTest::testResultDataSerializator();
}
//-----------------------------------------------------------------------------
TEST(DRCEProtocolsTest, testInputJsonMessage)
{
  HCE::drce::tests::DRCEProtocolsTest::testInputJsonMessage();
}
//-----------------------------------------------------------------------------
TEST(DRCEProtocolsTest, testTaskExecuteRequest)
{
  HCE::drce::tests::DRCEProtocolsTest::testTaskExecuteRequest();
}
//-----------------------------------------------------------------------------
TEST(DRCEProtocolsTest, testOutputJsonMessage)
{
  HCE::drce::tests::DRCEProtocolsTest::testOutputJsonMessage();
}
//-----------------------------------------------------------------------------
TEST(DRCEProtocolsTest, testSessionOptions)
{
  HCE::drce::tests::DRCEProtocolsTest::testSessionOptions();
}
//-----------------------------------------------------------------------------
TEST(DRCEProtocolsTest, testResourceLimits)
{
  HCE::drce::tests::DRCEProtocolsTest::testResourceLimits();
}
//-----------------------------------------------------------------------------
TEST(DRCEProtocolsTest, testFilesItemList)
{
  HCE::drce::tests::DRCEProtocolsTest::testFilesItemList();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(DRCEActionTypesTest, testCreateBeforeExec)
{
  HCE::drce::tests::DRCEActionTypesTest::testCreateBeforeExec();
}
//-----------------------------------------------------------------------------
TEST(DRCEActionTypesTest, testDeleteBeforeExec)
{
  HCE::drce::tests::DRCEActionTypesTest::testDeleteBeforeExec();
}
//-----------------------------------------------------------------------------
TEST(DRCEActionTypesTest, testReadAfterExec)
{
  HCE::drce::tests::DRCEActionTypesTest::testReadAfterExec();
}
//-----------------------------------------------------------------------------
TEST(DRCEActionTypesTest, testDeleteAfterExec)
{
  HCE::drce::tests::DRCEActionTypesTest::testDeleteAfterExec();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testEmptyCommand)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testEmptyCommand();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testInputStreamWithCommand)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testInputStreamWithCommand();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testInputStreamWithoutCommand)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testInputStreamWithoutCommand();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testCommandSort)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testCommandSort();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testBadCommandLs)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testBadCommandLs();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testCommandLs)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testCommandLs();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testCommandPs)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testCommandPs();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testCommandPhp)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testCommandPhp();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testCommandPerl)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testCommandPerl();
}
//-----------------------------------------------------------------------------
TEST(DRCERequestLocalShellTest, testCommandJava)
{
  HCE::drce::tests::DRCERequestLocalShellTest::testCommandJava();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testApplyEnviroments)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testApplyEnviroments();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellSortInput)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellSortInput();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellSortOutput)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellSortOutput();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellSort)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellSort();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellPsInput)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellPsInput();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellPsOutput)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellPsOutput();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellPs)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellPs();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellPhpVersion)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellPhpVersion();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellPhpScript)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellPhpScript();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellPerlVersion)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellPerlVersion();
}
//-----------------------------------------------------------------------------
TEST(DRCEFunctionalObjectTest, testRequestLocalShellPerlScript)
{
  HCE::drce::tests::DRCEFunctionalObjectTest::testRequestLocalShellPerlScript();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(DRCETaskRequestsTest, testSerializeUnserializeSetTaskToExecuteRequest)
{
  HCE::drce::tests::DRCETaskRequestsTest::testSerializeUnserializeSetTaskToExecuteRequest();
}
//-----------------------------------------------------------------------------
TEST(DRCETaskRequestsTest, testSerializeUnserializeCheckTaskRequest)
{
  HCE::drce::tests::DRCETaskRequestsTest::testSerializeUnserializeCheckTaskRequest();
}
//-----------------------------------------------------------------------------
TEST(DRCETaskRequestsTest, testSerializeUnserializeGetTaskDataRequest)
{
  HCE::drce::tests::DRCETaskRequestsTest::testSerializeUnserializeGetTaskDataRequest();
}
//-----------------------------------------------------------------------------
TEST(DRCETaskRequestsTest, testSerializeUnserializeTerminateTaskRequest)
{
  HCE::drce::tests::DRCETaskRequestsTest::testSerializeUnserializeTerminateTaskRequest();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
Poco::SharedPtr<HCE::drce::DRCEFunctionalObject> pFunctionalObject = nullptr;
Poco::SharedPtr<HCE::drce::DRCENodeOptions> pNodeOptions = nullptr;
static unsigned int requestId = 0;

class LocalShellAsyncRequestTest : public ::testing::Test
{
protected:
  static void SetUpTestCase(void)
  {
    pNodeOptions = new HCE::drce::DRCENodeOptions(HCE::drce::tests::DRCETaskThreadingModeTest::getNodeOptions());
    pFunctionalObject = Poco::SharedPtr<HCE::drce::DRCEFunctionalObject>(new HCE::drce::DRCEFunctionalObject(
        pNodeOptions->getNodeName(),
        pNodeOptions->getHomeDir(),
        pNodeOptions->getTasksDataDir(),
        pNodeOptions->getTasksStatusDir(),
        pNodeOptions->getNodeHost(),
        pNodeOptions->getNodePort()));
    requestId = 500;
  }
  static void TearDownTestCase(void)
  {
    pFunctionalObject = nullptr;
    pNodeOptions = nullptr;
  }
  void SetUp(void)
  {
    ++requestId;
  }
  void TearDown(void)
  {
    HCE::drce::tests::DRCECleanupTest::cleanupTestData(*pNodeOptions);
  }
};
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTaskRequestTimeLimitsSyncWithTimeMax)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTaskRequestTimeLimits(*pFunctionalObject, requestId, HCE::drce::SessionOptions::ThreadMode::tmSync, 40000);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTaskRequestTimeLimitsAsyncWithTimeMax)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTaskRequestTimeLimits(*pFunctionalObject, requestId, HCE::drce::SessionOptions::ThreadMode::tmAsync, 40000);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTaskRequestTimeLimitsSyncWithoutTimeMax)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTaskRequestTimeLimits(*pFunctionalObject, requestId, HCE::drce::SessionOptions::ThreadMode::tmSync, 0);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTaskRequestTimeLimitsAsyncWithoutTimeMax)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTaskRequestTimeLimits(*pFunctionalObject, requestId, HCE::drce::SessionOptions::ThreadMode::tmAsync, 0);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTaskRequestExpiredTimeSync)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTaskRequestExpiredTime(*pFunctionalObject,
      requestId, HCE::drce::SessionOptions::ThreadMode::tmSync, HCE::drce::SessionOptions::CleanupFlag::cfNotDelete);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTaskRequestExpiredTimeAsync)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTaskRequestExpiredTime(*pFunctionalObject,
      requestId, HCE::drce::SessionOptions::ThreadMode::tmAsync, HCE::drce::SessionOptions::CleanupFlag::cfNotDelete);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTaskRequestExpiredTimeSyncWithCleanup)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTaskRequestExpiredTime(*pFunctionalObject,
      requestId, HCE::drce::SessionOptions::ThreadMode::tmSync, HCE::drce::SessionOptions::CleanupFlag::cfDelete);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTaskRequestExpiredTimeAsyncWithCleanup)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTaskRequestExpiredTime(*pFunctionalObject,
      requestId, HCE::drce::SessionOptions::ThreadMode::tmAsync, HCE::drce::SessionOptions::CleanupFlag::cfDelete);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testExecuteSyncRequest)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testExecuteSyncRequest(*pFunctionalObject, requestId);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testSetTaskToExecuteRequest)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testSetTaskToExecuteRequest(*pFunctionalObject, requestId);
  HCE::drce::tests::DRCETaskThreadingModeTest::testSetTaskToExecuteRequest(*pFunctionalObject, ++requestId);
  while (pFunctionalObject->getAsyncTasksCount())
  {
    Poco::Thread::sleep(10000);
    std::cout << "wait ..." << std::endl;
  }
  Poco::Thread::sleep(10000);
  HCE::drce::tests::DRCECleanupTest::cleanupTestData(*pFunctionalObject);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testGetTaskDataRequest)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testGetTaskDataRequest(*pFunctionalObject, requestId);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testCheckTaskRequest)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testCheckTaskRequest(*pFunctionalObject, requestId);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testExecuteNotification)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testExecuteNotification(*pFunctionalObject, requestId);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTerminateTaskRequestUseDefaultAlgorithm)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTerminateTaskRequest(*pFunctionalObject, requestId, HCE::drce::DRCETaskRequestTerminate::AlgorithmType::atDefault);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTerminateTaskRequestUseCustomAlgorithm)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTerminateTaskRequest(*pFunctionalObject, requestId, HCE::drce::DRCETaskRequestTerminate::AlgorithmType::atCustom);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testDeleteTaskDataRequest)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testDeleteTaskDataRequest(*pFunctionalObject, requestId);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTerminateExpiredTaskSync)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTerminateExpiredTaskSync(*pFunctionalObject, requestId);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testTerminateExpiredTaskAsync)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTerminateExpiredTaskAsync(*pFunctionalObject, requestId);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testParallelAsyncExecution)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testParallelAsyncExecution(*pFunctionalObject, requestId, 1);
}
//-----------------------------------------------------------------------------
/*
TEST_F(LocalShellAsyncRequestTest, testMaxThreadLimits)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testMaxThreadLimits(*pFunctionalObject, requestId, 5, 5);
}
*/
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testMultipleRequests)
{
  HCE::drce::tests::DRCEStressTest::testMultipleRequests(*pFunctionalObject, HCE::drce::SessionOptions::SessionType::stHostShell, 10);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testRequestsTimeDelay)
{
  HCE::drce::tests::DRCEStressTest::testRequestsTimeDelay(*pFunctionalObject, HCE::drce::SessionOptions::SessionType::stHostShell, 10, 10);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testResourceLimitsAsync)
{
  HCE::drce::tests::DRCEStressTest::testResourceLimits(*pFunctionalObject,
      HCE::drce::SessionOptions::SessionType::stHostShell,
      HCE::drce::SessionOptions::ThreadMode::tmAsync);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testResourceLimitsSync)
{
  HCE::drce::tests::DRCEStressTest::testResourceLimits(*pFunctionalObject,
      HCE::drce::SessionOptions::SessionType::stHostShell,
      HCE::drce::SessionOptions::ThreadMode::tmSync);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testResourceUsageLimitsAsync)
{
  HCE::drce::tests::DRCEStressTest::testResourceUsageLimits(*pFunctionalObject,
      HCE::drce::SessionOptions::SessionType::stHostShell,
      HCE::drce::SessionOptions::ThreadMode::tmAsync);
}
//-----------------------------------------------------------------------------
TEST_F(LocalShellAsyncRequestTest, testResourceUsageLimitsSync)
{
  HCE::drce::tests::DRCEStressTest::testResourceUsageLimits(*pFunctionalObject,
      HCE::drce::SessionOptions::SessionType::stHostShell,
      HCE::drce::SessionOptions::ThreadMode::tmSync);
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(TaskRequestTest, testTerminateTaskRequestCleanUp)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testTerminateTaskRequestCleanUp();
}
//-----------------------------------------------------------------------------
TEST(TaskRequestTest, testRequestLocalShellAsyncCleanUp)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testRequestLocalShellAsyncCleanUp();
}
//-----------------------------------------------------------------------------
TEST(TaskRequestTest, testCurrentTasksQueue)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testCurrentTasksQueue();
}
//-----------------------------------------------------------------------------
TEST(TaskRequestTest, testListAllTasks)
{
  HCE::drce::tests::DRCETaskThreadingModeTest::testListAllTasks();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testAsyncTaskAsyncSubtasks)
{
  HCE::drce::tests::DRCECleanupTest::testAsyncTaskAsyncSubtasks();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testAsyncTaskSyncSubtasks)
{
  HCE::drce::tests::DRCECleanupTest::testAsyncTaskSyncSubtasks();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testSyncTaskAsyncSubtasks)
{
  HCE::drce::tests::DRCECleanupTest::testSyncTaskAsyncSubtasks();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testSyncTaskSyncSubtasks)
{
  HCE::drce::tests::DRCECleanupTest::testSyncTaskSyncSubtasks();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testAsyncTaskMixSubtasks)
{
  HCE::drce::tests::DRCECleanupTest::testAsyncTaskMixSubtasks();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testSyncTaskMixSubtasks)
{
  HCE::drce::tests::DRCECleanupTest::testSyncTaskMixSubtasks();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testAsyncTaskMixSubtasksCleanup)
{
  HCE::drce::tests::DRCECleanupTest::testAsyncTaskMixSubtasksCleanup();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testSyncTaskMixSubtasksCleanup)
{
  HCE::drce::tests::DRCECleanupTest::testSyncTaskMixSubtasksCleanup();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testRequestGetDataCleanup)
{
  HCE::drce::tests::DRCECleanupTest::testRequestGetDataCleanup();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testRequestDeleteDataCleanup)
{
  HCE::drce::tests::DRCECleanupTest::testRequestDeleteDataCleanup();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testRequestTerminateCleanup)
{
  HCE::drce::tests::DRCECleanupTest::testRequestTerminateCleanup();
}
//-----------------------------------------------------------------------------
TEST(DRCECleanupTest, testRequestDeleteData)
{
  HCE::drce::tests::DRCECleanupTest::testRequestDeleteData();
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------