From a99bf35314e0cfbd429359752d71c1bb7423cf84 Mon Sep 17 00:00:00 2001 From: Bulat Gayazov Date: Fri, 4 Apr 2025 01:36:32 +0000 Subject: [PATCH 1/3] Retuned client-ydb_value_ut and client-ydb_params_ut --- tests/unit/client/CMakeLists.txt | 45 ++- tests/unit/client/params/params_ut.cpp | 75 ++-- tests/unit/client/value/value_ut.cpp | 483 +++++++++++++++++-------- 3 files changed, 396 insertions(+), 207 deletions(-) diff --git a/tests/unit/client/CMakeLists.txt b/tests/unit/client/CMakeLists.txt index 78778d8d13..c802d73d40 100644 --- a/tests/unit/client/CMakeLists.txt +++ b/tests/unit/client/CMakeLists.txt @@ -62,17 +62,16 @@ add_ydb_test(NAME client-oauth2_ut unit ) -# add_ydb_test(NAME client-ydb_params_ut -# SOURCES -# params/params_ut.cpp -# LINK_LIBRARIES -# yutil -# cpp-testing-unittest_main -# YDB-CPP-SDK::Params -# YDB-CPP-SDK::YsonValue -# LABELS -# unit -# ) +add_ydb_test(NAME client-ydb_params_ut + SOURCES + params/params_ut.cpp + LINK_LIBRARIES + yutil + cpp-testing-unittest_main + YDB-CPP-SDK::Params + LABELS + unit +) add_ydb_test(NAME client-ydb_result_ut SOURCES @@ -86,16 +85,14 @@ add_ydb_test(NAME client-ydb_result_ut unit ) -# add_ydb_test(NAME client-ydb_value_ut -# SOURCES -# value/value_ut.cpp -# LINK_LIBRARIES -# yutil -# cpp-testing-unittest_main -# YDB-CPP-SDK::Value -# YDB-CPP-SDK::JsonValue -# YDB-CPP-SDK::YsonValue -# YDB-CPP-SDK::Params -# LABELS -# unit -# ) +add_ydb_test(NAME client-ydb_value_ut + SOURCES + value/value_ut.cpp + LINK_LIBRARIES + yutil + cpp-testing-unittest_main + YDB-CPP-SDK::Value + YDB-CPP-SDK::Params + LABELS + unit +) diff --git a/tests/unit/client/params/params_ut.cpp b/tests/unit/client/params/params_ut.cpp index 1919774ff0..efd7468f6f 100644 --- a/tests/unit/client/params/params_ut.cpp +++ b/tests/unit/client/params/params_ut.cpp @@ -1,14 +1,20 @@ #include -#include - #include #include +#include +#include using namespace NYdb; using TExpectedErrorException = yexception; +void CheckProtoValue(const Ydb::Value& value, const TString& expected) { + TStringType protoStr; + google::protobuf::TextFormat::PrintToString(value, &protoStr); + UNIT_ASSERT_NO_DIFF(protoStr, expected); +} + Y_UNIT_TEST_SUITE(ParamsBuilder) { Y_UNIT_TEST(Build) { auto params = TParamsBuilder() @@ -27,15 +33,18 @@ Y_UNIT_TEST_SUITE(ParamsBuilder) { .Build() .Build(); - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), - R"(List)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")), - R"([[10u];#])"); + UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), "List"); - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), - R"(String)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")), - R"("test")"); + CheckProtoValue(params.GetValue("$param1")->GetProto(), + "items {\n" + " uint64_value: 10\n" + "}\n" + "items {\n" + " null_flag_value: NULL_VALUE\n" + "}\n"); + + UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), "String"); + CheckProtoValue(params.GetValue("$param2")->GetProto(), "bytes_value: \"test\"\n"); } Y_UNIT_TEST(BuildFromValue) { @@ -62,15 +71,23 @@ Y_UNIT_TEST_SUITE(ParamsBuilder) { .AddParam("$param2", value2) .Build(); - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), - R"(Utf8)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")), - R"("test1")"); - - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), - R"(List?>)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")), - R"([[[-11;"test2"]];#])"); + UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), "Utf8"); + + CheckProtoValue(params.GetValue("$param1")->GetProto(), "text_value: \"test1\"\n"); + + UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), "List?>"); + CheckProtoValue(params.GetValue("$param2")->GetProto(), + "items {\n" + " items {\n" + " int32_value: -11\n" + " }\n" + " items {\n" + " bytes_value: \"test2\"\n" + " }\n" + "}\n" + "items {\n" + " null_flag_value: NULL_VALUE\n" + "}\n"); } Y_UNIT_TEST(BuildWithTypeInfo) { @@ -106,15 +123,17 @@ Y_UNIT_TEST_SUITE(ParamsBuilder) { .Build() .Build(); - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), - R"(List)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param1")), - R"(["str1";"str2"])"); - - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), - R"(Uint32?)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(*params.GetValue("$param2")), - R"(#)"); + UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), "List"); + CheckProtoValue(params.GetValue("$param1")->GetProto(), + "items {\n" + " bytes_value: \"str1\"\n" + "}\n" + "items {\n" + " bytes_value: \"str2\"\n" + "}\n"); + + UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), "Uint32?"); + CheckProtoValue(params.GetValue("$param2")->GetProto(), "null_flag_value: NULL_VALUE\n"); } Y_UNIT_TEST(MissingParam) { diff --git a/tests/unit/client/value/value_ut.cpp b/tests/unit/client/value/value_ut.cpp index f0551cf1ff..c10164366c 100644 --- a/tests/unit/client/value/value_ut.cpp +++ b/tests/unit/client/value/value_ut.cpp @@ -3,8 +3,6 @@ #include #include -#include -#include #include #include @@ -15,6 +13,13 @@ namespace NYdb { using TExpectedErrorException = yexception; +void CheckProtoValue(const Ydb::Value& value, const TString& expected) { + TStringType protoStr; + google::protobuf::TextFormat::PrintToString(value, &protoStr); + Cerr << protoStr << Endl; + UNIT_ASSERT_NO_DIFF(protoStr, expected); +} + Y_UNIT_TEST_SUITE(YdbValue) { Y_UNIT_TEST(ParseType1) { auto protoTypeStr = R"( @@ -263,29 +268,28 @@ Y_UNIT_TEST_SUITE(YdbValue) { } )"; - auto protoValueStr = R"( - items { - uint32_value: 137 - } - items { - items { - bytes_value: "String1" - } - items { - bytes_value: "String2" - } - } - items { - items { - null_flag_value: NULL_VALUE - } - items { - text_value: "UtfString" - } - items { - } - } - )"; + auto protoValueStr = + "items {\n" + " uint32_value: 137\n" + "}\n" + "items {\n" + " items {\n" + " bytes_value: \"String1\"\n" + " }\n" + " items {\n" + " bytes_value: \"String2\"\n" + " }\n" + "}\n" + "items {\n" + " items {\n" + " null_flag_value: NULL_VALUE\n" + " }\n" + " items {\n" + " text_value: \"UtfString\"\n" + " }\n" + " items {\n" + " }\n" + "}\n"; Ydb::Type protoType; google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); @@ -295,8 +299,7 @@ Y_UNIT_TEST_SUITE(YdbValue) { TValue value(TType(protoType), protoValue); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([137u;["String1";"String2"];[#;"UtfString";"Void"]])"); + CheckProtoValue(value.GetProto(), protoValueStr); } Y_UNIT_TEST(ParseValue2) { @@ -318,28 +321,27 @@ Y_UNIT_TEST_SUITE(YdbValue) { } )"; - auto protoValueStr = R"( - pairs { - key { - uint32_value: 10 - } - payload { - items { - uint32_value: 1000 - } - } - } - pairs { - key { - uint32_value: 20 - } - payload { - items { - uint32_value: 2000 - } - } - } - )"; + auto protoValueStr = + "pairs {\n" + " key {\n" + " uint32_value: 10\n" + " }\n" + " payload {\n" + " items {\n" + " uint32_value: 1000\n" + " }\n" + " }\n" + "}\n" + "pairs {\n" + " key {\n" + " uint32_value: 20\n" + " }\n" + " payload {\n" + " items {\n" + " uint32_value: 2000\n" + " }\n" + " }\n" + "}\n"; Ydb::Type protoType; google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); @@ -349,10 +351,7 @@ Y_UNIT_TEST_SUITE(YdbValue) { TValue value(TType(protoType), protoValue); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[10u;[1000u]];[20u;[2000u]]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([[10,{"Member1":"1972-09-27"}],[20,{"Member1":"1975-06-24"}]])"); + CheckProtoValue(value.GetProto(), protoValueStr); } Y_UNIT_TEST(ParseValuePg) { @@ -411,22 +410,19 @@ Y_UNIT_TEST_SUITE(YdbValue) { } )"; - auto protoValueStr = R"( - items { - text_value: "my_text_value" - } - items { - bytes_value: "my_binary_value" - } - items { - text_value: "" - } - items { - bytes_value: "" - } - items { - } - )"; + auto protoValueStr = + "items {\n" + " text_value: \"my_text_value\"\n" + "}\n" + "items {\n" + " bytes_value: \"my_binary_value\"\n" + "}\n" + "items {\n" + " text_value: \"\"\n" + "}\n" + "items {\n" + " bytes_value: \"\"\n" + "}\n"; Ydb::Type protoType; google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); @@ -436,12 +432,7 @@ Y_UNIT_TEST_SUITE(YdbValue) { TValue value(TType(protoType), protoValue); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"(["my_text_value";["my_binary_value"];"";[""];#])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"({"A":"my_text_value","B":["my_binary_value"],"C":"","D":[""],"E":null})"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Base64), - R"({"A":"my_text_value","B":["bXlfYmluYXJ5X3ZhbHVl"],"C":"","D":[""],"E":null})"); + CheckProtoValue(value.GetProto(), protoValueStr); } Y_UNIT_TEST(ParseValueMaybe) { @@ -641,10 +632,7 @@ Y_UNIT_TEST_SUITE(YdbValue) { .DyNumber("12.345") .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"("12.345")"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"("12.345")"); + CheckProtoValue(value.GetProto(), "text_value: \"12.345\"\n"); } Y_UNIT_TEST(BuildTaggedValue) { @@ -654,10 +642,7 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndTagged() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"("12.345")"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"("12.345")"); + CheckProtoValue(value.GetProto(), "text_value: \"12.345\"\n"); } Y_UNIT_TEST(BuildValueList) { @@ -675,10 +660,16 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndList() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([17;19;21])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([17,19,21])"); + CheckProtoValue(value.GetProto(), + "items {\n" + " int32_value: 17\n" + "}\n" + "items {\n" + " int32_value: 19\n" + "}\n" + "items {\n" + " int32_value: 21\n" + "}\n"); } Y_UNIT_TEST(BuildValueListEmpty) { @@ -688,10 +679,7 @@ Y_UNIT_TEST_SUITE(YdbValue) { UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), R"(List)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([])"); + CheckProtoValue(value.GetProto(), ""); } Y_UNIT_TEST(BuildValueListEmpty2) { @@ -707,10 +695,14 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndList() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[10u];[]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([[10],[]])"); + CheckProtoValue(value.GetProto(), + "items {\n" + " items {\n" + " uint32_value: 10\n" + " }\n" + "}\n" + "items {\n" + "}\n"); } Y_UNIT_TEST(BuildValueListEmpty3) { @@ -726,10 +718,14 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndList() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[];[10u]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([[],[10]])"); + CheckProtoValue(value.GetProto(), + "items {\n" + "}\n" + "items {\n" + " items {\n" + " uint32_value: 10\n" + " }\n" + "}\n"); } Y_UNIT_TEST(BuildValueBadCall) { @@ -763,10 +759,6 @@ Y_UNIT_TEST_SUITE(YdbValue) { UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), R"(List)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[1];#;[57];#])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([1,null,57,null])"); auto expectedProtoValueStr = "items {\n" @@ -782,9 +774,7 @@ Y_UNIT_TEST_SUITE(YdbValue) { " null_flag_value: NULL_VALUE\n" "}\n"; - TStringType protoValueStr; - google::protobuf::TextFormat::PrintToString(value.GetProto(), &protoValueStr); - UNIT_ASSERT_NO_DIFF(protoValueStr, expectedProtoValueStr); + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueNestedOptional) { @@ -819,10 +809,6 @@ Y_UNIT_TEST_SUITE(YdbValue) { UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), R"(Tuple)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[[10]];[[[-1]]];[#];[[#]]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([10,-1,null,null])"); auto expectedProtoValueStr = "items {\n" @@ -844,9 +830,7 @@ Y_UNIT_TEST_SUITE(YdbValue) { " }\n" "}\n"; - TStringType protoValueStr; - google::protobuf::TextFormat::PrintToString(value.GetProto(), &protoValueStr); - UNIT_ASSERT_NO_DIFF(protoValueStr, expectedProtoValueStr); + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueOptionalMismatch1) { @@ -918,13 +902,37 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndList() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[1u;"Anna";-100;#];[2u;"Paul";-200;["Some details"]]])"); - UNIT_ASSERT_NO_DIFF( - FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([{"Id":1,"Name":"Anna","Value":-100,"Description":null},)" - R"({"Id":2,"Name":"Paul","Value":-200,"Description":"Some details"}])" - ); + auto expectedProtoValueStr = + "items {\n" + " items {\n" + " uint32_value: 1\n" + " }\n" + " items {\n" + " bytes_value: \"Anna\"\n" + " }\n" + " items {\n" + " int32_value: -100\n" + " }\n" + " items {\n" + " null_flag_value: NULL_VALUE\n" + " }\n" + "}\n" + "items {\n" + " items {\n" + " uint32_value: 2\n" + " }\n" + " items {\n" + " bytes_value: \"Paul\"\n" + " }\n" + " items {\n" + " int32_value: -200\n" + " }\n" + " items {\n" + " text_value: \"Some details\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueStructMissingMember) { @@ -986,13 +994,76 @@ Y_UNIT_TEST_SUITE(YdbValue) { UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), R"(Tuple)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([%true;-1;1u;-2;2u;-3;3u;-4;4u;-5.5;6.6;7u;8u;9u;-10;"2018-02-02,Europe/Moscow";"2018-02-03T15:00:00,Europe/Moscow";"2018-02-07T15:00:00,Europe/Moscow";"TestString";"TestUtf8";"[]";"{}"])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([true,-1,1,-2,2,-3,3,-4,4,-5.5,6.6,"1970-01-08","1970-01-01T00:00:08Z",)" - R"("1970-01-01T00:00:00.000009Z",-10,"2018-02-02,Europe/Moscow",)" - R"("2018-02-03T15:00:00,Europe/Moscow","2018-02-07T15:00:00,Europe/Moscow",)" - R"("TestString","TestUtf8","[]","{}"])"); + + auto expectedProtoValueStr = + "items {\n" + " bool_value: true\n" + "}\n" + "items {\n" + " int32_value: -1\n" + "}\n" + "items {\n" + " uint32_value: 1\n" + "}\n" + "items {\n" + " int32_value: -2\n" + "}\n" + "items {\n" + " uint32_value: 2\n" + "}\n" + "items {\n" + " int32_value: -3\n" + "}\n" + "items {\n" + " uint32_value: 3\n" + "}\n" + "items {\n" + " int64_value: -4\n" + "}\n" + "items {\n" + " uint64_value: 4\n" + "}\n" + "items {\n" + " float_value: -5.5\n" + "}\n" + "items {\n" + " double_value: 6.6\n" + "}\n" + "items {\n" + " uint32_value: 7\n" + "}\n" + "items {\n" + " uint32_value: 8\n" + "}\n" + "items {\n" + " uint64_value: 9\n" + "}\n" + "items {\n" + " int64_value: -10\n" + "}\n" + "items {\n" + " text_value: \"2018-02-02,Europe/Moscow\"\n" + "}\n" + "items {\n" + " text_value: \"2018-02-03T15:00:00,Europe/Moscow\"\n" + "}\n" + "items {\n" + " text_value: \"2018-02-07T15:00:00,Europe/Moscow\"\n" + "}\n" + "items {\n" + " bytes_value: \"TestString\"\n" + "}\n" + "items {\n" + " text_value: \"TestUtf8\"\n" + "}\n" + "items {\n" + " bytes_value: \"[]\"\n" + "}\n" + "items {\n" + " text_value: \"{}\"\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueTuple1) { @@ -1014,10 +1085,25 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndList() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[10;"Str1"];[20;"Str2"]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([[10,"Str1"],[20,"Str2"]])"); + auto expectedProtoValueStr = + "items {\n" + " items {\n" + " int32_value: 10\n" + " }\n" + " items {\n" + " bytes_value: \"Str1\"\n" + " }\n" + "}\n" + "items {\n" + " items {\n" + " int32_value: 20\n" + " }\n" + " items {\n" + " bytes_value: \"Str2\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueTuple2) { @@ -1038,10 +1124,25 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndList() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[-10;"Utf1"];[-20;"Utf2"]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([[-10,"Utf1"],[-20,"Utf2"]])"); + auto expectedProtoValueStr = + "items {\n" + " items {\n" + " int32_value: -10\n" + " }\n" + " items {\n" + " text_value: \"Utf1\"\n" + " }\n" + "}\n" + "items {\n" + " items {\n" + " int32_value: -20\n" + " }\n" + " items {\n" + " text_value: \"Utf2\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueTupleElementsMismatch1) { @@ -1139,10 +1240,25 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndDict() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[1;"Str1"];[2;"Str2"]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([[1,"Str1"],[2,"Str2"]])"); + auto expectedProtoValueStr = + "pairs {\n" + " key {\n" + " int32_value: 1\n" + " }\n" + " payload {\n" + " bytes_value: \"Str1\"\n" + " }\n" + "}\n" + "pairs {\n" + " key {\n" + " int32_value: 2\n" + " }\n" + " payload {\n" + " bytes_value: \"Str2\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueDict2) { @@ -1159,10 +1275,25 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndDict() .Build(); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[1;"Str1"];[2;"Str2"]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([[1,"Str1"],[2,"Str2"]])"); + auto expectedProtoValueStr = + "pairs {\n" + " key {\n" + " int32_value: 1\n" + " }\n" + " payload {\n" + " bytes_value: \"Str1\"\n" + " }\n" + "}\n" + "pairs {\n" + " key {\n" + " int32_value: 2\n" + " }\n" + " payload {\n" + " bytes_value: \"Str2\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueDictTypeMismatch1) { @@ -1216,10 +1347,9 @@ Y_UNIT_TEST_SUITE(YdbValue) { UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), R"(Dict)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([])"); + + auto expectedProtoValueStr = ""; + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueDictEmpty2) { @@ -1244,10 +1374,24 @@ Y_UNIT_TEST_SUITE(YdbValue) { UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), R"(List>)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([[[1;"Str1"]];[];[]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([[[1,"Str1"]],[],[]])"); + + auto expectedProtoValueStr = + "items {\n" + " pairs {\n" + " key {\n" + " int32_value: 1\n" + " }\n" + " payload {\n" + " bytes_value: \"Str1\"\n" + " }\n" + " }\n" + "}\n" + "items {\n" + "}\n" + "items {\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(BuildValueDictEmptyNoType) { @@ -1353,10 +1497,39 @@ Y_UNIT_TEST_SUITE(YdbValue) { UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), R"(Tuple,Utf8?,List,Dict,DyNumber?>)"); - UNIT_ASSERT_NO_DIFF(FormatValueYson(value), - R"([["Sergey";1u];#;[%true];[[10;#]];["12.345"]])"); - UNIT_ASSERT_NO_DIFF(FormatValueJson(value, EBinaryStringEncoding::Unicode), - R"([{"Name":"Sergey","Value":1},null,[true],[[10,null]],"12.345"])"); + + auto expectedProtoValueStr = + "items {\n" + " items {\n" + " bytes_value: \"Sergey\"\n" + " }\n" + " items {\n" + " uint64_value: 1\n" + " }\n" + "}\n" + "items {\n" + " null_flag_value: NULL_VALUE\n" + "}\n" + "items {\n" + " items {\n" + " bool_value: true\n" + " }\n" + "}\n" + "items {\n" + " pairs {\n" + " key {\n" + " int32_value: 10\n" + " }\n" + " payload {\n" + " null_flag_value: NULL_VALUE\n" + " }\n" + " }\n" + "}\n" + "items {\n" + " text_value: \"12.345\"\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); } Y_UNIT_TEST(CorrectUuid) { From a7226d1c2c9437c2b807707184030a3d0d57a459 Mon Sep 17 00:00:00 2001 From: Bulat Gayazov Date: Fri, 4 Apr 2025 15:57:23 +0000 Subject: [PATCH 2/3] Use GTest for tests --- cmake/testing.cmake | 6 + tests/integration/bulk_upsert/CMakeLists.txt | 1 - .../integration/server_restart/CMakeLists.txt | 3 +- tests/unit/client/CMakeLists.txt | 11 +- tests/unit/client/params/params_ut.cpp | 414 ++- tests/unit/client/value/value_ut.cpp | 2499 ++++++++--------- 6 files changed, 1414 insertions(+), 1520 deletions(-) diff --git a/cmake/testing.cmake b/cmake/testing.cmake index b4f1014f9a..ab20c3169a 100644 --- a/cmake/testing.cmake +++ b/cmake/testing.cmake @@ -130,6 +130,9 @@ function(add_ydb_test) WORKING_DIRECTORY ${YDB_TEST_WORKING_DIRECTORY} ) + target_link_libraries(${YDB_TEST_NAME} PRIVATE + GTest::gtest_main + ) else() add_yunittest( NAME @@ -146,6 +149,9 @@ function(add_ydb_test) WORKING_DIRECTORY ${YDB_TEST_WORKING_DIRECTORY} ) + target_link_libraries(${YDB_TEST_NAME} PRIVATE + cpp-testing-unittest_main + ) endif() set_yunittest_property( diff --git a/tests/integration/bulk_upsert/CMakeLists.txt b/tests/integration/bulk_upsert/CMakeLists.txt index 1dbed97089..fc7b29110d 100644 --- a/tests/integration/bulk_upsert/CMakeLists.txt +++ b/tests/integration/bulk_upsert/CMakeLists.txt @@ -2,7 +2,6 @@ add_ydb_test(NAME bulk_upsert SOURCES main.cpp bulk_upsert.cpp - bulk_upsert.h LINK_LIBRARIES yutil YDB-CPP-SDK::Table diff --git a/tests/integration/server_restart/CMakeLists.txt b/tests/integration/server_restart/CMakeLists.txt index 37fab1cd77..2420bae608 100644 --- a/tests/integration/server_restart/CMakeLists.txt +++ b/tests/integration/server_restart/CMakeLists.txt @@ -1,4 +1,4 @@ -add_ydb_test(NAME server_restart +add_ydb_test(NAME server_restart GTEST SOURCES main.cpp LINK_LIBRARIES @@ -6,7 +6,6 @@ add_ydb_test(NAME server_restart api-grpc YDB-CPP-SDK::Query gRPC::grpc++ - GTest::gtest_main LABELS integration ) diff --git a/tests/unit/client/CMakeLists.txt b/tests/unit/client/CMakeLists.txt index c802d73d40..d49186853a 100644 --- a/tests/unit/client/CMakeLists.txt +++ b/tests/unit/client/CMakeLists.txt @@ -3,7 +3,6 @@ add_ydb_test(NAME client-ydb_coordination_ut coordination/coordination_ut.cpp LINK_LIBRARIES yutil - cpp-testing-unittest_main YDB-CPP-SDK::Coordination api-grpc LABELS @@ -15,7 +14,6 @@ add_ydb_test(NAME client-extensions-discovery_mutator_ut discovery_mutator/discovery_mutator_ut.cpp LINK_LIBRARIES yutil - cpp-testing-unittest_main YDB-CPP-SDK::DiscoveryMutator YDB-CPP-SDK::Table LABELS @@ -27,7 +25,6 @@ add_ydb_test(NAME client-ydb_driver_ut driver/driver_ut.cpp LINK_LIBRARIES yutil - cpp-testing-unittest_main YDB-CPP-SDK::Driver YDB-CPP-SDK::Table LABELS @@ -53,7 +50,6 @@ add_ydb_test(NAME client-oauth2_ut oauth2_token_exchange/jwt_token_source_ut.cpp LINK_LIBRARIES yutil - cpp-testing-unittest_main http-server json string_utils-base64 @@ -62,12 +58,11 @@ add_ydb_test(NAME client-oauth2_ut unit ) -add_ydb_test(NAME client-ydb_params_ut +add_ydb_test(NAME client-ydb_params_ut GTEST SOURCES params/params_ut.cpp LINK_LIBRARIES yutil - cpp-testing-unittest_main YDB-CPP-SDK::Params LABELS unit @@ -78,19 +73,17 @@ add_ydb_test(NAME client-ydb_result_ut result/result_ut.cpp LINK_LIBRARIES yutil - cpp-testing-unittest_main YDB-CPP-SDK::Result YDB-CPP-SDK::Params LABELS unit ) -add_ydb_test(NAME client-ydb_value_ut +add_ydb_test(NAME client-ydb_value_ut GTEST SOURCES value/value_ut.cpp LINK_LIBRARIES yutil - cpp-testing-unittest_main YDB-CPP-SDK::Value YDB-CPP-SDK::Params LABELS diff --git a/tests/unit/client/params/params_ut.cpp b/tests/unit/client/params/params_ut.cpp index efd7468f6f..9d66fe05e7 100644 --- a/tests/unit/client/params/params_ut.cpp +++ b/tests/unit/client/params/params_ut.cpp @@ -1,7 +1,5 @@ +#include #include - -#include -#include #include #include @@ -12,252 +10,232 @@ using TExpectedErrorException = yexception; void CheckProtoValue(const Ydb::Value& value, const TString& expected) { TStringType protoStr; google::protobuf::TextFormat::PrintToString(value, &protoStr); - UNIT_ASSERT_NO_DIFF(protoStr, expected); + ASSERT_EQ(protoStr, expected); } -Y_UNIT_TEST_SUITE(ParamsBuilder) { - Y_UNIT_TEST(Build) { - auto params = TParamsBuilder() - .AddParam("$param1") - .BeginList() - .AddListItem() - .BeginOptional() - .Uint64(10) - .EndOptional() - .AddListItem() - .EmptyOptional() - .EndList() - .Build() - .AddParam("$param2") - .String("test") - .Build() - .Build(); - - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), "List"); - - CheckProtoValue(params.GetValue("$param1")->GetProto(), - "items {\n" - " uint64_value: 10\n" - "}\n" - "items {\n" - " null_flag_value: NULL_VALUE\n" - "}\n"); - - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), "String"); - CheckProtoValue(params.GetValue("$param2")->GetProto(), "bytes_value: \"test\"\n"); - } - - Y_UNIT_TEST(BuildFromValue) { - auto value2 = TValueBuilder() +TEST(ParamsBuilder, Build) { + auto params = TParamsBuilder() + .AddParam("$param1") .BeginList() .AddListItem() .BeginOptional() - .BeginTuple() - .AddElement() - .Int32(-11) - .AddElement() - .String("test2") - .EndTuple() + .Uint64(10) .EndOptional() .AddListItem() .EmptyOptional() .EndList() - .Build(); - - auto params = TParamsBuilder() - .AddParam("$param1") - .Utf8("test1") - .Build() - .AddParam("$param2", value2) - .Build(); - - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), "Utf8"); - - CheckProtoValue(params.GetValue("$param1")->GetProto(), "text_value: \"test1\"\n"); - - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), "List?>"); - CheckProtoValue(params.GetValue("$param2")->GetProto(), - "items {\n" - " items {\n" - " int32_value: -11\n" - " }\n" - " items {\n" - " bytes_value: \"test2\"\n" - " }\n" - "}\n" - "items {\n" - " null_flag_value: NULL_VALUE\n" - "}\n"); - } - - Y_UNIT_TEST(BuildWithTypeInfo) { - auto param1Type = TTypeBuilder() - .BeginList() - .Primitive(EPrimitiveType::String) - .EndList() - .Build(); + .Build() + .AddParam("$param2") + .String("test") + .Build() + .Build(); + + ASSERT_EQ(FormatType(params.GetValue("$param1")->GetType()), "List"); + + CheckProtoValue(params.GetValue("$param1")->GetProto(), + "items {\n" + " uint64_value: 10\n" + "}\n" + "items {\n" + " null_flag_value: NULL_VALUE\n" + "}\n"); + + ASSERT_EQ(FormatType(params.GetValue("$param2")->GetType()), "String"); + CheckProtoValue(params.GetValue("$param2")->GetProto(), "bytes_value: \"test\"\n"); +} - auto param2Type = TTypeBuilder() +TEST(ParamsBuilder, BuildFromValue) { + auto value2 = TValueBuilder() + .BeginList() + .AddListItem() .BeginOptional() - .Primitive(EPrimitiveType::Uint32) + .BeginTuple() + .AddElement() + .Int32(-11) + .AddElement() + .String("test2") + .EndTuple() .EndOptional() - .Build(); + .AddListItem() + .EmptyOptional() + .EndList() + .Build(); + + auto params = TParamsBuilder() + .AddParam("$param1") + .Utf8("test1") + .Build() + .AddParam("$param2", value2) + .Build(); + + ASSERT_EQ(FormatType(params.GetValue("$param1")->GetType()), "Utf8"); + + CheckProtoValue(params.GetValue("$param1")->GetProto(), "text_value: \"test1\"\n"); + + ASSERT_EQ(FormatType(params.GetValue("$param2")->GetType()), "List?>"); + CheckProtoValue(params.GetValue("$param2")->GetProto(), + "items {\n" + " items {\n" + " int32_value: -11\n" + " }\n" + " items {\n" + " bytes_value: \"test2\"\n" + " }\n" + "}\n" + "items {\n" + " null_flag_value: NULL_VALUE\n" + "}\n"); +} - std::map paramsMap; - paramsMap.emplace("$param1", param1Type); - paramsMap.emplace("$param2", param2Type); +TEST(ParamsBuilder, BuildWithTypeInfo) { + auto param1Type = TTypeBuilder() + .BeginList() + .Primitive(EPrimitiveType::String) + .EndList() + .Build(); + + auto param2Type = TTypeBuilder() + .BeginOptional() + .Primitive(EPrimitiveType::Uint32) + .EndOptional() + .Build(); + + std::map paramsMap; + paramsMap.emplace("$param1", param1Type); + paramsMap.emplace("$param2", param2Type); + + auto value1 = TValueBuilder() + .BeginList() + .AddListItem() + .String("str1") + .AddListItem() + .String("str2") + .EndList() + .Build(); + + auto params = TParamsBuilder(paramsMap) + .AddParam("$param1", value1) + .AddParam("$param2") + .EmptyOptional() + .Build() + .Build(); + + ASSERT_EQ(FormatType(params.GetValue("$param1")->GetType()), "List"); + CheckProtoValue(params.GetValue("$param1")->GetProto(), + "items {\n" + " bytes_value: \"str1\"\n" + "}\n" + "items {\n" + " bytes_value: \"str2\"\n" + "}\n"); + + ASSERT_EQ(FormatType(params.GetValue("$param2")->GetType()), "Uint32?"); + CheckProtoValue(params.GetValue("$param2")->GetProto(), "null_flag_value: NULL_VALUE\n"); +} - auto value1 = TValueBuilder() - .BeginList() - .AddListItem() - .String("str1") - .AddListItem() - .String("str2") - .EndList() - .Build(); +TEST(ParamsBuilder, MissingParam) { + auto param1Type = TTypeBuilder() + .BeginList() + .Primitive(EPrimitiveType::String) + .EndList() + .Build(); + + auto param2Type = TTypeBuilder() + .BeginOptional() + .Primitive(EPrimitiveType::Uint32) + .EndOptional() + .Build(); + std::map paramsMap; + paramsMap.emplace("$param1", param1Type); + paramsMap.emplace("$param2", param2Type); + + ASSERT_THROW({ auto params = TParamsBuilder(paramsMap) - .AddParam("$param1", value1) - .AddParam("$param2") + .AddParam("$param3") .EmptyOptional() .Build() .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param1")->GetType()), "List"); - CheckProtoValue(params.GetValue("$param1")->GetProto(), - "items {\n" - " bytes_value: \"str1\"\n" - "}\n" - "items {\n" - " bytes_value: \"str2\"\n" - "}\n"); - - UNIT_ASSERT_NO_DIFF(FormatType(params.GetValue("$param2")->GetType()), "Uint32?"); - CheckProtoValue(params.GetValue("$param2")->GetProto(), "null_flag_value: NULL_VALUE\n"); - } - - Y_UNIT_TEST(MissingParam) { - auto param1Type = TTypeBuilder() - .BeginList() - .Primitive(EPrimitiveType::String) - .EndList() - .Build(); +TEST(ParamsBuilder, IncompleteParam) { + auto paramsBuilder = TParamsBuilder(); - auto param2Type = TTypeBuilder() + auto& param1Builder = paramsBuilder.AddParam("$param1"); + auto& param2Builder = paramsBuilder.AddParam("$param2"); + + param1Builder + .BeginList() + .AddListItem() .BeginOptional() - .Primitive(EPrimitiveType::Uint32) + .Uint64(10) .EndOptional() - .Build(); + .AddListItem() + .EmptyOptional() + .EndList() + .Build(); - std::map paramsMap; - paramsMap.emplace("$param1", param1Type); - paramsMap.emplace("$param2", param2Type); + param2Builder.String("test"); - try { - auto params = TParamsBuilder(paramsMap) - .AddParam("$param3") - .EmptyOptional() - .Build() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } + ASSERT_THROW(paramsBuilder.Build(), TExpectedErrorException); +} - UNIT_ASSERT(false); - } +TEST(ParamsBuilder, TypeMismatch) { + auto param1Type = TTypeBuilder() + .BeginList() + .Primitive(EPrimitiveType::String) + .EndList() + .Build(); - Y_UNIT_TEST(IncompleteParam) { - auto paramsBuilder = TParamsBuilder(); + auto param2Type = TTypeBuilder() + .BeginOptional() + .Primitive(EPrimitiveType::Uint32) + .EndOptional() + .Build(); - auto& param1Builder = paramsBuilder.AddParam("$param1"); - auto& param2Builder = paramsBuilder.AddParam("$param2"); + std::map paramsMap; + paramsMap.emplace("$param1", param1Type); + paramsMap.emplace("$param2", param2Type); - param1Builder - .BeginList() - .AddListItem() - .BeginOptional() - .Uint64(10) - .EndOptional() - .AddListItem() + ASSERT_THROW({ + auto params = TParamsBuilder(paramsMap) + .AddParam("$param1") .EmptyOptional() - .EndList() - .Build(); - - param2Builder.String("test"); - - try { - paramsBuilder.Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(TypeMismatch) { - auto param1Type = TTypeBuilder() - .BeginList() - .Primitive(EPrimitiveType::String) - .EndList() - .Build(); - - auto param2Type = TTypeBuilder() - .BeginOptional() - .Primitive(EPrimitiveType::Uint32) - .EndOptional() - .Build(); - - std::map paramsMap; - paramsMap.emplace("$param1", param1Type); - paramsMap.emplace("$param2", param2Type); - - try { - auto params = TParamsBuilder(paramsMap) - .AddParam("$param1") - .EmptyOptional() - .Build() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(TypeMismatchFromValue) { - auto param1Type = TTypeBuilder() - .BeginList() - .Primitive(EPrimitiveType::String) - .EndList() - .Build(); - - auto param2Type = TTypeBuilder() - .BeginOptional() - .Primitive(EPrimitiveType::Uint32) - .EndOptional() + .Build() .Build(); + }, TExpectedErrorException); +} - std::map paramsMap; - paramsMap.emplace("$param1", param1Type); - paramsMap.emplace("$param2", param2Type); - - auto value1 = TValueBuilder() - .BeginList() - .AddListItem() - .String("str1") - .AddListItem() - .String("str2") - .EndList() +TEST(ParamsBuilder, TypeMismatchFromValue) { + auto param1Type = TTypeBuilder() + .BeginList() + .Primitive(EPrimitiveType::String) + .EndList() + .Build(); + + auto param2Type = TTypeBuilder() + .BeginOptional() + .Primitive(EPrimitiveType::Uint32) + .EndOptional() + .Build(); + + std::map paramsMap; + paramsMap.emplace("$param1", param1Type); + paramsMap.emplace("$param2", param2Type); + + auto value1 = TValueBuilder() + .BeginList() + .AddListItem() + .String("str1") + .AddListItem() + .String("str2") + .EndList() + .Build(); + + ASSERT_THROW({ + auto params = TParamsBuilder(paramsMap) + .AddParam("$param2", value1) .Build(); - - try { - auto params = TParamsBuilder(paramsMap) - .AddParam("$param2", value1) - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } + }, TExpectedErrorException); } diff --git a/tests/unit/client/value/value_ut.cpp b/tests/unit/client/value/value_ut.cpp index c10164366c..459e185dba 100644 --- a/tests/unit/client/value/value_ut.cpp +++ b/tests/unit/client/value/value_ut.cpp @@ -1,12 +1,8 @@ +#include #include #include - #include #include - -#include -#include - #include namespace NYdb { @@ -16,866 +12,884 @@ using TExpectedErrorException = yexception; void CheckProtoValue(const Ydb::Value& value, const TString& expected) { TStringType protoStr; google::protobuf::TextFormat::PrintToString(value, &protoStr); - Cerr << protoStr << Endl; - UNIT_ASSERT_NO_DIFF(protoStr, expected); + ASSERT_EQ(protoStr, expected); } -Y_UNIT_TEST_SUITE(YdbValue) { - Y_UNIT_TEST(ParseType1) { - auto protoTypeStr = R"( - struct_type { - members { - name: "Member1" - type { - type_id: UINT32 - } +TEST(YdbValue, ParseType1) { + auto protoTypeStr = R"( + struct_type { + members { + name: "Member1" + type { + type_id: UINT32 } - members { - name: "Member2" - type { - list_type { - item { - type_id: STRING - } + } + members { + name: "Member2" + type { + list_type { + item { + type_id: STRING } } } - members { - name: "Member3" - type { - tuple_type { - elements { - optional_type { - item { - type_id: UTF8 - } - } - } - elements { - decimal_type { - precision: 8 - scale: 13 + } + members { + name: "Member3" + type { + tuple_type { + elements { + optional_type { + item { + type_id: UTF8 } } - elements { - void_type: NULL_VALUE + } + elements { + decimal_type { + precision: 8 + scale: 13 } } + elements { + void_type: NULL_VALUE + } } } } - )"; + } + )"; - Ydb::Type protoType; - google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); + Ydb::Type protoType; + google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); - UNIT_ASSERT_NO_DIFF(FormatType(protoType), - R"(Struct<'Member1':Uint32,'Member2':List,'Member3':Tuple>)"); - } + ASSERT_EQ(FormatType(protoType), + R"(Struct<'Member1':Uint32,'Member2':List,'Member3':Tuple>)"); +} - Y_UNIT_TEST(ParseType2) { - auto protoTypeStr = R"( - dict_type { - key { - type_id: UINT32 - } - payload { - struct_type { - members { - name: "Member1" - type { - type_id: DATE - } +TEST(YdbValue, ParseType2) { + auto protoTypeStr = R"( + dict_type { + key { + type_id: UINT32 + } + payload { + struct_type { + members { + name: "Member1" + type { + type_id: DATE } } } } - )"; + } + )"; - Ydb::Type protoType; - google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); + Ydb::Type protoType; + google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); - UNIT_ASSERT_NO_DIFF(FormatType(protoType), - R"(Dict>)"); - } + ASSERT_EQ(FormatType(protoType), + R"(Dict>)"); +} - Y_UNIT_TEST(ParseTaggedType) { - auto protoTypeStr = R"( - tagged_type { - tag: "my_tag" - type { - type_id: STRING - } +TEST(YdbValue, ParseTaggedType) { + auto protoTypeStr = R"( + tagged_type { + tag: "my_tag" + type { + type_id: STRING } - )"; + } + )"; - Ydb::Type protoType; - google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); + Ydb::Type protoType; + google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); - UNIT_ASSERT_NO_DIFF(FormatType(protoType), - R"(Tagged)"); - } + ASSERT_EQ(FormatType(protoType), + R"(Tagged)"); +} - Y_UNIT_TEST(BuildTaggedType) { - auto type = TTypeBuilder() - .BeginTagged("my_tag") - .BeginList() - .BeginOptional() - .Primitive(EPrimitiveType::Uint32) - .EndOptional() - .EndList() - .EndTagged() - .Build(); +TEST(YdbValue, BuildTaggedType) { + auto type = TTypeBuilder() + .BeginTagged("my_tag") + .BeginList() + .BeginOptional() + .Primitive(EPrimitiveType::Uint32) + .EndOptional() + .EndList() + .EndTagged() + .Build(); - UNIT_ASSERT_NO_DIFF(FormatType(type), - R"(Tagged,'my_tag'>)"); - } + ASSERT_EQ(FormatType(type), + R"(Tagged,'my_tag'>)"); +} - Y_UNIT_TEST(BuildType) { - auto type = TTypeBuilder() - .BeginStruct() - .AddMember("Member1") - .BeginList() +TEST(YdbValue, BuildType) { + auto type = TTypeBuilder() + .BeginStruct() + .AddMember("Member1") + .BeginList() + .BeginOptional() + .Primitive(EPrimitiveType::Uint32) + .EndOptional() + .EndList() + .AddMember("Member2") + .BeginDict() + .DictKey().Primitive(EPrimitiveType::Int64) + .DictPayload() + .BeginTuple() + .AddElement() + .Decimal(TDecimalType(8, 13)) + .AddElement() + .Pg(TPgType("pgint2")) + .AddElement() .BeginOptional() - .Primitive(EPrimitiveType::Uint32) + .Primitive(EPrimitiveType::Utf8) .EndOptional() - .EndList() - .AddMember("Member2") - .BeginDict() - .DictKey().Primitive(EPrimitiveType::Int64) - .DictPayload() - .BeginTuple() - .AddElement() - .Decimal(TDecimalType(8, 13)) - .AddElement() - .Pg(TPgType("pgint2")) - .AddElement() - .BeginOptional() - .Primitive(EPrimitiveType::Utf8) - .EndOptional() - .EndTuple() - .EndDict() - .EndStruct() - .Build(); - - UNIT_ASSERT_NO_DIFF(FormatType(type), - R"(Struct<'Member1':List,'Member2':Dict>>)"); - } - - Y_UNIT_TEST(BuildTypeReuse) { - auto intType = TTypeBuilder() - .Primitive(EPrimitiveType::Int32) - .Build(); - - UNIT_ASSERT_NO_DIFF(FormatType(intType), - R"(Int32)"); - - auto optIntType = TTypeBuilder() - .Optional(intType) - .Build(); - - UNIT_ASSERT_NO_DIFF(FormatType(optIntType), - R"(Int32?)"); + .EndTuple() + .EndDict() + .EndStruct() + .Build(); - auto structType = TTypeBuilder() - .BeginStruct() - .AddMember("Member1", intType) - .AddMember("Member2") - .List(optIntType) - .EndStruct() - .Build(); + ASSERT_EQ(FormatType(type), + R"(Struct<'Member1':List,'Member2':Dict>>)"); +} - UNIT_ASSERT_NO_DIFF(FormatType(structType), - R"(Struct<'Member1':Int32,'Member2':List>)"); +TEST(YdbValue, BuildTypeReuse) { + auto intType = TTypeBuilder() + .Primitive(EPrimitiveType::Int32) + .Build(); + + ASSERT_EQ(FormatType(intType), + R"(Int32)"); + + auto optIntType = TTypeBuilder() + .Optional(intType) + .Build(); + + ASSERT_EQ(FormatType(optIntType), + R"(Int32?)"); + + auto structType = TTypeBuilder() + .BeginStruct() + .AddMember("Member1", intType) + .AddMember("Member2") + .List(optIntType) + .EndStruct() + .Build(); + + ASSERT_EQ(FormatType(structType), + R"(Struct<'Member1':Int32,'Member2':List>)"); + + auto tupleType = TTypeBuilder() + .BeginTuple() + .AddElement(optIntType) + .AddElement() + .Primitive(EPrimitiveType::String) + .EndTuple() + .Build(); + + ASSERT_EQ(FormatType(tupleType), + R"(Tuple)"); + + auto type = TTypeBuilder() + .BeginDict() + .DictKey(tupleType) + .DictPayload(structType) + .EndDict() + .Build(); + + ASSERT_EQ(FormatType(type), + R"(Dict,Struct<'Member1':Int32,'Member2':List>>)"); +} - auto tupleType = TTypeBuilder() +TEST(YdbValue, BuildTypeIncomplete) { + ASSERT_THROW({ + auto value = TTypeBuilder() .BeginTuple() - .AddElement(optIntType) + .AddElement() + .Primitive(EPrimitiveType::Uint32) .AddElement() .Primitive(EPrimitiveType::String) - .EndTuple() .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT_NO_DIFF(FormatType(tupleType), - R"(Tuple)"); - - auto type = TTypeBuilder() - .BeginDict() - .DictKey(tupleType) - .DictPayload(structType) - .EndDict() - .Build(); - - UNIT_ASSERT_NO_DIFF(FormatType(type), - R"(Dict,Struct<'Member1':Int32,'Member2':List>>)"); - } - - Y_UNIT_TEST(BuildTypeIncomplete) { - try { - auto value = TTypeBuilder() - .BeginTuple() - .AddElement() - .Primitive(EPrimitiveType::Uint32) - .AddElement() - .Primitive(EPrimitiveType::String) - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(ParseValue1) { - auto protoTypeStr = R"( - struct_type { - members { - name: "Member1" - type { - type_id: UINT32 - } +TEST(YdbValue, ParseValue1) { + auto protoTypeStr = R"( + struct_type { + members { + name: "Member1" + type { + type_id: UINT32 } - members { - name: "Member2" - type { - list_type { - item { - type_id: STRING - } + } + members { + name: "Member2" + type { + list_type { + item { + type_id: STRING } } } - members { - name: "Member3" - type { - tuple_type { - elements { - optional_type { - item { - type_id: UTF8 - } + } + members { + name: "Member3" + type { + tuple_type { + elements { + optional_type { + item { + type_id: UTF8 } } - elements { - type_id: UTF8 - } - elements { - void_type: NULL_VALUE - } + } + elements { + type_id: UTF8 + } + elements { + void_type: NULL_VALUE } } } } - )"; + } + )"; + + auto protoValueStr = + "items {\n" + " uint32_value: 137\n" + "}\n" + "items {\n" + " items {\n" + " bytes_value: \"String1\"\n" + " }\n" + " items {\n" + " bytes_value: \"String2\"\n" + " }\n" + "}\n" + "items {\n" + " items {\n" + " null_flag_value: NULL_VALUE\n" + " }\n" + " items {\n" + " text_value: \"UtfString\"\n" + " }\n" + " items {\n" + " }\n" + "}\n"; + + Ydb::Type protoType; + google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); + + Ydb::Value protoValue; + google::protobuf::TextFormat::ParseFromString(protoValueStr, &protoValue); + + TValue value(TType(protoType), protoValue); + + CheckProtoValue(value.GetProto(), protoValueStr); +} - auto protoValueStr = - "items {\n" - " uint32_value: 137\n" - "}\n" - "items {\n" - " items {\n" - " bytes_value: \"String1\"\n" - " }\n" - " items {\n" - " bytes_value: \"String2\"\n" - " }\n" - "}\n" - "items {\n" - " items {\n" - " null_flag_value: NULL_VALUE\n" - " }\n" - " items {\n" - " text_value: \"UtfString\"\n" - " }\n" - " items {\n" - " }\n" - "}\n"; - - Ydb::Type protoType; - google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); - - Ydb::Value protoValue; - google::protobuf::TextFormat::ParseFromString(protoValueStr, &protoValue); - - TValue value(TType(protoType), protoValue); - - CheckProtoValue(value.GetProto(), protoValueStr); - } - - Y_UNIT_TEST(ParseValue2) { - auto protoTypeStr = R"( - dict_type { - key { - type_id: UINT32 - } - payload { - struct_type { - members { - name: "Member1" - type { - type_id: DATE - } +TEST(YdbValue, ParseValue2) { + auto protoTypeStr = R"( + dict_type { + key { + type_id: UINT32 + } + payload { + struct_type { + members { + name: "Member1" + type { + type_id: DATE } } } } - )"; + } + )"; + + auto protoValueStr = + "pairs {\n" + " key {\n" + " uint32_value: 10\n" + " }\n" + " payload {\n" + " items {\n" + " uint32_value: 1000\n" + " }\n" + " }\n" + "}\n" + "pairs {\n" + " key {\n" + " uint32_value: 20\n" + " }\n" + " payload {\n" + " items {\n" + " uint32_value: 2000\n" + " }\n" + " }\n" + "}\n"; + + Ydb::Type protoType; + google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); + + Ydb::Value protoValue; + google::protobuf::TextFormat::ParseFromString(protoValueStr, &protoValue); + + TValue value(TType(protoType), protoValue); + + CheckProtoValue(value.GetProto(), protoValueStr); +} - auto protoValueStr = - "pairs {\n" - " key {\n" - " uint32_value: 10\n" - " }\n" - " payload {\n" - " items {\n" - " uint32_value: 1000\n" - " }\n" - " }\n" - "}\n" - "pairs {\n" - " key {\n" - " uint32_value: 20\n" - " }\n" - " payload {\n" - " items {\n" - " uint32_value: 2000\n" - " }\n" - " }\n" - "}\n"; - - Ydb::Type protoType; - google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); - - Ydb::Value protoValue; - google::protobuf::TextFormat::ParseFromString(protoValueStr, &protoValue); - - TValue value(TType(protoType), protoValue); - - CheckProtoValue(value.GetProto(), protoValueStr); - } - - Y_UNIT_TEST(ParseValuePg) { - auto protoTypeStr = R"( - struct_type { - members { - name: "A" - type { - pg_type { - oid: 123 - typlen: 345 - typmod: -321 - } - } - } - members { - name: "B" - type { - pg_type { - oid: 123 - typlen: -345 - typmod: 321 - } - } - } - members { - name: "C" - type { - pg_type { - oid: 123 - typlen: -345 - typmod: -321 - } +TEST(YdbValue, ParseValuePg) { + auto protoTypeStr = R"( + struct_type { + members { + name: "A" + type { + pg_type { + oid: 123 + typlen: 345 + typmod: -321 } } - members { - name: "D" - type { - pg_type { - oid: 123 - typlen: -1 - typmod: -1 - } + } + members { + name: "B" + type { + pg_type { + oid: 123 + typlen: -345 + typmod: 321 } } - members { - name: "E" - type { - pg_type { - oid: 123 - typlen: -1 - typmod: -1 - } + } + members { + name: "C" + type { + pg_type { + oid: 123 + typlen: -345 + typmod: -321 } } } - )"; - - auto protoValueStr = - "items {\n" - " text_value: \"my_text_value\"\n" - "}\n" - "items {\n" - " bytes_value: \"my_binary_value\"\n" - "}\n" - "items {\n" - " text_value: \"\"\n" - "}\n" - "items {\n" - " bytes_value: \"\"\n" - "}\n"; - - Ydb::Type protoType; - google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); - - Ydb::Value protoValue; - google::protobuf::TextFormat::ParseFromString(protoValueStr, &protoValue); - - TValue value(TType(protoType), protoValue); - - CheckProtoValue(value.GetProto(), protoValueStr); - } - - Y_UNIT_TEST(ParseValueMaybe) { - auto protoTypeStr = R"( - tuple_type { - elements { - optional_type { - item { - type_id: UTF8 - } + members { + name: "D" + type { + pg_type { + oid: 123 + typlen: -1 + typmod: -1 } } - elements { - optional_type { - item { - type_id: INT8 - } + } + members { + name: "E" + type { + pg_type { + oid: 123 + typlen: -1 + typmod: -1 } } - elements { - optional_type { - item { - type_id: DOUBLE - } + } + } + )"; + + auto protoValueStr = + "items {\n" + " text_value: \"my_text_value\"\n" + "}\n" + "items {\n" + " bytes_value: \"my_binary_value\"\n" + "}\n" + "items {\n" + " text_value: \"\"\n" + "}\n" + "items {\n" + " bytes_value: \"\"\n" + "}\n"; + + Ydb::Type protoType; + google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); + + Ydb::Value protoValue; + google::protobuf::TextFormat::ParseFromString(protoValueStr, &protoValue); + + TValue value(TType(protoType), protoValue); + + CheckProtoValue(value.GetProto(), protoValueStr); +} + +TEST(YdbValue, ParseValueMaybe) { + auto protoTypeStr = R"( + tuple_type { + elements { + optional_type { + item { + type_id: UTF8 } } - elements { - optional_type { - item { - type_id: UINT64 - } + } + elements { + optional_type { + item { + type_id: INT8 } } - elements { - optional_type { - item { - type_id: DYNUMBER - } + } + elements { + optional_type { + item { + type_id: DOUBLE } } } - )"; - - auto protoValueStr = R"( - items { - text_value: "SomeUtf" - } - items { - int32_value: -5 - } - items { - null_flag_value: NULL_VALUE - } - items { - nested_value { - uint64_value: 7 + elements { + optional_type { + item { + type_id: UINT64 + } } } - items { - nested_value { - text_value: "12.345" + elements { + optional_type { + item { + type_id: DYNUMBER + } } } - )"; - - Ydb::Type protoType; - google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); - - Ydb::Value protoValue; - google::protobuf::TextFormat::ParseFromString(protoValueStr, &protoValue); - - TValue value(TType(protoType), protoValue); - TValueParser parser(value); - - parser.OpenTuple(); - UNIT_ASSERT(parser.TryNextElement()); - UNIT_ASSERT(parser.GetOptionalUtf8() == "SomeUtf"); - UNIT_ASSERT(parser.TryNextElement()); - UNIT_ASSERT(parser.GetOptionalInt8() == -5); - UNIT_ASSERT(parser.TryNextElement()); - UNIT_ASSERT(parser.GetOptionalDouble() == std::optional()); - UNIT_ASSERT(parser.TryNextElement()); - UNIT_ASSERT(parser.GetOptionalUint64() == (ui64)7); - UNIT_ASSERT(parser.TryNextElement()); - UNIT_ASSERT(parser.GetOptionalDyNumber() == "12.345"); - parser.CloseTuple(); - } - - Y_UNIT_TEST(BuildValueIncomplete) { - try { - auto value = TValueBuilder() - .BeginTuple() - .AddElement() - .Uint32(10) - .AddElement() - .String("test") - .Build(); - } catch (const TExpectedErrorException& e) { - return; } + )"; - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueListItemMismatch1) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .Int32(17) - .AddListItem() - .Uint32(19) - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; + auto protoValueStr = R"( + items { + text_value: "SomeUtf" } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueListItemMismatch2) { - auto itemValue = TValueBuilder() - .String("Test") - .Build(); - - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem(itemValue) - .AddListItem() - .Int32(17) - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; + items { + int32_value: -5 } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueListItemMismatch3) { - auto itemValue = TValueBuilder() - .String("Test") - .Build(); - - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .Int32(17) - .AddListItem(itemValue) - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; + items { + null_flag_value: NULL_VALUE } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueListItemMismatch4) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .BeginList() - .AddListItem() - .Uint32(10) - .EndList() - .AddListItem() - .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint64).Build()) - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; + items { + nested_value { + uint64_value: 7 + } } - - UNIT_ASSERT(false); - } - - - Y_UNIT_TEST(BuildValueEmptyListUnknown) { - try { - auto value = TValueBuilder() - .EmptyList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; + items { + nested_value { + text_value: "12.345" + } } + )"; + + Ydb::Type protoType; + google::protobuf::TextFormat::ParseFromString(protoTypeStr, &protoType); + + Ydb::Value protoValue; + google::protobuf::TextFormat::ParseFromString(protoValueStr, &protoValue); + + TValue value(TType(protoType), protoValue); + TValueParser parser(value); + + parser.OpenTuple(); + ASSERT_TRUE(parser.TryNextElement()); + ASSERT_EQ(parser.GetOptionalUtf8(), "SomeUtf"); + ASSERT_TRUE(parser.TryNextElement()); + ASSERT_EQ(parser.GetOptionalInt8(), -5); + ASSERT_TRUE(parser.TryNextElement()); + ASSERT_EQ(parser.GetOptionalDouble(), std::optional()); + ASSERT_TRUE(parser.TryNextElement()); + ASSERT_EQ(parser.GetOptionalUint64(), (ui64)7); + ASSERT_TRUE(parser.TryNextElement()); + ASSERT_EQ(parser.GetOptionalDyNumber(), "12.345"); + parser.CloseTuple(); +} - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildDyNumberValue) { - auto value = TValueBuilder() - .DyNumber("12.345") - .Build(); - - CheckProtoValue(value.GetProto(), "text_value: \"12.345\"\n"); - } - - Y_UNIT_TEST(BuildTaggedValue) { +TEST(YdbValue, BuildValueIncomplete) { + ASSERT_THROW({ auto value = TValueBuilder() - .BeginTagged("my_tag") - .DyNumber("12.345") - .EndTagged() - .Build(); - - CheckProtoValue(value.GetProto(), "text_value: \"12.345\"\n"); - } - - Y_UNIT_TEST(BuildValueList) { - auto intValue = TValueBuilder() - .Int32(21) + .BeginTuple() + .AddElement() + .Uint32(10) + .AddElement() + .String("test") .Build(); + }, TExpectedErrorException); +} +TEST(YdbValue, BuildValueListItemMismatch1) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginList() .AddListItem() .Int32(17) .AddListItem() - .Int32(19) - .AddListItem(intValue) + .Uint32(19) .EndList() .Build(); + }, TExpectedErrorException); +} - CheckProtoValue(value.GetProto(), - "items {\n" - " int32_value: 17\n" - "}\n" - "items {\n" - " int32_value: 19\n" - "}\n" - "items {\n" - " int32_value: 21\n" - "}\n"); - } - - Y_UNIT_TEST(BuildValueListEmpty) { +TEST(YdbValue, BuildValueListItemMismatch2) { + auto itemValue = TValueBuilder() + .String("Test") + .Build(); + + ASSERT_THROW({ auto value = TValueBuilder() - .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build()) + .BeginList() + .AddListItem(itemValue) + .AddListItem() + .Int32(17) + .EndList() .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), - R"(List)"); - CheckProtoValue(value.GetProto(), ""); - } +TEST(YdbValue, BuildValueListItemMismatch3) { + auto itemValue = TValueBuilder() + .String("Test") + .Build(); - Y_UNIT_TEST(BuildValueListEmpty2) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginList() .AddListItem() - .BeginList() - .AddListItem() - .Uint32(10) - .EndList() - .AddListItem() - .EmptyList() + .Int32(17) + .AddListItem(itemValue) .EndList() .Build(); + }, TExpectedErrorException); +} - CheckProtoValue(value.GetProto(), - "items {\n" - " items {\n" - " uint32_value: 10\n" - " }\n" - "}\n" - "items {\n" - "}\n"); - } - - Y_UNIT_TEST(BuildValueListEmpty3) { +TEST(YdbValue, BuildValueListItemMismatch4) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginList() - .AddListItem() - .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build()) .AddListItem() .BeginList() .AddListItem() .Uint32(10) .EndList() + .AddListItem() + .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint64).Build()) .EndList() .Build(); + }, TExpectedErrorException); +} - CheckProtoValue(value.GetProto(), - "items {\n" - "}\n" - "items {\n" - " items {\n" - " uint32_value: 10\n" - " }\n" - "}\n"); - } - - Y_UNIT_TEST(BuildValueBadCall) { - try { - auto value = TValueBuilder() - .AddListItem() - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } +TEST(YdbValue, BuildValueEmptyListUnknown) { + ASSERT_THROW({ + auto value = TValueBuilder() + .EmptyList() + .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT(false); - } +TEST(YdbValue, BuildDyNumberValue) { + auto value = TValueBuilder() + .DyNumber("12.345") + .Build(); - Y_UNIT_TEST(BuildValueOptional) { - auto value = TValueBuilder() + CheckProtoValue(value.GetProto(), "text_value: \"12.345\"\n"); +} + +TEST(YdbValue, BuildTaggedValue) { + auto value = TValueBuilder() + .BeginTagged("my_tag") + .DyNumber("12.345") + .EndTagged() + .Build(); + + CheckProtoValue(value.GetProto(), "text_value: \"12.345\"\n"); +} + +TEST(YdbValue, BuildValueList) { + auto intValue = TValueBuilder() + .Int32(21) + .Build(); + + auto value = TValueBuilder() + .BeginList() + .AddListItem() + .Int32(17) + .AddListItem() + .Int32(19) + .AddListItem(intValue) + .EndList() + .Build(); + + CheckProtoValue(value.GetProto(), + "items {\n" + " int32_value: 17\n" + "}\n" + "items {\n" + " int32_value: 19\n" + "}\n" + "items {\n" + " int32_value: 21\n" + "}\n"); +} + +TEST(YdbValue, BuildValueListEmpty) { + auto value = TValueBuilder() + .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build()) + .Build(); + + ASSERT_EQ(FormatType(value.GetType()), + R"(List)"); + CheckProtoValue(value.GetProto(), ""); +} + +TEST(YdbValue, BuildValueListEmpty2) { + auto value = TValueBuilder() + .BeginList() + .AddListItem() .BeginList() .AddListItem() - .OptionalInt32(1) - .AddListItem() - .EmptyOptional() + .Uint32(10) + .EndList() + .AddListItem() + .EmptyList() + .EndList() + .Build(); + + CheckProtoValue(value.GetProto(), + "items {\n" + " items {\n" + " uint32_value: 10\n" + " }\n" + "}\n" + "items {\n" + "}\n"); +} + +TEST(YdbValue, BuildValueListEmpty3) { + auto value = TValueBuilder() + .BeginList() + .AddListItem() + .EmptyList(TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build()) + .AddListItem() + .BeginList() .AddListItem() - .BeginOptional() - .Int32(57) - .EndOptional() + .Uint32(10) + .EndList() + .EndList() + .Build(); + + CheckProtoValue(value.GetProto(), + "items {\n" + "}\n" + "items {\n" + " items {\n" + " uint32_value: 10\n" + " }\n" + "}\n"); +} + +TEST(YdbValue, BuildValueBadCall) { + ASSERT_THROW({ + auto value = TValueBuilder() .AddListItem() - .EmptyOptional(TTypeBuilder().Primitive(EPrimitiveType::Int32).Build()) .EndList() .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), - R"(List)"); - - auto expectedProtoValueStr = - "items {\n" - " int32_value: 1\n" - "}\n" - "items {\n" - " null_flag_value: NULL_VALUE\n" - "}\n" - "items {\n" - " int32_value: 57\n" - "}\n" - "items {\n" - " null_flag_value: NULL_VALUE\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueNestedOptional) { - auto value = TValueBuilder() - .BeginTuple() - .AddElement() +TEST(YdbValue, BuildValueOptional) { + auto value = TValueBuilder() + .BeginList() + .AddListItem() + .OptionalInt32(1) + .AddListItem() + .EmptyOptional() + .AddListItem() + .BeginOptional() + .Int32(57) + .EndOptional() + .AddListItem() + .EmptyOptional(TTypeBuilder().Primitive(EPrimitiveType::Int32).Build()) + .EndList() + .Build(); + + ASSERT_EQ(FormatType(value.GetType()), + R"(List)"); + + auto expectedProtoValueStr = + "items {\n" + " int32_value: 1\n" + "}\n" + "items {\n" + " null_flag_value: NULL_VALUE\n" + "}\n" + "items {\n" + " int32_value: 57\n" + "}\n" + "items {\n" + " null_flag_value: NULL_VALUE\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} + +TEST(YdbValue, BuildValueNestedOptional) { + auto value = TValueBuilder() + .BeginTuple() + .AddElement() + .BeginOptional() .BeginOptional() - .BeginOptional() - .Int32(10) - .EndOptional() + .Int32(10) .EndOptional() - .AddElement() + .EndOptional() + .AddElement() + .BeginOptional() .BeginOptional() .BeginOptional() - .BeginOptional() - .Int64(-1) - .EndOptional() + .Int64(-1) .EndOptional() .EndOptional() - .AddElement() + .EndOptional() + .AddElement() + .BeginOptional() + .EmptyOptional(TTypeBuilder().Primitive(EPrimitiveType::String).Build()) + .EndOptional() + .AddElement() + .BeginOptional() .BeginOptional() - .EmptyOptional(TTypeBuilder().Primitive(EPrimitiveType::String).Build()) + .EmptyOptional(EPrimitiveType::Utf8) .EndOptional() - .AddElement() + .EndOptional() + .EndTuple() + .Build(); + + ASSERT_EQ(FormatType(value.GetType()), + R"(Tuple)"); + + auto expectedProtoValueStr = + "items {\n" + " int32_value: 10\n" + "}\n" + "items {\n" + " int64_value: -1\n" + "}\n" + "items {\n" + " nested_value {\n" + " null_flag_value: NULL_VALUE\n" + " }\n" + "}\n" + "items {\n" + " nested_value {\n" + " nested_value {\n" + " null_flag_value: NULL_VALUE\n" + " }\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} + +TEST(YdbValue, BuildValueOptionalMismatch1) { + ASSERT_THROW({ + auto value = TValueBuilder() + .BeginList() + .AddListItem() .BeginOptional() - .BeginOptional() - .EmptyOptional(EPrimitiveType::Utf8) - .EndOptional() + .Uint32(10) .EndOptional() - .EndTuple() + .AddListItem() + .BeginOptional() + .Int32(20) + .EndOptional() + .EndList() .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), - R"(Tuple)"); - - auto expectedProtoValueStr = - "items {\n" - " int32_value: 10\n" - "}\n" - "items {\n" - " int64_value: -1\n" - "}\n" - "items {\n" - " nested_value {\n" - " null_flag_value: NULL_VALUE\n" - " }\n" - "}\n" - "items {\n" - " nested_value {\n" - " nested_value {\n" - " null_flag_value: NULL_VALUE\n" - " }\n" - " }\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueOptionalMismatch1) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .BeginOptional() - .Uint32(10) - .EndOptional() - .AddListItem() - .BeginOptional() - .Int32(20) - .EndOptional() - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueOptionalMismatch2) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .BeginOptional() - .Uint32(10) - .EndOptional() - .AddListItem() - .BeginOptional() - .Int32(57) - .EndOptional() - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } +TEST(YdbValue, BuildValueOptionalMismatch2) { + ASSERT_THROW({ + auto value = TValueBuilder() + .BeginList() + .AddListItem() + .BeginOptional() + .Uint32(10) + .EndOptional() + .AddListItem() + .BeginOptional() + .Int32(57) + .EndOptional() + .EndList() + .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT(false); - } +TEST(YdbValue, BuildValueStruct) { + auto value = TValueBuilder() + .BeginList() + .AddListItem() + .BeginStruct() + .AddMember("Id") + .Uint32(1) + .AddMember("Name") + .String("Anna") + .AddMember("Value") + .Int32(-100) + .AddMember("Description") + .EmptyOptional(EPrimitiveType::Utf8) + .EndStruct() + .AddListItem() + .BeginStruct() + .AddMember("Name") + .String("Paul") + .AddMember("Value", TValueBuilder().Int32(-200).Build()) + .AddMember("Id") + .Uint32(2) + .AddMember("Description") + .OptionalUtf8("Some details") + .EndStruct() + .EndList() + .Build(); + + auto expectedProtoValueStr = + "items {\n" + " items {\n" + " uint32_value: 1\n" + " }\n" + " items {\n" + " bytes_value: \"Anna\"\n" + " }\n" + " items {\n" + " int32_value: -100\n" + " }\n" + " items {\n" + " null_flag_value: NULL_VALUE\n" + " }\n" + "}\n" + "items {\n" + " items {\n" + " uint32_value: 2\n" + " }\n" + " items {\n" + " bytes_value: \"Paul\"\n" + " }\n" + " items {\n" + " int32_value: -200\n" + " }\n" + " items {\n" + " text_value: \"Some details\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} - Y_UNIT_TEST(BuildValueStruct) { +TEST(YdbValue, BuildValueStructMissingMember) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginList() .AddListItem() @@ -886,187 +900,223 @@ Y_UNIT_TEST_SUITE(YdbValue) { .String("Anna") .AddMember("Value") .Int32(-100) - .AddMember("Description") - .EmptyOptional(EPrimitiveType::Utf8) .EndStruct() .AddListItem() .BeginStruct() - .AddMember("Name") - .String("Paul") - .AddMember("Value", TValueBuilder().Int32(-200).Build()) + .AddMember("Value") + .Int32(-200) .AddMember("Id") .Uint32(2) - .AddMember("Description") - .OptionalUtf8("Some details") .EndStruct() .EndList() .Build(); + }, TExpectedErrorException); +} - auto expectedProtoValueStr = - "items {\n" - " items {\n" - " uint32_value: 1\n" - " }\n" - " items {\n" - " bytes_value: \"Anna\"\n" - " }\n" - " items {\n" - " int32_value: -100\n" - " }\n" - " items {\n" - " null_flag_value: NULL_VALUE\n" - " }\n" - "}\n" - "items {\n" - " items {\n" - " uint32_value: 2\n" - " }\n" - " items {\n" - " bytes_value: \"Paul\"\n" - " }\n" - " items {\n" - " int32_value: -200\n" - " }\n" - " items {\n" - " text_value: \"Some details\"\n" - " }\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueStructMissingMember) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .BeginStruct() - .AddMember("Id") - .Uint32(1) - .AddMember("Name") - .String("Anna") - .AddMember("Value") - .Int32(-100) - .EndStruct() - .AddListItem() - .BeginStruct() - .AddMember("Value") - .Int32(-200) - .AddMember("Id") - .Uint32(2) - .EndStruct() - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } +TEST(YdbValue, BuildValueTuplePrimitives) { + auto value = TValueBuilder() + .BeginTuple() + .AddElement().Bool(true) + .AddElement().Int8(-1) + .AddElement().Uint8(1) + .AddElement().Int16(-2) + .AddElement().Uint16(2) + .AddElement().Int32(-3) + .AddElement().Uint32(3) + .AddElement().Int64(-4) + .AddElement().Uint64(4) + .AddElement().Float(-5.5) + .AddElement().Double(6.6) + .AddElement().Date(TInstant::Days(7)) + .AddElement().Datetime(TInstant::Seconds(8)) + .AddElement().Timestamp(TInstant::MicroSeconds(9)) + .AddElement().Interval(-10) + .AddElement().TzDate("2018-02-02,Europe/Moscow") + .AddElement().TzDatetime("2018-02-03T15:00:00,Europe/Moscow") + .AddElement().TzTimestamp("2018-02-07T15:00:00,Europe/Moscow") + .AddElement().String("TestString") + .AddElement().Utf8("TestUtf8") + .AddElement().Yson("[]") + .AddElement().Json("{}") + .EndTuple() + .Build(); + + ASSERT_EQ(FormatType(value.GetType()), + R"(Tuple)"); + + auto expectedProtoValueStr = + "items {\n" + " bool_value: true\n" + "}\n" + "items {\n" + " int32_value: -1\n" + "}\n" + "items {\n" + " uint32_value: 1\n" + "}\n" + "items {\n" + " int32_value: -2\n" + "}\n" + "items {\n" + " uint32_value: 2\n" + "}\n" + "items {\n" + " int32_value: -3\n" + "}\n" + "items {\n" + " uint32_value: 3\n" + "}\n" + "items {\n" + " int64_value: -4\n" + "}\n" + "items {\n" + " uint64_value: 4\n" + "}\n" + "items {\n" + " float_value: -5.5\n" + "}\n" + "items {\n" + " double_value: 6.6\n" + "}\n" + "items {\n" + " uint32_value: 7\n" + "}\n" + "items {\n" + " uint32_value: 8\n" + "}\n" + "items {\n" + " uint64_value: 9\n" + "}\n" + "items {\n" + " int64_value: -10\n" + "}\n" + "items {\n" + " text_value: \"2018-02-02,Europe/Moscow\"\n" + "}\n" + "items {\n" + " text_value: \"2018-02-03T15:00:00,Europe/Moscow\"\n" + "}\n" + "items {\n" + " text_value: \"2018-02-07T15:00:00,Europe/Moscow\"\n" + "}\n" + "items {\n" + " bytes_value: \"TestString\"\n" + "}\n" + "items {\n" + " text_value: \"TestUtf8\"\n" + "}\n" + "items {\n" + " bytes_value: \"[]\"\n" + "}\n" + "items {\n" + " text_value: \"{}\"\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} - UNIT_ASSERT(false); - } +TEST(YdbValue, BuildValueTuple1) { + auto value = TValueBuilder() + .BeginList() + .AddListItem() + .BeginTuple() + .AddElement() + .Int32(10) + .AddElement() + .String("Str1") + .EndTuple() + .AddListItem() + .BeginTuple() + .AddElement(TValueBuilder().Int32(20).Build()) + .AddElement() + .String("Str2") + .EndTuple() + .EndList() + .Build(); + + auto expectedProtoValueStr = + "items {\n" + " items {\n" + " int32_value: 10\n" + " }\n" + " items {\n" + " bytes_value: \"Str1\"\n" + " }\n" + "}\n" + "items {\n" + " items {\n" + " int32_value: 20\n" + " }\n" + " items {\n" + " bytes_value: \"Str2\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} - Y_UNIT_TEST(BuildValueTuplePrimitives) { - auto value = TValueBuilder() +TEST(YdbValue, BuildValueTuple2) { + auto value = TValueBuilder() + .BeginList() + .AddListItem() .BeginTuple() - .AddElement().Bool(true) - .AddElement().Int8(-1) - .AddElement().Uint8(1) - .AddElement().Int16(-2) - .AddElement().Uint16(2) - .AddElement().Int32(-3) - .AddElement().Uint32(3) - .AddElement().Int64(-4) - .AddElement().Uint64(4) - .AddElement().Float(-5.5) - .AddElement().Double(6.6) - .AddElement().Date(TInstant::Days(7)) - .AddElement().Datetime(TInstant::Seconds(8)) - .AddElement().Timestamp(TInstant::MicroSeconds(9)) - .AddElement().Interval(-10) - .AddElement().TzDate("2018-02-02,Europe/Moscow") - .AddElement().TzDatetime("2018-02-03T15:00:00,Europe/Moscow") - .AddElement().TzTimestamp("2018-02-07T15:00:00,Europe/Moscow") - .AddElement().String("TestString") - .AddElement().Utf8("TestUtf8") - .AddElement().Yson("[]") - .AddElement().Json("{}") + .AddElement(TValueBuilder().Int32(-10).Build()) + .AddElement(TValueBuilder().Utf8("Utf1").Build()) .EndTuple() + .AddListItem() + .BeginTuple() + .AddElement() + .Int32(-20) + .AddElement() + .Utf8("Utf2") + .EndTuple() + .EndList() + .Build(); + + auto expectedProtoValueStr = + "items {\n" + " items {\n" + " int32_value: -10\n" + " }\n" + " items {\n" + " text_value: \"Utf1\"\n" + " }\n" + "}\n" + "items {\n" + " items {\n" + " int32_value: -20\n" + " }\n" + " items {\n" + " text_value: \"Utf2\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} + +TEST(YdbValue, BuildValueTupleElementsMismatch1) { + ASSERT_THROW({ + auto value = TValueBuilder() + .BeginList() + .AddListItem() + .BeginTuple() + .AddElement() + .Int32(10) + .AddElement() + .String("Str1") + .EndTuple() + .AddListItem() + .BeginTuple() + .AddElement() + .Int32(-20) + .EndTuple() + .EndList() .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), - R"(Tuple)"); - - auto expectedProtoValueStr = - "items {\n" - " bool_value: true\n" - "}\n" - "items {\n" - " int32_value: -1\n" - "}\n" - "items {\n" - " uint32_value: 1\n" - "}\n" - "items {\n" - " int32_value: -2\n" - "}\n" - "items {\n" - " uint32_value: 2\n" - "}\n" - "items {\n" - " int32_value: -3\n" - "}\n" - "items {\n" - " uint32_value: 3\n" - "}\n" - "items {\n" - " int64_value: -4\n" - "}\n" - "items {\n" - " uint64_value: 4\n" - "}\n" - "items {\n" - " float_value: -5.5\n" - "}\n" - "items {\n" - " double_value: 6.6\n" - "}\n" - "items {\n" - " uint32_value: 7\n" - "}\n" - "items {\n" - " uint32_value: 8\n" - "}\n" - "items {\n" - " uint64_value: 9\n" - "}\n" - "items {\n" - " int64_value: -10\n" - "}\n" - "items {\n" - " text_value: \"2018-02-02,Europe/Moscow\"\n" - "}\n" - "items {\n" - " text_value: \"2018-02-03T15:00:00,Europe/Moscow\"\n" - "}\n" - "items {\n" - " text_value: \"2018-02-07T15:00:00,Europe/Moscow\"\n" - "}\n" - "items {\n" - " bytes_value: \"TestString\"\n" - "}\n" - "items {\n" - " text_value: \"TestUtf8\"\n" - "}\n" - "items {\n" - " bytes_value: \"[]\"\n" - "}\n" - "items {\n" - " text_value: \"{}\"\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueTuple1) { +TEST(YdbValue, BuildValueTupleElementsMismatch2) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginList() .AddListItem() @@ -1078,155 +1128,113 @@ Y_UNIT_TEST_SUITE(YdbValue) { .EndTuple() .AddListItem() .BeginTuple() - .AddElement(TValueBuilder().Int32(20).Build()) + .AddElement() + .Int32(20) .AddElement() .String("Str2") + .AddElement() + .Uint64(1) .EndTuple() .EndList() .Build(); + }, TExpectedErrorException); +} - auto expectedProtoValueStr = - "items {\n" - " items {\n" - " int32_value: 10\n" - " }\n" - " items {\n" - " bytes_value: \"Str1\"\n" - " }\n" - "}\n" - "items {\n" - " items {\n" - " int32_value: 20\n" - " }\n" - " items {\n" - " bytes_value: \"Str2\"\n" - " }\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueTuple2) { +TEST(YdbValue, BuildValueTupleTypeMismatch) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginList() .AddListItem() .BeginTuple() - .AddElement(TValueBuilder().Int32(-10).Build()) - .AddElement(TValueBuilder().Utf8("Utf1").Build()) + .AddElement() + .Int32(10) + .AddElement() + .String("Str1") .EndTuple() .AddListItem() .BeginTuple() .AddElement() - .Int32(-20) + .Int32(20) .AddElement() .Utf8("Utf2") .EndTuple() .EndList() .Build(); + }, TExpectedErrorException); +} - auto expectedProtoValueStr = - "items {\n" - " items {\n" - " int32_value: -10\n" - " }\n" - " items {\n" - " text_value: \"Utf1\"\n" - " }\n" - "}\n" - "items {\n" - " items {\n" - " int32_value: -20\n" - " }\n" - " items {\n" - " text_value: \"Utf2\"\n" - " }\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueTupleElementsMismatch1) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .BeginTuple() - .AddElement() - .Int32(10) - .AddElement() - .String("Str1") - .EndTuple() - .AddListItem() - .BeginTuple() - .AddElement() - .Int32(-20) - .EndTuple() - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueTupleElementsMismatch2) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .BeginTuple() - .AddElement() - .Int32(10) - .AddElement() - .String("Str1") - .EndTuple() - .AddListItem() - .BeginTuple() - .AddElement() - .Int32(20) - .AddElement() - .String("Str2") - .AddElement() - .Uint64(1) - .EndTuple() - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueTupleTypeMismatch) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .BeginTuple() - .AddElement() - .Int32(10) - .AddElement() - .String("Str1") - .EndTuple() - .AddListItem() - .BeginTuple() - .AddElement() - .Int32(20) - .AddElement() - .Utf8("Utf2") - .EndTuple() - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } +TEST(YdbValue, BuildValueDict1) { + auto value = TValueBuilder() + .BeginDict() + .AddDictItem() + .DictKey(TValueBuilder().Int32(1).Build()) + .DictPayload(TValueBuilder().String("Str1").Build()) + .AddDictItem() + .DictKey() + .Int32(2) + .DictPayload() + .String("Str2") + .EndDict() + .Build(); + + auto expectedProtoValueStr = + "pairs {\n" + " key {\n" + " int32_value: 1\n" + " }\n" + " payload {\n" + " bytes_value: \"Str1\"\n" + " }\n" + "}\n" + "pairs {\n" + " key {\n" + " int32_value: 2\n" + " }\n" + " payload {\n" + " bytes_value: \"Str2\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} - UNIT_ASSERT(false); - } +TEST(YdbValue, BuildValueDict2) { + auto value = TValueBuilder() + .BeginDict() + .AddDictItem() + .DictKey() + .Int32(1) + .DictPayload() + .String("Str1") + .AddDictItem() + .DictKey(TValueBuilder().Int32(2).Build()) + .DictPayload(TValueBuilder().String("Str2").Build()) + .EndDict() + .Build(); + + auto expectedProtoValueStr = + "pairs {\n" + " key {\n" + " int32_value: 1\n" + " }\n" + " payload {\n" + " bytes_value: \"Str1\"\n" + " }\n" + "}\n" + "pairs {\n" + " key {\n" + " int32_value: 2\n" + " }\n" + " payload {\n" + " bytes_value: \"Str2\"\n" + " }\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} - Y_UNIT_TEST(BuildValueDict1) { +TEST(YdbValue, BuildValueDictTypeMismatch1) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginDict() .AddDictItem() @@ -1236,32 +1244,14 @@ Y_UNIT_TEST_SUITE(YdbValue) { .DictKey() .Int32(2) .DictPayload() - .String("Str2") + .Utf8("Utf2") .EndDict() .Build(); + }, TExpectedErrorException); +} - auto expectedProtoValueStr = - "pairs {\n" - " key {\n" - " int32_value: 1\n" - " }\n" - " payload {\n" - " bytes_value: \"Str1\"\n" - " }\n" - "}\n" - "pairs {\n" - " key {\n" - " int32_value: 2\n" - " }\n" - " payload {\n" - " bytes_value: \"Str2\"\n" - " }\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueDict2) { +TEST(YdbValue, BuildValueDictTypeMismatch2) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginDict() .AddDictItem() @@ -1270,281 +1260,210 @@ Y_UNIT_TEST_SUITE(YdbValue) { .DictPayload() .String("Str1") .AddDictItem() - .DictKey(TValueBuilder().Int32(2).Build()) + .DictKey(TValueBuilder().Uint32(2).Build()) .DictPayload(TValueBuilder().String("Str2").Build()) .EndDict() .Build(); + }, TExpectedErrorException); +} - auto expectedProtoValueStr = - "pairs {\n" - " key {\n" - " int32_value: 1\n" - " }\n" - " payload {\n" - " bytes_value: \"Str1\"\n" - " }\n" - "}\n" - "pairs {\n" - " key {\n" - " int32_value: 2\n" - " }\n" - " payload {\n" - " bytes_value: \"Str2\"\n" - " }\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueDictTypeMismatch1) { - try { - auto value = TValueBuilder() - .BeginDict() - .AddDictItem() - .DictKey(TValueBuilder().Int32(1).Build()) - .DictPayload(TValueBuilder().String("Str1").Build()) - .AddDictItem() - .DictKey() - .Int32(2) - .DictPayload() - .Utf8("Utf2") - .EndDict() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } +TEST(YdbValue, BuildValueDictEmpty1) { + auto value = TValueBuilder() + .EmptyDict( + TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build(), + TTypeBuilder().Primitive(EPrimitiveType::String).Build()) + .Build(); - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueDictTypeMismatch2) { - try { - auto value = TValueBuilder() - .BeginDict() - .AddDictItem() - .DictKey() - .Int32(1) - .DictPayload() - .String("Str1") - .AddDictItem() - .DictKey(TValueBuilder().Uint32(2).Build()) - .DictPayload(TValueBuilder().String("Str2").Build()) - .EndDict() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } + ASSERT_EQ(FormatType(value.GetType()), + R"(Dict)"); - UNIT_ASSERT(false); - } + auto expectedProtoValueStr = ""; + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} - Y_UNIT_TEST(BuildValueDictEmpty1) { - auto value = TValueBuilder() +TEST(YdbValue, BuildValueDictEmpty2) { + auto value = TValueBuilder() + .BeginList() + .AddListItem() + .BeginDict() + .AddDictItem() + .DictKey() + .Int32(1) + .DictPayload() + .String("Str1") + .EndDict() + .AddListItem() + .EmptyDict() + .AddListItem() .EmptyDict( - TTypeBuilder().Primitive(EPrimitiveType::Uint32).Build(), + TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(), TTypeBuilder().Primitive(EPrimitiveType::String).Build()) - .Build(); - - UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), - R"(Dict)"); - - auto expectedProtoValueStr = ""; - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } + .EndList() + .Build(); + + ASSERT_EQ(FormatType(value.GetType()), + R"(List>)"); + + auto expectedProtoValueStr = + "items {\n" + " pairs {\n" + " key {\n" + " int32_value: 1\n" + " }\n" + " payload {\n" + " bytes_value: \"Str1\"\n" + " }\n" + " }\n" + "}\n" + "items {\n" + "}\n" + "items {\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} - Y_UNIT_TEST(BuildValueDictEmpty2) { +TEST(YdbValue, BuildValueDictEmptyNoType) { + ASSERT_THROW({ auto value = TValueBuilder() .BeginList() - .AddListItem() - .BeginDict() - .AddDictItem() - .DictKey() - .Int32(1) - .DictPayload() - .String("Str1") - .EndDict() .AddListItem() .EmptyDict() + .EndList() + .Build(); + }, TExpectedErrorException); +} + +TEST(YdbValue, BuildValueDictEmptyTypeMismatch) { + ASSERT_THROW({ + auto value = TValueBuilder() + .BeginList() .AddListItem() .EmptyDict( TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(), TTypeBuilder().Primitive(EPrimitiveType::String).Build()) + .AddListItem() + .EmptyDict( + TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(), + TTypeBuilder().Primitive(EPrimitiveType::Utf8).Build()) .EndList() .Build(); + }, TExpectedErrorException); +} - UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), - R"(List>)"); - - auto expectedProtoValueStr = - "items {\n" - " pairs {\n" - " key {\n" - " int32_value: 1\n" - " }\n" - " payload {\n" - " bytes_value: \"Str1\"\n" - " }\n" - " }\n" - "}\n" - "items {\n" - "}\n" - "items {\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(BuildValueDictEmptyNoType) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .EmptyDict() - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueDictEmptyTypeMismatch) { - try { - auto value = TValueBuilder() - .BeginList() - .AddListItem() - .EmptyDict( - TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(), - TTypeBuilder().Primitive(EPrimitiveType::String).Build()) - .AddListItem() - .EmptyDict( - TTypeBuilder().Primitive(EPrimitiveType::Int32).Build(), - TTypeBuilder().Primitive(EPrimitiveType::Utf8).Build()) - .EndList() - .Build(); - } catch (const TExpectedErrorException& e) { - return; - } - - UNIT_ASSERT(false); - } - - Y_UNIT_TEST(BuildValueWithType) { - auto type = TTypeBuilder() - .BeginTuple() - .AddElement() - .BeginStruct() - .AddMember("Name") - .Primitive(EPrimitiveType::String) - .AddMember("Value") - .Primitive(EPrimitiveType::Uint64) - .EndStruct() - .AddElement() +TEST(YdbValue, BuildValueWithType) { + auto type = TTypeBuilder() + .BeginTuple() + .AddElement() + .BeginStruct() + .AddMember("Name") + .Primitive(EPrimitiveType::String) + .AddMember("Value") + .Primitive(EPrimitiveType::Uint64) + .EndStruct() + .AddElement() + .BeginOptional() + .Primitive(EPrimitiveType::Utf8) + .EndOptional() + .AddElement() + .BeginList() + .Primitive(EPrimitiveType::Bool) + .EndList() + .AddElement() + .BeginDict() + .DictKey() + .Primitive(EPrimitiveType::Int32) + .DictPayload() .BeginOptional() - .Primitive(EPrimitiveType::Utf8) + .Primitive(EPrimitiveType::Uint8) .EndOptional() - .AddElement() - .BeginList() - .Primitive(EPrimitiveType::Bool) - .EndList() - .AddElement() - .BeginDict() + .EndDict() + .AddElement() + .BeginOptional() + .Primitive(EPrimitiveType::DyNumber) + .EndOptional() + .EndTuple() + .Build(); + + auto value = TValueBuilder(type) + .BeginTuple() + .AddElement() + .BeginStruct() + .AddMember("Value") + .Uint64(1) + .AddMember("Name") + .String("Sergey") + .EndStruct() + .AddElement() + .EmptyOptional() + .AddElement() + .BeginList() + .AddListItem() + .Bool(true) + .EndList() + .AddElement() + .BeginDict() + .AddDictItem() .DictKey() - .Primitive(EPrimitiveType::Int32) + .Int32(10) .DictPayload() - .BeginOptional() - .Primitive(EPrimitiveType::Uint8) - .EndOptional() - .EndDict() - .AddElement() - .BeginOptional() - .Primitive(EPrimitiveType::DyNumber) - .EndOptional() - .EndTuple() - .Build(); - - auto value = TValueBuilder(type) - .BeginTuple() - .AddElement() - .BeginStruct() - .AddMember("Value") - .Uint64(1) - .AddMember("Name") - .String("Sergey") - .EndStruct() - .AddElement() - .EmptyOptional() - .AddElement() - .BeginList() - .AddListItem() - .Bool(true) - .EndList() - .AddElement() - .BeginDict() - .AddDictItem() - .DictKey() - .Int32(10) - .DictPayload() - .EmptyOptional() - .EndDict() - .AddElement() - .BeginOptional() - .DyNumber("12.345") - .EndOptional() - .EndTuple() - .Build(); + .EmptyOptional() + .EndDict() + .AddElement() + .BeginOptional() + .DyNumber("12.345") + .EndOptional() + .EndTuple() + .Build(); + + ASSERT_EQ(FormatType(value.GetType()), + R"(Tuple,Utf8?,List,Dict,DyNumber?>)"); + + auto expectedProtoValueStr = + "items {\n" + " items {\n" + " bytes_value: \"Sergey\"\n" + " }\n" + " items {\n" + " uint64_value: 1\n" + " }\n" + "}\n" + "items {\n" + " null_flag_value: NULL_VALUE\n" + "}\n" + "items {\n" + " items {\n" + " bool_value: true\n" + " }\n" + "}\n" + "items {\n" + " pairs {\n" + " key {\n" + " int32_value: 10\n" + " }\n" + " payload {\n" + " null_flag_value: NULL_VALUE\n" + " }\n" + " }\n" + "}\n" + "items {\n" + " text_value: \"12.345\"\n" + "}\n"; + + CheckProtoValue(value.GetProto(), expectedProtoValueStr); +} - UNIT_ASSERT_NO_DIFF(FormatType(value.GetType()), - R"(Tuple,Utf8?,List,Dict,DyNumber?>)"); - - auto expectedProtoValueStr = - "items {\n" - " items {\n" - " bytes_value: \"Sergey\"\n" - " }\n" - " items {\n" - " uint64_value: 1\n" - " }\n" - "}\n" - "items {\n" - " null_flag_value: NULL_VALUE\n" - "}\n" - "items {\n" - " items {\n" - " bool_value: true\n" - " }\n" - "}\n" - "items {\n" - " pairs {\n" - " key {\n" - " int32_value: 10\n" - " }\n" - " payload {\n" - " null_flag_value: NULL_VALUE\n" - " }\n" - " }\n" - "}\n" - "items {\n" - " text_value: \"12.345\"\n" - "}\n"; - - CheckProtoValue(value.GetProto(), expectedProtoValueStr); - } - - Y_UNIT_TEST(CorrectUuid) { - std::string uuidStr = "5ca32c22-841b-11e8-adc0-fa7ae01bbebc"; - TUuidValue uuid(uuidStr); - UNIT_ASSERT_VALUES_EQUAL(uuidStr, uuid.ToString()); - } - - Y_UNIT_TEST(IncorrectUuid) { - UNIT_ASSERT_EXCEPTION(TUuidValue(""), TContractViolation); - UNIT_ASSERT_EXCEPTION(TUuidValue("0123456789abcdef0123456789abcdef0123456789abcdef"), TContractViolation); - UNIT_ASSERT_EXCEPTION(TUuidValue("5ca32c22+841b-11e8-adc0-fa7ae01bbebc"), TContractViolation); - UNIT_ASSERT_EXCEPTION(TUuidValue("5ca32-c22841b-11e8-adc0-fa7ae01bbebc"), TContractViolation); - } +TEST(YdbValue, CorrectUuid) { + std::string uuidStr = "5ca32c22-841b-11e8-adc0-fa7ae01bbebc"; + TUuidValue uuid(uuidStr); + ASSERT_EQ(uuidStr, uuid.ToString()); +} +TEST(YdbValue, IncorrectUuid) { + ASSERT_THROW(TUuidValue(""), TContractViolation); + ASSERT_THROW(TUuidValue("0123456789abcdef0123456789abcdef0123456789abcdef"), TContractViolation); + ASSERT_THROW(TUuidValue("5ca32c22+841b-11e8-adc0-fa7ae01bbebc"), TContractViolation); + ASSERT_THROW(TUuidValue("5ca32-c22841b-11e8-adc0-fa7ae01bbebc"), TContractViolation); } } // namespace NYdb From 569c9631a90baef6e954ad4bcf18d07ede9e5207 Mon Sep 17 00:00:00 2001 From: Bulat Gayazov Date: Fri, 4 Apr 2025 16:02:22 +0000 Subject: [PATCH 3/3] fix --- tests/integration/basic_example/CMakeLists.txt | 3 +-- tests/integration/bulk_upsert/CMakeLists.txt | 3 +-- 2 files changed, 2 insertions(+), 4 deletions(-) diff --git a/tests/integration/basic_example/CMakeLists.txt b/tests/integration/basic_example/CMakeLists.txt index 573e9745a1..6178b80c71 100644 --- a/tests/integration/basic_example/CMakeLists.txt +++ b/tests/integration/basic_example/CMakeLists.txt @@ -1,4 +1,4 @@ -add_ydb_test(NAME basic-example +add_ydb_test(NAME basic-example GTEST SOURCES main.cpp basic_example_data.cpp @@ -9,7 +9,6 @@ add_ydb_test(NAME basic-example YDB-CPP-SDK::Driver YDB-CPP-SDK::Proto YDB-CPP-SDK::Table - GTest::gtest_main LABELS integration ) diff --git a/tests/integration/bulk_upsert/CMakeLists.txt b/tests/integration/bulk_upsert/CMakeLists.txt index fc7b29110d..8b8ef9741b 100644 --- a/tests/integration/bulk_upsert/CMakeLists.txt +++ b/tests/integration/bulk_upsert/CMakeLists.txt @@ -1,11 +1,10 @@ -add_ydb_test(NAME bulk_upsert +add_ydb_test(NAME bulk_upsert GTEST SOURCES main.cpp bulk_upsert.cpp LINK_LIBRARIES yutil YDB-CPP-SDK::Table - GTest::gtest_main LABELS integration )