add IPA unittests

vpr/test/test_server_convertutils.cpp

@@ -0,0 +1,18 @@
+#include "convertutils.h"
+
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers_all.hpp"
+
+TEST_CASE("test_server_convert_utils_to_int", "[vpr]")
+{
+    REQUIRE(std::optional<int>{-2} == tryConvertToInt("-2"));
+    REQUIRE(std::optional<int>{0} == tryConvertToInt("0"));
+    REQUIRE(std::optional<int>{2} == tryConvertToInt("2"));
+    REQUIRE(std::nullopt == tryConvertToInt("2."));
+    REQUIRE(std::nullopt == tryConvertToInt("2.0"));
+    REQUIRE(std::nullopt == tryConvertToInt("two"));
+    REQUIRE(std::nullopt == tryConvertToInt("2k"));
+    REQUIRE(std::nullopt == tryConvertToInt("k2"));
+}
+
+

vpr/test/test_server_taskresolver.cpp

@@ -0,0 +1,112 @@
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers_all.hpp"
+
+#include "taskresolver.h"
+#include <memory>
+
+namespace {
+
+TEST_CASE("test_server_taskresolver_cmdSpamFilter", "[vpr]") {
+    server::TaskResolver resolver;
+    const int cmd = 10;
+
+    {
+        server::TaskPtr task0 = std::make_unique<server::Task>(1,cmd);
+        server::TaskPtr task1 = std::make_unique<server::Task>(2,cmd);
+        server::TaskPtr task2 = std::make_unique<server::Task>(3,cmd);
+        server::TaskPtr task3 = std::make_unique<server::Task>(4,cmd);
+        server::TaskPtr task4 = std::make_unique<server::Task>(5,cmd);
+
+        resolver.addTask(task0);
+        resolver.addTask(task1);
+        resolver.addTask(task2);
+        resolver.addTask(task3);
+        resolver.addTask(task4);
+    }
+
+    std::vector<server::TaskPtr> finished;
+    resolver.takeFinished(finished);
+
+    REQUIRE(finished.size() == 4);
+
+    for (const auto& task: finished) {
+        REQUIRE(task->isFinished());
+        REQUIRE(task->hasError());
+        REQUIRE(task->jobId() != 1);
+        REQUIRE(task->cmd() == cmd);
+    }
+    REQUIRE(resolver.tasksNum() == 1);
+    const server::TaskPtr& task = resolver.tasks().at(0);
+    REQUIRE(task->jobId() == 1);
+    REQUIRE(task->cmd() == cmd);
+}
+
+TEST_CASE("test_server_taskresolver_cmdOverrideFilter", "[vpr]") {
+    server::TaskResolver resolver;
+    const int cmd = 10;
+
+    {
+        server::TaskPtr task0 = std::make_unique<server::Task>(1,cmd,"1");
+        server::TaskPtr task1 = std::make_unique<server::Task>(2,cmd,"11");
+        server::TaskPtr task2 = std::make_unique<server::Task>(3,cmd,"222");
+
+        resolver.addTask(task0);
+        resolver.addTask(task1);
+        resolver.addTask(task2);
+    }
+
+    std::vector<server::TaskPtr> finished;
+    resolver.takeFinished(finished);
+
+    REQUIRE(finished.size() == 2);
+
+    for (const server::TaskPtr& task: finished) {
+        REQUIRE(task->isFinished());
+        REQUIRE(task->hasError());
+        REQUIRE(task->jobId() != 3);
+    }
+    REQUIRE(resolver.tasksNum() == 1);
+    const server::TaskPtr& task = resolver.tasks().at(0);
+    REQUIRE(task->jobId() == 3);
+    REQUIRE(task->cmd() == cmd);
+    REQUIRE(task->options() == "222");
+}
+
+TEST_CASE("test_server_taskresolver_cmdSpamAndOverrideOptions", "[vpr]") {
+    server::TaskResolver resolver;
+
+    {
+        server::TaskPtr task0 = std::make_unique<server::Task>(1,2,"1");
+        server::TaskPtr task1 = std::make_unique<server::Task>(2,2,"11");
+        server::TaskPtr task2 = std::make_unique<server::Task>(3,2,"222");
+        server::TaskPtr task3 = std::make_unique<server::Task>(4,2,"222");
+        server::TaskPtr task4 = std::make_unique<server::Task>(5,1);
+        server::TaskPtr task5 = std::make_unique<server::Task>(6,1);
+        server::TaskPtr task6 = std::make_unique<server::Task>(7,1);
+
+        resolver.addTask(task0);
+        resolver.addTask(task1);
+        resolver.addTask(task2);
+        resolver.addTask(task3);
+        resolver.addTask(task4);
+        resolver.addTask(task5);
+        resolver.addTask(task6);
+    }
+
+    std::vector<server::TaskPtr> finished;
+    resolver.takeFinished(finished);
+
+    REQUIRE(resolver.tasksNum() == 2);
+    const server::TaskPtr& task0 = resolver.tasks().at(0);
+    const server::TaskPtr& task1 = resolver.tasks().at(1);
+
+    REQUIRE(task0->jobId() == 3);
+    REQUIRE(task0->cmd() == 2);
+    REQUIRE(task0->options() == "222");
+
+    REQUIRE(task1->jobId() == 5);
+    REQUIRE(task1->cmd() == 1);
+    REQUIRE(task1->options() == "");
+}
+
+} // namespace

vpr/test/test_server_telegrambuffer.cpp

@@ -0,0 +1,146 @@
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers_all.hpp"
+
+#include "telegrambuffer.h"
+
+namespace {
+
+TEST_CASE("test_server_bytearray", "[vpr]") {
+    comm::ByteArray array1{"111"};
+    comm::ByteArray array2{"222"};
+    comm::ByteArray array{array1};
+    array.append(array2);
+
+    REQUIRE(array.at(0) == '1');
+    REQUIRE(array.at(1) == '1');
+    REQUIRE(array.at(2) == '1');
+    REQUIRE(array.at(3) == '2');
+    REQUIRE(array.at(4) == '2');
+    REQUIRE(array.at(5) == '2');
+
+    REQUIRE(array.to_string() == "111222");
+
+    REQUIRE(array.size() == 6);
+
+    array.append('3');
+
+    REQUIRE(array.size() == 7);
+    REQUIRE(array.to_string() == "1112223");
+
+    REQUIRE(array.at(6) == '3');
+
+    array.clear();
+
+    REQUIRE(array.size() == 0);
+    REQUIRE(array.to_string() == "");
+}
+
+TEST_CASE("test_server_telegrambuffer_oneOpened", "[vpr]") {
+    comm::TelegramBuffer buff;
+    buff.append(comm::ByteArray{"111"});
+    buff.append(comm::ByteArray{"222"});
+
+    auto frames = buff.takeTelegramFrames();
+    REQUIRE(frames.size() == 0);
+
+    REQUIRE(buff.data().to_string() == "111222");
+}
+
+TEST_CASE("test_server_telegrambuffer_notFilledTelegramButWithPrependedRubish", "[vpr]")
+{
+    comm::TelegramBuffer tBuff;
+
+    const comm::ByteArray rubish{"#@!"};
+    const comm::ByteArray msgBody{"some message"};
+    const comm::TelegramHeader msgHeader{comm::TelegramHeader::constructFromData(msgBody)};
+
+    tBuff.append(rubish);
+    tBuff.append(msgHeader.buffer());
+
+    auto frames = tBuff.takeTelegramFrames();
+    REQUIRE(0 == frames.size());
+
+    REQUIRE(msgHeader.buffer() == tBuff.data()); // the rubish prefix fragment will be absent here
+}
+
+TEST_CASE("test_server_telegrambuffer__oneFinishedOneOpened", "[vpr]")
+{
+    comm::TelegramBuffer tBuff;
+
+    const comm::ByteArray msgBody1{"message1"};
+    const comm::ByteArray msgBody2{"message2"};
+
+    const comm::TelegramHeader msgHeader1{comm::TelegramHeader::constructFromData(msgBody1)};
+    const comm::TelegramHeader msgHeader2{comm::TelegramHeader::constructFromData(msgBody2)};
+
+    comm::ByteArray t1(msgHeader1.buffer());
+    t1.append(msgBody1);
+
+    comm::ByteArray t2(msgHeader2.buffer());
+    t2.append(msgBody2);
+    t2.resize(t2.size()-2); // drop 2 last elements
+
+    tBuff.append(t1);
+    tBuff.append(t2);
+
+    auto frames = tBuff.takeTelegramFrames();
+    REQUIRE(1 == frames.size());
+
+    REQUIRE(msgBody1 == frames[0]->data);
+
+    REQUIRE(t2 == tBuff.data());
+}
+
+TEST_CASE("test_server_telegrambuffer_twoFinished", "[vpr]")
+{
+    comm::TelegramBuffer tBuff;
+
+    const comm::ByteArray msgBody1{"message1"};
+    const comm::ByteArray msgBody2{"message2"};
+
+    const comm::TelegramHeader msgHeader1{comm::TelegramHeader::constructFromData(msgBody1)};
+    const comm::TelegramHeader msgHeader2{comm::TelegramHeader::constructFromData(msgBody2)};
+
+    comm::ByteArray t1(msgHeader1.buffer());
+    t1.append(msgBody1);
+
+    comm::ByteArray t2(msgHeader2.buffer());
+    t2.append(msgBody2);
+
+    tBuff.append(t1);
+    tBuff.append(t2);
+
+    auto frames = tBuff.takeTelegramFrames();
+    REQUIRE(2 == frames.size());
+
+    REQUIRE(msgBody1 == frames[0]->data);
+    REQUIRE(msgBody2 == frames[1]->data);
+
+    REQUIRE(comm::ByteArray{} == tBuff.data());
+}
+
+TEST_CASE("test_server_telegrambuffer_clear", "[vpr]")
+{
+    comm::TelegramBuffer tBuff;
+
+    const comm::ByteArray msgBody1{"message1"};
+    const comm::ByteArray msgBody2{"message2"};
+
+    const comm::TelegramHeader msgHeader1{comm::TelegramHeader::constructFromData(msgBody1)};
+    const comm::TelegramHeader msgHeader2{comm::TelegramHeader::constructFromData(msgBody2)};
+
+    comm::ByteArray t1(msgHeader1.buffer());
+    t1.append(msgBody1);
+
+    comm::ByteArray t2(msgHeader2.buffer());
+    t2.append(msgBody2);
+
+    tBuff.clear();
+
+    auto frames = tBuff.takeTelegramFrames();
+    REQUIRE(0 == frames.size());
+
+    REQUIRE(comm::ByteArray{} == tBuff.data());
+}
+
+} // namespace

vpr/test/test_server_telegramoptions.cpp

@@ -0,0 +1,19 @@
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers_all.hpp"
+
+#include "telegramoptions.h"
+
+namespace {
+
+TEST_CASE("test_server_telegramoptions", "[vpr]") {
+    server::TelegramOptions options{"int:path_num:11;string:path_type:debug;int:details_level:3;bool:is_flat_routing:0", {"path_num", "path_type", "details_level", "is_flat_routing"}};
+
+    REQUIRE(options.errorsStr() == "");
+
+    REQUIRE(options.getString("path_type") == "debug");
+    REQUIRE(options.getInt("path_num", -1) == 11);
+    REQUIRE(options.getInt("details_level", -1) == 3);
+    REQUIRE(options.getBool("is_flat_routing", true) == false);
+}
+
+} // namespace

vpr/test/test_server_telegramparser.cpp

@@ -0,0 +1,43 @@
+#include "telegramparser.h"
+
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers_all.hpp"
+
+TEST_CASE("test_server_telegram_parser_base", "[vpr]")
+{
+    const std::string tdata{R"({"JOB_ID":"7","CMD":"2","OPTIONS":"type1:name1:value1;type2:name2:v a l u e 2;t3:n3:v3","DATA":"some_data...","STATUS":"1"})"};
+
+    REQUIRE(std::optional<int>{7} == comm::TelegramParser::tryExtractFieldJobId(tdata));
+    REQUIRE(std::optional<int>{2} == comm::TelegramParser::tryExtractFieldCmd(tdata));
+    std::optional<std::string> optionsOpt;
+    REQUIRE(comm::TelegramParser::tryExtractFieldOptions(tdata, optionsOpt) == true);
+    REQUIRE(std::optional<std::string>{"type1:name1:value1;type2:name2:v a l u e 2;t3:n3:v3"} == optionsOpt);
+    std::optional<std::string> dataOpt;
+    REQUIRE(comm::TelegramParser::tryExtractFieldData(tdata, dataOpt) == true);
+    REQUIRE(std::optional<std::string>{"some_data..."} == dataOpt);
+    REQUIRE(std::optional<int>{1} == comm::TelegramParser::tryExtractFieldStatus(tdata));
+}
+
+TEST_CASE("test_server_telegram_parser_invalid_keys", "[vpr]")
+{
+    const std::string tBadData{R"({"_JOB_ID":"7","_CMD":"2","_OPTIONS":"type1:name1:value1;type2:name2:v a l u e 2;t3:n3:v3","_DATA":"some_data...","_STATUS":"1"})"};
+
+    REQUIRE(std::nullopt == comm::TelegramParser::tryExtractFieldJobId(tBadData));
+    REQUIRE(std::nullopt == comm::TelegramParser::tryExtractFieldCmd(tBadData));
+    std::optional<std::string> optionsOpt;
+    REQUIRE_FALSE(comm::TelegramParser::tryExtractFieldOptions(tBadData, optionsOpt));
+    REQUIRE(std::nullopt == optionsOpt);
+    std::optional<std::string> dataOpt;
+    REQUIRE_FALSE(comm::TelegramParser::tryExtractFieldData(tBadData, dataOpt));
+    REQUIRE(std::nullopt == dataOpt);
+    REQUIRE(std::nullopt == comm::TelegramParser::tryExtractFieldStatus(tBadData));
+}
+
+TEST_CASE("test_server_telegram_parser_invalid_types", "[vpr]")
+{
+    const std::string tBadData{R"({"JOB_ID":"x","CMD":"y","STATUS":"z"})"};
+
+    REQUIRE(std::nullopt == comm::TelegramParser::tryExtractFieldJobId(tBadData));
+    REQUIRE(std::nullopt == comm::TelegramParser::tryExtractFieldCmd(tBadData));
+    REQUIRE(std::nullopt == comm::TelegramParser::tryExtractFieldStatus(tBadData));
+}

vpr/test/test_server_zlibutils.cpp

@@ -0,0 +1,20 @@
+#include "zlibutils.h"
+
+#include "catch2/catch_test_macros.hpp"
+#include "catch2/matchers/catch_matchers_all.hpp"
+
+TEST_CASE("test_server_zlib_utils", "[vpr]")
+{
+    const std::string orig{"This string is going to be compressed now"};
+
+    std::string compressed = tryCompress(orig);
+    std::string decompressed = tryDecompress(compressed);
+
+    REQUIRE(orig != compressed);
+    REQUIRE(orig == decompressed);
+}
+
+
+
+
+