mirror of
https://github.com/XRPLF/clio.git
synced 2026-04-29 15:37:53 +00:00
1468 lines
50 KiB
C++
1468 lines
50 KiB
C++
#include "data/AmendmentCenter.hpp"
|
|
#include "data/Types.hpp"
|
|
#include "rpc/Errors.hpp"
|
|
#include "rpc/JS.hpp"
|
|
#include "rpc/RPCHelpers.hpp"
|
|
#include "rpc/common/Types.hpp"
|
|
#include "util/AsioContextTestFixture.hpp"
|
|
#include "util/LoggerFixtures.hpp"
|
|
#include "util/MockAmendmentCenter.hpp"
|
|
#include "util/MockBackendTestFixture.hpp"
|
|
#include "util/MockPrometheus.hpp"
|
|
#include "util/NameGenerator.hpp"
|
|
#include "util/Spawn.hpp"
|
|
#include "util/Taggable.hpp"
|
|
#include "util/TestObject.hpp"
|
|
#include "util/config/ConfigDefinition.hpp"
|
|
#include "util/config/ConfigValue.hpp"
|
|
#include "util/config/Types.hpp"
|
|
|
|
#include <boost/asio/impl/spawn.hpp>
|
|
#include <boost/asio/spawn.hpp>
|
|
#include <boost/json/array.hpp>
|
|
#include <boost/json/object.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 <xrpl/protocol/AccountID.h>
|
|
#include <xrpl/protocol/ErrorCodes.h>
|
|
#include <xrpl/protocol/Indexes.h>
|
|
#include <xrpl/protocol/LedgerFormats.h>
|
|
#include <xrpl/protocol/SField.h>
|
|
#include <xrpl/protocol/STObject.h>
|
|
#include <xrpl/protocol/Serializer.h>
|
|
#include <xrpl/protocol/UintTypes.h>
|
|
#include <xrpl/protocol/jss.h>
|
|
|
|
#include <array>
|
|
#include <chrono>
|
|
#include <cstddef>
|
|
#include <cstdint>
|
|
#include <optional>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <string_view>
|
|
#include <tuple>
|
|
#include <vector>
|
|
|
|
using namespace data;
|
|
using namespace rpc;
|
|
using namespace testing;
|
|
|
|
namespace {
|
|
|
|
constexpr auto kACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
|
|
constexpr auto kACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
|
|
constexpr auto kINDEX1 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
|
|
constexpr auto kINDEX2 = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322";
|
|
constexpr auto kTXN_ID = "E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
|
|
constexpr auto kLEDGER_SEQ_OBJECT = 50;
|
|
constexpr auto kCURRENCY = "0158415500000000C1F76FF6ECB0BAC600000000";
|
|
constexpr auto kAMM_ACCOUNT = "rnW8FAPgpQgA6VoESnVrUVJHBdq9QAtRZs";
|
|
constexpr auto kISSUER = "rK9DrarGKnVEo2nYp5MfVRXRYf5yRX3mwD";
|
|
constexpr auto kLPTOKEN_CURRENCY = "037C35306B24AAB7FF90848206E003279AA47090";
|
|
constexpr auto kAMM_ID = 54321;
|
|
|
|
} // namespace
|
|
|
|
class RPCHelpersTest : public util::prometheus::WithPrometheus,
|
|
public MockBackendTest,
|
|
public SyncAsioContextTest {
|
|
public:
|
|
RPCHelpersTest()
|
|
{
|
|
backend_->setRange(10, 300);
|
|
}
|
|
|
|
protected:
|
|
StrictMockAmendmentCenterSharedPtr mockAmendmentCenterPtr_;
|
|
};
|
|
|
|
TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidIndexNotHex)
|
|
{
|
|
util::spawn(ctx_, [this](boost::asio::yield_context yield) {
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, "nothex,10", yield, [](auto) {
|
|
|
|
});
|
|
EXPECT_FALSE(ret.has_value());
|
|
EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS);
|
|
EXPECT_EQ(ret.error().message, "Malformed cursor.");
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, TraverseOwnedNodesMarkerInvalidPageNotInt)
|
|
{
|
|
util::spawn(ctx_, [this](boost::asio::yield_context yield) {
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, "nothex,abc", yield, [](auto) {
|
|
|
|
});
|
|
EXPECT_FALSE(ret.has_value());
|
|
EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS);
|
|
EXPECT_EQ(ret.error().message, "Malformed cursor.");
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
// limit = 10, return 2 objects
|
|
TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarker)
|
|
{
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto owneDirKk = ripple::keylet::ownerDir(account).key;
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1);
|
|
|
|
// return owner index
|
|
ripple::STObject const ownerDir =
|
|
createOwnerDirLedgerObject({ripple::uint256{kINDEX1}, ripple::uint256{kINDEX2}}, kINDEX1);
|
|
ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_))
|
|
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
|
|
|
|
// return two payment channel objects
|
|
std::vector<Blob> bbs;
|
|
ripple::STObject const channel1 =
|
|
createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28);
|
|
bbs.push_back(channel1.getSerializer().peekData());
|
|
bbs.push_back(channel1.getSerializer().peekData());
|
|
ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs));
|
|
EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1);
|
|
|
|
util::spawn(ctx_, [this, &account](boost::asio::yield_context yield) {
|
|
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, {}, yield, [](auto) {});
|
|
EXPECT_TRUE(ret.has_value());
|
|
EXPECT_EQ(
|
|
ret.value().toString(),
|
|
"0000000000000000000000000000000000000000000000000000000000000000,"
|
|
"0"
|
|
);
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
// limit = 10, return 10 objects and marker
|
|
TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnSamePageMarker)
|
|
{
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto owneDirKk = ripple::keylet::ownerDir(account).key;
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1);
|
|
|
|
std::vector<Blob> bbs;
|
|
|
|
int objectsCount = 11;
|
|
ripple::STObject const channel1 =
|
|
createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28);
|
|
std::vector<ripple::uint256> indexes;
|
|
while (objectsCount != 0) {
|
|
// return owner index
|
|
indexes.emplace_back(kINDEX1);
|
|
bbs.push_back(channel1.getSerializer().peekData());
|
|
objectsCount--;
|
|
}
|
|
|
|
ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1);
|
|
ownerDir.setFieldU64(ripple::sfIndexNext, 99);
|
|
ON_CALL(*backend_, doFetchLedgerObject(owneDirKk, testing::_, testing::_))
|
|
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs));
|
|
EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1);
|
|
|
|
util::spawn(ctx_, [this, &account](boost::asio::yield_context yield) {
|
|
auto count = 0;
|
|
auto ret = traverseOwnedNodes(*backend_, account, 9, 10, {}, yield, [&](auto) { count++; });
|
|
EXPECT_TRUE(ret.has_value());
|
|
EXPECT_EQ(count, 10);
|
|
EXPECT_EQ(ret.value().toString(), fmt::format("{},0", kINDEX1));
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
// 10 objects per page, limit is 15, return the second page as marker
|
|
TEST_F(RPCHelpersTest, TraverseOwnedNodesNoInputMarkerReturnOtherPageMarker)
|
|
{
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto ownerDirKk = ripple::keylet::ownerDir(account).key;
|
|
static constexpr auto kNEXT_PAGE = 99;
|
|
static constexpr auto kLIMIT = 15;
|
|
auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), kNEXT_PAGE).key;
|
|
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
|
|
|
|
std::vector<Blob> bbs;
|
|
|
|
int objectsCount = 10;
|
|
ripple::STObject const channel1 =
|
|
createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28);
|
|
std::vector<ripple::uint256> indexes;
|
|
while (objectsCount != 0) {
|
|
// return owner index
|
|
indexes.emplace_back(kINDEX1);
|
|
objectsCount--;
|
|
}
|
|
objectsCount = 15;
|
|
while (objectsCount != 0) {
|
|
bbs.push_back(channel1.getSerializer().peekData());
|
|
objectsCount--;
|
|
}
|
|
|
|
ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1);
|
|
ownerDir.setFieldU64(ripple::sfIndexNext, kNEXT_PAGE);
|
|
// first page 's next page is 99
|
|
ON_CALL(*backend_, doFetchLedgerObject(ownerDirKk, testing::_, testing::_))
|
|
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
|
|
ripple::STObject ownerDir2 = createOwnerDirLedgerObject(indexes, kINDEX1);
|
|
// second page's next page is 0
|
|
ownerDir2.setFieldU64(ripple::sfIndexNext, 0);
|
|
ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_))
|
|
.WillByDefault(Return(ownerDir2.getSerializer().peekData()));
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs));
|
|
EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1);
|
|
|
|
util::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
|
|
auto count = 0;
|
|
auto ret =
|
|
traverseOwnedNodes(*backend_, account, 9, kLIMIT, {}, yield, [&](auto) { count++; });
|
|
EXPECT_TRUE(ret.has_value());
|
|
EXPECT_EQ(count, kLIMIT);
|
|
EXPECT_EQ(ret.value().toString(), fmt::format("{},{}", kINDEX1, kNEXT_PAGE));
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
// Send a valid marker
|
|
TEST_F(RPCHelpersTest, TraverseOwnedNodesWithMarkerReturnSamePageMarker)
|
|
{
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), 99).key;
|
|
static constexpr auto kLIMIT = 8;
|
|
static constexpr auto kPAGE_NUM = 99;
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject).Times(2);
|
|
|
|
std::vector<Blob> bbs;
|
|
|
|
int objectsCount = 10;
|
|
ripple::STObject const channel1 =
|
|
createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28);
|
|
std::vector<ripple::uint256> indexes;
|
|
while (objectsCount != 0) {
|
|
// return owner index
|
|
indexes.emplace_back(kINDEX1);
|
|
objectsCount--;
|
|
}
|
|
objectsCount = 10;
|
|
while (objectsCount != 0) {
|
|
bbs.push_back(channel1.getSerializer().peekData());
|
|
objectsCount--;
|
|
}
|
|
|
|
ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1);
|
|
ownerDir.setFieldU64(ripple::sfIndexNext, 0);
|
|
// return ownerdir when search by marker
|
|
ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_))
|
|
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObjects).WillByDefault(Return(bbs));
|
|
EXPECT_CALL(*backend_, doFetchLedgerObjects).Times(1);
|
|
|
|
util::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
|
|
auto count = 0;
|
|
auto ret = traverseOwnedNodes(
|
|
*backend_,
|
|
account,
|
|
9,
|
|
kLIMIT,
|
|
fmt::format("{},{}", kINDEX1, kPAGE_NUM),
|
|
yield,
|
|
[&](auto) { count++; }
|
|
);
|
|
EXPECT_TRUE(ret.has_value());
|
|
EXPECT_EQ(count, kLIMIT);
|
|
EXPECT_EQ(ret.value().toString(), fmt::format("{},{}", kINDEX1, kPAGE_NUM));
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
// Send a valid marker, but marker contain an unexisting index
|
|
// return invalid params error
|
|
TEST_F(RPCHelpersTest, TraverseOwnedNodesWithUnexistingIndexMarker)
|
|
{
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto ownerDir2Kk = ripple::keylet::page(ripple::keylet::ownerDir(account), 99).key;
|
|
static constexpr auto kLIMIT = 8;
|
|
static constexpr auto kPAGE_NUM = 99;
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject).Times(1);
|
|
|
|
int objectsCount = 10;
|
|
ripple::STObject const channel1 =
|
|
createPaymentChannelLedgerObject(kACCOUNT, kACCOUNT2, 100, 10, 32, kTXN_ID, 28);
|
|
std::vector<ripple::uint256> indexes;
|
|
while (objectsCount != 0) {
|
|
// return owner index
|
|
indexes.emplace_back(kINDEX1);
|
|
objectsCount--;
|
|
}
|
|
ripple::STObject ownerDir = createOwnerDirLedgerObject(indexes, kINDEX1);
|
|
ownerDir.setFieldU64(ripple::sfIndexNext, 0);
|
|
// return ownerdir when search by marker
|
|
ON_CALL(*backend_, doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_))
|
|
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
|
|
|
|
util::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
|
|
auto count = 0;
|
|
auto ret = traverseOwnedNodes(
|
|
*backend_,
|
|
account,
|
|
9,
|
|
kLIMIT,
|
|
fmt::format("{},{}", kINDEX2, kPAGE_NUM),
|
|
yield,
|
|
[&](auto) { count++; }
|
|
);
|
|
EXPECT_FALSE(ret.has_value());
|
|
EXPECT_EQ(ret.error(), ripple::rpcINVALID_PARAMS);
|
|
EXPECT_EQ(ret.error().message, "Invalid marker.");
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, EncodeCTID)
|
|
{
|
|
auto const ctid = encodeCTID(0x1234, 0x67, 0x89);
|
|
ASSERT_TRUE(ctid);
|
|
EXPECT_EQ(*ctid, "C000123400670089");
|
|
EXPECT_FALSE(encodeCTID(0x1FFFFFFF, 0x67, 0x89));
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, DecodeCTIDString)
|
|
{
|
|
auto const ctid = decodeCTID("C000123400670089");
|
|
ASSERT_TRUE(ctid);
|
|
EXPECT_EQ(*ctid, std::make_tuple(0x1234, 0x67, 0x89));
|
|
EXPECT_FALSE(decodeCTID("F000123400670089"));
|
|
EXPECT_FALSE(decodeCTID("F0001234006700"));
|
|
EXPECT_FALSE(decodeCTID("F000123400*700"));
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, DecodeCTIDInt)
|
|
{
|
|
uint64_t ctidStr = 0xC000123400670089;
|
|
auto const ctid = decodeCTID(ctidStr);
|
|
ASSERT_TRUE(ctid);
|
|
EXPECT_EQ(*ctid, std::make_tuple(0x1234, 0x67, 0x89));
|
|
ctidStr = 0xF000123400670089;
|
|
EXPECT_FALSE(decodeCTID(ctidStr));
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, DecodeInvalidCTID)
|
|
{
|
|
EXPECT_FALSE(decodeCTID('c'));
|
|
EXPECT_FALSE(decodeCTID(true));
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, DeliverMaxAliasV1)
|
|
{
|
|
std::array<std::string, 3> const inputArray = {
|
|
R"JSON({
|
|
"TransactionType": "Payment",
|
|
"Amount": {
|
|
"test": "test"
|
|
}
|
|
})JSON",
|
|
R"JSON({
|
|
"TransactionType": "OfferCreate",
|
|
"Amount": {
|
|
"test": "test"
|
|
}
|
|
})JSON",
|
|
R"JSON({
|
|
"TransactionType": "Payment",
|
|
"Amount1": {
|
|
"test": "test"
|
|
}
|
|
})JSON"
|
|
};
|
|
|
|
std::array<std::string, 3> outputArray = {
|
|
R"JSON({
|
|
"TransactionType": "Payment",
|
|
"Amount": {
|
|
"test": "test"
|
|
},
|
|
"DeliverMax": {
|
|
"test": "test"
|
|
}
|
|
})JSON",
|
|
R"JSON({
|
|
"TransactionType": "OfferCreate",
|
|
"Amount": {
|
|
"test": "test"
|
|
}
|
|
})JSON",
|
|
R"JSON({
|
|
"TransactionType": "Payment",
|
|
"Amount1": {
|
|
"test": "test"
|
|
}
|
|
})JSON"
|
|
};
|
|
|
|
for (size_t i = 0; i < inputArray.size(); i++) {
|
|
auto req = boost::json::parse(inputArray[i]).as_object();
|
|
insertDeliverMaxAlias(req, 1);
|
|
auto const expectedReq = boost::json::parse(outputArray[i]).as_object();
|
|
EXPECT_EQ(req, expectedReq) << req << "\n" << expectedReq;
|
|
}
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, DeliverMaxAliasV2)
|
|
{
|
|
constexpr auto kJSON = R"JSON({
|
|
"TransactionType": "Payment",
|
|
"Amount": {
|
|
"test": "test"
|
|
}
|
|
})JSON";
|
|
auto req = boost::json::parse(kJSON).as_object();
|
|
|
|
insertDeliverMaxAlias(req, 2);
|
|
EXPECT_EQ(
|
|
req,
|
|
boost::json::parse(
|
|
R"JSON({
|
|
"TransactionType": "Payment",
|
|
"DeliverMax": {
|
|
"test": "test"
|
|
}
|
|
})JSON"
|
|
)
|
|
);
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, LedgerHeaderJson)
|
|
{
|
|
auto const ledgerHeader = createLedgerHeader(kINDEX1, 30);
|
|
auto const binJson = toJson(ledgerHeader, true, 1u);
|
|
|
|
constexpr auto kEXPECT_BIN = R"JSON({
|
|
"ledger_data": "0000001E000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000",
|
|
"closed": true
|
|
})JSON";
|
|
EXPECT_EQ(binJson, boost::json::parse(kEXPECT_BIN));
|
|
|
|
auto const expectJson = fmt::format(
|
|
R"JSON({{
|
|
"account_hash": "0000000000000000000000000000000000000000000000000000000000000000",
|
|
"close_flags": 0,
|
|
"close_time": 0,
|
|
"close_time_resolution": 0,
|
|
"close_time_iso": "2000-01-01T00:00:00Z",
|
|
"ledger_hash": "{}",
|
|
"ledger_index": "{}",
|
|
"parent_close_time": 0,
|
|
"parent_hash": "0000000000000000000000000000000000000000000000000000000000000000",
|
|
"total_coins": "0",
|
|
"transaction_hash": "0000000000000000000000000000000000000000000000000000000000000000",
|
|
"closed": true
|
|
}})JSON",
|
|
kINDEX1,
|
|
30
|
|
);
|
|
auto json = toJson(ledgerHeader, false, 1u);
|
|
// remove platform-related close_time_human field
|
|
json.erase(JS(close_time_human));
|
|
EXPECT_EQ(json, boost::json::parse(expectJson));
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, LedgerHeaderJsonV2)
|
|
{
|
|
auto const ledgerHeader = createLedgerHeader(kINDEX1, 30);
|
|
|
|
auto const expectJson = fmt::format(
|
|
R"JSON({{
|
|
"account_hash": "0000000000000000000000000000000000000000000000000000000000000000",
|
|
"close_flags": 0,
|
|
"close_time": 0,
|
|
"close_time_resolution": 0,
|
|
"close_time_iso": "2000-01-01T00:00:00Z",
|
|
"ledger_hash": "{}",
|
|
"ledger_index": {},
|
|
"parent_close_time": 0,
|
|
"parent_hash": "0000000000000000000000000000000000000000000000000000000000000000",
|
|
"total_coins": "0",
|
|
"transaction_hash": "0000000000000000000000000000000000000000000000000000000000000000",
|
|
"closed": true
|
|
}})JSON",
|
|
kINDEX1,
|
|
30
|
|
);
|
|
auto json = toJson(ledgerHeader, false, 2u);
|
|
// remove platform-related close_time_human field
|
|
json.erase(JS(close_time_human));
|
|
EXPECT_EQ(json, boost::json::parse(expectJson));
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, TransactionAndMetadataBinaryJsonV1)
|
|
{
|
|
auto const txMeta = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 30, 1, kINDEX1, kINDEX2);
|
|
auto const json = toJsonWithBinaryTx(txMeta, 1);
|
|
EXPECT_TRUE(json.contains(JS(tx_blob)));
|
|
EXPECT_TRUE(json.contains(JS(meta)));
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, TransactionAndMetadataBinaryJsonV2)
|
|
{
|
|
auto const txMeta = createAcceptNftBuyerOfferTxWithMetadata(kACCOUNT, 30, 1, kINDEX1, kINDEX2);
|
|
auto const json = toJsonWithBinaryTx(txMeta, 2);
|
|
EXPECT_TRUE(json.contains(JS(tx_blob)));
|
|
EXPECT_TRUE(json.contains(JS(meta_blob)));
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, ParseIssue)
|
|
{
|
|
constexpr auto kJSON = R"JSON({
|
|
"issuer": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
|
|
"currency": "JPY"
|
|
})JSON";
|
|
auto issue = parseIssue(boost::json::parse(kJSON).as_object());
|
|
EXPECT_TRUE(issue.account == getAccountIdWithString(kACCOUNT2));
|
|
|
|
issue = parseIssue(boost::json::parse(R"JSON({"currency": "XRP"})JSON").as_object());
|
|
EXPECT_TRUE(ripple::isXRP(issue.currency));
|
|
|
|
EXPECT_THROW(
|
|
parseIssue(boost::json::parse(R"JSON({"currency": 2})JSON").as_object()), std::runtime_error
|
|
);
|
|
|
|
EXPECT_THROW(
|
|
parseIssue(boost::json::parse(R"JSON({"currency": "XRP2"})JSON").as_object()),
|
|
std::runtime_error
|
|
);
|
|
|
|
constexpr auto kJSON2 = R"JSON({
|
|
"issuer": "abcd",
|
|
"currency": "JPY"
|
|
})JSON";
|
|
EXPECT_THROW(parseIssue(boost::json::parse(kJSON2).as_object()), std::runtime_error);
|
|
|
|
EXPECT_THROW(
|
|
parseIssue(
|
|
boost::json::parse(R"JSON({"issuer": "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"})JSON")
|
|
.as_object()
|
|
),
|
|
std::runtime_error
|
|
);
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_BlobDoesNotExist)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuerKey = ripple::keylet::account(account);
|
|
|
|
// returns empty blob
|
|
ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(std::optional<Blob>{}));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
// return false: blob doesn't exist
|
|
EXPECT_FALSE(fetchAndCheckAnyFlagsExists(
|
|
*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield
|
|
));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_AccountWithCorrectFlag)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuerKey = ripple::keylet::account(account);
|
|
|
|
// create account with highDeepFreeze Flag
|
|
auto const accountObject =
|
|
createAccountRootObject(kACCOUNT, ripple::lsfHighDeepFreeze, 1, 10, 2, kTXN_ID, 3);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(accountObject.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
// returns true: accountObject has the highDeepFreeze flag
|
|
EXPECT_TRUE(fetchAndCheckAnyFlagsExists(
|
|
*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield
|
|
));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, FetchAndCheckAnyFlagExists_TrustLineIsFrozenAndCheckFreezeFlag)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuerKey = ripple::keylet::account(account);
|
|
|
|
// create account with lowDeepFreeze Flag
|
|
auto const accountObject =
|
|
createAccountRootObject(kACCOUNT, ripple::lsfLowDeepFreeze, 1, 10, 2, kTXN_ID, 3);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(accountObject.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
// returns false: accountObject has the lowDeepFreeze flag
|
|
EXPECT_FALSE(fetchAndCheckAnyFlagsExists(
|
|
*backend_, kLEDGER_SEQ_OBJECT, issuerKey, {ripple::lsfHighDeepFreeze}, yield
|
|
));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, isGlobalFrozen_AccountIsGlobalFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuerKey = ripple::keylet::account(account);
|
|
|
|
auto const accountObject =
|
|
createAccountRootObject(kACCOUNT, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(issuerKey.key, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(accountObject.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
// returns false: accountObject has the lowDeepFreeze flag
|
|
EXPECT_TRUE(isGlobalFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, yield));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsDeepFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const account2 = getAccountIdWithString(kACCOUNT2);
|
|
|
|
// create a trustline between account and account2 and is deep frozen
|
|
auto const trustLineKey =
|
|
ripple::keylet::line(account, account2, ripple::Currency{kCURRENCY}).key;
|
|
auto const trustlineDeepFrozen = createRippleStateLedgerObject(
|
|
"USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowDeepFreeze
|
|
);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(trustlineDeepFrozen.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
EXPECT_TRUE(isDeepFrozen(
|
|
*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account2, yield
|
|
));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, isDeepFrozen_TrustLineIsNotDeepFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const account2 = getAccountIdWithString(kACCOUNT2);
|
|
|
|
// create a trustline between account and account2 that is frozen (NOT DeepFrozen)
|
|
auto const trustLineKey =
|
|
ripple::keylet::line(account, account2, ripple::Currency{kCURRENCY}).key;
|
|
auto const trustlineFrozen = createRippleStateLedgerObject(
|
|
"USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowFreeze
|
|
);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(trustlineFrozen.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
EXPECT_FALSE(isDeepFrozen(
|
|
*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account2, yield
|
|
));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, isDeepFrozen_IssuerAndAccountIsSameWillNotBeDeepFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuer = getAccountIdWithString(kACCOUNT2);
|
|
|
|
auto const trustLineKey =
|
|
ripple::keylet::line(account, issuer, ripple::Currency{kCURRENCY}).key;
|
|
auto const trustlineDeepFrozen = createRippleStateLedgerObject(
|
|
"USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowDeepFreeze
|
|
);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(trustlineDeepFrozen.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
// both accounts are same so trustline is not deep frozen
|
|
EXPECT_FALSE(isDeepFrozen(
|
|
*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account, yield
|
|
));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, isFrozen_IssuerAccountIsGlobalFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuer = getAccountIdWithString(kACCOUNT2);
|
|
|
|
auto const accountObject =
|
|
createAccountRootObject(kACCOUNT2, ripple::lsfGlobalFreeze, 1, 10, 2, kTXN_ID, 3);
|
|
auto const issuerKey = ripple::keylet::account(issuer).key;
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(issuerKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(accountObject.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
EXPECT_TRUE(isFrozen(
|
|
*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, issuer, yield
|
|
));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, isFrozen_IssuerAndAccountIsSameWillNotBeFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuer = getAccountIdWithString(kACCOUNT2);
|
|
|
|
auto const trustLineKey =
|
|
ripple::keylet::line(account, issuer, ripple::Currency{kCURRENCY}).key;
|
|
auto const trustlineDeepFrozen = createRippleStateLedgerObject(
|
|
"USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfHighFreeze
|
|
);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(trustlineDeepFrozen.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
EXPECT_FALSE(isFrozen(
|
|
*backend_, kLEDGER_SEQ_OBJECT, account, ripple::Currency{kCURRENCY}, account, yield
|
|
));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, isFrozen_IssuerTrustLineIsFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuer = getAccountIdWithString(kACCOUNT2);
|
|
ripple::Currency const currency{kCURRENCY};
|
|
|
|
auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key;
|
|
|
|
// issuer is higher than account, so the correct flag to set is High freeze
|
|
auto const trustlineFrozen = createRippleStateLedgerObject(
|
|
"USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfHighFreeze
|
|
);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(trustlineFrozen.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
EXPECT_TRUE(isFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, currency, issuer, yield));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, isFrozen_IssuerWithLowFreezeIsNotFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuer = getAccountIdWithString(kACCOUNT2);
|
|
ripple::Currency const currency{kCURRENCY};
|
|
|
|
auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key;
|
|
|
|
// issuer is higher than account, but the flag set here is low freeze
|
|
auto const trustlineFrozen = createRippleStateLedgerObject(
|
|
"USD", kACCOUNT, 8, kACCOUNT, 1000, kACCOUNT2, 2000, kINDEX1, 2, ripple::lsfLowFreeze
|
|
);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(trustlineFrozen.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
EXPECT_FALSE(isFrozen(*backend_, kLEDGER_SEQ_OBJECT, account, currency, issuer, yield));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, AccountHolds_TrustLineNotfrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuer = getAccountIdWithString(kACCOUNT2);
|
|
ripple::Currency const currency{kCURRENCY};
|
|
|
|
auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key;
|
|
auto const trustLine = createRippleStateLedgerObject(
|
|
kCURRENCY, kACCOUNT2, 500, kACCOUNT, 1000, kACCOUNT2, 1000, kTXN_ID, 1, 0
|
|
);
|
|
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillOnce(Return(trustLine.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
auto const result = accountHolds(
|
|
*backend_,
|
|
*mockAmendmentCenterPtr_,
|
|
kLEDGER_SEQ_OBJECT,
|
|
account,
|
|
currency,
|
|
issuer,
|
|
false,
|
|
yield
|
|
);
|
|
// Check issuer has a balance of 500
|
|
EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 500));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, AccountHolds_NoTrustLine)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuer = getAccountIdWithString(kACCOUNT2);
|
|
ripple::Currency const currency{kCURRENCY};
|
|
|
|
auto const key = ripple::keylet::line(account, issuer, currency).key;
|
|
|
|
// return no trustline found
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(key, kLEDGER_SEQ_OBJECT, _))
|
|
.WillOnce(Return(std::nullopt));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
auto const result = accountHolds(
|
|
*backend_,
|
|
*mockAmendmentCenterPtr_,
|
|
kLEDGER_SEQ_OBJECT,
|
|
account,
|
|
currency,
|
|
issuer,
|
|
false,
|
|
yield
|
|
);
|
|
// balance is 0 as trustline is frozen
|
|
EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 0));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, AccountHolds_TrustLineButFrozen)
|
|
{
|
|
auto const account = getAccountIdWithString(kACCOUNT);
|
|
auto const issuer = getAccountIdWithString(kACCOUNT2);
|
|
ripple::Currency const currency{kCURRENCY};
|
|
|
|
// balance of 500, but trustline is frozen
|
|
auto const trustLineKey = ripple::keylet::line(account, issuer, currency).key;
|
|
|
|
auto const trustLine = createRippleStateLedgerObject(
|
|
kCURRENCY,
|
|
kACCOUNT2,
|
|
500,
|
|
kACCOUNT,
|
|
1000,
|
|
kACCOUNT2,
|
|
1000,
|
|
kTXN_ID,
|
|
1,
|
|
ripple::lsfHighFreeze
|
|
);
|
|
|
|
ON_CALL(*backend_, doFetchLedgerObject(trustLineKey, kLEDGER_SEQ_OBJECT, _))
|
|
.WillByDefault(Return(trustLine.getSerializer().peekData()));
|
|
|
|
runSpawn([&](boost::asio::yield_context yield) {
|
|
auto const result = accountHolds(
|
|
*backend_,
|
|
*mockAmendmentCenterPtr_,
|
|
kLEDGER_SEQ_OBJECT,
|
|
account,
|
|
currency,
|
|
issuer,
|
|
true,
|
|
yield
|
|
);
|
|
EXPECT_EQ(result, ripple::STAmount(getIssue(kCURRENCY, kACCOUNT2), 0));
|
|
});
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, AccountHoldsFixLPTAmendmentDisabled)
|
|
{
|
|
auto ammAccount = getAccountIdWithString(kAMM_ACCOUNT);
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
|
|
auto const lptRippleState = createRippleStateLedgerObject(
|
|
kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3
|
|
);
|
|
auto const lptRippleStateKk =
|
|
ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key;
|
|
|
|
// trustline fetched twice. once in accountHolds and once in isFrozen
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_))
|
|
.Times(2)
|
|
.WillRepeatedly(Return(lptRippleState.getSerializer().peekData()));
|
|
|
|
auto const ammID = ripple::uint256{kAMM_ID};
|
|
auto const ammAccountKk = ripple::keylet::account(ammAccount).key;
|
|
auto const ammAccountRoot =
|
|
createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID);
|
|
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_))
|
|
.WillOnce(Return(ammAccountRoot.getSerializer().peekData()));
|
|
|
|
EXPECT_CALL(
|
|
*mockAmendmentCenterPtr_,
|
|
isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)
|
|
)
|
|
.WillOnce(Return(false));
|
|
|
|
util::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
|
|
auto ret = accountHolds(
|
|
*backend_,
|
|
*mockAmendmentCenterPtr_,
|
|
0,
|
|
account,
|
|
ripple::to_currency(kLPTOKEN_CURRENCY),
|
|
ammAccount,
|
|
true,
|
|
yield
|
|
);
|
|
EXPECT_EQ(ret.mantissa(), 1000000000000000);
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, AccountHoldsLPTokenNotAMMAccount)
|
|
{
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto account2 = getAccountIdWithString(kACCOUNT2);
|
|
|
|
auto const usdRippleState = createRippleStateLedgerObject(
|
|
"USD", kACCOUNT2, 100, kACCOUNT, 100, kACCOUNT2, 100, kTXN_ID, 3
|
|
);
|
|
auto const usdRippleStateKk =
|
|
ripple::keylet::line(account2, account, ripple::to_currency("USD")).key;
|
|
|
|
// trustline fetched twice. once in accountHolds and once in isFrozen
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(usdRippleStateKk, testing::_, testing::_))
|
|
.Times(2)
|
|
.WillRepeatedly(Return(usdRippleState.getSerializer().peekData()));
|
|
|
|
EXPECT_CALL(
|
|
*mockAmendmentCenterPtr_,
|
|
isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)
|
|
)
|
|
.WillOnce(Return(true));
|
|
|
|
auto const account2Kk = ripple::keylet::account(account2).key;
|
|
auto const account2Root = createAccountRootObject(kACCOUNT2, 0, 2, 200, 2, kINDEX1, 2, 0);
|
|
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(account2Kk, testing::_, testing::_))
|
|
.Times(2)
|
|
.WillRepeatedly(Return(account2Root.getSerializer().peekData()));
|
|
|
|
util::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
|
|
auto ret = accountHolds(
|
|
*backend_,
|
|
*mockAmendmentCenterPtr_,
|
|
0,
|
|
account,
|
|
ripple::to_currency("USD"),
|
|
account2,
|
|
true,
|
|
yield
|
|
);
|
|
EXPECT_EQ(ret.mantissa(), 1000000000000000);
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset1Frozen)
|
|
{
|
|
auto ammAccount = getAccountIdWithString(kAMM_ACCOUNT);
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto issuer = getAccountIdWithString(kISSUER);
|
|
|
|
auto const lptRippleState = createRippleStateLedgerObject(
|
|
kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3
|
|
);
|
|
auto const lptRippleStateKk =
|
|
ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key;
|
|
|
|
// trustline fetched twice. once in accountHolds and once in isFrozen
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_))
|
|
.Times(2)
|
|
.WillRepeatedly(Return(lptRippleState.getSerializer().peekData()));
|
|
|
|
EXPECT_CALL(
|
|
*mockAmendmentCenterPtr_,
|
|
isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)
|
|
)
|
|
.WillOnce(Return(true));
|
|
|
|
auto const ammID = ripple::uint256{kAMM_ID};
|
|
auto const ammAccountKk = ripple::keylet::account(ammAccount).key;
|
|
auto const ammAccountRoot =
|
|
createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID);
|
|
|
|
// accountroot fetched twice, once in isFrozen, once in accountHolds
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_))
|
|
.Times(2)
|
|
.WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData()));
|
|
|
|
auto const amm = createAmmObject(
|
|
kAMM_ACCOUNT, "USD", kISSUER, "XRP", ripple::toBase58(ripple::xrpAccount())
|
|
);
|
|
EXPECT_CALL(
|
|
*backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_)
|
|
)
|
|
.Times(1)
|
|
.WillOnce(Return(amm.getSerializer().peekData()));
|
|
|
|
auto const issuerKk = ripple::keylet::account(issuer).key;
|
|
auto const issuerAccountRoot =
|
|
createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, 0);
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_))
|
|
.WillOnce(Return(issuerAccountRoot.getSerializer().peekData()));
|
|
|
|
util::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
|
|
auto ret = accountHolds(
|
|
*backend_,
|
|
*mockAmendmentCenterPtr_,
|
|
0,
|
|
account,
|
|
ripple::to_currency(kLPTOKEN_CURRENCY),
|
|
ammAccount,
|
|
true,
|
|
yield
|
|
);
|
|
EXPECT_EQ(ret.mantissa(), 0);
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, AccountHoldsLPTokenAsset2Frozen)
|
|
{
|
|
auto ammAccount = getAccountIdWithString(kAMM_ACCOUNT);
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto issuer = getAccountIdWithString(kISSUER);
|
|
|
|
auto const lptRippleState = createRippleStateLedgerObject(
|
|
kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3
|
|
);
|
|
auto const lptRippleStateKk =
|
|
ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key;
|
|
|
|
// trustline fetched twice. once in accountHolds and once in isFrozen
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_)).Times(2);
|
|
ON_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_))
|
|
.WillByDefault(testing::Return(lptRippleState.getSerializer().peekData()));
|
|
|
|
EXPECT_CALL(
|
|
*mockAmendmentCenterPtr_,
|
|
isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)
|
|
)
|
|
.WillOnce(testing::Return(true));
|
|
|
|
auto const ammID = ripple::uint256{kAMM_ID};
|
|
auto const ammAccountKk = ripple::keylet::account(ammAccount).key;
|
|
auto const ammAccountRoot =
|
|
createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID);
|
|
|
|
// accountroot fetched twice, once in isFrozen, once in accountHolds
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_))
|
|
.Times(2)
|
|
.WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData()));
|
|
|
|
auto const amm = createAmmObject(
|
|
kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kISSUER
|
|
);
|
|
EXPECT_CALL(
|
|
*backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_)
|
|
)
|
|
.WillOnce(Return(amm.getSerializer().peekData()));
|
|
|
|
auto const issuerKk = ripple::keylet::account(issuer).key;
|
|
auto const issuerAccountRoot =
|
|
createAccountRootObject(kISSUER, ripple::lsfGlobalFreeze, 2, 200, 2, kINDEX1, 2, 0);
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_))
|
|
.WillOnce(Return(issuerAccountRoot.getSerializer().peekData()));
|
|
|
|
util::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
|
|
auto ret = accountHolds(
|
|
*backend_,
|
|
*mockAmendmentCenterPtr_,
|
|
0,
|
|
account,
|
|
ripple::to_currency(kLPTOKEN_CURRENCY),
|
|
ammAccount,
|
|
true,
|
|
yield
|
|
);
|
|
EXPECT_EQ(ret.mantissa(), 0);
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
TEST_F(RPCHelpersTest, AccountHoldsLPTokenUnfrozen)
|
|
{
|
|
auto ammAccount = getAccountIdWithString(kAMM_ACCOUNT);
|
|
auto account = getAccountIdWithString(kACCOUNT);
|
|
auto issuer = getAccountIdWithString(kISSUER);
|
|
|
|
auto const lptRippleState = createRippleStateLedgerObject(
|
|
kLPTOKEN_CURRENCY, kAMM_ACCOUNT, 100, kACCOUNT, 100, kAMM_ACCOUNT, 100, kTXN_ID, 3
|
|
);
|
|
auto const lptRippleStateKk =
|
|
ripple::keylet::line(ammAccount, account, ripple::to_currency(kLPTOKEN_CURRENCY)).key;
|
|
|
|
// trustline fetched twice. once in accountHolds and once in isFrozen
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(lptRippleStateKk, testing::_, testing::_))
|
|
.Times(2)
|
|
.WillRepeatedly(Return(lptRippleState.getSerializer().peekData()));
|
|
|
|
EXPECT_CALL(
|
|
*mockAmendmentCenterPtr_,
|
|
isEnabled(testing::_, Amendments::fixFrozenLPTokenTransfer, testing::_)
|
|
)
|
|
.WillOnce(Return(true));
|
|
|
|
auto const ammID = ripple::uint256{kAMM_ID};
|
|
auto const ammAccountKk = ripple::keylet::account(ammAccount).key;
|
|
auto const ammAccountRoot =
|
|
createAccountRootObject(kAMM_ACCOUNT, 0, 2, 200, 2, kINDEX1, 2, 0, ammID);
|
|
|
|
// accountroot fetched twice, once in isFrozen, once in accountHolds
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(ammAccountKk, testing::_, testing::_))
|
|
.Times(2)
|
|
.WillRepeatedly(Return(ammAccountRoot.getSerializer().peekData()));
|
|
|
|
auto const amm = createAmmObject(
|
|
kAMM_ACCOUNT, "XRP", ripple::toBase58(ripple::xrpAccount()), "USD", kISSUER
|
|
);
|
|
EXPECT_CALL(
|
|
*backend_, doFetchLedgerObject(ripple::keylet::amm(ammID).key, testing::_, testing::_)
|
|
)
|
|
.WillOnce(Return(amm.getSerializer().peekData()));
|
|
|
|
auto const issuerKk = ripple::keylet::account(issuer).key;
|
|
auto const issuerAccountRoot = createAccountRootObject(kISSUER, 0, 2, 200, 2, kINDEX1, 2, 0);
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(issuerKk, testing::_, testing::_))
|
|
.WillOnce(Return(issuerAccountRoot.getSerializer().peekData()));
|
|
|
|
auto const usdRippleState =
|
|
createRippleStateLedgerObject("USD", kISSUER, 100, kACCOUNT, 100, kISSUER, 100, kTXN_ID, 3);
|
|
auto const usdRippleStateKk =
|
|
ripple::keylet::line(issuer, account, ripple::to_currency("USD")).key;
|
|
|
|
EXPECT_CALL(*backend_, doFetchLedgerObject(usdRippleStateKk, testing::_, testing::_))
|
|
.WillOnce(Return(usdRippleState.getSerializer().peekData()));
|
|
|
|
util::spawn(ctx_, [&, this](boost::asio::yield_context yield) {
|
|
auto ret = accountHolds(
|
|
*backend_,
|
|
*mockAmendmentCenterPtr_,
|
|
0,
|
|
account,
|
|
ripple::to_currency(kLPTOKEN_CURRENCY),
|
|
ammAccount,
|
|
true,
|
|
yield
|
|
);
|
|
EXPECT_EQ(ret.mantissa(), 1000000000000000);
|
|
});
|
|
ctx_.run();
|
|
}
|
|
|
|
struct IsAdminCmdParamTestCaseBundle {
|
|
std::string testName;
|
|
std::string method;
|
|
std::string testJson;
|
|
bool expected;
|
|
};
|
|
|
|
struct IsAdminCmdParameterTest : public TestWithParam<IsAdminCmdParamTestCaseBundle> {};
|
|
|
|
static auto
|
|
generateTestValuesForParametersTest()
|
|
{
|
|
return std::vector<IsAdminCmdParamTestCaseBundle>{
|
|
{
|
|
.testName = "ledgerEntry",
|
|
.method = "ledger_entry",
|
|
.testJson = R"JSON({"type": false})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "featureVetoedTrue",
|
|
.method = "feature",
|
|
.testJson = R"JSON({"vetoed": true, "feature": "foo"})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "featureVetoedFalse",
|
|
.method = "feature",
|
|
.testJson = R"JSON({"vetoed": false, "feature": "foo"})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "featureVetoedIsStr",
|
|
.method = "feature",
|
|
.testJson = R"JSON({"vetoed": "String"})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledger",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerWithType",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"type": "fee"})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerFullTrue",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": true})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerFullFalse",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": false})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsStr",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": "String"})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsEmptyStr",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": ""})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsNumber1",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": 1})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsNumber0",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": 0})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsNull",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": null})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsFloat0",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": 0.0})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsFloat1",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": 0.1})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsArray",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": [1]})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsEmptyArray",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": []})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsObject",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": {"key": 1}})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerFullIsEmptyObject",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"full": {}})JSON",
|
|
.expected = false,
|
|
},
|
|
|
|
{
|
|
.testName = "ledgerAccountsTrue",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": true})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsFalse",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": false})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsStr",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": "String"})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsEmptyStr",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": ""})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsNumber1",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": 1})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsNumber0",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": 0})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsNull",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": null})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsFloat0",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": 0.0})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsFloat1",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": 0.1})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsArray",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": [1]})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsEmptyArray",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": []})JSON",
|
|
.expected = false,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsObject",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": {"key": 1}})JSON",
|
|
.expected = true,
|
|
},
|
|
{
|
|
.testName = "ledgerAccountsIsEmptyObject",
|
|
.method = "ledger",
|
|
.testJson = R"JSON({"accounts": {}})JSON",
|
|
.expected = false,
|
|
},
|
|
};
|
|
}
|
|
|
|
INSTANTIATE_TEST_CASE_P(
|
|
IsAdminCmdTest,
|
|
IsAdminCmdParameterTest,
|
|
ValuesIn(generateTestValuesForParametersTest()),
|
|
tests::util::kNAME_GENERATOR
|
|
);
|
|
|
|
TEST_P(IsAdminCmdParameterTest, Test)
|
|
{
|
|
auto const testBundle = GetParam();
|
|
EXPECT_EQ(
|
|
isAdminCmd(testBundle.method, boost::json::parse(testBundle.testJson).as_object()),
|
|
testBundle.expected
|
|
);
|
|
}
|
|
|
|
struct RPCHelpersLogDurationTestBundle {
|
|
std::string testName;
|
|
std::chrono::milliseconds duration;
|
|
std::string expectedLogLevel;
|
|
bool expectDuration;
|
|
};
|
|
|
|
struct RPCHelpersLogDurationTest : LoggerFixture,
|
|
testing::WithParamInterface<RPCHelpersLogDurationTestBundle> {
|
|
boost::json::object const request = {
|
|
{"method", "account_info"},
|
|
{"params",
|
|
boost::json::array{boost::json::object{
|
|
{"account", "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"},
|
|
{"secret", "should be deleted"}
|
|
}}}
|
|
};
|
|
util::TagDecoratorFactory tagFactory{util::config::ClioConfigDefinition{
|
|
{"log.tag_style",
|
|
util::config::ConfigValue{util::config::ConfigType::String}.defaultValue("none")}
|
|
}};
|
|
struct DummyTaggable : util::Taggable {
|
|
DummyTaggable(util::TagDecoratorFactory& f) : util::Taggable(f)
|
|
{
|
|
}
|
|
};
|
|
DummyTaggable taggable{tagFactory};
|
|
};
|
|
|
|
TEST_P(RPCHelpersLogDurationTest, LogDuration)
|
|
{
|
|
auto const& tag = taggable.tag();
|
|
|
|
logDuration(request, tag, GetParam().duration);
|
|
|
|
std::string const output = getLoggerString();
|
|
|
|
EXPECT_NE(output.find(GetParam().expectedLogLevel), std::string::npos) << output;
|
|
EXPECT_NE(output.find(tag.toString()), std::string::npos);
|
|
|
|
if (GetParam().expectDuration) {
|
|
std::string const durationStr =
|
|
std::to_string(GetParam().duration.count()) + " milliseconds";
|
|
EXPECT_NE(output.find(durationStr), std::string::npos);
|
|
}
|
|
|
|
EXPECT_NE(output.find("account_info"), std::string::npos);
|
|
EXPECT_EQ(output.find("should be deleted"), std::string::npos);
|
|
}
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
RPCHelpersLogDurationTests,
|
|
RPCHelpersLogDurationTest,
|
|
testing::Values(
|
|
RPCHelpersLogDurationTestBundle{
|
|
"ShortDurationLogsAsInfo",
|
|
std::chrono::milliseconds(500),
|
|
"inf:RPC ",
|
|
true
|
|
},
|
|
RPCHelpersLogDurationTestBundle{
|
|
"MediumDurationLogsAsWarning",
|
|
std::chrono::milliseconds(5000),
|
|
"war:RPC ",
|
|
true
|
|
},
|
|
RPCHelpersLogDurationTestBundle{
|
|
"LongDurationLogsAsError",
|
|
std::chrono::milliseconds(15000),
|
|
"err:RPC ",
|
|
true
|
|
}
|
|
),
|
|
tests::util::kNAME_GENERATOR
|
|
);
|