testJson.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_fits_test
 * @copyright 2022 ESO - European Southern Observatory
 *
 * @brief Unit tests for json handling.
 */
 
#include <gtest/gtest.h>
#include <gmock/gmock.h>
 
#include <nlohmann/json.hpp>
#include <ostream>
 
#include <daq/fits/json.hpp>
 
using namespace daq::fits;
 
class TestJson : public ::testing::Test {
public:
};
 
TEST_F(TestJson, ParseInvalidJsonThrowsNlohmannException) {
    // Setup
    auto trailing_comma = R"(
    [
      {
        "type": "valueKeyword",
        "name": "STRKW",
        "value": "VALUE STRING"
      },
    ]
    )";
 
    // Test
    EXPECT_THROW(ParseJsonKeywords(trailing_comma), nlohmann::json::exception);
}
 
TEST_F(TestJson, ParseValueKeywords) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "valueKeyword",
        "name": "STRKW",
        "value": "VALUE STRING"
      },
      {
        "type": "valueKeyword",
        "name": "BOOLKW",
        "value": true
      },
      {
        "type": "valueKeyword",
        "name": "INTMIN",
        "value": -9223372036854775807
      },
      {
        "type": "valueKeyword",
        "name": "INTMAX",
        "value": 9223372036854775807
      },
      {
        "type": "valueKeyword",
        "name": "UINTMAX",
        "value": 18446744073709551615
      },
      {
        "type": "valueKeyword",
        "name": "FLOATMIN",
        "value": -1.79769313486231e+308
      },
      {
        "type": "valueKeyword",
        "name": "FLOATMAX",
        "value": 1.79769313486231e+308
      }
    ]
    )";
 
    // Test
    std::vector<KeywordVariant> parsed = ParseJsonKeywords(keywords_str);
    ASSERT_EQ(7u, parsed.size());
    for (auto const& kw_var : parsed) {
        ASSERT_TRUE(std::holds_alternative<ValueKeyword>(kw_var));
    }
 
    {
        ValueKeyword kw = std::get<ValueKeyword>(parsed[0]);
        EXPECT_EQ(ValueKeyword("STRKW", std::string("VALUE STRING"), std::nullopt), kw);
    }
    {
        ValueKeyword kw = std::get<ValueKeyword>(parsed[1]);
        EXPECT_EQ(ValueKeyword("BOOLKW", true, std::nullopt), kw);
    }
    {
        ValueKeyword kw = std::get<ValueKeyword>(parsed[2]);
        EXPECT_EQ(ValueKeyword("INTMIN", int64_t(-9223372036854775807), std::nullopt), kw);
    }
    {
        ValueKeyword kw = std::get<ValueKeyword>(parsed[3]);
        EXPECT_EQ(ValueKeyword("INTMAX", uint64_t(9223372036854775807), std::nullopt), kw);
    }
    {
        ValueKeyword kw = std::get<ValueKeyword>(parsed[4]);
        EXPECT_EQ(ValueKeyword("UINTMAX", 18446744073709551615u, std::nullopt), kw);
    }
    {
        ValueKeyword kw = std::get<ValueKeyword>(parsed[5]);
        EXPECT_EQ(ValueKeyword("FLOATMIN", -1.79769313486231e+308, std::nullopt), kw);
    }
    {
        ValueKeyword kw = std::get<ValueKeyword>(parsed[6]);
        EXPECT_EQ(ValueKeyword("FLOATMAX", 1.79769313486231e+308, std::nullopt), kw);
    }
}
 
TEST_F(TestJson, ParseEsoKeywords) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "esoKeyword",
        "name": "STRKW",
        "value": "VALUE STRING"
      },
      {
        "type": "esoKeyword",
        "name": "BOOLKW",
        "value": true
      },
      {
        "type": "esoKeyword",
        "name": "INTMIN",
        "value": -9223372036854775807
      },
      {
        "type": "esoKeyword",
        "name": "INTMAX",
        "value": 9223372036854775807
      },
      {
        "type": "esoKeyword",
        "name": "UINTMAX",
        "value": 18446744073709551615
      },
      {
        "type": "esoKeyword",
        "name": "FLOATMIN",
        "value": -1.79769313486231e+308
      },
      {
        "type": "esoKeyword",
        "name": "FLOATMAX",
        "value": 1.79769313486231e+308
      },
      {
        "type": "esoKeyword",
        "name": "KW WITH SPACE",
        "value": "spaces"
      }
    ]
    )";
 
    // Test
    std::vector<KeywordVariant> parsed = ParseJsonKeywords(keywords_str);
    ASSERT_EQ(8u, parsed.size());
    for (auto const& kw_var : parsed) {
        ASSERT_TRUE(std::holds_alternative<EsoKeyword>(kw_var));
    }
 
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[0]);
        EXPECT_EQ(EsoKeyword("STRKW", std::string("VALUE STRING"), std::nullopt), kw);
    }
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[1]);
        EXPECT_EQ(EsoKeyword("BOOLKW", true, std::nullopt), kw);
    }
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[2]);
        EXPECT_EQ(EsoKeyword("INTMIN", int64_t(-9223372036854775807), std::nullopt), kw);
    }
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[3]);
        EXPECT_EQ(EsoKeyword("INTMAX", uint64_t(9223372036854775807), std::nullopt), kw);
    }
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[4]);
        EXPECT_EQ(EsoKeyword("UINTMAX", 18446744073709551615u, std::nullopt), kw);
    }
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[5]);
        EXPECT_EQ(EsoKeyword("FLOATMIN", -1.79769313486231e+308, std::nullopt), kw);
    }
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[6]);
        EXPECT_EQ(EsoKeyword("FLOATMAX", 1.79769313486231e+308, std::nullopt), kw);
    }
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[7]);
        EXPECT_EQ(EsoKeyword("KW WITH SPACE", "spaces", std::nullopt), kw);
    }
}
 
TEST_F(TestJson, ParseLiteralKeyword) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "literalKeyword",
        "value": "SIMPLE  =                T / Standard FITS"
      },
      {
        "type": "literalKeyword",
        "value": "OBJECT  = 'target.cat'     / Original target."
      },
      {
        "type": "literalKeyword",
        "value": "HIERARCH ESO KW = T / Comment"
      }
    ]
    )";
 
    // Test
    std::vector<KeywordVariant> parsed = ParseJsonKeywords(keywords_str);
    ASSERT_EQ(3u, parsed.size());
    for (auto const& kw_var : parsed) {
        ASSERT_TRUE(std::holds_alternative<LiteralKeyword>(kw_var));
    }
 
    {
        LiteralKeyword kw = std::get<LiteralKeyword>(parsed[0]);
        EXPECT_EQ(LiteralKeyword("SIMPLE  =                T / Standard FITS"), kw);
    }
    {
        LiteralKeyword kw = std::get<LiteralKeyword>(parsed[1]);
        EXPECT_EQ(LiteralKeyword("OBJECT  = 'target.cat'     / Original target."), kw);
        EXPECT_EQ("OBJECT  = 'target.cat'     / Original target.", kw.GetRecord());
    }
    {
        LiteralKeyword kw = std::get<LiteralKeyword>(parsed[2]);
        EXPECT_EQ(LiteralKeyword("HIERARCH ESO KW = T / Comment"), kw);
    }
}
 
TEST_F(TestJson, ParseOptionalKeywordComment) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "valueKeyword",
        "name": "STRKW1",
        "value": "VALUE STRING",
        "comment": "this is a comment"
      },
      {
        "type": "esoKeyword",
        "name": "STRKW2",
        "value": "VALUE STRING",
        "comment": "this is also a comment"
      }
    ]
    )";
 
    // Test
    std::vector<KeywordVariant> parsed = ParseJsonKeywords(keywords_str);
    ASSERT_EQ(2u, parsed.size());
    ASSERT_TRUE(std::holds_alternative<ValueKeyword>(parsed[0]));
    ASSERT_TRUE(std::holds_alternative<EsoKeyword>(parsed[1]));
 
    {
        ValueKeyword kw = std::get<ValueKeyword>(parsed[0]);
        EXPECT_EQ(ValueKeyword("STRKW1", std::string("VALUE STRING"), "this is a comment"), kw);
    }
    {
        EsoKeyword kw = std::get<EsoKeyword>(parsed[1]);
        EXPECT_EQ(EsoKeyword("STRKW2", std::string("VALUE STRING"), "this is also a comment"), kw);
    }
}
 
TEST_F(TestJson, ParseEmptyArray) {
    // Setup
    auto keywords_str = R"(
    []
    )";
    auto res = ParseJsonKeywords(keywords_str);
    EXPECT_EQ(0u, res.size());
}
 
TEST_F(TestJson, ParseFailsIfNotAnArray) {
    // Setup
    auto keywords_str = R"(
      {
        "type": "valueKeyword",
        "name": "FLOATMAX",
        "value": 1.79769313486231e+308
      }
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfNotAnObjectInArray) {
    // Setup
    auto keywords_str = R"(
    [
        1,
        [],
        "",
        null
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfObjectMissTypeProperty) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "name": "FLOATMAX",
        "value": "value"
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfObjectHasUnknownTypeProperty) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "unknown",
        "name": "FLOATMAX",
        "value": 1.79769313486231e+308
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfTypeIsNotString) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": true,
        "name": "FLOATMAX",
        "value": 1.79769313486231e+308
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfObjectMissNameProperty) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "valueKeyword",
        "value": 1.79769313486231e+308
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfObjectMissValue) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "valueKeyword",
        "name": "FLOATMAX"
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfLiteralKeywordMissValue) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "literalKeyword"
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfLiteralKeywordValueIsNotString) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "literalKeyword",
        "value": null
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfLiteralKeywordValueTooLong) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "literalKeyword",
        "value": "AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA0"
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfObjectHasUnsupportedValueType) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "valueKeyword",
        "name": "NAME",
        "value": {"foo": true}
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfNameIsNotString) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "valueKeyword",
        "name": 1.0,
        "value": "value"
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, ParseFailsIfObjectHasCommentThatIsNotString) {
    // Setup
    auto keywords_str = R"(
    [
      {
        "type": "valueKeyword",
        "name": "NAME",
        "value": "value",
        "comment": 1.0
      }
    ]
    )";
    EXPECT_THROW(ParseJsonKeywords(keywords_str), std::invalid_argument);
}
 
TEST_F(TestJson, SerializeJsonKeywords) {
    KeywordVector kws;
    kws.push_back(ValueKeyword("NAME", "VALUE", "COMMENT"));
    kws.push_back(ValueKeyword("NAME2", 1.0, "COMMENT"));
    kws.push_back(ValueKeyword("NAME3", false));
    kws.push_back(EsoKeyword("FOO BAR", -1234l, "COMMENT"));
    kws.push_back(EsoKeyword("FOO BAR BAZ", 1234lu, "COMMENT"));
    kws.push_back(LiteralKeyword("HIERARCH ESO KW = T / Comment"));
 
    auto json = SerializeJsonKeywords(kws);
    auto parsed_kws = ParseJsonKeywords(json);
 
    EXPECT_THAT(parsed_kws, ::testing::ContainerEq(kws));
}