ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-12-06 17:27:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Use std::expected instead of std::variant for errors (#2160)

Browse Source
This commit is contained in:
Ayaz Salikhov
2025-06-03 13:34:25 +01:00
committed by GitHub
parent 19257f8aa9
commit 550f0fae85
40 changed files with 295 additions and 310 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
tests/unit/rpc/ForwardingProxyTests.cpp
View File

@@ -318,8 +318,7 @@ TEST_F(RPCForwardingProxyTest, ForwardCallsBalancerWithCorrectParams)
auto const res = proxy_.forward(ctx);
auto const data = std::get_if<json::object>(&res.response);
EXPECT_TRUE(data != nullptr);
EXPECT_TRUE(res.response.has_value());
});
}
@@ -348,8 +347,7 @@ TEST_F(RPCForwardingProxyTest, ForwardingFailYieldsErrorStatus)
auto const res = proxy_.forward(ctx);
auto const status = std::get_if<Status>(&res.response);
EXPECT_TRUE(status != nullptr);
EXPECT_EQ(*status, rpc::ClioError::EtlInvalidResponse);
EXPECT_FALSE(res.response.has_value());
EXPECT_EQ(res.response.error(), rpc::ClioError::EtlInvalidResponse);
});
}

27
tests/unit/rpc/RPCEngineTests.cpp
View File

@@ -258,13 +258,11 @@ TEST_P(RPCEngineFlowParameterTest, Test)
);
auto const res = engine->buildResponse(ctx);
auto const status = std::get_if<rpc::Status>(&res.response);
auto const response = std::get_if<boost::json::object>(&res.response);
ASSERT_EQ(status == nullptr, testBundle.response.has_value());
ASSERT_EQ(res.response.has_value(), testBundle.response.has_value());
if (testBundle.response.has_value()) {
EXPECT_EQ(*response, testBundle.response.value());
EXPECT_EQ(res.response.value(), testBundle.response.value());
} else {
EXPECT_EQ(*status, testBundle.status.value());
EXPECT_EQ(res.response.error(), testBundle.status.value());
}
});
}
@@ -295,9 +293,8 @@ TEST_F(RPCEngineTest, ThrowDatabaseError)
);
auto const res = engine->buildResponse(ctx);
auto const status = std::get_if<rpc::Status>(&res.response);
ASSERT_TRUE(status != nullptr);
EXPECT_EQ(*status, Status{RippledError::rpcTOO_BUSY});
ASSERT_FALSE(res.response.has_value());
EXPECT_EQ(res.response.error(), Status{RippledError::rpcTOO_BUSY});
});
}
@@ -327,9 +324,8 @@ TEST_F(RPCEngineTest, ThrowException)
);
auto const res = engine->buildResponse(ctx);
auto const status = std::get_if<rpc::Status>(&res.response);
ASSERT_TRUE(status != nullptr);
EXPECT_EQ(*status, Status{RippledError::rpcINTERNAL});
ASSERT_FALSE(res.response.has_value());
EXPECT_EQ(res.response.error(), Status{RippledError::rpcINTERNAL});
});
}
@@ -454,8 +450,8 @@ TEST_P(RPCEngineCacheParameterTest, Test)
);
auto const res = engine->buildResponse(ctx);
auto const response = std::get_if<boost::json::object>(&res.response);
EXPECT_EQ(*response, boost::json::parse(R"JSON({ "computed": "world_50"})JSON").as_object());
ASSERT_TRUE(res.response.has_value());
EXPECT_EQ(res.response.value(), boost::json::parse(R"JSON({ "computed": "world_50"})JSON").as_object());
});
}
}
@@ -499,9 +495,8 @@ TEST_F(RPCEngineTest, NotCacheIfErrorHappen)
);
auto const res = engine->buildResponse(ctx);
auto const error = std::get_if<rpc::Status>(&res.response);
ASSERT_NE(error, nullptr);
EXPECT_EQ(*error, rpc::Status{"Very custom error"});
ASSERT_FALSE(res.response.has_value());
EXPECT_EQ(res.response.error(), rpc::Status{"Very custom error"});
});
}
}

45
tests/unit/rpc/RPCHelpersTests.cpp
View File

@@ -103,10 +103,9 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidIndexNotHex)
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, "nothex,10", yield, [](auto) {
});
auto status = std::get_if<Status>(&ret);
EXPECT_TRUE(status != nullptr);
EXPECT_EQ(*status, ripple::rpcINVALID_PARAMS);
EXPECT_EQ(status->message, "Malformed cursor.");
EXPECT_FALSE(ret.has_value());
EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS);
EXPECT_EQ(ret.error().message, "Malformed cursor.");
});
ctx_.run();
}
@@ -118,10 +117,9 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidPageNotInt)
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, "nothex,abc", yield, [](auto) {
});
auto status = std::get_if<Status>(&ret);
EXPECT_TRUE(status != nullptr);
EXPECT_EQ(*status, ripple::rpcINVALID_PARAMS);
EXPECT_EQ(status->message, "Malformed cursor.");
EXPECT_FALSE(ret.has_value());
EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS);
EXPECT_EQ(ret.error().message, "Malformed cursor.");
});
ctx_.run();
}
@@ -148,13 +146,10 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarker)
EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1);
boost::asio::spawn(ctx_, [this, &account](boost::asio::yield_context yield) {
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, {}, yield, [](auto) {
});
auto cursor = std::get_if<AccountCursor>(&ret);
EXPECT_TRUE(cursor != nullptr);
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, {}, yield, [](auto) {});
EXPECT_TRUE(ret.has_value());
EXPECT_EQ(
cursor->toString(),
ret.value().toString(),
"0000000000000000000000000000000000000000000000000000000000000000,"
"0"
);
@@ -192,10 +187,9 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker)
boost::asio::spawn(ctx_, [this, &account](boost::asio::yield_context yield) {
auto count = 0;
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, {}, yield, [&](auto) { count++; });
auto cursor = std::get_if<AccountCursor>(&ret);
EXPECT_TRUE(cursor != nullptr);
EXPECT_TRUE(ret.has_value());
EXPECT_EQ(count, 10);
EXPECT_EQ(cursor->toString(), fmt::format("{},0", kINDEX1));
EXPECT_EQ(ret.value().toString(), fmt::format("{},0", kINDEX1));
});
ctx_.run();
}
@@ -244,10 +238,9 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker)
boost::asio::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
auto count = 0;
auto ret = traverseOwnedNodes(*backend_, account, 9, kLIMIT, {}, yield, [&](auto) { count++; });
auto cursor = std::get_if<AccountCursor>(&ret);
EXPECT_TRUE(cursor != nullptr);
EXPECT_TRUE(ret.has_value());
EXPECT_EQ(count, kLIMIT);
EXPECT_EQ(cursor->toString(), fmt::format("{},{}", kINDEX1, kNEXT_PAGE));
EXPECT_EQ(ret.value().toString(), fmt::format("{},{}", kINDEX1, kNEXT_PAGE));
});
ctx_.run();
}
@@ -291,10 +284,9 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker)
auto ret = traverseOwnedNodes(
*backend_, account, 9, kLIMIT, fmt::format("{},{}", kINDEX1, kPAGE_NUM), yield, [&](auto) { count++; }
);
auto cursor = std::get_if<AccountCursor>(&ret);
EXPECT_TRUE(cursor != nullptr);
EXPECT_TRUE(ret.has_value());
EXPECT_EQ(count, kLIMIT);
EXPECT_EQ(cursor->toString(), fmt::format("{},{}", kINDEX1, kPAGE_NUM));
EXPECT_EQ(ret.value().toString(), fmt::format("{},{}", kINDEX1, kPAGE_NUM));
});
ctx_.run();
}
@@ -328,10 +320,9 @@ TEST_F(RPCHelpersTest, TraverseOwnedNodesWithUnexistingIndexMarker)
auto ret = traverseOwnedNodes(
*backend_, account, 9, kLIMIT, fmt::format("{},{}", kINDEX2, kPAGE_NUM), yield, [&](auto) { count++; }
);
auto status = std::get_if<Status>(&ret);
EXPECT_TRUE(status != nullptr);
EXPECT_EQ(*status, ripple::rpcINVALID_PARAMS);
EXPECT_EQ(status->message, "Invalid marker.");
EXPECT_FALSE(ret.has_value());
EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS);
EXPECT_EQ(ret.error().message, "Invalid marker.");
});
ctx_.run();
}

24
tests/unit/rpc/handlers/BookOffersTests.cpp
View File

@@ -611,12 +611,12 @@ generateNormalPathBookOffersTestBundles()
kPAYS20_USD_GETS10_XRP_BOOK_DIR
);
auto const getsXRPPaysUSDBook = getBookBase(std::get<ripple::Book>(
rpc::parseBook(ripple::to_currency("USD"), account, ripple::xrpCurrency(), ripple::xrpAccount())
));
auto const getsUSDPaysXRPBook = getBookBase(std::get<ripple::Book>(
rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), account)
));
auto const getsXRPPaysUSDBook = getBookBase(
rpc::parseBook(ripple::to_currency("USD"), account, ripple::xrpCurrency(), ripple::xrpAccount()).value()
);
auto const getsUSDPaysXRPBook = getBookBase(
rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), account).value()
);
auto const getsXRPPaysUSDInputJson = fmt::format(
R"JSON({{
@@ -1450,9 +1450,9 @@ TEST_F(RPCBookOffersHandlerTest, Limit)
// return valid book dir
EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1);
auto const getsXRPPaysUSDBook = getBookBase(std::get<ripple::Book>(
rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount())
));
auto const getsXRPPaysUSDBook = getBookBase(
rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount()).value()
);
ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _))
.WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}));
@@ -1523,9 +1523,9 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax)
// return valid book dir
EXPECT_CALL(*backend_, doFetchSuccessorKey).Times(1);
auto const getsXRPPaysUSDBook = getBookBase(std::get<ripple::Book>(
rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount())
));
auto const getsXRPPaysUSDBook = getBookBase(
rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount()).value()
);
ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, seq, _))
.WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}));

24
tests/unit/rpc/handlers/SubscribeTests.cpp
View File

@@ -822,13 +822,13 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothSnapshotSet)
auto const issuer = getAccountIdWithString(kACCOUNT);
auto const getsXRPPaysUSDBook = getBookBase(std::get<ripple::Book>(
rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount())
));
auto const getsXRPPaysUSDBook = getBookBase(
rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount()).value()
);
auto const reversedBook = getBookBase(std::get<ripple::Book>(
rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), issuer)
));
auto const reversedBook = getBookBase(
rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), issuer).value()
);
ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMAX_SEQ, _))
.WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}));
@@ -992,13 +992,13 @@ TEST_F(RPCSubscribeHandlerTest, BooksBothUnsetSnapshotSet)
auto const issuer = getAccountIdWithString(kACCOUNT);
auto const getsXRPPaysUSDBook = getBookBase(std::get<ripple::Book>(
rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount())
));
auto const getsXRPPaysUSDBook = getBookBase(
rpc::parseBook(ripple::to_currency("USD"), issuer, ripple::xrpCurrency(), ripple::xrpAccount()).value()
);
auto const reversedBook = getBookBase(std::get<ripple::Book>(
rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), issuer)
));
auto const reversedBook = getBookBase(
rpc::parseBook(ripple::xrpCurrency(), ripple::xrpAccount(), ripple::to_currency("USD"), issuer).value()
);
ON_CALL(*backend_, doFetchSuccessorKey(getsXRPPaysUSDBook, kMAX_SEQ, _))
.WillByDefault(Return(ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}));

4
tests/unit/rpc/handlers/UnsubscribeTests.cpp
View File

@@ -653,7 +653,7 @@ TEST_F(RPCUnsubscribeTest, Books)
));
auto const parsedBookMaybe = rpc::parseBook(input.as_object().at("books").as_array()[0].as_object());
auto const book = std::get<ripple::Book>(parsedBookMaybe);
auto const book = parsedBookMaybe.value();
EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(book, _)).Times(1);
EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(ripple::reversed(book), _)).Times(1);
@@ -686,7 +686,7 @@ TEST_F(RPCUnsubscribeTest, SingleBooks)
));
auto const parsedBookMaybe = rpc::parseBook(input.as_object().at("books").as_array()[0].as_object());
auto const book = std::get<ripple::Book>(parsedBookMaybe);
auto const book = parsedBookMaybe.value();
EXPECT_CALL(*mockSubscriptionManagerPtr_, unsubBook(book, _)).Times(1);