ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-12-03 18:15:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: No ALL_CAPS (#1760)

Browse Source 
Fixes #1680
This commit is contained in:
Alex Kremer
2025-01-02 11:39:31 +00:00
committed by GitHub
parent efe5d08205
commit 820b32c6d7
361 changed files with 10061 additions and 9724 deletions
Download Patch File Download Diff File Expand all files Collapse all files

434
tests/unit/rpc/handlers/AccountTxTests.cpp
View File

@@ -42,19 +42,23 @@ using namespace rpc;
namespace json = boost::json;
using namespace testing;
constexpr static auto MINSEQ = 10;
constexpr static auto MAXSEQ = 30;
constexpr static auto ACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr static auto ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr static auto LEDGERHASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
constexpr static auto NFTID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF";
constexpr static auto NFTID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA";
constexpr static auto NFTID3 = "15FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF";
namespace {
constexpr auto kMIN_SEQ = 10;
constexpr auto kMAX_SEQ = 30;
constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr auto kLEDGER_HASH = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
constexpr auto kNFT_ID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF";
constexpr auto kNFT_ID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA";
constexpr auto kNFT_ID3 = "15FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF";
} // namespace
struct RPCAccountTxHandlerTest : HandlerBaseTest {
RPCAccountTxHandlerTest()
{
backend->setRange(MINSEQ, MAXSEQ);
backend_->setRange(kMIN_SEQ, kMAX_SEQ);
}
};
@@ -352,7 +356,7 @@ struct AccountTxParameterTest : public RPCAccountTxHandlerTest,
"ledger_index_min": 11,
"ledger_hash": "{}"
}})",
LEDGERHASH
kLEDGER_HASH
),
.expectedError = "invalidParams",
.expectedErrorMessage = "containsLedgerSpecifierAndRange"
@@ -366,7 +370,7 @@ struct AccountTxParameterTest : public RPCAccountTxHandlerTest,
"ledger_index_min": 11,
"ledger_hash": "{}"
}})",
LEDGERHASH
kLEDGER_HASH
),
.expectedError = std::nullopt,
.expectedErrorMessage = std::nullopt,
@@ -401,7 +405,7 @@ INSTANTIATE_TEST_CASE_P(
RPCAccountTxGroup1,
AccountTxParameterTest,
ValuesIn(AccountTxParameterTest::generateTestValuesForParametersTest()),
tests::util::NameGenerator
tests::util::kNAME_GENERATOR
);
TEST_P(AccountTxParameterTest, CheckParams)
@@ -413,7 +417,7 @@ TEST_P(AccountTxParameterTest, CheckParams)
ASSERT_TRUE(testBundle.expectedErrorMessage.has_value());
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
@@ -421,10 +425,10 @@ TEST_P(AccountTxParameterTest, CheckParams)
EXPECT_EQ(err.at("error_message").as_string(), *testBundle.expectedErrorMessage);
});
} else {
EXPECT_CALL(*backend, fetchAccountTransactions);
EXPECT_CALL(*backend_, fetchAccountTransactions);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
EXPECT_TRUE(output);
});
@@ -438,19 +442,19 @@ genTransactions(uint32_t seq1, uint32_t seq2)
{
auto transactions = std::vector<TransactionAndMetadata>{};
auto trans1 = TransactionAndMetadata();
ripple::STObject const obj = CreatePaymentTransactionObject(ACCOUNT, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32);
trans1.transaction = obj.getSerializer().peekData();
trans1.ledgerSequence = seq1;
ripple::STObject const metaObj = CreatePaymentTransactionMetaObject(ACCOUNT, ACCOUNT2, 22, 23);
ripple::STObject const metaObj = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23);
trans1.metadata = metaObj.getSerializer().peekData();
trans1.date = 1;
transactions.push_back(trans1);
auto trans2 = TransactionAndMetadata();
ripple::STObject const obj2 = CreatePaymentTransactionObject(ACCOUNT, ACCOUNT2, 1, 1, 32);
ripple::STObject const obj2 = createPaymentTransactionObject(kACCOUNT, kACCOUNT2, 1, 1, 32);
trans2.transaction = obj.getSerializer().peekData();
trans2.ledgerSequence = seq2;
ripple::STObject const metaObj2 = CreatePaymentTransactionMetaObject(ACCOUNT, ACCOUNT2, 22, 23);
ripple::STObject const metaObj2 = createPaymentTransactionMetaObject(kACCOUNT, kACCOUNT2, 22, 23);
trans2.metadata = metaObj2.getSerializer().peekData();
trans2.date = 2;
transactions.push_back(trans2);
@@ -462,22 +466,22 @@ genNFTTransactions(uint32_t seq)
{
auto transactions = std::vector<TransactionAndMetadata>{};
auto trans1 = CreateMintNFTTxWithMetadata(ACCOUNT, 1, 50, 123, NFTID);
auto trans1 = createMintNftTxWithMetadata(kACCOUNT, 1, 50, 123, kNFT_ID);
trans1.ledgerSequence = seq;
trans1.date = 1;
transactions.push_back(trans1);
auto trans2 = CreateAcceptNFTOfferTxWithMetadata(ACCOUNT, 1, 50, NFTID2);
auto trans2 = createAcceptNftOfferTxWithMetadata(kACCOUNT, 1, 50, kNFT_ID2);
trans2.ledgerSequence = seq;
trans2.date = 2;
transactions.push_back(trans2);
auto trans3 = CreateCancelNFTOffersTxWithMetadata(ACCOUNT, 1, 50, std::vector<std::string>{NFTID2, NFTID3});
auto trans3 = createCancelNftOffersTxWithMetadata(kACCOUNT, 1, 50, std::vector<std::string>{kNFT_ID2, kNFT_ID3});
trans3.ledgerSequence = seq;
trans3.date = 3;
transactions.push_back(trans3);
auto trans4 = CreateCreateNFTOfferTxWithMetadata(ACCOUNT, 1, 50, NFTID, 123, NFTID2);
auto trans4 = createCreateNftOfferTxWithMetadata(kACCOUNT, 1, 50, kNFT_ID, 123, kNFT_ID2);
trans4.ledgerSequence = seq;
trans4.date = 4;
transactions.push_back(trans4);
@@ -487,39 +491,39 @@ genNFTTransactions(uint32_t seq)
TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue)
{
auto const transactions = genTransactions(MINSEQ + 1, MAXSEQ - 1);
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
true,
testing::Optional(testing::Eq(TransactionsCursor{MINSEQ, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ, INT32_MAX})),
testing::_
)
)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
"ledger_index_max": {},
"forward": true
}})",
ACCOUNT,
MINSEQ + 1,
MAXSEQ - 1
kACCOUNT,
kMIN_SEQ + 1,
kMAX_SEQ - 1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ + 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ - 1);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1);
EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"({"ledger": 12, "seq": 34})"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 2);
EXPECT_FALSE(output.result->as_object().contains("limit"));
@@ -528,39 +532,39 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardTrue)
TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse)
{
auto const transactions = genTransactions(MINSEQ + 1, MAXSEQ - 1);
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ - 1, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
testing::_
)
)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
"ledger_index_max": {},
"forward": false
}})",
ACCOUNT,
MINSEQ + 1,
MAXSEQ - 1
kACCOUNT,
kMIN_SEQ + 1,
kMAX_SEQ - 1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ + 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ - 1);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1);
EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"({"ledger": 12, "seq": 34})"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 2);
EXPECT_FALSE(output.result->as_object().contains("limit"));
@@ -569,39 +573,39 @@ TEST_F(RPCAccountTxHandlerTest, IndexSpecificForwardFalse)
TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue)
{
auto const transactions = genTransactions(MINSEQ + 1, MAXSEQ - 1);
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
true,
testing::Optional(testing::Eq(TransactionsCursor{MINSEQ - 1, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMIN_SEQ - 1, INT32_MAX})),
testing::_
)
)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
"ledger_index_max": {},
"forward": true
}})",
ACCOUNT,
kACCOUNT,
-1,
-1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ);
EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"({"ledger": 12, "seq": 34})"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 2);
EXPECT_FALSE(output.result->as_object().contains("limit"));
@@ -610,39 +614,39 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardTrue)
TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse)
{
auto const transactions = genTransactions(MINSEQ + 1, MAXSEQ - 1);
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
testing::_
)
)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
"ledger_index_max": {},
"forward": false
}})",
ACCOUNT,
kACCOUNT,
-1,
-1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ);
EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"({"ledger": 12, "seq": 34})"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 2);
EXPECT_FALSE(output.result->as_object().contains("limit"));
@@ -651,39 +655,39 @@ TEST_F(RPCAccountTxHandlerTest, IndexNotSpecificForwardFalse)
TEST_F(RPCAccountTxHandlerTest, BinaryTrue)
{
auto const transactions = genTransactions(MINSEQ + 1, MAXSEQ - 1);
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
testing::_
)
)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
"ledger_index_max": {},
"binary": true
}})",
ACCOUNT,
kACCOUNT,
-1,
-1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ);
EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"({"ledger": 12, "seq": 34})"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 2);
EXPECT_EQ(
@@ -706,38 +710,38 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrue)
TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2)
{
auto const transactions = genTransactions(MINSEQ + 1, MAXSEQ - 1);
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
testing::_
)
)
.WillOnce(Return(transCursor));
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
"ledger_index_max": {},
"binary": true
}})",
ACCOUNT,
kACCOUNT,
-1,
-1
));
auto const output = handler.process(input, Context{.yield = yield, .apiVersion = 2u});
auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2u});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ);
EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"({"ledger": 12, "seq": 34})"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 2);
EXPECT_EQ(
@@ -760,11 +764,11 @@ TEST_F(RPCAccountTxHandlerTest, BinaryTrueV2)
TEST_F(RPCAccountTxHandlerTest, LimitAndMarker)
{
auto const transactions = genTransactions(MINSEQ + 1, MAXSEQ - 1);
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_, testing::_, false, testing::Optional(testing::Eq(TransactionsCursor{10, 11})), testing::_
)
@@ -772,8 +776,8 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
@@ -782,15 +786,15 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker)
"forward": false,
"marker": {{"ledger":10,"seq":11}}
}})",
ACCOUNT,
kACCOUNT,
-1,
-1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ);
EXPECT_EQ(output.result->at("limit").as_uint64(), 2);
EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"({"ledger": 12, "seq": 34})"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 2);
@@ -800,40 +804,40 @@ TEST_F(RPCAccountTxHandlerTest, LimitAndMarker)
TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndex)
{
// adjust the order for forward->false
auto const transactions = genTransactions(MAXSEQ - 1, MINSEQ + 1);
auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ - 1, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
testing::_
)
)
.Times(1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, MAXSEQ - 1);
EXPECT_CALL(*backend, fetchLedgerBySequence).Times(1);
ON_CALL(*backend, fetchLedgerBySequence(MAXSEQ - 1, _)).WillByDefault(Return(ledgerHeader));
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1);
EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1);
ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(ledgerHeader));
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index": {}
}})",
ACCOUNT,
MAXSEQ - 1
kACCOUNT,
kMAX_SEQ - 1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MAXSEQ - 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ - 1);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMAX_SEQ - 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1);
EXPECT_FALSE(output.result->as_object().contains("limit"));
EXPECT_FALSE(output.result->as_object().contains("marker"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 1);
@@ -842,20 +846,20 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndex)
TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerIntIndex)
{
EXPECT_CALL(*backend, fetchLedgerBySequence).Times(1);
ON_CALL(*backend, fetchLedgerBySequence(MAXSEQ - 1, _)).WillByDefault(Return(std::nullopt));
EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1);
ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(std::nullopt));
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index": {}
}})",
ACCOUNT,
MAXSEQ - 1
kACCOUNT,
kMAX_SEQ - 1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -865,20 +869,20 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerIntIndex)
TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerStringIndex)
{
EXPECT_CALL(*backend, fetchLedgerBySequence).Times(1);
ON_CALL(*backend, fetchLedgerBySequence(MAXSEQ - 1, _)).WillByDefault(Return(std::nullopt));
EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1);
ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ - 1, _)).WillByDefault(Return(std::nullopt));
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index": "{}"
}})",
ACCOUNT,
MAXSEQ - 1
kACCOUNT,
kMAX_SEQ - 1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -889,40 +893,40 @@ TEST_F(RPCAccountTxHandlerTest, SpecificNonexistLedgerStringIndex)
TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash)
{
// adjust the order for forward->false
auto const transactions = genTransactions(MAXSEQ - 1, MINSEQ + 1);
auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ - 1, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
testing::_
)
)
.Times(1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, MAXSEQ - 1);
EXPECT_CALL(*backend, fetchLedgerByHash).Times(1);
ON_CALL(*backend, fetchLedgerByHash(ripple::uint256{LEDGERHASH}, _)).WillByDefault(Return(ledgerHeader));
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ - 1);
EXPECT_CALL(*backend_, fetchLedgerByHash).Times(1);
ON_CALL(*backend_, fetchLedgerByHash(ripple::uint256{kLEDGER_HASH}, _)).WillByDefault(Return(ledgerHeader));
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_hash": "{}"
}})",
ACCOUNT,
LEDGERHASH
kACCOUNT,
kLEDGER_HASH
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MAXSEQ - 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ - 1);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMAX_SEQ - 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1);
EXPECT_FALSE(output.result->as_object().contains("limit"));
EXPECT_FALSE(output.result->as_object().contains("marker"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 1);
@@ -932,39 +936,39 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerHash)
TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndexValidated)
{
// adjust the order for forward->false
auto const transactions = genTransactions(MAXSEQ, MAXSEQ - 1);
auto const transactions = genTransactions(kMAX_SEQ, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})),
testing::_
)
)
.Times(1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, MAXSEQ);
EXPECT_CALL(*backend, fetchLedgerBySequence).Times(1);
ON_CALL(*backend, fetchLedgerBySequence(MAXSEQ, _)).WillByDefault(Return(ledgerHeader));
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ);
EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(1);
ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(ledgerHeader));
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index": "validated"
}})",
ACCOUNT
kACCOUNT
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MAXSEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMAX_SEQ);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ);
EXPECT_FALSE(output.result->as_object().contains("limit"));
EXPECT_FALSE(output.result->as_object().contains("marker"));
EXPECT_EQ(output.result->at("transactions").as_array().size(), 1);
@@ -973,39 +977,39 @@ TEST_F(RPCAccountTxHandlerTest, SpecificLedgerIndexValidated)
TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq)
{
auto const transactions = genTransactions(MAXSEQ - 1, MINSEQ + 1);
auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ - 1, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 1, INT32_MAX})),
testing::_
)
)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
"ledger_index_max": {},
"forward": false
}})",
ACCOUNT,
MINSEQ + 2,
MAXSEQ - 1
kACCOUNT,
kMIN_SEQ + 2,
kMAX_SEQ - 1
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ + 2);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ - 1);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 2);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 1);
EXPECT_EQ(output.result->at("transactions").as_array().size(), 1);
EXPECT_FALSE(output.result->as_object().contains("limit"));
EXPECT_FALSE(output.result->as_object().contains("marker"));
@@ -1014,39 +1018,39 @@ TEST_F(RPCAccountTxHandlerTest, TxLessThanMinSeq)
TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq)
{
auto const transactions = genTransactions(MAXSEQ - 1, MINSEQ + 1);
auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_,
testing::_,
false,
testing::Optional(testing::Eq(TransactionsCursor{MAXSEQ - 2, INT32_MAX})),
testing::Optional(testing::Eq(TransactionsCursor{kMAX_SEQ - 2, INT32_MAX})),
testing::_
)
)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
"ledger_index_max": {},
"forward": false
}})",
ACCOUNT,
MINSEQ + 1,
MAXSEQ - 2
kACCOUNT,
kMIN_SEQ + 1,
kMAX_SEQ - 2
));
auto const output = handler.process(input, Context{yield});
auto const output = handler.process(kINPUT, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("account").as_string(), ACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), MINSEQ + 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), MAXSEQ - 2);
EXPECT_EQ(output.result->at("account").as_string(), kACCOUNT);
EXPECT_EQ(output.result->at("ledger_index_min").as_uint64(), kMIN_SEQ + 1);
EXPECT_EQ(output.result->at("ledger_index_max").as_uint64(), kMAX_SEQ - 2);
EXPECT_EQ(output.result->at("transactions").as_array().size(), 1);
EXPECT_FALSE(output.result->as_object().contains("limit"));
EXPECT_EQ(output.result->at("marker").as_object(), json::parse(R"({"ledger": 12, "seq": 34})"));
@@ -1055,7 +1059,7 @@ TEST_F(RPCAccountTxHandlerTest, TxLargerThanMaxSeq)
TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
{
auto const OUT = R"({
auto const out = R"({
"account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"ledger_index_min": 10,
"ledger_index_max": 30,
@@ -1252,11 +1256,11 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
}
})";
auto const transactions = genNFTTransactions(MINSEQ + 1);
auto const transactions = genNFTTransactions(kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_, testing::_, false, testing::Optional(testing::Eq(TransactionsCursor{10, 11})), testing::_
)
@@ -1264,8 +1268,8 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
.Times(1);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
@@ -1273,19 +1277,19 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v1)
"forward": false,
"marker": {{"ledger": 10, "seq": 11}}
}})",
ACCOUNT,
kACCOUNT,
-1,
-1
));
auto const output = handler.process(input, Context{.yield = yield, .apiVersion = 1u});
auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 1u});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(OUT));
EXPECT_EQ(*output.result, json::parse(out));
});
}
TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
{
auto const OUT = R"({
auto const out = R"({
"account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"ledger_index_min": 10,
"ledger_index_max": 30,
@@ -1490,23 +1494,23 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
}
})";
auto const transactions = genNFTTransactions(MINSEQ + 1);
auto const transactions = genNFTTransactions(kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend,
*backend_,
fetchAccountTransactions(
testing::_, testing::_, false, testing::Optional(testing::Eq(TransactionsCursor{10, 11})), testing::_
)
)
.Times(1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, 11);
EXPECT_CALL(*backend, fetchLedgerBySequence).Times(transactions.size()).WillRepeatedly(Return(ledgerHeader));
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, 11);
EXPECT_CALL(*backend_, fetchLedgerBySequence).Times(transactions.size()).WillRepeatedly(Return(ledgerHeader));
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto static const input = json::parse(fmt::format(
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto static const kINPUT = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index_min": {},
@@ -1514,13 +1518,13 @@ TEST_F(RPCAccountTxHandlerTest, NFTTxs_API_v2)
"forward": false,
"marker": {{"ledger": 10, "seq": 11}}
}})",
ACCOUNT,
kACCOUNT,
-1,
-1
));
auto const output = handler.process(input, Context{.yield = yield, .apiVersion = 2u});
auto const output = handler.process(kINPUT, Context{.yield = yield, .apiVersion = 2u});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(OUT));
EXPECT_EQ(*output.result, json::parse(out));
});
}
@@ -2008,24 +2012,26 @@ INSTANTIATE_TEST_CASE_P(
RPCAccountTxTransactionTypeTest,
AccountTxTransactionTypeTest,
ValuesIn(generateTransactionTypeTestValues()),
tests::util::NameGenerator
tests::util::kNAME_GENERATOR
);
TEST_P(AccountTxTransactionTypeTest, SpecificTransactionType)
{
auto const transactions = genTransactions(MAXSEQ, MAXSEQ - 1);
auto const transactions = genTransactions(kMAX_SEQ, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(*backend, fetchAccountTransactions(_, _, false, Optional(Eq(TransactionsCursor{MAXSEQ, INT32_MAX})), _))
ON_CALL(*backend_, fetchAccountTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL(
*backend_, fetchAccountTransactions(_, _, false, Optional(Eq(TransactionsCursor{kMAX_SEQ, INT32_MAX})), _)
)
.Times(1);
auto const ledgerHeader = CreateLedgerHeader(LEDGERHASH, MAXSEQ);
ON_CALL(*backend, fetchLedgerBySequence(MAXSEQ, _)).WillByDefault(Return(ledgerHeader));
EXPECT_CALL(*backend, fetchLedgerBySequence(MAXSEQ, _)).Times(Between(1, 2));
auto const ledgerHeader = createLedgerHeader(kLEDGER_HASH, kMAX_SEQ);
ON_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).WillByDefault(Return(ledgerHeader));
EXPECT_CALL(*backend_, fetchLedgerBySequence(kMAX_SEQ, _)).Times(Between(1, 2));
auto const testBundle = GetParam();
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{AccountTxHandler{backend}};
auto const handler = AnyHandler{AccountTxHandler{backend_}};
auto const req = json::parse(testBundle.testJson);
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = testBundle.apiVersion});
EXPECT_TRUE(output);