TheCloud/dwarfs
1
0
Fork 0
mirror of https://github.com/mhx/dwarfs.git synced 2025-08-04 02:06:22 -04:00
Code Issues Packages Projects Releases Wiki Activity

test: even more metadata requirements tests

Browse Source
This commit is contained in:
Marcus Holland-Moritz 2024-01-06 22:41:29 +01:00
parent db6316af2b
commit e6dbb1aaa4
1 changed files with 182 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

191
test/metadata_requirements_test.cpp
View File

@ -37,7 +37,8 @@ using namespace dwarfs;
TEST(metadata_requirements, dynamic_test) {
std::string requirements = R"({
"compression": ["set", ["lz4", "zstd"]],
"block_size": ["range", 16, 1024]
"block_size": ["range", 16, 1024],
"channels": ["set", [1, 2, 4]]
})";
std::unique_ptr<compression_metadata_requirements<folly::dynamic>> req;
@ -48,7 +49,8 @@ TEST(metadata_requirements, dynamic_test) {
{
std::string metadata = R"({
"compression": "lz4",
"block_size": 256
"block_size": 256,
"channels": 2
})";
EXPECT_NO_THROW(req->check(metadata));
@ -58,7 +60,8 @@ TEST(metadata_requirements, dynamic_test) {
std::string metadata = R"({
"compression": "lz4",
"foo": "bar",
"block_size": 256
"block_size": 256,
"channels": 2
})";
EXPECT_NO_THROW(req->check(metadata));
@ -67,21 +70,23 @@ TEST(metadata_requirements, dynamic_test) {
{
std::string metadata = R"({
"compression": "lzma",
"block_size": 256
"block_size": 256,
"channels": 2
})";
EXPECT_THAT(
[&]() { req->check(metadata); },
[&] { req->check(metadata); },
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"compression 'lzma' does not meet requirements [lz4, zstd]")));
}
{
std::string metadata = R"({
"block_size": 256
"block_size": 256,
"channels": 2
})";
EXPECT_THAT([&]() { req->check(metadata); },
EXPECT_THAT([&] { req->check(metadata); },
ThrowsMessage<std::runtime_error>(
testing::HasSubstr("missing requirement 'compression'")));
}
@ -89,13 +94,171 @@ TEST(metadata_requirements, dynamic_test) {
{
std::string metadata = R"({
"compression": "zstd",
"block_size": 8
"block_size": 8,
"channels": 2
})";
EXPECT_THAT([&]() { req->check(metadata); },
EXPECT_THAT([&] { req->check(metadata); },
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"block_size '8' does not meet requirements [16, 1024]")));
}
{
std::string metadata = R"({
"compression": "zstd",
"block_size": "foo",
"channels": 2
})";
EXPECT_THAT([&] { req->check(metadata); },
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"non-integral type for requirement 'block_size', "
"got type 'string'")));
}
{
std::string metadata = R"({
"compression": 13,
"block_size": 256,
"channels": 2
})";
EXPECT_THAT([&] { req->check(metadata); },
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"non-string type for requirement 'compression', "
"got type 'int64'")));
}
{
std::string metadata = R"({
"compression": 13,
"block_size": 256,
"channels": "foo"
})";
EXPECT_THAT([&] { req->check(metadata); },
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"non-integral type for requirement 'channels', "
"got type 'string'")));
}
{
std::string metadata = R"({
"compression": 13,
"block_size": 256,
"channels": 3
})";
EXPECT_THAT([&] { req->check(metadata); },
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"channels '3' does not meet requirements [1, 2, 4]")));
}
}
TEST(metadata_requirements, dynamic_test_error) {
using namespace std::literals::string_literals;
using req_type = compression_metadata_requirements<folly::dynamic>;
EXPECT_THAT(
[&] { req_type tmp(R"([])"s); },
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"metadata requirements must be an object, got type 'array'")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": 42
})"s);
},
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"requirement 'compression' must be an array, got type 'int64'")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": [1]
})"s);
},
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"requirement 'compression' must be an array of at least 2 elements, "
"got only 1")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": [1, 2]
})"s);
},
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"type for requirement 'compression' must be a string, got type "
"'int64'")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": ["foo", 2]
})"s);
},
ThrowsMessage<std::runtime_error>(
testing::HasSubstr("unsupported requirement type 'foo'")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": ["range", 2]
})"s);
},
ThrowsMessage<std::runtime_error>(
testing::HasSubstr("unexpected array size 2 for requirement "
"'compression', expected 3")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": ["range", "foo", 42]
})"s);
},
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"could not parse minimum value 'foo' for requirement 'compression': "
"Invalid leading character: \"foo\"")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": ["range", 43, 42]
})"s);
},
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"expected minimum '43' to be less than or equal to maximum '42' for "
"requirement 'compression'")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": ["set", 2]
})"s);
},
ThrowsMessage<std::runtime_error>(
testing::HasSubstr("set for requirement 'compression' must be an "
"array, got type 'int64'")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": ["set", []]
})"s);
},
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"set for requirement 'compression' must not be empty")));
EXPECT_THAT(
[&] {
req_type tmp(R"({
"compression": ["set", ["foo", "bar", "foo"]]
})"s);
},
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"duplicate value 'foo' for requirement 'compression'")));
}
namespace {
@ -366,6 +529,16 @@ TEST_F(metadata_requirements_test, static_test_req_set_with_invalid_value) {
EXPECT_NO_THROW(req->parse(dyn));
}
TEST_F(metadata_requirements_test, static_test_req_error_invalid_set5) {
auto dyn = folly::parseJson(R"({
"enum": ["set", ["grmpf", "foo", "foo"]]
})");
EXPECT_THAT([&]() { req->parse(dyn); },
ThrowsMessage<std::runtime_error>(testing::HasSubstr(
"duplicate value 'foo' for requirement 'enum'")));
}
TEST_F(metadata_requirements_test, static_test_req_error_range_invalid1) {
auto dyn = folly::parseJson(R"({
"int16": ["range"]