testStartDaqV2.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_libjson
 * @copyright
 * (c) Copyright ESO 2022
 * All Rights Reserved
 * ESO (eso.org) is an Intergovernmental Organisation, and therefore special legal conditions apply.
 */
#include <daq/json/startDaqV2.hpp>
 
#include <gtest/gtest.h>
 
using namespace ::testing;
 
namespace daq::json {
 
class TestParseStartDaqV2Spec : public ::testing::Test {
public:
    void SetUp() {
        using namespace nlohmann;
        m_spec = R"(
        {
          "id": "myid",
          "awaitCompletionInterval": 3.0,
          "mergeTarget": {
            "sourceName": "primary"
          },
          "sources": [
            {
              "type": "primarySource",
              "sourceName": "primary",
              "rrUri": "zpb.rr://prim",
              "keywordRules": [
                {
                  "type": "filter",
                  "selectionPatterns": [
                    "+e *",
                    "+v *"
                  ]
                }
              ]
            },
            {
              "type": "metadataSource",
              "sourceName": "metadata",
              "rrUri": "zpb.rr://meta",
              "initialKeywords": "user",
              "keywordRules": [
                {
                  "type": "transform",
                  "selectionPatterns": [
                    "+e INS1 *"
                  ],
                  "regex": "INS1 ",
                  "format": "INS2 "
                }
              ]
            },
            {
              "type": "fitsKeywords",
              "sourceName": "keywords",
              "keywords": [
                {
                  "type": "valueKeyword",
                  "name": "TELESCOP",
                  "value": "ESO-ELT"
                }
              ],
              "keywordRules": [
                {
                  "type": "transform",
                  "selectionPatterns": [
                    "+e INS1 *"
                  ],
                  "regex": "INS1 ",
                  "format": "INS2 "
                }
              ]
            },
            {
              "type": "fitsFile",
              "sourceName": "file",
              "location": "host:/path/to.fits.",
              "keywordRules": [
                {
                  "type": "transform",
                  "selectionPatterns": [
                    "+e INS1 *"
                  ],
                  "regex": "INS1 ",
                  "format": "INS2 "
                }
              ]
            }
          ],
          "filePrefix": "prefix",
          "receivers": [
            {
              "type": "olasReceiver",
              "host": "1.2.3.4",
              "path": "/absolute/path"
            }
          ]
        }
        )"_json;
    }
    nlohmann::json m_spec;
};
 
TEST_F(TestParseStartDaqV2Spec, RoundTripParsing) {
    auto spec_1 = ParseStartDaqV2Spec(m_spec);
    auto spec_1_json = nlohmann::json();
    to_json(spec_1_json, spec_1);
 
    auto spec_2 = ParseStartDaqV2Spec(spec_1_json);
    EXPECT_EQ(spec_1, spec_2);
}
 
TEST_F(TestParseStartDaqV2Spec, SuccessfulTemplate) {
    auto spec = ParseStartDaqV2Spec(m_spec);
 
    EXPECT_EQ(spec.id, "myid");
    EXPECT_EQ(spec.file_prefix, "prefix");
    EXPECT_EQ(spec.await_completion_interval, std::chrono::milliseconds(3000));
 
    ASSERT_EQ(spec.sources.size(), 4u);
 
    ASSERT_TRUE(spec.merge_target);
    EXPECT_EQ(spec.merge_target->source_name, "primary");
    {
        auto const& prim = std::get<StartDaqV2Spec::PrimaryDataSource>(spec.sources[0]);
        EXPECT_EQ(prim.source_name, "primary");
        EXPECT_EQ(prim.rr_uri, "zpb.rr://prim");
 
        ASSERT_EQ(prim.keyword_rules.size(), 1u);
        auto const& filter = std::get<KeywordFilter>(prim.keyword_rules.at(0));
        ASSERT_EQ(filter.selection_patterns.size(), 2u);
        EXPECT_EQ(filter.selection_patterns[0], "+e *");
        EXPECT_EQ(filter.selection_patterns[1], "+v *");
    }
    {
        auto const& meta = std::get<StartDaqV2Spec::MetadataSource>(spec.sources[1]);
        EXPECT_EQ(meta.rr_uri, "zpb.rr://meta");
        EXPECT_EQ(meta.source_name, "metadata");
        EXPECT_EQ(meta.initial_keywords, InitialKeywords::User);
 
        ASSERT_EQ(meta.keyword_rules.size(), 1u);
        auto const& transform = std::get<KeywordTransform>(meta.keyword_rules.at(0));
        ASSERT_EQ(transform.selection_patterns.size(), 1u);
        EXPECT_EQ(transform.selection_patterns[0], "+e INS1 *");
        EXPECT_EQ(transform.regex, "INS1 ");
        EXPECT_EQ(transform.format, "INS2 ");
    }
    {
        auto const& kws = std::get<FitsKeywordsSource>(spec.sources[2]);
        EXPECT_EQ(kws.source_name, "keywords");
    }
    {
        auto const& file = std::get<FitsFileSource>(spec.sources[3]);
        EXPECT_EQ(file.source_name, "file");
    }
    {
        // receivers
        ASSERT_EQ(spec.receivers.size(), 1u);
        ASSERT_TRUE(std::holds_alternative<OlasReceiver>(spec.receivers[0]));
        auto const& olas_receiver = std::get<OlasReceiver>(spec.receivers[0]);
        EXPECT_EQ(olas_receiver.host, "1.2.3.4");
        EXPECT_EQ(olas_receiver.path, "/absolute/path/");
    }
}
 
TEST_F(TestParseStartDaqV2Spec, EmptyKeywordRulesModelledAsEmptyOptional) {
    m_spec["sources"][0].erase("keywordRules");
    m_spec["sources"][1].erase("keywordRules");
    auto spec = ParseStartDaqV2Spec(m_spec);
 
    EXPECT_EQ(spec.id, "myid");
    EXPECT_EQ(spec.file_prefix, "prefix");
 
    ASSERT_EQ(spec.sources.size(), 4u);
 
    {
        auto const& prim = std::get<StartDaqV2Spec::PrimaryDataSource>(spec.sources[0]);
        EXPECT_EQ(prim.source_name, "primary");
        EXPECT_EQ(prim.rr_uri, "zpb.rr://prim");
 
        ASSERT_TRUE(prim.keyword_rules.empty());
    }
    {
        auto const& meta = std::get<StartDaqV2Spec::MetadataSource>(spec.sources[1]);
        EXPECT_EQ(meta.rr_uri, "zpb.rr://meta");
        EXPECT_EQ(meta.source_name, "metadata");
 
        ASSERT_TRUE(meta.keyword_rules.empty());
    }
}
 
TEST_F(TestParseStartDaqV2Spec, NoIdIsModelledAsEmptyString) {
    m_spec.erase("id");
    auto spec = ParseStartDaqV2Spec(m_spec);
    EXPECT_EQ(spec.id, "");
}
 
TEST_F(TestParseStartDaqV2Spec, EmptydIsAllowed) {
    m_spec["id"] = "";
    auto spec = ParseStartDaqV2Spec(m_spec);
    EXPECT_EQ(spec.id, "");
}
 
TEST_F(TestParseStartDaqV2Spec, AwaitCompletionIntervalIsOptional) {
    m_spec.erase("awaitCompletionInterval");
    auto spec = ParseStartDaqV2Spec(m_spec);
 
    EXPECT_EQ(spec.await_completion_interval, std::nullopt);
}
 
TEST_F(TestParseStartDaqV2Spec, AwaitCompletionIntervalAcceptsIntegers) {
    m_spec["awaitCompletionInterval"] = 2;
    auto spec = ParseStartDaqV2Spec(m_spec);
 
    EXPECT_EQ(spec.await_completion_interval, std::chrono::milliseconds(2000));
}
 
TEST_F(TestParseStartDaqV2Spec, MergeTargetWithoutSourceIsInvalid) {
    m_spec["mergeTarget"].erase("sourceName");
    EXPECT_THROW(ParseStartDaqV2Spec(m_spec), StartDaqV2SpecError);
}
 
TEST_F(TestParseStartDaqV2Spec, MergeTargetMatchingMultipleSourcesIsInvalid) {
    m_spec["sources"][1]["sourceName"] = "primary";
    EXPECT_THROW(ParseStartDaqV2Spec(m_spec), StartDaqV2SpecError);
}
 
TEST_F(TestParseStartDaqV2Spec, MergeTargetWithoutCorrespondingSourceIsInvalid) {
    m_spec["mergeTarget"]["sourceName"] = "foob";
    EXPECT_THROW(ParseStartDaqV2Spec(m_spec), StartDaqV2SpecError);
}
 
TEST_F(TestParseStartDaqV2Spec, MergeTargetMetadataIsValid) {
    m_spec["mergeTarget"]["sourceName"] = "metadata";
    EXPECT_NO_THROW(ParseStartDaqV2Spec(m_spec));
}
 
TEST_F(TestParseStartDaqV2Spec, MergeTargetFitsfileIsValid) {
    m_spec["mergeTarget"]["sourceName"] = "file";
    EXPECT_NO_THROW(ParseStartDaqV2Spec(m_spec));
}
 
TEST_F(TestParseStartDaqV2Spec, MergeTargetIsOptional) {
    m_spec.erase("mergeTarget");
    auto spec = ParseStartDaqV2Spec(m_spec);
    EXPECT_FALSE(spec.merge_target);
}
 
TEST_F(TestParseStartDaqV2Spec, MergeTargetWithKeywordsSourceIsInvalid) {
    m_spec["mergeTarget"]["sourceName"] = "keywords";
    EXPECT_THROW(ParseStartDaqV2Spec(m_spec), StartDaqV2SpecError);
}
 
TEST_F(TestParseStartDaqV2Spec, AwaitCompletionIntervalMustBePositive) {
    m_spec["awaitCompletionInterval"] = -1.0;
    EXPECT_THROW(ParseStartDaqV2Spec(m_spec), StartDaqV2SpecError);
}
 
TEST_F(TestParseStartDaqV2Spec, EmptyReceiversIsAllowed) {
    m_spec["receivers"] = nlohmann::json::array();
    auto spec = ParseStartDaqV2Spec(m_spec);
    EXPECT_TRUE(spec.receivers.empty());
}
 
TEST_F(TestParseStartDaqV2Spec, UndefinedReceiversIsAllowed) {
    m_spec.erase("receivers");
    auto spec = ParseStartDaqV2Spec(m_spec);
    EXPECT_TRUE(spec.receivers.empty());
}
 
}  // namespace daq::json