ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2026-06-04 01:06:45 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
eaf770ccca0094934a451e97702a04f3ccd6118d
clio/tests/unit/rpc/handlers/TxTests.cpp
Alex Kremer dbc98894ba refactor: Rename static constants (#3073)
2026-05-13 12:09:06 +01:00

1166 lines
42 KiB
C++
Raw Blame History

#include "data/Types.hpp"
#include "etl/ETLState.hpp"
#include "rpc/Errors.hpp"
#include "rpc/common/AnyHandler.hpp"
#include "rpc/common/Types.hpp"
#include "rpc/handlers/Tx.hpp"
#include "util/HandlerBaseTestFixture.hpp"
#include "util/MockETLService.hpp"
#include "util/TestObject.hpp"
#include <boost/json/parse.hpp>
#include <fmt/format.h>
#include <gmock/gmock.h>
#include <gtest/gtest.h>
#include <xrpl/basics/base_uint.h>
#include <algorithm>
#include <cctype>
#include <optional>
#include <string>
#include <vector>
using namespace rpc;
using namespace data;
namespace json = boost::json;
using namespace testing;
using TestTxHandler = TxHandler;
namespace {
constexpr auto kTxnId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD";
constexpr auto kNftId = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DF";
constexpr auto kNftID2 = "05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DA";
constexpr auto kLedgerHash = "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
constexpr auto kAccount = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr auto kAccount2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr auto kCurrency = "0158415500000000C1F76FF6ECB0BAC600000000";
constexpr auto kCtid = "C002807000010002"; // seq 163952 txindex 1 netid 2
constexpr auto kSeqFromCtid = 163952;
constexpr auto kDefaultOuT1 = R"JSON({
"Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"Fee": "2",
"Sequence": 100,
"SigningPubKey": "74657374",
"TakerGets": {
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
"issuer": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
"value": "200"
},
"TakerPays": "300",
"TransactionType": "OfferCreate",
"hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
"ctid": "C000006400640000",
"meta": {
"AffectedNodes": [
{
"CreatedNode": {
"LedgerEntryType": "Offer",
"NewFields": {
"TakerGets": "200",
"TakerPays": {
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
"issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"value": "300"
}
}
}
}
],
"TransactionIndex": 100,
"TransactionResult": "tesSUCCESS"
},
"date": 123456,
"ledger_index": 100,
"inLedger": 100,
"validated": true
})JSON";
constexpr auto kDefaultOuT2 = R"JSON({
"hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
"ledger_hash": "4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652",
"ledger_index": 100,
"meta": {
"AffectedNodes": [
{
"CreatedNode": {
"LedgerEntryType": "Offer",
"NewFields": {
"TakerGets": "200",
"TakerPays": {
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
"issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"value": "300"
}
}
}
}
],
"TransactionIndex": 100,
"TransactionResult": "tesSUCCESS"
},
"ctid": "C000006400640000",
"tx_json": {
"Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"ctid": "C000006400640000",
"date": 123456,
"Fee": "2",
"ledger_index": 100,
"Sequence": 100,
"SigningPubKey": "74657374",
"TakerGets": {
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
"issuer": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
"value": "200"
},
"TakerPays": "300",
"TransactionType": "OfferCreate"
},
"close_time_iso": "2000-01-01T00:00:00Z",
"validated": true
})JSON";
constexpr auto kIndex = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322";
} // namespace
class RPCTxTest : public HandlerBaseTest {};
TEST_F(RPCTxTest, ExcessiveLgrRange)
{
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"min_ledger": 1,
"max_ledger": 1002
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "excessiveLgrRange");
EXPECT_EQ(err.at("error_message").as_string(), "Ledger range exceeds 1000.");
});
}
TEST_F(RPCTxTest, InvalidBinaryV1)
{
TransactionAndMetadata tx;
tx.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData();
tx.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"binary": 12
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1u});
ASSERT_TRUE(output);
});
}
TEST_F(RPCTxTest, InvalidBinaryV2)
{
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"binary": 12
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
});
}
TEST_F(RPCTxTest, InvalidLgrRange)
{
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"max_ledger": 1,
"min_ledger": 10
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.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)
{
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _))
.WillOnce(Return(std::optional<TransactionAndMetadata>{}));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "txnNotFound");
EXPECT_EQ(err.at("error_message").as_string(), "Transaction not found.");
});
}
TEST_F(RPCTxTest, TxnNotFoundInGivenRangeSearchAllFalse)
{
backend_->setRange(10, 30);
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _))
.WillOnce(Return(std::optional<TransactionAndMetadata>{}));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"min_ledger": 1,
"max_ledger": 1000
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.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)
{
backend_->setRange(1, 1000);
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _))
.WillOnce(Return(std::optional<TransactionAndMetadata>{}));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"min_ledger": 1,
"max_ledger": 1000
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.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);
});
}
// when ledger range and ctid are provided, searched_all should not be present, because the seq is
// specified in ctid
TEST_F(RPCTxTest, CtidNotFoundSearchAllFalse)
{
backend_->setRange(1, 1000);
EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeqFromCtid, _))
.WillOnce(Return(std::vector<TransactionAndMetadata>{}));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{2}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"ctid": "{}",
"min_ledger": 1,
"max_ledger": 1000
}})JSON",
kCtid
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "txnNotFound");
EXPECT_EQ(err.at("error_message").as_string(), "Transaction not found.");
EXPECT_FALSE(err.contains("searched_all"));
});
}
TEST_F(RPCTxTest, DefaultParameter_API_v1)
{
TransactionAndMetadata tx;
tx.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData();
tx.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1u});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(kDefaultOuT1));
});
}
TEST_F(RPCTxTest, PaymentTx_API_v1)
{
TransactionAndMetadata tx;
tx.transaction =
createPaymentTransactionObject(kAccount, kAccount2, 2, 3, 300).getSerializer().peekData();
tx.metadata =
createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 1u});
ASSERT_TRUE(output);
EXPECT_TRUE(output.result->as_object().contains("DeliverMax"));
EXPECT_EQ(output.result->at("Amount"), output.result->at("DeliverMax"));
});
}
TEST_F(RPCTxTest, PaymentTx_API_v2)
{
TransactionAndMetadata tx;
tx.transaction =
createPaymentTransactionObject(kAccount, kAccount2, 2, 3, 300).getSerializer().peekData();
tx.metadata =
createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _))
.WillOnce(Return(std::nullopt));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u});
ASSERT_TRUE(output);
EXPECT_TRUE(output.result->as_object().contains("tx_json"));
EXPECT_TRUE(output.result->as_object().at("tx_json").as_object().contains("DeliverMax"));
EXPECT_FALSE(output.result->as_object().at("tx_json").as_object().contains("Amount"));
});
}
TEST_F(RPCTxTest, DefaultParameter_API_v2)
{
TransactionAndMetadata tx;
tx.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData();
tx.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const ledgerHeader = createLedgerHeader(kLedgerHash, tx.ledgerSequence);
EXPECT_CALL(*backend_, fetchLedgerBySequence(tx.ledgerSequence, _))
.WillOnce(Return(ledgerHeader));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{.yield = yield, .apiVersion = 2u});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(kDefaultOuT2));
});
}
TEST_F(RPCTxTest, ReturnBinary)
{
// Note: `inLedger` is API v1 only. See DefaultOutput_*
static constexpr auto kOut = R"JSON({
"meta": "201C00000064F8E311006FE864D50AA87BEE5380000158415500000000C1F76FF6ECB0BAC6000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA96540000000000000C8E1E1F1031000",
"tx": "120007240000006464400000000000012C65D5071AFD498D00000158415500000000C1F76FF6ECB0BAC600000000D31252CF902EF8DD8451243869B38667CBD89DF368400000000000000273047465737481144B4E9C06F24296074F7BC48F92A97916C6DC5EA9",
"hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
"date": 123456,
"ledger_index": 100,
"inLedger": 100,
"validated": true,
"ctid": "C000006400640000"
})JSON";
TransactionAndMetadata tx;
tx.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData();
tx.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"binary": true
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(kOut));
});
}
// mimic 1.12 rippled, return ctid when binary is true. This will be changed on rippled.
TEST_F(RPCTxTest, ReturnBinaryWithCTID)
{
// Note: `inLedger` is API v1 only. See DefaultOutput_*
static constexpr auto kOut = R"JSON({
"meta": "201C00000064F8E311006FE864D50AA87BEE5380000158415500000000C1F76FF6ECB0BAC6000000004B4E9C06F24296074F7BC48F92A97916C6DC5EA96540000000000000C8E1E1F1031000",
"tx": "120007240000006464400000000000012C65D5071AFD498D00000158415500000000C1F76FF6ECB0BAC600000000D31252CF902EF8DD8451243869B38667CBD89DF368400000000000000273047465737481144B4E9C06F24296074F7BC48F92A97916C6DC5EA9",
"hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
"date": 123456,
"ledger_index": 100,
"inLedger": 100,
"ctid": "C000006400640002",
"validated": true
})JSON";
TransactionAndMetadata tx;
tx.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData();
tx.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 2}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"binary": true
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(kOut));
});
}
TEST_F(RPCTxTest, MintNFT)
{
// Note: `inLedger` is API v1 only. See DefaultOutput_*
static auto const kOut = fmt::format(
R"JSON({{
"Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"Fee": "50",
"NFTokenTaxon": 123,
"Sequence": 1,
"SigningPubKey": "74657374",
"TransactionType": "NFTokenMint",
"hash": "C74463F49CFDCBEF3E9902672719918CDE5042DC7E7660BEBD1D1105C4B6DFF4",
"ctid": "C000006400000000",
"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
}})JSON",
kNftId,
kNftId
);
TransactionAndMetadata tx = createMintNftTxWithMetadata(kAccount, 1, 50, 123, kNftId);
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(kOut));
});
}
TEST_F(RPCTxTest, NFTAcceptOffer)
{
TransactionAndMetadata tx =
createAcceptNftBuyerOfferTxWithMetadata(kAccount, 1, 50, kNftId, kIndex);
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("meta").at("nftoken_id").as_string(), kNftId);
});
}
TEST_F(RPCTxTest, NFTCancelOffer)
{
std::vector<std::string> ids{kNftId, kNftID2};
TransactionAndMetadata tx = createCancelNftOffersTxWithMetadata(kAccount, 1, 50, ids);
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this, &ids](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
for (auto const& id : output.result->at("meta").at("nftoken_ids").as_array()) {
auto const idStr = id.as_string();
auto const it =
std::find(ids.begin(), ids.end(), idStr); // NOLINT(modernize-use-ranges)
ASSERT_NE(it, ids.end()) << "Unexpected NFT ID: " << idStr;
ids.erase(it);
}
EXPECT_TRUE(ids.empty());
});
}
TEST_F(RPCTxTest, NFTCreateOffer)
{
TransactionAndMetadata tx =
createCreateNftOfferTxWithMetadata(kAccount, 1, 50, kNftId, 123, kNftID2);
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_TRUE(output.result->at("meta").at("offer_id").as_string() == kNftID2);
});
}
TEST_F(RPCTxTest, CTIDAndTransactionBothProvided)
{
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}",
"ctid": "{}"
}})JSON",
kTxnId,
kCtid
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
});
}
TEST_F(RPCTxTest, CTIDAndTransactionBothNotProvided)
{
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(R"JSON({ "command": "tx"})JSON");
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
});
}
TEST_F(RPCTxTest, CTIDInvalidType)
{
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(R"JSON({ "command": "tx", "ctid": 123})JSON");
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
});
}
TEST_F(RPCTxTest, CTIDInvalidString)
{
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 5}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(R"JSON({ "command": "tx", "ctid": "B002807000010002"})JSON");
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "Invalid parameters.");
});
}
TEST_F(RPCTxTest, CTIDNotMatch)
{
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 5}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"ctid": "{}"
}})JSON",
kCtid
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_FALSE(output);
auto const err = rpc::makeError(output.result.error());
EXPECT_EQ(err.at("error").as_string(), "wrongNetwork");
EXPECT_EQ(err.at("error_code").as_uint64(), rpc::RippledError::rpcWRONG_NETWORK);
EXPECT_EQ(
err.at("error_message").as_string(),
"Wrong network. You should submit this request to a node running on NetworkID: 2"
);
});
}
TEST_F(RPCTxTest, ReturnCTIDForTxInput)
{
static constexpr auto kOut = R"JSON({
"Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"Fee": "2",
"Sequence": 100,
"SigningPubKey": "74657374",
"TakerGets": {
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
"issuer": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
"value": "200"
},
"ctid": "C000006400640002",
"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,
"inLedger": 100,
"validated": true
})JSON";
TransactionAndMetadata tx;
tx.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData();
tx.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 2}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(kOut));
});
}
TEST_F(RPCTxTest, NotReturnCTIDIfETLNotAvailable)
{
static constexpr auto kOut = R"JSON({
"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,
"inLedger": 100,
"validated": true
})JSON";
TransactionAndMetadata tx;
tx.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 100, 200, 300).getSerializer().peekData();
tx.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx.date = 123456;
tx.ledgerSequence = 100;
EXPECT_CALL(*backend_, fetchTransaction(ripple::uint256{kTxnId}, _)).WillOnce(Return(tx));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(std::nullopt));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"transaction": "{}"
}})JSON",
kTxnId
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(kOut));
});
}
TEST_F(RPCTxTest, ViaCTID)
{
static auto const kOut = fmt::format(
R"JSON({{
"Account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"Fee": "2",
"Sequence": 100,
"SigningPubKey": "74657374",
"TakerGets": {{
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
"issuer": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
"value": "200"
}},
"ctid": "{}",
"TakerPays": "300",
"TransactionType": "OfferCreate",
"hash": "2E2FBAAFF767227FE4381C4BE9855986A6B9F96C62F6E443731AB36F7BBB8A08",
"meta": {{
"AffectedNodes": [
{{
"CreatedNode": {{
"LedgerEntryType": "Offer",
"NewFields": {{
"TakerGets": "200",
"TakerPays": {{
"currency": "0158415500000000C1F76FF6ECB0BAC600000000",
"issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"value": "300"
}}
}}
}}
}}
],
"TransactionIndex": 1,
"TransactionResult": "tesSUCCESS"
}},
"date": 123456,
"ledger_index": {},
"inLedger": {},
"validated": true
}})JSON",
kCtid,
kSeqFromCtid,
kSeqFromCtid
);
TransactionAndMetadata tx1;
tx1.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 1, 200, 300).getSerializer().peekData();
tx1.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx1.date = 123456;
tx1.ledgerSequence = kSeqFromCtid;
TransactionAndMetadata tx2;
tx2.transaction =
createPaymentTransactionObject(kAccount, kAccount2, 2, 3, 300).getSerializer().peekData();
tx2.metadata =
createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData();
tx2.ledgerSequence = kSeqFromCtid;
EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeqFromCtid, _))
.WillOnce(Return(std::vector{tx1, tx2}));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 2}));
runSpawn([this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"ctid": "{}"
}})JSON",
kCtid
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(*output.result, json::parse(kOut));
});
}
TEST_F(RPCTxTest, ViaLowercaseCTID)
{
TransactionAndMetadata tx1;
tx1.metadata =
createMetaDataForCreateOffer(kCurrency, kAccount, 1, 200, 300).getSerializer().peekData();
tx1.transaction =
createCreateOfferTransactionObject(kAccount, 2, 100, kCurrency, kAccount2, 200, 300)
.getSerializer()
.peekData();
tx1.date = 123456;
tx1.ledgerSequence = kSeqFromCtid;
TransactionAndMetadata tx2;
tx2.transaction =
createPaymentTransactionObject(kAccount, kAccount2, 2, 3, 300).getSerializer().peekData();
tx2.metadata =
createPaymentTransactionMetaObject(kAccount, kAccount2, 110, 30).getSerializer().peekData();
tx2.ledgerSequence = kSeqFromCtid;
EXPECT_CALL(*backend_, fetchAllTransactionsInLedger(kSeqFromCtid, _))
.WillOnce(Return(std::vector{tx1, tx2}));
auto const rawETLPtr = dynamic_cast<MockETLService*>(mockETLServicePtr_.get());
ASSERT_NE(rawETLPtr, nullptr);
EXPECT_CALL(*rawETLPtr, getETLState).WillOnce(Return(etl::ETLState{.networkID = 2}));
std::string ctid(kCtid);
std::ranges::transform(ctid, ctid.begin(), ::tolower);
runSpawn([&, this](auto yield) {
auto const handler = AnyHandler{TestTxHandler{backend_, mockETLServicePtr_}};
auto const req = json::parse(
fmt::format(
R"JSON({{
"command": "tx",
"ctid": "{}"
}})JSON",
ctid
)
);
auto const output = handler.process(req, Context{yield});
ASSERT_TRUE(output);
EXPECT_EQ(output.result->at("ctid").as_string(), kCtid);
});
}
Reference in New Issue View Git Blame Copy Permalink