testJson.cpp

Go to the documentation of this file.

/**
 * @file
 * @ingroup daq_ocm_fits_test
 * @copyright 2021 ESO - European Southern Observatory
 *
 * @brief Unit tests for json handling.
 */
 
#include <gtest/gtest.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, 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, 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);
}