mirror of
https://github.com/XRPLF/clio.git
synced 2025-12-06 17:27:58 +00:00
450 lines
17 KiB
C++
450 lines
17 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
This file is part of clio: https://github.com/XRPLF/clio
|
|
Copyright (c) 2023, the clio developers.
|
|
|
|
Permission to use, copy, modify, and distribute this software for any
|
|
purpose with or without fee is hereby granted, provided that the above
|
|
copyright notice and this permission notice appear in all copies.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
//==============================================================================
|
|
|
|
#include <rpc/common/AnyHandler.h>
|
|
#include <rpc/handlers/Tx.h>
|
|
#include <util/Fixtures.h>
|
|
#include <util/TestObject.h>
|
|
|
|
#include <fmt/core.h>
|
|
|
|
using namespace rpc;
|
|
namespace json = boost::json;
|
|
using namespace testing;
|
|
|
|
auto constexpr static TXNID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD";
|
|
auto constexpr static NFTID = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF";
|
|
auto constexpr static NFTID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA";
|
|
auto constexpr static ACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
|
|
auto constexpr static ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
|
|
auto constexpr static CURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
|
|
|
|
auto constexpr static DEFAULT_OUT = R"({
|
|
"Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
|
|
"Fee": "2",
|
|
"Sequence": 100,
|
|
"SigningPubKey": "74657374",
|
|
"TakerGets": {
|
|
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
|
|
"issuer": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
|
|
"value": "200"
|
|
},
|
|
"TakerPays": "300",
|
|
"TransactionType": "OfferCreate",
|
|
"hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
|
|
"meta": {
|
|
"AffectedNodes": [
|
|
{
|
|
"CreatedNode": {
|
|
"LedgerEntryType": "Offer",
|
|
"NewFields": {
|
|
"TakerGets": "200",
|
|
"TakerPays": {
|
|
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
|
|
"issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
|
|
"value": "300"
|
|
}
|
|
}
|
|
}
|
|
}
|
|
],
|
|
"TransactionIndex": 100,
|
|
"TransactionResult": "tesSUCCESS"
|
|
},
|
|
"date": 123456,
|
|
"ledger_index": 100,
|
|
"validated": true
|
|
})";
|
|
|
|
class RPCTxTest : public HandlerBaseTest
|
|
{
|
|
};
|
|
|
|
TEST_F(RPCTxTest, ExcessiveLgrRange)
|
|
{
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}",
|
|
"min_ledger": 1,
|
|
"max_ledger": 1002
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_FALSE(output);
|
|
|
|
auto const err = rpc::makeError(output.error());
|
|
EXPECT_EQ(err.at("error").as_string(), "excessiveLgrRange");
|
|
EXPECT_EQ(err.at("error_message").as_string(), "Ledger range exceeds 1000.");
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, InvalidLgrRange)
|
|
{
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}",
|
|
"max_ledger": 1,
|
|
"min_ledger": 10
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_FALSE(output);
|
|
|
|
auto const err = rpc::makeError(output.error());
|
|
EXPECT_EQ(err.at("error").as_string(), "invalidLgrRange");
|
|
EXPECT_EQ(err.at("error_message").as_string(), "Ledger range is invalid.");
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, TxnNotFound)
|
|
{
|
|
auto const rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
|
|
.WillByDefault(Return(std::optional<TransactionAndMetadata>{}));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}"
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_FALSE(output);
|
|
|
|
auto const err = rpc::makeError(output.error());
|
|
EXPECT_EQ(err.at("error").as_string(), "txnNotFound");
|
|
EXPECT_EQ(err.at("error_message").as_string(), "Transaction not found.");
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse)
|
|
{
|
|
auto const rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
|
|
mockBackendPtr->updateRange(10); // min
|
|
mockBackendPtr->updateRange(30); // max
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
|
|
.WillByDefault(Return(std::optional<TransactionAndMetadata>{}));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}",
|
|
"min_ledger": 1,
|
|
"max_ledger": 1000
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_FALSE(output);
|
|
|
|
auto const err = rpc::makeError(output.error());
|
|
EXPECT_EQ(err.at("error").as_string(), "txnNotFound");
|
|
EXPECT_EQ(err.at("error_message").as_string(), "Transaction not found.");
|
|
EXPECT_EQ(err.at("searched_all").as_bool(), false);
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllTrue)
|
|
{
|
|
auto const rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
|
|
mockBackendPtr->updateRange(1); // min
|
|
mockBackendPtr->updateRange(1000); // max
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _))
|
|
.WillByDefault(Return(std::optional<TransactionAndMetadata>{}));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}",
|
|
"min_ledger": 1,
|
|
"max_ledger": 1000
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_FALSE(output);
|
|
|
|
auto const err = rpc::makeError(output.error());
|
|
EXPECT_EQ(err.at("error").as_string(), "txnNotFound");
|
|
EXPECT_EQ(err.at("error_message").as_string(), "Transaction not found.");
|
|
EXPECT_EQ(err.at("searched_all").as_bool(), true);
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, DefaultParameter_API_v1)
|
|
{
|
|
auto const rawBackendPtr = dynamic_cast<MockBackend*>(mockBackendPtr.get());
|
|
ASSERT_NE(rawBackendPtr, nullptr);
|
|
|
|
TransactionAndMetadata tx;
|
|
tx.metadata = CreateMetaDataForCreateOffer(CURRENCY, ACCOUNT, 100, 200, 300).getSerializer().peekData();
|
|
tx.transaction =
|
|
CreateCreateOfferTransactionObject(ACCOUNT, 2, 100, CURRENCY, ACCOUNT2, 200, 300).getSerializer().peekData();
|
|
tx.date = 123456;
|
|
tx.ledgerSequence = 100;
|
|
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}"
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1u});
|
|
ASSERT_TRUE(output);
|
|
|
|
auto v1Output = json::parse(DEFAULT_OUT);
|
|
v1Output.as_object()[JS(inLedger)] = v1Output.as_object()[JS(ledger_index)];
|
|
EXPECT_EQ(*output, v1Output);
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, DefaultParameter_API_v2)
|
|
{
|
|
auto const rawBackendPtr = dynamic_cast<MockBackend*>(mockBackendPtr.get());
|
|
ASSERT_NE(rawBackendPtr, nullptr);
|
|
|
|
TransactionAndMetadata tx;
|
|
tx.metadata = CreateMetaDataForCreateOffer(CURRENCY, ACCOUNT, 100, 200, 300).getSerializer().peekData();
|
|
tx.transaction =
|
|
CreateCreateOfferTransactionObject(ACCOUNT, 2, 100, CURRENCY, ACCOUNT2, 200, 300).getSerializer().peekData();
|
|
tx.date = 123456;
|
|
tx.ledgerSequence = 100;
|
|
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}"
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u});
|
|
ASSERT_TRUE(output);
|
|
EXPECT_EQ(*output, json::parse(DEFAULT_OUT));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, ReturnBinary)
|
|
{
|
|
// Note: `inLedger` is API v1 only. See DefaultOutput_*
|
|
auto constexpr static OUT = R"({
|
|
"meta": "201C00000064F8E311006FE864D50AA87BEE5380000158415500000000C1F76FF6ECB0BAC6000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA96540000000000000C8E1E1F1031000",
|
|
"tx": "120007240000006464400000000000012C65D5071AFD498D00000158415500000000C1F76FF6ECB0BAC600000000D31252CF902EF8DD8451243869B38667CBD89DF368400000000000000273047465737481144B4E9C06F24296074F7BC48F92A97916C6DC5EA9",
|
|
"hash": "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD",
|
|
"date": 123456,
|
|
"ledger_index": 100,
|
|
"inLedger": 100,
|
|
"validated": true
|
|
})";
|
|
auto const rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
|
|
TransactionAndMetadata tx;
|
|
tx.metadata = CreateMetaDataForCreateOffer(CURRENCY, ACCOUNT, 100, 200, 300).getSerializer().peekData();
|
|
tx.transaction =
|
|
CreateCreateOfferTransactionObject(ACCOUNT, 2, 100, CURRENCY, ACCOUNT2, 200, 300).getSerializer().peekData();
|
|
tx.date = 123456;
|
|
tx.ledgerSequence = 100;
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}",
|
|
"binary": true
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_TRUE(output);
|
|
EXPECT_EQ(*output, json::parse(OUT));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, MintNFT)
|
|
{
|
|
// Note: `inLedger` is API v1 only. See DefaultOutput_*
|
|
auto const static OUT = fmt::format(
|
|
R"({{
|
|
"Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
|
|
"Fee": "50",
|
|
"NFTokenTaxon": 123,
|
|
"Sequence": 1,
|
|
"SigningPubKey": "74657374",
|
|
"TransactionType": "NFTokenMint",
|
|
"hash": "C74463F49CFDCBEF3E9902672719918CDE5042DC7E7660BEBD1D1105C4B6DFF4",
|
|
"meta": {{
|
|
"AffectedNodes": [
|
|
{{
|
|
"ModifiedNode": {{
|
|
"FinalFields": {{
|
|
"NFTokens": [
|
|
{{
|
|
"NFToken":
|
|
{{
|
|
"NFTokenID": "{}",
|
|
"URI": "7465737475726C"
|
|
}}
|
|
}},
|
|
{{
|
|
"NFToken":
|
|
{{
|
|
"NFTokenID": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC",
|
|
"URI": "7465737475726C"
|
|
}}
|
|
}}
|
|
]
|
|
}},
|
|
"LedgerEntryType": "NFTokenPage",
|
|
"PreviousFields": {{
|
|
"NFTokens": [
|
|
{{
|
|
"NFToken":
|
|
{{
|
|
"NFTokenID": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC",
|
|
"URI": "7465737475726C"
|
|
}}
|
|
}}
|
|
]
|
|
}}
|
|
}}
|
|
}}
|
|
],
|
|
"TransactionIndex": 0,
|
|
"TransactionResult": "tesSUCCESS",
|
|
"nftoken_id": "{}"
|
|
}},
|
|
"date": 123456,
|
|
"ledger_index": 100,
|
|
"inLedger": 100,
|
|
"validated": true
|
|
}})",
|
|
NFTID,
|
|
NFTID);
|
|
TransactionAndMetadata tx = CreateMintNFTTxWithMetadata(ACCOUNT, 1, 50, 123, NFTID);
|
|
auto const rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
|
|
tx.date = 123456;
|
|
tx.ledgerSequence = 100;
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}"
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_TRUE(output);
|
|
EXPECT_EQ(*output, json::parse(OUT));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, NFTAcceptOffer)
|
|
{
|
|
TransactionAndMetadata tx = CreateAcceptNFTOfferTxWithMetadata(ACCOUNT, 1, 50, NFTID);
|
|
auto const rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
|
|
tx.date = 123456;
|
|
tx.ledgerSequence = 100;
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}"
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_TRUE(output);
|
|
EXPECT_EQ(output->at("meta").at("nftoken_id").as_string(), NFTID);
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, NFTCancelOffer)
|
|
{
|
|
std::vector<std::string> ids{NFTID, NFTID2};
|
|
TransactionAndMetadata tx = CreateCancelNFTOffersTxWithMetadata(ACCOUNT, 1, 50, ids);
|
|
auto const rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
|
|
tx.date = 123456;
|
|
tx.ledgerSequence = 100;
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
runSpawn([this, &ids](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}"
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_TRUE(output);
|
|
|
|
for (auto const& id : output->at("meta").at("nftoken_ids").as_array())
|
|
{
|
|
auto const idStr = id.as_string();
|
|
ids.erase(std::find(ids.begin(), ids.end(), std::string{idStr.c_str(), idStr.size()}));
|
|
}
|
|
|
|
EXPECT_TRUE(ids.empty());
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCTxTest, NFTCreateOffer)
|
|
{
|
|
TransactionAndMetadata tx = CreateCreateNFTOfferTxWithMetadata(ACCOUNT, 1, 50, NFTID, 123, NFTID2);
|
|
auto const rawBackendPtr = static_cast<MockBackend*>(mockBackendPtr.get());
|
|
tx.date = 123456;
|
|
tx.ledgerSequence = 100;
|
|
ON_CALL(*rawBackendPtr, fetchTransaction(ripple::uint256{TXNID}, _)).WillByDefault(Return(tx));
|
|
EXPECT_CALL(*rawBackendPtr, fetchTransaction).Times(1);
|
|
runSpawn([this](auto yield) {
|
|
auto const handler = AnyHandler{TxHandler{mockBackendPtr}};
|
|
auto const req = json::parse(fmt::format(
|
|
R"({{
|
|
"command": "tx",
|
|
"transaction": "{}"
|
|
}})",
|
|
TXNID));
|
|
auto const output = handler.process(req, Context{yield});
|
|
ASSERT_TRUE(output);
|
|
EXPECT_TRUE(output->at("meta").at("offer_id").as_string() == NFTID2);
|
|
});
|
|
}
|