test/utils_test.cpp

#include "config.h"

#include "mockups.hpp"
#include "utils.hpp"

#include <chrono>
#include <filesystem>
#include <fstream>
#include <memory>
#include <optional>
#include <string>
#include <string_view>
#include <thread>

#include <gtest/gtest.h>

namespace boot_time_monitor
{
namespace
{

namespace fs = std::filesystem;

TEST(DoesUtilWorkTest, Works)
{
    Util u;
    auto curUpTime = u.getUpTimeInMs();
    auto curWallTime = u.getWallTimeInMs();
    std::this_thread::sleep_for(std::chrono::seconds(2));

    ASSERT_NE(curUpTime, std::nullopt);
    ASSERT_GT(curUpTime.value(), 0);

    EXPECT_GT(u.getUpTimeInMs().value_or(-1), curUpTime);
    EXPECT_GT(u.getWallTimeInMs(), curWallTime);
}

TEST(ValidNameTest, Valid)
{
    Util u;
    EXPECT_TRUE(u.isValidName("0129"));
    EXPECT_TRUE(u.isValidName("ABCZ"));
    EXPECT_TRUE(u.isValidName("abcz"));
    EXPECT_TRUE(u.isValidName("____"));
    EXPECT_TRUE(u.isValidName("A_a_1_"));
    EXPECT_FALSE(u.isValidName("A-_a_1_"));
    EXPECT_FALSE(u.isValidName("A_a*_1_"));
    EXPECT_FALSE(u.isValidName("A_a_1@_"));
    EXPECT_FALSE(u.isValidName("A#_a_1_"));
    EXPECT_FALSE(u.isValidName("A_a _1_"));
}

TEST(getPathTest, Works)
{
    Util u;
    EXPECT_EQ(u.getCPPath("host0", false),
              std::string(bootTimeDataDir) + "host0_checkpoints.csv");
    EXPECT_EQ(u.getCPPath("bmc", false),
              std::string(bootTimeDataDir) + "bmc_checkpoints.csv");
    EXPECT_EQ(u.getCPPath("_N_o_d_e_", false),
              std::string(bootTimeDataDir) + "_N_o_d_e__checkpoints.csv");

    EXPECT_EQ(u.getCPPath("host0", true),
              std::string(bootTimeDataDir) + "host0_checkpoints.csv.completed");
    EXPECT_EQ(u.getCPPath("bmc", true),
              std::string(bootTimeDataDir) + "bmc_checkpoints.csv.completed");
    EXPECT_EQ(u.getCPPath("_N_o_d_e_", true),
              std::string(bootTimeDataDir) +
                  "_N_o_d_e__checkpoints.csv.completed");

    EXPECT_EQ(u.getDurPath("host0", false),
              std::string(bootTimeDataDir) + "host0_durations.csv");
    EXPECT_EQ(u.getDurPath("bmc", false),
              std::string(bootTimeDataDir) + "bmc_durations.csv");
    EXPECT_EQ(u.getDurPath("_N_o_d_e_", false),
              std::string(bootTimeDataDir) + "_N_o_d_e__durations.csv");

    EXPECT_EQ(u.getDurPath("host0", true),
              std::string(bootTimeDataDir) + "host0_durations.csv.completed");
    EXPECT_EQ(u.getDurPath("bmc", true),
              std::string(bootTimeDataDir) + "bmc_durations.csv.completed");
    EXPECT_EQ(u.getDurPath("_N_o_d_e_", true),
              std::string(bootTimeDataDir) +
                  "_N_o_d_e__durations.csv.completed");
}

TEST(DoesFileUtilWork, CheckpointWorks)
{
    constexpr std::string_view cpName = "temp_cp";
    const std::string cpCompleted = std::string{cpName} + kCompletedSuffix;

    // Clean previous test result
    fs::remove(cpName);
    fs::remove(cpCompleted);

    FileUtil cpUtil(cpName);
    EXPECT_TRUE(cpUtil.isEmpty());
    cpUtil.addCheckpoint("checkpoint_10", 10, 20);
    cpUtil.addCheckpoint("checkpoint_30", 30, 50);
    EXPECT_FALSE(cpUtil.isEmpty());

    // Completed data should be empty
    EXPECT_TRUE(cpUtil.loadCheckpoints(true)->empty());
    auto vec = cpUtil.loadCheckpoints(false);
    EXPECT_EQ(vec->size(), 2);
    EXPECT_EQ((*vec)[0].name, "checkpoint_10");
    EXPECT_EQ((*vec)[0].wallTime, 10);
    EXPECT_EQ((*vec)[0].monoTime, 20);
    EXPECT_EQ((*vec)[1].name, "checkpoint_30");
    EXPECT_EQ((*vec)[1].wallTime, 30);
    EXPECT_EQ((*vec)[1].monoTime, 50);

    cpUtil.completeCurrent();
    // Current data should be empty
    EXPECT_TRUE(cpUtil.loadCheckpoints(false)->empty());
    EXPECT_TRUE(cpUtil.isEmpty());

    // Check completed data
    vec = cpUtil.loadCheckpoints(true);
    EXPECT_EQ(vec->size(), 2);
    EXPECT_EQ((*vec)[0].name, "checkpoint_10");
    EXPECT_EQ((*vec)[0].wallTime, 10);
    EXPECT_EQ((*vec)[0].monoTime, 20);
    EXPECT_EQ((*vec)[1].name, "checkpoint_30");
    EXPECT_EQ((*vec)[1].wallTime, 30);
    EXPECT_EQ((*vec)[1].monoTime, 50);

    // Check file content
    std::string input = "";
    std::ifstream ifs(cpCompleted);
    ASSERT_TRUE(ifs.good());
    ifs >> input;
    EXPECT_EQ(input, "checkpoint_10,10,20");
    ifs >> input;
    EXPECT_EQ(input, "checkpoint_30,30,50");
    EXPECT_FALSE(ifs >> input);
    ifs.close();
}

TEST(DoesFileUtilWork, DurationWorks)
{
    constexpr std::string_view durName = "temp_dur";
    const std::string durCompleted = std::string{durName} + kCompletedSuffix;

    // Clean previous test result
    fs::remove(durName);
    fs::remove(durCompleted);

    FileUtil durUtil(durName);
    EXPECT_TRUE(durUtil.isEmpty());
    durUtil.addDuration("duration_1000", 1000);
    durUtil.addDuration("duration_3000", 3000);
    EXPECT_FALSE(durUtil.isEmpty());

    // Completed data should be empty
    EXPECT_TRUE(durUtil.loadDurations(true)->empty());
    auto vec = durUtil.loadDurations(false);
    EXPECT_EQ(vec->size(), 2);
    EXPECT_EQ((*vec)[0].name, "duration_1000");
    EXPECT_EQ((*vec)[0].duration, 1000);
    EXPECT_EQ((*vec)[1].name, "duration_3000");
    EXPECT_EQ((*vec)[1].duration, 3000);

    durUtil.completeCurrent();
    // Current data should be empty
    EXPECT_TRUE(durUtil.loadDurations(false)->empty());
    EXPECT_TRUE(durUtil.isEmpty());

    // Check completed data
    vec = durUtil.loadDurations(true);
    EXPECT_EQ(vec->size(), 2);
    EXPECT_EQ((*vec)[0].name, "duration_1000");
    EXPECT_EQ((*vec)[0].duration, 1000);
    EXPECT_EQ((*vec)[1].name, "duration_3000");
    EXPECT_EQ((*vec)[1].duration, 3000);

    // Check file content
    std::string input = "";
    std::ifstream ifs(durCompleted);
    ASSERT_TRUE(ifs.good());
    ifs >> input;
    EXPECT_EQ(input, "duration_1000,1000");
    ifs >> input;
    EXPECT_EQ(input, "duration_3000,3000");
    EXPECT_FALSE(ifs >> input);
    ifs.close();
}

} // namespace
} // namespace boot_time_monitor