ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-11-20 19:56:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

style: Fix formatting via clang-format (#1809)

Browse Source 
For #1760
This commit is contained in:
Peter Chen
2025-01-03 23:00:03 -05:00
committed by GitHub
parent 820b32c6d7
commit cce7aa2893
13 changed files with 351 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
tests/integration/migration/cassandra/CassandraMigrationManagerTests.cpp
View File

@@ -310,7 +310,8 @@ TEST_F(MigrationCassandraManagerLedgerTableTest, MigrateExampleLedgerMigrator)
EXPECT_EQ(newTableSize, gLedgerHeaderRawData.size()); EXPECT_EQ(newTableSize, gLedgerHeaderRawData.size());
auto const getAccountHash = [this](std::uint32_t seq) { auto const getAccountHash = [this](std::uint32_t seq) {
return data::synchronous([&](auto ctx) { return testMigrationBackend_->fetchAccountHashViaSequence(seq, ctx); }); return data::synchronous([&](auto ctx) { return testMigrationBackend_->fetchAccountHashViaSequence(seq, ctx); }
);
}; };
EXPECT_EQ( EXPECT_EQ(

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

@@ -646,31 +646,33 @@ generateNormalPathBookOffersTestBundles()
return std::vector<BookOffersNormalTestBundle>{ return std::vector<BookOffersNormalTestBundle>{
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{
.testName="PaysUSDGetsXRPNoFrozenOwnerFundEnough", .testName = "PaysUSDGetsXRPNoFrozenOwnerFundEnough",
.inputJson=getsXRPPaysUSDInputJson, .inputJson = getsXRPPaysUSDInputJson,
// prepare offer dir index // prepare offer dir index
.mockedSuccessors=std::map<ripple::uint256, std::optional<ripple::uint256>>{ .mockedSuccessors =
{getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, std::map<ripple::uint256, std::optional<ripple::uint256>>{
{ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional<ripple::uint256>{}} {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}},
}, {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional<ripple::uint256>{}}
.mockedLedgerObjects=std::map<ripple::uint256, ripple::Blob>{ },
// book dir object .mockedLedgerObjects =
{ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::map<ripple::uint256, ripple::Blob>{
createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // book dir object
// pays issuer account object {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR},
{ripple::keylet::account(account).key, createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()},
createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()}, // pays issuer account object
// owner account object {ripple::keylet::account(account).key,
{ripple::keylet::account(account2).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()},
createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()}, // owner account object
// fee settings: base ->3 inc->2, account2 has 2 objects ,total {ripple::keylet::account(account2).key,
// reserve ->7 createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()},
// owner_funds should be 193 // fee settings: base ->3 inc->2, account2 has 2 objects ,total
{ripple::keylet::fees().key, feeLedgerObject} // reserve ->7
}, // owner_funds should be 193
.ledgerObjectCalls=5, {ripple::keylet::fees().key, feeLedgerObject}
.mockedOffers=std::vector<ripple::STObject>{gets10XRPPays20USDOffer}, },
.expectedJson=fmt::format( .ledgerObjectCalls = 5,
.mockedOffers = std::vector<ripple::STObject>{gets10XRPPays20USDOffer},
.expectedJson = fmt::format(
R"({{ R"({{
"ledger_hash":"{}", "ledger_hash":"{}",
"ledger_index":300, "ledger_index":300,
@@ -704,31 +706,33 @@ generateNormalPathBookOffersTestBundles()
) )
}, },
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{
.testName="PaysUSDGetsXRPNoFrozenOwnerFundNotEnough", .testName = "PaysUSDGetsXRPNoFrozenOwnerFundNotEnough",
.inputJson=getsXRPPaysUSDInputJson, .inputJson = getsXRPPaysUSDInputJson,
// prepare offer dir index // prepare offer dir index
.mockedSuccessors=std::map<ripple::uint256, std::optional<ripple::uint256>>{ .mockedSuccessors =
{getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, std::map<ripple::uint256, std::optional<ripple::uint256>>{
{ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional<ripple::uint256>{}} {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}},
}, {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional<ripple::uint256>{}}
.mockedLedgerObjects=std::map<ripple::uint256, ripple::Blob>{ },
// book dir object .mockedLedgerObjects =
{ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::map<ripple::uint256, ripple::Blob>{
createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // book dir object
// pays issuer account object {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR},
{ripple::keylet::account(account).key, createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()},
createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()}, // pays issuer account object
// owner account object, hold {ripple::keylet::account(account).key,
{ripple::keylet::account(account2).key, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2).getSerializer().peekData()},
createAccountRootObject(kACCOUNT2, 0, 2, 5 + 7, 2, kINDEX1, 2).getSerializer().peekData()}, // owner account object, hold
// fee settings: base ->3 inc->2, account2 has 2 objects {ripple::keylet::account(account2).key,
// ,total createAccountRootObject(kACCOUNT2, 0, 2, 5 + 7, 2, kINDEX1, 2).getSerializer().peekData()},
// reserve ->7 // fee settings: base ->3 inc->2, account2 has 2 objects
{ripple::keylet::fees().key, feeLedgerObject} // ,total
}, // reserve ->7
.ledgerObjectCalls=5, {ripple::keylet::fees().key, feeLedgerObject}
.mockedOffers=std::vector<ripple::STObject>{gets10XRPPays20USDOffer}, },
.expectedJson=fmt::format( .ledgerObjectCalls = 5,
.mockedOffers = std::vector<ripple::STObject>{gets10XRPPays20USDOffer},
.expectedJson = fmt::format(
R"({{ R"({{
"ledger_hash":"{}", "ledger_hash":"{}",
"ledger_index":300, "ledger_index":300,
@@ -769,26 +773,28 @@ generateNormalPathBookOffersTestBundles()
) )
}, },
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{
.testName="PaysUSDGetsXRPFrozen", .testName = "PaysUSDGetsXRPFrozen",
.inputJson=getsXRPPaysUSDInputJson, .inputJson = getsXRPPaysUSDInputJson,
// prepare offer dir index // prepare offer dir index
.mockedSuccessors=std::map<ripple::uint256, std::optional<ripple::uint256>>{ .mockedSuccessors =
{getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}}, std::map<ripple::uint256, std::optional<ripple::uint256>>{
{ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional<ripple::uint256>{}} {getsXRPPaysUSDBook, ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}},
}, {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::optional<ripple::uint256>{}}
.mockedLedgerObjects=std::map<ripple::uint256, ripple::Blob>{ },
// book dir object .mockedLedgerObjects =
{ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR}, std::map<ripple::uint256, ripple::Blob>{
createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // book dir object
// pays issuer account object {ripple::uint256{kPAYS20_USD_GETS10_XRP_BOOK_DIR},
{ripple::keylet::account(account).key, createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()},
createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2) // pays issuer account object
.getSerializer() {ripple::keylet::account(account).key,
.peekData()} createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2)
}, .getSerializer()
.ledgerObjectCalls=3, .peekData()}
.mockedOffers=std::vector<ripple::STObject>{gets10XRPPays20USDOffer}, },
.expectedJson=fmt::format( .ledgerObjectCalls = 3,
.mockedOffers = std::vector<ripple::STObject>{gets10XRPPays20USDOffer},
.expectedJson = fmt::format(
R"({{ R"({{
"ledger_hash":"{}", "ledger_hash":"{}",
"ledger_index":300, "ledger_index":300,
@@ -829,26 +835,30 @@ generateNormalPathBookOffersTestBundles()
) )
}, },
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{
.testName="GetsUSDPaysXRPFrozen", .testName = "GetsUSDPaysXRPFrozen",
.inputJson=paysXRPGetsUSDInputJson, .inputJson = paysXRPGetsUSDInputJson,
// prepare offer dir index // prepare offer dir index
.mockedSuccessors=std::map<ripple::uint256, std::optional<ripple::uint256>>{ .mockedSuccessors =
{getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, std::map<ripple::uint256, std::optional<ripple::uint256>>{
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}} {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}},
}, {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}}
.mockedLedgerObjects=std::map<ripple::uint256, ripple::Blob>{ },
// book dir object .mockedLedgerObjects =
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::map<ripple::uint256, ripple::Blob>{
createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // book dir object
// gets issuer account object {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR},
{ripple::keylet::account(account).key, createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()},
createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) // gets issuer account object
.getSerializer() {ripple::keylet::account(account).key,
.peekData()} createAccountRootObject(
}, kACCOUNT, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2
.ledgerObjectCalls=3, )
.mockedOffers=std::vector<ripple::STObject>{gets10USDPays20XRPOffer}, .getSerializer()
.expectedJson=fmt::format( .peekData()}
},
.ledgerObjectCalls = 3,
.mockedOffers = std::vector<ripple::STObject>{gets10USDPays20XRPOffer},
.expectedJson = fmt::format(
R"({{ R"({{
"ledger_hash":"{}", "ledger_hash":"{}",
"ledger_index":300, "ledger_index":300,
@@ -890,29 +900,31 @@ generateNormalPathBookOffersTestBundles()
) )
}, },
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{
.testName="PaysXRPGetsUSDWithTransferFee", .testName = "PaysXRPGetsUSDWithTransferFee",
.inputJson=paysXRPGetsUSDInputJson, .inputJson = paysXRPGetsUSDInputJson,
// prepare offer dir index // prepare offer dir index
.mockedSuccessors=std::map<ripple::uint256, std::optional<ripple::uint256>>{ .mockedSuccessors =
{getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, std::map<ripple::uint256, std::optional<ripple::uint256>>{
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}} {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}},
}, {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}}
.mockedLedgerObjects=std::map<ripple::uint256, ripple::Blob>{ },
// book dir object .mockedLedgerObjects =
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::map<ripple::uint256, ripple::Blob>{
createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // book dir object
// gets issuer account object, rate is 1/2 {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR},
{ripple::keylet::account(account).key, createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()},
createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) // gets issuer account object, rate is 1/2
.getSerializer() {ripple::keylet::account(account).key,
.peekData()}, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2)
// trust line between gets issuer and owner,owner has 8 USD .getSerializer()
{ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, .peekData()},
trustline8Balance.getSerializer().peekData()}, // trust line between gets issuer and owner,owner has 8 USD
}, {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key,
.ledgerObjectCalls=6, trustline8Balance.getSerializer().peekData()},
.mockedOffers=std::vector<ripple::STObject>{gets10USDPays20XRPOffer}, },
.expectedJson=fmt::format( .ledgerObjectCalls = 6,
.mockedOffers = std::vector<ripple::STObject>{gets10USDPays20XRPOffer},
.expectedJson = fmt::format(
R"({{ R"({{
"ledger_hash":"{}", "ledger_hash":"{}",
"ledger_index":300, "ledger_index":300,
@@ -954,36 +966,39 @@ generateNormalPathBookOffersTestBundles()
) )
}, },
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{
.testName="PaysXRPGetsUSDWithMultipleOffers", .testName = "PaysXRPGetsUSDWithMultipleOffers",
.inputJson=paysXRPGetsUSDInputJson, .inputJson = paysXRPGetsUSDInputJson,
// prepare offer dir index // prepare offer dir index
.mockedSuccessors=std::map<ripple::uint256, std::optional<ripple::uint256>>{ .mockedSuccessors =
{getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, std::map<ripple::uint256, std::optional<ripple::uint256>>{
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}} {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}},
}, {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}}
.mockedLedgerObjects=std::map<ripple::uint256, ripple::Blob>{ },
// book dir object .mockedLedgerObjects =
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::map<ripple::uint256, ripple::Blob>{
createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1) // book dir object
.getSerializer() {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR},
.peekData()}, createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1)
// gets issuer account object .getSerializer()
{ripple::keylet::account(account).key, .peekData()},
createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) // gets issuer account object
.getSerializer() {ripple::keylet::account(account).key,
.peekData()}, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2)
// trust line between gets issuer and owner,owner has 30 USD .getSerializer()
{ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, .peekData()},
trustline30Balance.getSerializer().peekData()}, // trust line between gets issuer and owner,owner has 30 USD
}, {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key,
.ledgerObjectCalls=6, trustline30Balance.getSerializer().peekData()},
.mockedOffers=std::vector<ripple::STObject>{// After offer1, balance is 30 - 2*10 = 10 },
gets10USDPays20XRPOffer, .ledgerObjectCalls = 6,
// offer2 not fully funded, balance is 10, rate is 2, so only .mockedOffers =
// gets 5 std::vector<ripple::STObject>{// After offer1, balance is 30 - 2*10 = 10
gets10USDPays20XRPOffer gets10USDPays20XRPOffer,
}, // offer2 not fully funded, balance is 10, rate is 2, so only
.expectedJson=fmt::format( // gets 5
gets10USDPays20XRPOffer
},
.expectedJson = fmt::format(
R"({{ R"({{
"ledger_hash":"{}", "ledger_hash":"{}",
"ledger_index":300, "ledger_index":300,
@@ -1047,26 +1062,28 @@ generateNormalPathBookOffersTestBundles()
) )
}, },
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{
.testName="PaysXRPGetsUSDSellingOwnCurrency", .testName = "PaysXRPGetsUSDSellingOwnCurrency",
.inputJson=paysXRPGetsUSDInputJson, .inputJson = paysXRPGetsUSDInputJson,
// prepare offer dir index // prepare offer dir index
.mockedSuccessors=std::map<ripple::uint256, std::optional<ripple::uint256>>{ .mockedSuccessors =
{getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, std::map<ripple::uint256, std::optional<ripple::uint256>>{
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}} {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}},
}, {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}}
.mockedLedgerObjects=std::map<ripple::uint256, ripple::Blob>{ },
// book dir object .mockedLedgerObjects =
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::map<ripple::uint256, ripple::Blob>{
createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // book dir object
// gets issuer account object, rate is 1/2 {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR},
{ripple::keylet::account(account).key, createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()},
createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) // gets issuer account object, rate is 1/2
.getSerializer() {ripple::keylet::account(account).key,
.peekData()}, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2)
}, .getSerializer()
.ledgerObjectCalls=3, .peekData()},
.mockedOffers=std::vector<ripple::STObject>{gets10USDPays20XRPOwnerOffer}, },
.expectedJson=fmt::format( .ledgerObjectCalls = 3,
.mockedOffers = std::vector<ripple::STObject>{gets10USDPays20XRPOwnerOffer},
.expectedJson = fmt::format(
R"({{ R"({{
"ledger_hash":"{}", "ledger_hash":"{}",
"ledger_index":300, "ledger_index":300,
@@ -1102,29 +1119,31 @@ generateNormalPathBookOffersTestBundles()
) )
}, },
BookOffersNormalTestBundle{ BookOffersNormalTestBundle{
.testName="PaysXRPGetsUSDTrustLineFrozen", .testName = "PaysXRPGetsUSDTrustLineFrozen",
.inputJson=paysXRPGetsUSDInputJson, .inputJson = paysXRPGetsUSDInputJson,
// prepare offer dir index // prepare offer dir index
.mockedSuccessors=std::map<ripple::uint256, std::optional<ripple::uint256>>{ .mockedSuccessors =
{getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}}, std::map<ripple::uint256, std::optional<ripple::uint256>>{
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}} {getsUSDPaysXRPBook, ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}},
}, {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::optional<ripple::uint256>{}}
.mockedLedgerObjects=std::map<ripple::uint256, ripple::Blob>{ },
// book dir object .mockedLedgerObjects =
{ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR}, std::map<ripple::uint256, ripple::Blob>{
createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()}, // book dir object
// gets issuer account object, rate is 1/2 {ripple::uint256{kPAYS20_XRP_GETS10_USD_BOOK_DIR},
{ripple::keylet::account(account).key, createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1).getSerializer().peekData()},
createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2) // gets issuer account object, rate is 1/2
.getSerializer() {ripple::keylet::account(account).key,
.peekData()}, createAccountRootObject(kACCOUNT, 0, 2, 200, 2, kINDEX1, 2, kTRANSFER_RATE_X2)
// trust line between gets issuer and owner,owner has 8 USD .getSerializer()
{ripple::keylet::line(account2, account, ripple::to_currency("USD")).key, .peekData()},
frozenTrustLine.getSerializer().peekData()}, // trust line between gets issuer and owner,owner has 8 USD
}, {ripple::keylet::line(account2, account, ripple::to_currency("USD")).key,
.ledgerObjectCalls=6, frozenTrustLine.getSerializer().peekData()},
.mockedOffers=std::vector<ripple::STObject>{gets10USDPays20XRPOffer}, },
.expectedJson=fmt::format( .ledgerObjectCalls = 6,
.mockedOffers = std::vector<ripple::STObject>{gets10USDPays20XRPOffer},
.expectedJson = fmt::format(
R"({{ R"({{
"ledger_hash":"{}", "ledger_hash":"{}",
"ledger_index":300, "ledger_index":300,
@@ -1199,7 +1218,7 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaIntSequence)
)); ));
auto const handler = AnyHandler{BookOffersHandler{backend_}}; auto const handler = AnyHandler{BookOffersHandler{backend_}};
runSpawn([&](boost::asio::yield_context yield) { runSpawn([&](boost::asio::yield_context yield) {
auto const output = handler.process(kINPUT, Context{.yield=yield}); auto const output = handler.process(kINPUT, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -1230,7 +1249,7 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaSequence)
)); ));
auto const handler = AnyHandler{BookOffersHandler{backend_}}; auto const handler = AnyHandler{BookOffersHandler{backend_}};
runSpawn([&](boost::asio::yield_context yield) { runSpawn([&](boost::asio::yield_context yield) {
auto const output = handler.process(kINPUT, Context{.yield=yield}); auto const output = handler.process(kINPUT, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -1263,7 +1282,7 @@ TEST_F(RPCBookOffersHandlerTest, LedgerNonExistViaHash)
)); ));
auto const handler = AnyHandler{BookOffersHandler{backend_}}; auto const handler = AnyHandler{BookOffersHandler{backend_}};
runSpawn([&](boost::asio::yield_context yield) { runSpawn([&](boost::asio::yield_context yield) {
auto const output = handler.process(kINPUT, Context{.yield=yield}); auto const output = handler.process(kINPUT, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -1338,7 +1357,7 @@ TEST_F(RPCBookOffersHandlerTest, Limit)
)); ));
auto const handler = AnyHandler{BookOffersHandler{backend_}}; auto const handler = AnyHandler{BookOffersHandler{backend_}};
runSpawn([&](boost::asio::yield_context yield) { runSpawn([&](boost::asio::yield_context yield) {
auto const output = handler.process(kINPUT, Context{.yield=yield}); auto const output = handler.process(kINPUT, Context{.yield = yield});
ASSERT_TRUE(output); ASSERT_TRUE(output);
EXPECT_EQ(output.result.value().as_object().at("offers").as_array().size(), 5); EXPECT_EQ(output.result.value().as_object().at("offers").as_array().size(), 5);
}); });
@@ -1412,7 +1431,7 @@ TEST_F(RPCBookOffersHandlerTest, LimitMoreThanMax)
)); ));
auto const handler = AnyHandler{BookOffersHandler{backend_}}; auto const handler = AnyHandler{BookOffersHandler{backend_}};
runSpawn([&](boost::asio::yield_context yield) { runSpawn([&](boost::asio::yield_context yield) {
auto const output = handler.process(kINPUT, Context{.yield=yield}); auto const output = handler.process(kINPUT, Context{.yield = yield});
ASSERT_TRUE(output); ASSERT_TRUE(output);
EXPECT_EQ(output.result.value().as_object().at("offers").as_array().size(), BookOffersHandler::kLIMIT_MAX); EXPECT_EQ(output.result.value().as_object().at("offers").as_array().size(), BookOffersHandler::kLIMIT_MAX);
}); });

93
tests/unit/rpc/handlers/GatewayBalancesTests.cpp
View File

@@ -444,8 +444,8 @@ generateNormalPathTestBundles()
overflowState.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue("JPY", kISSUER), min64, 80)); overflowState.setFieldAmount(ripple::sfBalance, ripple::STAmount(getIssue("JPY", kISSUER), min64, 80));
return std::vector<NormalTestBundle>{ return std::vector<NormalTestBundle>{
NormalTestBundle{ NormalTestBundle{
.testName="AllBranches", .testName = "AllBranches",
.mockedDir=createOwnerDirLedgerObject( .mockedDir = createOwnerDirLedgerObject(
{ripple::uint256{kINDEX2}, {ripple::uint256{kINDEX2},
ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2},
ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2},
@@ -454,20 +454,22 @@ generateNormalPathTestBundles()
ripple::uint256{kINDEX2}}, ripple::uint256{kINDEX2}},
kINDEX1 kINDEX1
), ),
.mockedObjects=std::vector{// hotwallet .mockedObjects =
createRippleStateLedgerObject("USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123), std::vector{
// hotwallet // hotwallet
createRippleStateLedgerObject("CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123), createRippleStateLedgerObject("USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
// positive balance -> asset // hotwallet
createRippleStateLedgerObject("EUR", kISSUER, 30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123), createRippleStateLedgerObject("CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
// positive balance -> asset // positive balance -> asset
createRippleStateLedgerObject("JPY", kISSUER, 40, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123), createRippleStateLedgerObject("EUR", kISSUER, 30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123),
// obligation // positive balance -> asset
createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123), createRippleStateLedgerObject("JPY", kISSUER, 40, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123),
frozenState // obligation
createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123),
frozenState
}, },
.expectedJson=fmt::format( .expectedJson = fmt::format(
R"({{ R"({{
"obligations":{{ "obligations":{{
"JPY":"50" "JPY":"50"
@@ -513,13 +515,15 @@ generateNormalPathTestBundles()
kACCOUNT3, kACCOUNT3,
kACCOUNT kACCOUNT
), ),
.hotwallet=fmt::format(R"("hotwallet": "{}")", kACCOUNT2) .hotwallet = fmt::format(R"("hotwallet": "{}")", kACCOUNT2)
}, },
NormalTestBundle{ NormalTestBundle{
.testName="NoHotwallet", .testName = "NoHotwallet",
.mockedDir=createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1), .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}}, kINDEX1),
.mockedObjects=std::vector{createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123)}, .mockedObjects = std::vector{createRippleStateLedgerObject(
.expectedJson=fmt::format( "JPY", kISSUER, -50, kACCOUNT, 10, kACCOUNT3, 20, kTXN_ID, 123
)},
.expectedJson = fmt::format(
R"({{ R"({{
"obligations":{{ "obligations":{{
"JPY":"50" "JPY":"50"
@@ -533,10 +537,10 @@ generateNormalPathTestBundles()
.hotwallet = R"("ledger_index" : "validated")" .hotwallet = R"("ledger_index" : "validated")"
}, },
NormalTestBundle{ NormalTestBundle{
.testName="ObligationOverflow", .testName = "ObligationOverflow",
.mockedDir=createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1), .mockedDir = createOwnerDirLedgerObject({ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1),
.mockedObjects=std::vector{overflowState, overflowState}, .mockedObjects = std::vector{overflowState, overflowState},
.expectedJson=fmt::format( .expectedJson = fmt::format(
R"({{ R"({{
"obligations":{{ "obligations":{{
"JPY":"9999999999999999e80" "JPY":"9999999999999999e80"
@@ -550,20 +554,22 @@ generateNormalPathTestBundles()
.hotwallet = R"("ledger_index" : "validated")" .hotwallet = R"("ledger_index" : "validated")"
}, },
NormalTestBundle{ NormalTestBundle{
.testName="HighID", .testName = "HighID",
.mockedDir=createOwnerDirLedgerObject( .mockedDir = createOwnerDirLedgerObject(
{ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2} {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}
}, },
kINDEX1 kINDEX1
), ),
.mockedObjects=std::vector{// hotwallet .mockedObjects =
createRippleStateLedgerObject("USD", kISSUER, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123), std::vector{
// hotwallet // hotwallet
createRippleStateLedgerObject("CNY", kISSUER, 20, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123), createRippleStateLedgerObject("USD", kISSUER, 10, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123),
createRippleStateLedgerObject("EUR", kISSUER, 30, kACCOUNT3, 100, kACCOUNT, 200, kTXN_ID, 123), // hotwallet
createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT3, 10, kACCOUNT, 20, kTXN_ID, 123) createRippleStateLedgerObject("CNY", kISSUER, 20, kACCOUNT2, 100, kACCOUNT, 200, kTXN_ID, 123),
}, createRippleStateLedgerObject("EUR", kISSUER, 30, kACCOUNT3, 100, kACCOUNT, 200, kTXN_ID, 123),
.expectedJson=fmt::format( createRippleStateLedgerObject("JPY", kISSUER, -50, kACCOUNT3, 10, kACCOUNT, 20, kTXN_ID, 123)
},
.expectedJson = fmt::format(
R"({{ R"({{
"obligations":{{ "obligations":{{
"EUR":"30" "EUR":"30"
@@ -596,19 +602,20 @@ generateNormalPathTestBundles()
kACCOUNT3, kACCOUNT3,
kACCOUNT kACCOUNT
), ),
.hotwallet=fmt::format(R"("hotwallet": "{}")", kACCOUNT2) .hotwallet = fmt::format(R"("hotwallet": "{}")", kACCOUNT2)
}, },
NormalTestBundle{ NormalTestBundle{
.testName="HotWalletArray", .testName = "HotWalletArray",
.mockedDir=createOwnerDirLedgerObject( .mockedDir = createOwnerDirLedgerObject(
{ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1 {ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}, ripple::uint256{kINDEX2}}, kINDEX1
), ),
.mockedObjects=std::vector{ .mockedObjects =
createRippleStateLedgerObject("USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123), std::vector{
createRippleStateLedgerObject("CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123), createRippleStateLedgerObject("USD", kISSUER, -10, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
createRippleStateLedgerObject("EUR", kISSUER, -30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123) createRippleStateLedgerObject("CNY", kISSUER, -20, kACCOUNT, 100, kACCOUNT2, 200, kTXN_ID, 123),
createRippleStateLedgerObject("EUR", kISSUER, -30, kACCOUNT, 100, kACCOUNT3, 200, kTXN_ID, 123)
}, },
.expectedJson = fmt::format( .expectedJson = fmt::format(
R"({{ R"({{
"balances":{{ "balances":{{
@@ -637,7 +644,7 @@ generateNormalPathTestBundles()
kACCOUNT2, kACCOUNT2,
kACCOUNT kACCOUNT
), ),
.hotwallet=fmt::format(R"("hotwallet": ["{}", "{}"])", kACCOUNT2, kACCOUNT3) .hotwallet = fmt::format(R"("hotwallet": ["{}", "{}"])", kACCOUNT2, kACCOUNT3)
}, },
}; };
} }

30
tests/unit/rpc/handlers/LedgerIndexTests.cpp
View File

@@ -130,12 +130,30 @@ public:
{ {
// start from 2024-06-25T12:23:10Z to 2024-06-25T12:23:50Z with step 2 // start from 2024-06-25T12:23:10Z to 2024-06-25T12:23:50Z with step 2
return std::vector<LedgerIndexTestsCaseBundle>{ return std::vector<LedgerIndexTestsCaseBundle>{
{.testName="LaterThanMaxLedger", .json=R"({"date": "2024-06-25T12:23:55Z"})", .expectedLedgerIndex=kRANGE_MAX, .closeTimeIso="2024-06-25T12:23:50Z"}, {.testName = "LaterThanMaxLedger",
{.testName="GreaterThanMinLedger", .json=R"({"date": "2024-06-25T12:23:11Z"})", .expectedLedgerIndex=kRANGE_MIN, .closeTimeIso="2024-06-25T12:23:10Z"}, .json = R"({"date": "2024-06-25T12:23:55Z"})",
{.testName="IsMinLedger", .json=R"({"date": "2024-06-25T12:23:10Z"})", .expectedLedgerIndex=kRANGE_MIN, .closeTimeIso="2024-06-25T12:23:10Z"}, .expectedLedgerIndex = kRANGE_MAX,
{.testName="IsMaxLedger", .json=R"({"date": "2024-06-25T12:23:50Z"})", .expectedLedgerIndex=kRANGE_MAX, .closeTimeIso="2024-06-25T12:23:50Z"}, .closeTimeIso = "2024-06-25T12:23:50Z"},
{.testName="IsMidLedger", .json=R"({"date": "2024-06-25T12:23:30Z"})", .expectedLedgerIndex=20, .closeTimeIso="2024-06-25T12:23:30Z"}, {.testName = "GreaterThanMinLedger",
{.testName="BetweenLedgers", .json=R"({"date": "2024-06-25T12:23:29Z"})", .expectedLedgerIndex=19, .closeTimeIso="2024-06-25T12:23:28Z"} .json = R"({"date": "2024-06-25T12:23:11Z"})",
.expectedLedgerIndex = kRANGE_MIN,
.closeTimeIso = "2024-06-25T12:23:10Z"},
{.testName = "IsMinLedger",
.json = R"({"date": "2024-06-25T12:23:10Z"})",
.expectedLedgerIndex = kRANGE_MIN,
.closeTimeIso = "2024-06-25T12:23:10Z"},
{.testName = "IsMaxLedger",
.json = R"({"date": "2024-06-25T12:23:50Z"})",
.expectedLedgerIndex = kRANGE_MAX,
.closeTimeIso = "2024-06-25T12:23:50Z"},
{.testName = "IsMidLedger",
.json = R"({"date": "2024-06-25T12:23:30Z"})",
.expectedLedgerIndex = 20,
.closeTimeIso = "2024-06-25T12:23:30Z"},
{.testName = "BetweenLedgers",
.json = R"({"date": "2024-06-25T12:23:29Z"})",
.expectedLedgerIndex = 19,
.closeTimeIso = "2024-06-25T12:23:28Z"}
}; };
} }
}; };

14
tests/unit/rpc/handlers/LedgerTests.cpp
View File

@@ -766,10 +766,11 @@ TEST_F(RPCLedgerHandlerTest, DiffNotBinary)
EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1); EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1);
los.push_back(LedgerObject{.key=ripple::uint256{kINDEX2}, .blob=Blob{}}); // NOLINT(modernize-use-emplace) los.push_back(LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace)
los.push_back(LedgerObject{ los.push_back(LedgerObject{
.key=ripple::uint256{kINDEX1}, .key = ripple::uint256{kINDEX1},
.blob=createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3).getSerializer().peekData() .blob =
createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3).getSerializer().peekData()
}); });
ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los)); ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los));
@@ -809,10 +810,11 @@ TEST_F(RPCLedgerHandlerTest, DiffBinary)
EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1); EXPECT_CALL(*backend_, fetchLedgerDiff).Times(1);
los.push_back(LedgerObject{.key=ripple::uint256{kINDEX2}, .blob=Blob{}}); // NOLINT(modernize-use-emplace) los.push_back(LedgerObject{.key = ripple::uint256{kINDEX2}, .blob = Blob{}}); // NOLINT(modernize-use-emplace)
los.push_back(LedgerObject{ los.push_back(LedgerObject{
.key=ripple::uint256{kINDEX1}, .key = ripple::uint256{kINDEX1},
.blob=createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3).getSerializer().peekData() .blob =
createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kINDEX1, 3).getSerializer().peekData()
}); });
ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los)); ON_CALL(*backend_, fetchLedgerDiff(kRANGE_MAX, _)).WillByDefault(Return(los));

22
tests/unit/rpc/handlers/MPTHoldersTests.cpp
View File

@@ -264,7 +264,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerStringIndex)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; auto const handler = AnyHandler{MPTHoldersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -285,7 +285,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIntIndex)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; auto const handler = AnyHandler{MPTHoldersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -311,7 +311,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerHash2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; auto const handler = AnyHandler{MPTHoldersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -334,7 +334,7 @@ TEST_F(RPCMPTHoldersHandlerTest, NonExistLedgerViaLedgerIndex2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{MPTHoldersHandler{backend_}}; auto const handler = AnyHandler{MPTHoldersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -361,7 +361,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MPTNotFound)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{MPTHoldersHandler{this->backend_}}; auto handler = AnyHandler{MPTHoldersHandler{this->backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "objectNotFound"); EXPECT_EQ(err.at("error").as_string(), "objectNotFound");
@@ -391,7 +391,7 @@ TEST_F(RPCMPTHoldersHandlerTest, DefaultParameters)
auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID));
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()}; std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}})); ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_)
@@ -439,7 +439,7 @@ TEST_F(RPCMPTHoldersHandlerTest, CustomAmounts)
auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID), 0); auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID), 0);
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()}; std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}})); ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_)
@@ -485,7 +485,7 @@ TEST_F(RPCMPTHoldersHandlerTest, SpecificLedgerIndex)
auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID));
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()}; std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}})); ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
fetchMPTHolders( fetchMPTHolders(
@@ -534,7 +534,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MarkerParameter)
auto const mptoken = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID)); auto const mptoken = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID));
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()}; std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
auto const marker = getAccountIdWithString(kHOLDE_R1_ACCOUNT); auto const marker = getAccountIdWithString(kHOLDE_R1_ACCOUNT);
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor=marker})); ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = marker}));
EXPECT_CALL( EXPECT_CALL(
*backend_, fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(marker), Const(30), testing::_) *backend_, fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(marker), Const(30), testing::_)
) )
@@ -580,7 +580,7 @@ TEST_F(RPCMPTHoldersHandlerTest, MultipleMPTs)
auto const mptoken1 = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); auto const mptoken1 = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID));
auto const mptoken2 = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID)); auto const mptoken2 = createMpTokenObject(kHOLDE_R2_ACCOUNT, ripple::uint192(kMPT_ID));
std::vector<Blob> const mpts = {mptoken1.getSerializer().peekData(), mptoken2.getSerializer().peekData()}; std::vector<Blob> const mpts = {mptoken1.getSerializer().peekData(), mptoken2.getSerializer().peekData()};
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}})); ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_) fetchMPTHolders(ripple::uint192(kMPT_ID), testing::_, testing::Eq(std::nullopt), Const(30), testing::_)
@@ -622,7 +622,7 @@ TEST_F(RPCMPTHoldersHandlerTest, LimitMoreThanMAx)
auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID)); auto const mptoken = createMpTokenObject(kHOLDE_R1_ACCOUNT, ripple::uint192(kMPT_ID));
std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()}; std::vector<Blob> const mpts = {mptoken.getSerializer().peekData()};
ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens=mpts, .cursor={}})); ON_CALL(*backend_, fetchMPTHolders).WillByDefault(Return(MPTHoldersAndCursor{.mptokens = mpts, .cursor = {}}));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
fetchMPTHolders( fetchMPTHolders(

10
tests/unit/rpc/handlers/NFTBuyOffersTests.cpp
View File

@@ -229,7 +229,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
@@ -253,7 +253,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -279,7 +279,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerHash2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -302,7 +302,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NonExistLedgerViaLedgerIndex2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -328,7 +328,7 @@ TEST_F(RPCNFTBuyOffersHandlerTest, NoNFT)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}}; auto const handler = AnyHandler{NFTBuyOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "objectNotFound"); EXPECT_EQ(err.at("error").as_string(), "objectNotFound");

26
tests/unit/rpc/handlers/NFTHistoryTests.cpp
View File

@@ -290,7 +290,7 @@ genTransactions(uint32_t seq1, uint32_t seq2)
TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue) TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardTrue)
{ {
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -434,7 +434,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV1)
})"; })";
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -585,7 +585,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV2)
})"; })";
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
fetchNFTTransactions( fetchNFTTransactions(
@@ -624,7 +624,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexSpecificForwardFalseV2)
TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue) TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue)
{ {
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -661,7 +661,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardTrue)
TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse) TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse)
{ {
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -702,7 +702,7 @@ TEST_F(RPCNFTHistoryHandlerTest, IndexNotSpecificForwardFalse)
TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1) TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1)
{ {
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -757,7 +757,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV1)
TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2) TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2)
{ {
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
fetchNFTTransactions( fetchNFTTransactions(
@@ -811,7 +811,7 @@ TEST_F(RPCNFTHistoryHandlerTest, BinaryTrueV2)
TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker) TEST_F(RPCNFTHistoryHandlerTest, LimitAndMarker)
{ {
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -851,7 +851,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerIndex)
{ {
// adjust the order for forward->false // adjust the order for forward->false
auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -940,7 +940,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerHash)
{ {
// adjust the order for forward->false // adjust the order for forward->false
auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -982,7 +982,7 @@ TEST_F(RPCNFTHistoryHandlerTest, SpecificLedgerHash)
TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq) TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq)
{ {
auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -1023,7 +1023,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLessThanMinSeq)
TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq) TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq)
{ {
auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1); auto const transactions = genTransactions(kMAX_SEQ - 1, kMIN_SEQ + 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
@@ -1064,7 +1064,7 @@ TEST_F(RPCNFTHistoryHandlerTest, TxLargerThanMaxSeq)
TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax) TEST_F(RPCNFTHistoryHandlerTest, LimitMoreThanMax)
{ {
auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1); auto const transactions = genTransactions(kMIN_SEQ + 1, kMAX_SEQ - 1);
auto const transCursor = TransactionsAndCursor{.txns=transactions, .cursor=TransactionsCursor{12, 34}}; auto const transCursor = TransactionsAndCursor{.txns = transactions, .cursor = TransactionsCursor{12, 34}};
ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor)); ON_CALL(*backend_, fetchNFTTransactions).WillByDefault(Return(transCursor));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,

12
tests/unit/rpc/handlers/NFTInfoTests.cpp
View File

@@ -167,7 +167,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTInfoHandler{backend_}}; auto const handler = AnyHandler{NFTInfoHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
@@ -191,7 +191,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerStringIndex)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTInfoHandler{backend_}}; auto const handler = AnyHandler{NFTInfoHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -213,7 +213,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIntIndex)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTInfoHandler{backend_}}; auto const handler = AnyHandler{NFTInfoHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -239,7 +239,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerHash2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTInfoHandler{backend_}}; auto const handler = AnyHandler{NFTInfoHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -262,7 +262,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistLedgerViaLedgerIndex2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTInfoHandler{backend_}}; auto const handler = AnyHandler{NFTInfoHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -289,7 +289,7 @@ TEST_F(RPCNFTInfoHandlerTest, NonExistNFT)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTInfoHandler{backend_}}; auto const handler = AnyHandler{NFTInfoHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "objectNotFound"); EXPECT_EQ(err.at("error").as_string(), "objectNotFound");

10
tests/unit/rpc/handlers/NFTSellOffersTests.cpp
View File

@@ -229,7 +229,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; auto const handler = AnyHandler{NFTSellOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
@@ -253,7 +253,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; auto const handler = AnyHandler{NFTSellOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -279,7 +279,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerHash2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; auto const handler = AnyHandler{NFTSellOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -302,7 +302,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NonExistLedgerViaLedgerIndex2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; auto const handler = AnyHandler{NFTSellOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -328,7 +328,7 @@ TEST_F(RPCNFTSellOffersHandlerTest, NoNFT)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTSellOffersHandler{backend_}}; auto const handler = AnyHandler{NFTSellOffersHandler{backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "objectNotFound"); EXPECT_EQ(err.at("error").as_string(), "objectNotFound");

25
tests/unit/rpc/handlers/NFTsByIssuerTest.cpp
View File

@@ -225,7 +225,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
@@ -248,7 +248,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerStringIndex)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -269,7 +269,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIntIndex)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -295,7 +295,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerHash2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -318,7 +318,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, NonExistLedgerViaLedgerIndex2)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}}; auto const handler = AnyHandler{NFTsByIssuerHandler{backend_}};
auto const output = handler.process(input, Context{.yield=std::ref(yield)}); auto const output = handler.process(input, Context{.yield = std::ref(yield)});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound"); EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
@@ -345,7 +345,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, AccountNotFound)
)); ));
runSpawn([&, this](boost::asio::yield_context yield) { runSpawn([&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{NFTsByIssuerHandler{this->backend_}}; auto handler = AnyHandler{NFTsByIssuerHandler{this->backend_}};
auto const output = handler.process(input, Context{.yield=yield}); auto const output = handler.process(input, Context{.yield = yield});
ASSERT_FALSE(output); ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error()); auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "actNotFound"); EXPECT_EQ(err.at("error").as_string(), "actNotFound");
@@ -375,7 +375,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, DefaultParameters)
std::vector<NFT> const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; std::vector<NFT> const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)};
auto const account = getAccountIdWithString(kACCOUNT); auto const account = getAccountIdWithString(kACCOUNT);
ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts=nfts, .cursor={}})); ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}}));
EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(30), _, Eq(std::nullopt), _)).Times(1); EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(30), _, Eq(std::nullopt), _)).Times(1);
auto const input = json::parse(fmt::format( auto const input = json::parse(fmt::format(
@@ -427,7 +427,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, SpecificLedgerIndex)
std::vector<NFT> const nfts = {createNft(kNFT_ID1, kACCOUNT, specificLedger)}; std::vector<NFT> const nfts = {createNft(kNFT_ID1, kACCOUNT, specificLedger)};
auto const account = getAccountIdWithString(kACCOUNT); auto const account = getAccountIdWithString(kACCOUNT);
ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts=nfts, .cursor={}})); ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}}));
EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(specificLedger), _, Eq(std::nullopt), _)) EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(specificLedger), _, Eq(std::nullopt), _))
.Times(1); .Times(1);
@@ -469,7 +469,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, TaxonParameter)
std::vector<NFT> const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; std::vector<NFT> const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)};
auto const account = getAccountIdWithString(kACCOUNT); auto const account = getAccountIdWithString(kACCOUNT);
ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts=nfts, .cursor={}})); ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}}));
EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Optional(0), Const(30), _, Eq(std::nullopt), _)).Times(1); EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Optional(0), Const(30), _, Eq(std::nullopt), _)).Times(1);
auto const input = json::parse(fmt::format( auto const input = json::parse(fmt::format(
@@ -509,7 +509,8 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MarkerParameter)
std::vector<NFT> const nfts = {createNft(kNFT_ID3, kACCOUNT, 29)}; std::vector<NFT> const nfts = {createNft(kNFT_ID3, kACCOUNT, 29)};
auto const account = getAccountIdWithString(kACCOUNT); auto const account = getAccountIdWithString(kACCOUNT);
ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts=nfts, .cursor=ripple::uint256{kNFT_ID3}})); ON_CALL(*backend_, fetchNFTsByIssuer)
.WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = ripple::uint256{kNFT_ID3}}));
EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(ripple::uint256{kNFT_ID1}), _)).Times(1); EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, _, Const(30), _, Eq(ripple::uint256{kNFT_ID1}), _)).Times(1);
auto const input = json::parse(fmt::format( auto const input = json::parse(fmt::format(
@@ -553,7 +554,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, MultipleNFTs)
createNft(kNFT_ID1, kACCOUNT, 29), createNft(kNFT_ID2, kACCOUNT, 29), createNft(kNFT_ID3, kACCOUNT, 29) createNft(kNFT_ID1, kACCOUNT, 29), createNft(kNFT_ID2, kACCOUNT, 29), createNft(kNFT_ID3, kACCOUNT, 29)
}; };
auto const account = getAccountIdWithString(kACCOUNT); auto const account = getAccountIdWithString(kACCOUNT);
ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts=nfts, .cursor={}})); ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}}));
EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(30), _, Eq(std::nullopt), _)).Times(1); EXPECT_CALL(*backend_, fetchNFTsByIssuer(account, Eq(std::nullopt), Const(30), _, Eq(std::nullopt), _)).Times(1);
auto const input = json::parse(fmt::format( auto const input = json::parse(fmt::format(
@@ -591,7 +592,7 @@ TEST_F(RPCNFTsByIssuerHandlerTest, LimitMoreThanMax)
std::vector<NFT> const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)}; std::vector<NFT> const nfts = {createNft(kNFT_ID1, kACCOUNT, 29)};
auto const account = getAccountIdWithString(kACCOUNT); auto const account = getAccountIdWithString(kACCOUNT);
ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts=nfts, .cursor={}})); ON_CALL(*backend_, fetchNFTsByIssuer).WillByDefault(Return(NFTsAndCursor{.nfts = nfts, .cursor = {}}));
EXPECT_CALL( EXPECT_CALL(
*backend_, *backend_,
fetchNFTsByIssuer(account, Eq(std::nullopt), Const(30), NFTsByIssuerHandler::kLIMIT_MAX, Eq(std::nullopt), _) fetchNFTsByIssuer(account, Eq(std::nullopt), Const(30), NFTsByIssuerHandler::kLIMIT_MAX, Eq(std::nullopt), _)

17
tests/unit/web/RPCServerHandlerTests.cpp
View File

@@ -855,12 +855,17 @@ auto
generateInvalidVersions() generateInvalidVersions()
{ {
return std::vector<InvalidAPIVersionTestBundle>{ return std::vector<InvalidAPIVersionTestBundle>{
{.testName="v0", .version="0", .wsMessage=fmt::format("Requested API version is lower than minimum supported ({})", rpc::kAPI_VERSION_MIN)}, {.testName = "v0",
{.testName="v4", .version="4", .wsMessage=fmt::format("Requested API version is higher than maximum supported ({})", rpc::kAPI_VERSION_MAX)}, .version = "0",
{.testName="null", .version="null", .wsMessage="API version must be an integer"}, .wsMessage = fmt::format("Requested API version is lower than minimum supported ({})", rpc::kAPI_VERSION_MIN)},
{.testName="str", .version="\"bogus\"", .wsMessage="API version must be an integer"}, {.testName = "v4",
{.testName="bool", .version="false", .wsMessage="API version must be an integer"}, .version = "4",
{.testName="double", .version="12.34", .wsMessage="API version must be an integer"}, .wsMessage = fmt::format("Requested API version is higher than maximum supported ({})", rpc::kAPI_VERSION_MAX)
},
{.testName = "null", .version = "null", .wsMessage = "API version must be an integer"},
{.testName = "str", .version = "\"bogus\"", .wsMessage = "API version must be an integer"},
{.testName = "bool", .version = "false", .wsMessage = "API version must be an integer"},
{.testName = "double", .version = "12.34", .wsMessage = "API version must be an integer"},
}; };
} }

8
tests/unit/web/ng/impl/ConnectionHandlerTests.cpp
View File

@@ -69,13 +69,7 @@ struct ConnectionHandlerTest : SyncAsioContextTest {
: tagFactory{util::config::ClioConfigDefinition{ : tagFactory{util::config::ClioConfigDefinition{
{"log_tag_style", config::ConfigValue{config::ConfigType::String}.defaultValue("uint")} {"log_tag_style", config::ConfigValue{config::ConfigType::String}.defaultValue("uint")}
}} }}
, connectionHandler{ , connectionHandler{policy, maxParallelConnections, tagFactory, std::nullopt, onDisconnectMock.AsStdFunction()}
policy,
maxParallelConnections,
tagFactory,
std::nullopt,
onDisconnectMock.AsStdFunction()
}
{ {
} }