daggy/libdaggy/tests/unit_serialization.cpp

#include <catch2/catch.hpp>
#include <filesystem>
#include <fstream>
#include <iostream>

#include "daggy/Serialization.hpp"

namespace fs = std::filesystem;

TEST_CASE("parameter_deserialization", "[deserialize_parameters]")
{
  SECTION("Basic Parse")
  {
    std::string testParams{
        R"({"DATE": ["2021-05-06", "2021-05-07" ], "SOURCE": "name"})"};
    auto params = daggy::configFromJSON(testParams);
    REQUIRE(params.size() == 2);
    REQUIRE(std::holds_alternative<std::vector<std::string>>(params["DATE"]));
    REQUIRE(std::holds_alternative<std::string>(params["SOURCE"]));
  }
  SECTION("Invalid JSON")
  {
    std::string testParams{
        R"({"DATE": ["2021-05-06", "2021-05-07" ], "SOURCE": "name")"};
    REQUIRE_THROWS(daggy::configFromJSON(testParams));
  }
  SECTION("Non-string Keys")
  {
    std::string testParams{
        R"({"DATE": ["2021-05-06", "2021-05-07" ], 6: "name"})"};
    REQUIRE_THROWS(daggy::configFromJSON(testParams));
  }
  SECTION("Non-array/Non-string values")
  {
    std::string testParams{
        R"({"DATE": ["2021-05-06", "2021-05-07" ], "SOURCE": {"name": "kevin"}})"};
    REQUIRE_THROWS(daggy::configFromJSON(testParams));
  }
}

TEST_CASE("task_deserialization", "[deserialize_task]")
{
  SECTION("Build with no expansion")
  {
    std::string testTasks = R"({
        "A": {
            "job": { "command": ["/bin/echo", "A"] },
            "children": ["C"]
            },
        "B": {
            "job": {"command": ["/bin/echo", "B"]},
            "children": ["C"]
            },
        "C": {
            "job": {"command": ["/bin/echo", "C"]}
            }
        })";
    auto tasks            = daggy::tasksFromJSON(testTasks);
    REQUIRE(tasks.size() == 3);
  }

  SECTION("Build with job defaults")
  {
    std::string testTasks = R"({
        "A": {
            "job": { "command": ["/bin/echo", "A"] },
            "children": ["B"]
            },
        "B": {
            "job": {
                "command": ["/bin/echo", "C"],
                "memory": "1G"
                }
            }
        })";
    daggy::ConfigValues jobDefaults{{"runtime", "60"}, {"memory", "300M"}};
    auto tasks = daggy::tasksFromJSON(testTasks, jobDefaults);
    REQUIRE(tasks.size() == 2);
    REQUIRE(std::get<std::string>(tasks["A"].job["runtime"]) == "60");
    REQUIRE(std::get<std::string>(tasks["A"].job["memory"]) == "300M");
    REQUIRE(std::get<std::string>(tasks["B"].job["runtime"]) == "60");
    REQUIRE(std::get<std::string>(tasks["B"].job["memory"]) == "1G");
  }
}

TEST_CASE("task_serialization", "[serialize_tasks]")
{
  SECTION("Build with no expansion")
  {
    std::string testTasks =
        R"({"A": {"job": {"command": ["/bin/echo", "A"]}, "children": ["C"]}, "B": {"job": {"command": ["/bin/echo", "B"]}, "children": ["C"]}, "C": {"job": {"command": ["/bin/echo", "C"]}}})";
    auto tasks = daggy::tasksFromJSON(testTasks);

    auto genJSON    = daggy::tasksToJSON(tasks);
    auto regenTasks = daggy::tasksFromJSON(genJSON);

    REQUIRE(regenTasks.size() == tasks.size());

    for (const auto &[name, task] : regenTasks) {
      const auto &other = tasks[name];
      REQUIRE(task == other);
    }
  }
}

TEST_CASE("attempt_serialization", "[serialize_attempt]")
{
  SECTION("Serialize Simple Attempt")
  {
    using namespace daggy;

    AttemptRecord attempt{
				.startTime = Clock::now(),
				.stopTime = Clock::now(),
				.rc = 0,
				.executorLog = "",
				.outputLog = "",
				.errorLog = "",
			};

    auto json = attemptRecordToJSON(attempt);

    rj::Document doc;
    REQUIRE_NOTHROW(checkRJParse(doc.Parse(json.c_str()), "Parsing AttemptRecord"));
  }

  SECTION("Serialize Attempt with complicated logs")
  {
    using namespace daggy;

    AttemptRecord attempt{
				.startTime = Clock::now(),
				.stopTime = Clock::now(),
				.rc = 0,
				.executorLog = "",
				.outputLog = "This is a testament to\nmore complicated, \"potentially quoted\"\nproblem\tspaces\n",
				.errorLog = "",
			};

    auto json = attemptRecordToJSON(attempt);

    rj::Document doc;
    REQUIRE_NOTHROW(checkRJParse(doc.Parse(json.c_str()), "Parsing AttemptRecord"));
  }

}