testDpSpec.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_dpm_libmerge
 * @copyright ESO - European Southern Observatory
 */
#include <daq/error/report.hpp>
#include <daq/json/dpSpec.hpp>
 
#include <gmock/gmock.h>
#include <gtest/gtest.h>
 
#include <daq/test/expect.hpp>
 
using namespace testing;
 
namespace daq::json {
 
class TestParseLocation : public ::testing::Test {};
 
TEST_F(TestParseLocation, ParseSucceeds) {
    {
        Location o = ParseSourceLocation("user@foo");
        EXPECT_EQ(o.host, "");
        EXPECT_EQ(o.path, "foo");
    }
    {
        Location o = ParseSourceLocation("foo");
        EXPECT_EQ(o.host, "");
        EXPECT_EQ(o.path, "foo");
    }
    {
        Location o = ParseSourceLocation("host:~/files/file.fits");
        EXPECT_EQ(o.host, "host");
        EXPECT_EQ(o.path, "~/files/file.fits");
    }
    {
        Location o = ParseSourceLocation("host:/path/to/file:with:colons.fits");
        EXPECT_EQ(o.host, "host");
        EXPECT_EQ(o.path, "/path/to/file:with:colons.fits");
    }
    {
        Location o = ParseSourceLocation("user@host:/path/to/file:with:colons.fits");
        EXPECT_EQ(o.host, "host");
        EXPECT_EQ(o.path, "/path/to/file:with:colons.fits");
    }
}
 
TEST_F(TestParseLocation, ParseFails) {
    EXPECT_THROW(ParseSourceLocation("user@"), std::invalid_argument);
    EXPECT_THROW(ParseSourceLocation("@"), std::invalid_argument);
    EXPECT_THROW(ParseSourceLocation(":"), std::invalid_argument);
    EXPECT_THROW(ParseSourceLocation("user@:"), std::invalid_argument);
}
 
class TestParseDpSpec : public ::testing::Test {
public:
    void SetUp() {
        using namespace nlohmann;
        m_spec = R"(
            {
              "id": "TEST.ID",
              "target": {
                "fileId": "TEST.FILEID",
                "source": {
                  "sourceName": "dcs",
                  "location": "dcs-host:/path/to/somefile.fits",
                  "keywordRules": [
                    {
                      "type": "transform",
                      "selectionPatterns": [
                        "+e INS *"
                      ],
                      "regex": "^INS ",
                      "format": "INS2 "
                    },
                    {
                      "type": "filter",
                      "selectionPatterns": [
                        "+e INS2 *",
                        "+v VALUEKW"
                      ]
                    }
                  ]
                }
              },
              "sources": [
                {
                  "type": "fitsKeywords",
                  "sourceName": "ocm",
                  "keywordRules": [
                    {
                      "type": "filter",
                      "selectionPatterns": [
                        "+e *",
                        "+v *"
                      ]
                    }
                  ],
                  "keywords": [
                    {
                      "type": "valueKeyword",
                      "name": "ORIGIN",
                      "value": "ESO-PARANAL"
                    },
                    {
                      "type": "valueKeyword",
                      "name": "TELESCOP",
                      "value": "ESO-ELT"
                    },
                    {
                      "type": "valueKeyword",
                      "name": "OBJECT",
                      "value": "OBJECT,SKY"
                    },
                    {
                      "type": "esoKeyword",
                      "name": "OCS TEMPL ID",
                      "value": "template-id"
                    },
                    {
                      "type": "literalKeyword",
                      "value": "COMMENT Example of a commentary keyword."
                    }
                  ]
                },
                {
                  "type": "fitsKeywords",
                  "sourceName": "tcs",
                  "keywordRules": [
                  ],
                  "keywords": [
                    {
                      "type": "esoKeyword",
                      "name": "TEL AIRM START",
                      "value": 1.072
                    },
                    {
                      "type": "esoKeyword",
                      "name": "TEL AIRM END",
                      "value": 1.08
                    }
                  ]
                },
                {
                  "type": "fitsFile",
                  "sourceName": "fcs",
                  "location": "fcs-host:/path/to/somefile.fits",
                  "alertUnmergeable": false,
                  "keywordRules": [
                    {
                      "type": "filter",
                      "selectionPatterns": [
                        "+e INS *",
                        "-e INS TEMP[12] *",
                        "+v VALUEKW"
                      ]
                    },
                    {
                      "type": "transform",
                      "selectionPatterns": [
                        "+e INS *"
                      ],
                      "regex": "^INS ",
                      "format": "INS2 "
                    }
                  ]
                }
              ],
              "receivers": [
                {
                  "type": "olasReceiver",
                  "host": "1.2.3.4",
                  "path": "/absolute/path"
                }
              ]
            }
        )"_json;
    }
 
    nlohmann::json m_spec;
};
 
TEST_F(TestParseDpSpec, ParseSucceeds) {
    DpSpec spec = ParseDpSpec(m_spec);
    EXPECT_EQ(spec.id, "TEST.ID");
    EXPECT_EQ(spec.target.file_id, "TEST.FILEID");
 
    ASSERT_TRUE(spec.target.source.has_value());
    EXPECT_EQ(spec.target.source->source_name, "dcs");
 
    ASSERT_EQ(spec.target.source->keyword_rules.size(), 2u);
    auto const& transform = std::get<KeywordTransform>(spec.target.source->keyword_rules.at(0));
    ASSERT_EQ(transform.selection_patterns.size(), 1);
    EXPECT_EQ(transform.selection_patterns[0], "+e INS *");
    EXPECT_EQ(transform.format, "INS2 ");
    auto const& filter = std::get<KeywordFilter>(spec.target.source->keyword_rules.at(1));
    EXPECT_THAT(filter.selection_patterns, ElementsAre("+e INS2 *", "+v VALUEKW"));
 
    ASSERT_EQ(3u, spec.sources.size());
    auto const& ocm_kws_var = spec.sources[0];
    ASSERT_TRUE(std::holds_alternative<FitsKeywordsSource>(ocm_kws_var));
    auto const& tcs_kws_var = spec.sources[1];
    ASSERT_TRUE(std::holds_alternative<FitsKeywordsSource>(tcs_kws_var));
    auto const& fcs_fits_var = spec.sources[2];
    ASSERT_TRUE(std::holds_alternative<FitsFileSource>(fcs_fits_var));
    auto const& ocm_kws = std::get<FitsKeywordsSource>(spec.sources[0]);
    auto const& tcs_kws = std::get<FitsKeywordsSource>(spec.sources[1]);
    auto const& fcs_fits = std::get<FitsFileSource>(spec.sources[2]);
 
    {
        EXPECT_EQ(ocm_kws.source_name, "ocm");
        ASSERT_EQ(ocm_kws.keyword_rules.size(), 1);
        auto const& filter = std::get<KeywordFilter>(ocm_kws.keyword_rules.at(0));
        ASSERT_EQ(filter.selection_patterns.size(), 2);
        EXPECT_THAT(filter.selection_patterns, ElementsAre("+e *", "+v *"));
    }
 
    EXPECT_EQ(tcs_kws.source_name, "tcs");
    EXPECT_EQ(fcs_fits.source_name, "fcs");
    EXPECT_EQ(fcs_fits.alert_unmergeable, false);
 
    {
        // check receiver list
        ASSERT_EQ(1u, spec.receivers.size());
        auto const& olas_variant = spec.receivers[0];
        ASSERT_TRUE(std::holds_alternative<OlasReceiver>(olas_variant));
        auto const& olas_receiver = std::get<OlasReceiver>(olas_variant);
        EXPECT_EQ(olas_receiver.host, "1.2.3.4");
        EXPECT_EQ(olas_receiver.path, "/absolute/path/");
    }
}
 
TEST_F(TestParseDpSpec, ParseSucceedsWithOptionalTarget) {
    m_spec["target"].erase("targetSource");
    EXPECT_NO_THROW(ParseDpSpec(m_spec));
}
 
TEST_F(TestParseDpSpec, ParseSucceedsWithOptionalSources) {
    m_spec.erase("sources");
    EXPECT_NO_THROW(ParseDpSpec(m_spec));
}
 
TEST_F(TestParseDpSpec, ParseSucceedsWithOptionalSourcesEmpty) {
    m_spec["sources"] = nlohmann::json::array();
    EXPECT_NO_THROW(ParseDpSpec(m_spec));
}
 
TEST_F(TestParseDpSpec, ParseSucceedsWithOptionalReceivers) {
    m_spec.erase("receivers");
    EXPECT_NO_THROW(ParseDpSpec(m_spec));
}
 
TEST_F(TestParseDpSpec, ParseSucceedsWithOptionalReceiversEmpty) {
    m_spec["receivers"] = nlohmann::json::array();
    EXPECT_NO_THROW(ParseDpSpec(m_spec));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithMissingId) {
    m_spec.erase("id");
    EXPECT_THROW_WITH_MESSAGE(
        ParseDpSpec(m_spec), DpSpecError, MatchesRegex(R"(.*\‍(/id\).*missing.*)"));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithMissingFileId) {
    m_spec["target"].erase("fileId");
    EXPECT_THROW_WITH_MESSAGE(
        ParseDpSpec(m_spec), DpSpecError, MatchesRegex(R"(.*\‍(/target/fileId\).*missing.*)"));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithFileIdWrongType) {
    m_spec["target"]["fileId"] = 0u;
    EXPECT_THROW_WITH_MESSAGE(ParseDpSpec(m_spec),
                              DpSpecError,
                              MatchesRegex(R"(.*\‍(/target/fileId\).*must be a string.*)"));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithKeywordsBadType) {
    m_spec["sources"][0]["keywords"][0]["type"] = "";
    EXPECT_THROW_WITH_MESSAGE(ParseDpSpec(m_spec),
                              DpSpecError,
                              MatchesRegex(R"(.*\‍(/sources/0/keywords/0/type\).*empty.*)"));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithKeywordsNotDefined) {
    m_spec["sources"][0].erase("keywords");
    EXPECT_THROW_WITH_MESSAGE(
        ParseDpSpec(m_spec), DpSpecError, MatchesRegex(R"(.*\‍(/sources/0/keywords\).*missing.*)"));
}
TEST_F(TestParseDpSpec, ParseSucceedsWithKeywordRulesNotDefined) {
    m_spec["sources"][2].erase("keywordRules");
    EXPECT_NO_THROW(ParseDpSpec(m_spec));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithMissingSources) {
    m_spec["target"].erase("source");
    m_spec["sources"] = nlohmann::json::array();
 
    EXPECT_THROW_WITH_MESSAGE(
        ParseDpSpec(m_spec), DpSpecError, MatchesRegex(R"(.*\‍(/sources\).*At least one.*)"));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithUnknownSourceType) {
    m_spec["sources"][0]["type"] = "unknown";
 
    EXPECT_THROW_WITH_MESSAGE(
        ParseDpSpec(m_spec), DpSpecError, MatchesRegex(R"(.*\‍(/sources/0/type\).*unknown.*)"));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithUnknownSourceTypeNotObject) {
    m_spec["sources"][0] = 0;
 
    EXPECT_THROW_WITH_MESSAGE(
        ParseDpSpec(m_spec), DpSpecError, MatchesRegex(R"(.*\‍(/sources/0\).*object.*)"));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithUnknownSourcesWrongType) {
    m_spec["sources"] = 0;
 
    EXPECT_THROW_WITH_MESSAGE(
        ParseDpSpec(m_spec), DpSpecError, MatchesRegex(R"(.*\‍(/sources\).*array.*)"));
}
 
TEST_F(TestParseDpSpec, ParseFailsWithWrongAlertUnmergedType) {
    m_spec["sources"][2]["alertUnmergeable"] = "true";
 
    EXPECT_THROW_WITH_MESSAGE(ParseDpSpec(m_spec),
                              DpSpecError,
                              MatchesRegex(R"(.*\‍(/sources/2/alertUnmergeable\).*must be a boolean.*)"));
}
 
}  // namespace daq::json