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

Account channel (#519)

Browse Source 
Fixes #523
This commit is contained in:
cyan317
2023-02-24 09:34:29 +00:00
committed by GitHub
parent f6c2008540
commit 7d4e5ff0bd
12 changed files with 1412 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
CMakeLists.txt
View File

@@ -56,6 +56,8 @@ target_sources(clio PRIVATE
## NextGen RPC
src/rpc/common/Specs.cpp
src/rpc/common/Validators.cpp
## NextGen RPC handler
src/rpc/ngHandlers/AccountChannels.cpp
## RPC Methods
# Account
src/rpc/handlers/AccountChannels.cpp
@@ -115,7 +117,8 @@ if(BUILD_TESTS)
unittests/rpc/RPCHelpersTest.cpp
unittests/rpc/handlers/TestHandlerTests.cpp
unittests/rpc/handlers/DefaultProcessorTests.cpp
unittests/rpc/handlers/PingTest.cpp)
unittests/rpc/handlers/PingTest.cpp
unittests/rpc/handlers/AccountChannelsTest.cpp)
include(CMake/deps/gtest.cmake)
# if CODE_COVERAGE enable, add clio_test-ccov

67
src/rpc/RPCHelpers.cpp
View File

@@ -102,11 +102,7 @@ getRequiredUInt(boost::json::object const& request, std::string const& field)
}
std::optional<AccountCursor>
parseAccountCursor(
BackendInterface const& backend,
std::uint32_t seq,
std::optional<std::string> jsonCursor,
boost::asio::yield_context& yield)
parseAccountCursor(std::optional<std::string> jsonCursor)
{
ripple::uint256 cursorIndex = beast::zero;
std::uint64_t startHint = 0;
@@ -596,6 +592,39 @@ ledgerInfoFromRequest(Context const& ctx)
return *lgrInfo;
}
// extract ledgerInfoFromRequest's parameter from context
std::variant<Status, ripple::LedgerInfo>
getLedgerInfoFromHashOrSeq(
BackendInterface const& backend,
boost::asio::yield_context& yield,
std::optional<std::string> ledgerHash,
std::optional<uint32_t> ledgerIndex,
uint32_t maxSeq)
{
std::optional<ripple::LedgerInfo> lgrInfo;
auto const err =
RPC::Status{RPC::RippledError::rpcLGR_NOT_FOUND, "ledgerNotFound"};
if (ledgerHash)
{
lgrInfo =
backend.fetchLedgerByHash(ripple::uint256{*ledgerHash}, yield);
if (!lgrInfo || lgrInfo->seq > maxSeq)
return err;
return *lgrInfo;
}
auto const ledgerSequence = ledgerIndex.value_or(maxSeq);
// return without check db
if (ledgerSequence > maxSeq)
return err;
lgrInfo = backend.fetchLedgerBySequence(ledgerSequence, yield);
if (!lgrInfo)
return err;
return *lgrInfo;
}
std::vector<unsigned char>
ledgerInfoToBlob(ripple::LedgerInfo const& info, bool includeHash)
{
@@ -646,7 +675,7 @@ traverseOwnedNodes(
ripple::keylet::account(accountID).key, sequence, yield))
return Status{RippledError::rpcACT_NOT_FOUND};
auto maybeCursor = parseAccountCursor(backend, sequence, jsonCursor, yield);
auto const maybeCursor = parseAccountCursor(jsonCursor);
if (!maybeCursor)
return Status(ripple::rpcINVALID_PARAMS, "Malformed cursor");
@@ -664,6 +693,32 @@ traverseOwnedNodes(
atOwnedNode);
}
std::variant<Status, AccountCursor>
ngTraverseOwnedNodes(
BackendInterface const& backend,
ripple::AccountID const& accountID,
std::uint32_t sequence,
std::uint32_t limit,
std::optional<std::string> jsonCursor,
boost::asio::yield_context& yield,
std::function<void(ripple::SLE&&)> atOwnedNode)
{
auto const maybeCursor = parseAccountCursor(jsonCursor);
// the format is checked in RPC framework level
auto const [hexCursor, startHint] = *maybeCursor;
return traverseOwnedNodes(
backend,
ripple::keylet::ownerDir(accountID),
hexCursor,
startHint,
sequence,
limit,
jsonCursor,
yield,
atOwnedNode);
}
std::variant<Status, AccountCursor>
traverseOwnedNodes(
BackendInterface const& backend,

26
src/rpc/RPCHelpers.h
View File

@@ -50,11 +50,7 @@ std::uint64_t
getStartHint(ripple::SLE const& sle, ripple::AccountID const& accountID);
std::optional<AccountCursor>
parseAccountCursor(
BackendInterface const& backend,
std::uint32_t seq,
std::optional<std::string> jsonCursor,
boost::asio::yield_context& yield);
parseAccountCursor(std::optional<std::string> jsonCursor);
// TODO this function should probably be in a different file and namespace
std::pair<
@@ -106,6 +102,14 @@ generatePubLedgerMessage(
std::variant<Status, ripple::LedgerInfo>
ledgerInfoFromRequest(Context const& ctx);
std::variant<Status, ripple::LedgerInfo>
getLedgerInfoFromHashOrSeq(
BackendInterface const& backend,
boost::asio::yield_context& yield,
std::optional<std::string> ledgerHash,
std::optional<uint32_t> ledgerIndex,
uint32_t maxSeq);
std::variant<Status, AccountCursor>
traverseOwnedNodes(
BackendInterface const& backend,
@@ -128,6 +132,18 @@ traverseOwnedNodes(
boost::asio::yield_context& yield,
std::function<void(ripple::SLE&&)> atOwnedNode);
// Remove the account check from traverseOwnedNodes
// Account check has been done by framework,remove it from internal function
std::variant<Status, AccountCursor>
ngTraverseOwnedNodes(
BackendInterface const& backend,
ripple::AccountID const& accountID,
std::uint32_t sequence,
std::uint32_t limit,
std::optional<std::string> jsonCursor,
boost::asio::yield_context& yield,
std::function<void(ripple::SLE&&)> atOwnedNode);
std::shared_ptr<ripple::SLE const>
read(
ripple::Keylet const& keylet,

2
src/rpc/common/Concepts.h
View File

@@ -50,7 +50,7 @@ concept Requirement = requires(T a) {
*/
// clang-format off
template <typename T>
concept CoroutineProcess = requires(T a, typename T::Input in, typename T::Output out, boost::asio::yield_context* y) {
concept CoroutineProcess = requires(T a, typename T::Input in, typename T::Output out, boost::asio::yield_context& y) {
{ a.process(in, y) } -> std::same_as<HandlerReturnType<decltype(out)>>; };
template <typename T>

39
src/rpc/common/Validators.cpp
View File

@@ -18,6 +18,7 @@
//==============================================================================
#include <ripple/basics/base_uint.h>
#include <rpc/RPCHelpers.h>
#include <rpc/common/Validators.h>
#include <boost/json/value.hpp>
@@ -126,4 +127,42 @@ CustomValidator LedgerIndexValidator = CustomValidator{
return MaybeError{};
}};
CustomValidator AccountValidator = CustomValidator{
[](boost::json::value const& value, std::string_view key) -> MaybeError {
if (!value.is_string())
{
return Error{RPC::Status{
RPC::RippledError::rpcINVALID_PARAMS,
std::string(key) + "NotString"}};
}
// TODO: we are using accountFromStringStrict from RPCHelpers, after we
// remove all old handler, this function can be moved to here
if (!RPC::accountFromStringStrict(value.as_string().c_str()))
{
return Error{RPC::Status{
RPC::RippledError::rpcINVALID_PARAMS,
std::string(key) + "Malformed"}};
}
return MaybeError{};
}};
CustomValidator MarkerValidator = CustomValidator{
[](boost::json::value const& value, std::string_view key) -> MaybeError {
if (!value.is_string())
{
return Error{RPC::Status{
RPC::RippledError::rpcINVALID_PARAMS,
std::string(key) + "NotString"}};
}
// TODO: we are using parseAccountCursor from RPCHelpers, after we
// remove all old handler, this function can be moved to here
if (!RPC::parseAccountCursor(value.as_string().c_str()))
{
// align with the current error message
return Error{RPC::Status{
RPC::RippledError::rpcINVALID_PARAMS, "Malformed cursor"}};
}
return MaybeError{};
}};
} // namespace RPCng::validation

13
src/rpc/common/Validators.h
View File

@@ -360,4 +360,17 @@ extern CustomValidator LedgerIndexValidator;
*/
extern CustomValidator LedgerHashValidator;
/**
* @brief Provide a common used validator for account
* Account must be a string and the converted public key is valid
*/
extern CustomValidator AccountValidator;
/**
* @brief Provide a common used validator for marker
* Marker is composed of a comma separated index and start hint. The
* former will be read as hex, and the latter can cast to uint64.
*/
extern CustomValidator MarkerValidator;
} // namespace RPCng::validation

2
src/rpc/common/impl/Processors.h
View File

@@ -57,7 +57,7 @@ struct DefaultProcessor final
}
else
{
auto const ret = handler.process(inData, ptrYield);
auto const ret = handler.process(inData, *ptrYield);
// real handler is given expected Input, not json
if (!ret)
return Error{ret.error()}; // forward Status

210
src/rpc/ngHandlers/AccountChannels.cpp Normal file
View File

@@ -0,0 +1,210 @@
//------------------------------------------------------------------------------
/*
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/RPC.h>
#include <rpc/RPCHelpers.h>
#include <rpc/ngHandlers/AccountChannels.h>
namespace RPCng {
void
AccountChannelsHandler::addChannel(
std::vector<ChannelResponse>& jsonChannels,
ripple::SLE const& channelSle) const
{
ChannelResponse channel;
channel.channelID = ripple::to_string(channelSle.key());
channel.account =
ripple::to_string(channelSle.getAccountID(ripple::sfAccount));
channel.accountDestination =
ripple::to_string(channelSle.getAccountID(ripple::sfDestination));
channel.amount = channelSle[ripple::sfAmount].getText();
channel.balance = channelSle[ripple::sfBalance].getText();
if (publicKeyType(channelSle[ripple::sfPublicKey]))
{
ripple::PublicKey const pk(channelSle[ripple::sfPublicKey]);
channel.publicKey = toBase58(ripple::TokenType::AccountPublic, pk);
channel.publicKeyHex = strHex(pk);
}
channel.settleDelay = channelSle[ripple::sfSettleDelay];
if (auto const& v = channelSle[~ripple::sfExpiration])
channel.expiration = *v;
if (auto const& v = channelSle[~ripple::sfCancelAfter])
channel.cancelAfter = *v;
if (auto const& v = channelSle[~ripple::sfSourceTag])
channel.sourceTag = *v;
if (auto const& v = channelSle[~ripple::sfDestinationTag])
channel.destinationTag = *v;
jsonChannels.push_back(channel);
}
AccountChannelsHandler::Result
AccountChannelsHandler::process(
AccountChannelsHandler::Input input,
boost::asio::yield_context& yield) const
{
auto const range = sharedPtrBackend_->fetchLedgerRange();
auto const lgrInfoOrStatus = RPC::getLedgerInfoFromHashOrSeq(
*sharedPtrBackend_,
yield,
input.ledgerHash,
input.ledgerIndex,
range->maxSequence);
if (auto status = std::get_if<RPC::Status>(&lgrInfoOrStatus))
return Error{*status};
auto const lgrInfo = std::get<ripple::LedgerInfo>(lgrInfoOrStatus);
// no need to check the return value, validator check for us
auto const accountID = RPC::accountFromStringStrict(input.account);
auto const accountLedgerObject = sharedPtrBackend_->fetchLedgerObject(
ripple::keylet::account(*accountID).key, lgrInfo.seq, yield);
if (!accountLedgerObject)
return Error{RPC::Status{
RPC::RippledError::rpcACT_NOT_FOUND, "accountNotFound"}};
auto const destAccountID = input.destinationAccount
? RPC::accountFromStringStrict(input.destinationAccount.value())
: std::optional<ripple::AccountID>{};
Output response;
auto const addToResponse = [&](ripple::SLE&& sle) {
if (sle.getType() == ripple::ltPAYCHAN &&
sle.getAccountID(ripple::sfAccount) == accountID &&
(!destAccountID ||
*destAccountID == sle.getAccountID(ripple::sfDestination)))
{
addChannel(response.channels, sle);
}
return true;
};
auto const next = RPC::ngTraverseOwnedNodes(
*sharedPtrBackend_,
*accountID,
lgrInfo.seq,
input.limit,
input.marker,
yield,
addToResponse);
response.account = input.account;
response.limit = input.limit;
response.ledgerHash = ripple::strHex(lgrInfo.hash);
response.ledgerIndex = lgrInfo.seq;
auto const nextMarker = std::get<RPC::AccountCursor>(next);
if (nextMarker.isNonZero())
response.marker = nextMarker.toString();
return response;
}
AccountChannelsHandler::Input
tag_invoke(
boost::json::value_to_tag<AccountChannelsHandler::Input>,
boost::json::value const& jv)
{
auto const& jsonObject = jv.as_object();
AccountChannelsHandler::Input input;
input.account = jv.at("account").as_string().c_str();
if (jsonObject.contains("limit"))
{
input.limit = jv.at("limit").as_int64();
}
if (jsonObject.contains("marker"))
{
input.marker = jv.at("marker").as_string().c_str();
}
if (jsonObject.contains("ledger_hash"))
{
input.ledgerHash = jv.at("ledger_hash").as_string().c_str();
}
if (jsonObject.contains("destination_account"))
{
input.destinationAccount =
jv.at("destination_account").as_string().c_str();
}
if (jsonObject.contains("ledger_index"))
{
if (!jsonObject.at("ledger_index").is_string())
{
input.ledgerIndex = jv.at("ledger_index").as_int64();
}
else if (jsonObject.at("ledger_index").as_string() != "validated")
{
input.ledgerIndex =
std::stoi(jv.at("ledger_index").as_string().c_str());
}
}
return input;
}
void
tag_invoke(
boost::json::value_from_tag,
boost::json::value& jv,
AccountChannelsHandler::Output output)
{
boost::json::object obj;
obj = {
{"account", output.account},
{"ledger_hash", output.ledgerHash},
{"ledger_index", output.ledgerIndex},
{"validated", output.validated},
{"limit", output.limit},
{"channels", boost::json::value_from(output.channels)}};
if (output.marker)
obj["marker"] = output.marker.value();
jv = obj;
}
void
tag_invoke(
boost::json::value_from_tag,
boost::json::value& jv,
AccountChannelsHandler::ChannelResponse channel)
{
boost::json::object obj;
obj = {
{"channel_id", channel.channelID},
{"account", channel.account},
{"account_destination", channel.accountDestination},
{"amount", channel.amount},
{"balance", channel.balance},
{"settle_delay", channel.settleDelay}};
if (channel.publicKey)
obj["public_key"] = *(channel.publicKey);
if (channel.publicKeyHex)
obj["public_key_hex"] = *(channel.publicKeyHex);
if (channel.expiration)
obj["expiration"] = *(channel.expiration);
if (channel.cancelAfter)
obj["cancel_after"] = *(channel.cancelAfter);
if (channel.sourceTag)
obj["source_tag"] = *(channel.sourceTag);
if (channel.destinationTag)
obj["destination_tag"] = *(channel.destinationTag);
jv = obj;
}
} // namespace RPCng

125
src/rpc/ngHandlers/AccountChannels.h Normal file
View File

@@ -0,0 +1,125 @@
//------------------------------------------------------------------------------
/*
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.
*/
//==============================================================================
#pragma once
#include <backend/BackendInterface.h>
#include <rpc/common/Types.h>
#include <rpc/common/Validators.h>
#include <boost/asio/spawn.hpp>
#include <vector>
namespace RPCng {
class AccountChannelsHandler
{
// dependencies
std::shared_ptr<BackendInterface> const sharedPtrBackend_;
public:
// type align with SField.h
struct ChannelResponse
{
std::string channelID;
std::string account;
std::string accountDestination;
std::string amount;
std::string balance;
std::optional<std::string> publicKey;
std::optional<std::string> publicKeyHex;
uint32_t settleDelay;
std::optional<uint32_t> expiration;
std::optional<uint32_t> cancelAfter;
std::optional<uint32_t> sourceTag;
std::optional<uint32_t> destinationTag;
};
struct Output
{
std::vector<ChannelResponse> channels;
std::string account;
std::string ledgerHash;
uint32_t ledgerIndex;
// validated should be sent via framework
bool validated = true;
uint32_t limit;
std::optional<std::string> marker;
};
struct Input
{
std::string account;
std::optional<std::string> destinationAccount;
std::optional<std::string> ledgerHash;
std::optional<uint32_t> ledgerIndex;
uint32_t limit = 50;
std::optional<std::string> marker;
};
using Result = RPCng::HandlerReturnType<Output>;
AccountChannelsHandler(std::shared_ptr<BackendInterface>& sharedPtrBackend)
: sharedPtrBackend_(sharedPtrBackend)
{
}
RpcSpecConstRef
spec() const
{
// clang-format off
static const RpcSpec rpcSpec = {
{"account", validation::Required{}, validation::AccountValidator},
{"destination_account", validation::Type<std::string>{},validation::AccountValidator},
{"ledger_hash", validation::LedgerHashValidator},
{"limit", validation::Type<uint32_t>{},validation::Between{10,400}},
{"ledger_index", validation::LedgerIndexValidator},
{"marker", validation::MarkerValidator}
};
// clang-format on
return rpcSpec;
}
Result
process(Input input, boost::asio::yield_context& yield) const;
private:
void
addChannel(std::vector<ChannelResponse>& jsonLines, ripple::SLE const& line)
const;
};
AccountChannelsHandler::Input
tag_invoke(
boost::json::value_to_tag<AccountChannelsHandler::Input>,
boost::json::value const& jv);
void
tag_invoke(
boost::json::value_from_tag,
boost::json::value& jv,
AccountChannelsHandler::Output output);
void
tag_invoke(
boost::json::value_from_tag,
boost::json::value& jv,
AccountChannelsHandler::ChannelResponse channel);
} // namespace RPCng

43
unittests/rpc/BaseTests.cpp
View File

@@ -280,3 +280,46 @@ TEST_F(RPCBaseTest, LedgerIndexValidator)
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "ledgerIndexMalformed");
}
TEST_F(RPCBaseTest, AccountValidator)
{
auto spec = RpcSpec{
{"account", AccountValidator},
};
auto failingInput = json::parse(R"({ "account": 256 })");
ASSERT_FALSE(spec.validate(failingInput));
failingInput =
json::parse(R"({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })");
ASSERT_FALSE(spec.validate(failingInput));
failingInput = json::parse(
R"({ "account": "02000000000000000000000000000000000000000000000000000000000000000" })");
ASSERT_FALSE(spec.validate(failingInput));
auto passingInput =
json::parse(R"({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })");
ASSERT_TRUE(spec.validate(passingInput));
passingInput = json::parse(
R"({ "account": "020000000000000000000000000000000000000000000000000000000000000000" })");
ASSERT_TRUE(spec.validate(passingInput));
}
TEST_F(RPCBaseTest, MarkerValidator)
{
auto spec = RpcSpec{
{"marker", MarkerValidator},
};
auto failingInput = json::parse(R"({ "marker": 256 })");
ASSERT_FALSE(spec.validate(failingInput));
failingInput = json::parse(R"({ "marker": "testtest" })");
ASSERT_FALSE(spec.validate(failingInput));
failingInput = json::parse(R"({ "marker": "ABAB1234:1H" })");
ASSERT_FALSE(spec.validate(failingInput));
auto passingInput = json::parse(R"({ "account": "ABAB1234:123" })");
ASSERT_TRUE(spec.validate(passingInput));
}

893
unittests/rpc/handlers/AccountChannelsTest.cpp Normal file
View File

@@ -0,0 +1,893 @@
//------------------------------------------------------------------------------
/*
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/ngHandlers/AccountChannels.h>
#include <util/Fixtures.h>
#include <util/TestObject.h>
#include <fmt/core.h>
using namespace RPCng;
namespace json = boost::json;
using namespace testing;
constexpr static auto LEDGERHASH =
"4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652";
constexpr static auto ACCOUNT = "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn";
constexpr static auto ACCOUNT2 = "rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun";
constexpr static auto ACCOUNT3 = "rB9BMzh27F3Q6a5FtGPDayQoCCEdiRdqcK";
constexpr static auto INDEX1 =
"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321";
constexpr static auto INDEX2 =
"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322";
constexpr static auto TXNID =
"05FB0EB4B899F056FA095537C5817163801F544BAFCEA39C995D76DB4D16F9DD";
class RPCAccountHandlerTest : public SyncAsioContextTest, public MockBackendTest
{
void
SetUp() override
{
SyncAsioContextTest::SetUp();
MockBackendTest::SetUp();
}
void
TearDown() override
{
MockBackendTest::TearDown();
SyncAsioContextTest::TearDown();
}
};
TEST_F(RPCAccountHandlerTest, NonHexLedgerHash)
{
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit": 10,
"ledger_hash": "xxx"
}})",
ACCOUNT));
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "ledgerHashMalformed");
});
ctx.run();
}
TEST_F(RPCAccountHandlerTest, NonStringLedgerHash)
{
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit": 10,
"ledger_hash": 123
}})",
ACCOUNT));
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "ledgerHashNotString");
});
ctx.run();
}
TEST_F(RPCAccountHandlerTest, InvalidLedgerIndexString)
{
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit": 10,
"ledger_index": "notvalidated"
}})",
ACCOUNT));
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "ledgerIndexMalformed");
});
ctx.run();
}
TEST_F(RPCAccountHandlerTest, MarkerNotString)
{
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"marker":9
}})",
ACCOUNT));
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "markerNotString");
});
ctx.run();
}
// error case : invalid marker
// marker format is composed of a comma separated index and start hint. The
// former will be read as hex, and the latter using boost lexical cast.
TEST_F(RPCAccountHandlerTest, InvalidMarker)
{
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"marker": "123invalid"
}})",
ACCOUNT));
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "Malformed cursor");
});
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"marker":401
}})",
ACCOUNT));
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
});
ctx.run();
}
// the limit is between 10 400
TEST_F(RPCAccountHandlerTest, IncorrectLimit)
{
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit":9
}})",
ACCOUNT));
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
});
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit":401
}})",
ACCOUNT));
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
});
}
// error case: account invalid format, length is incorrect
TEST_F(RPCAccountHandlerTest, AccountInvalidFormat)
{
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(R"({
"account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp"
})");
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "accountMalformed");
});
ctx.run();
}
// error case: account invalid format
TEST_F(RPCAccountHandlerTest, AccountNotString)
{
boost::asio::spawn(ctx, [this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const input = json::parse(R"({
"account": 12
})");
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "invalidParams");
EXPECT_EQ(err.at("error_message").as_string(), "accountNotString");
});
ctx.run();
}
// error case ledger non exist via hash
TEST_F(RPCAccountHandlerTest, NonExistLedgerViaLedgerHash)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
// mock fetchLedgerByHash return empty
ON_CALL(*rawBackendPtr, fetchLedgerByHash)
.WillByDefault(Return(std::optional<ripple::LedgerInfo>{}));
EXPECT_CALL(*rawBackendPtr, fetchLedgerByHash).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_hash": "{}"
}})",
ACCOUNT,
LEDGERHASH));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
});
ctx.run();
}
// error case ledger non exist via index
TEST_F(RPCAccountHandlerTest, NonExistLedgerViaLedgerIndex)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
// mock fetchLedgerBySequence return empty
ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
.WillByDefault(Return(std::optional<ripple::LedgerInfo>{}));
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index": "4"
}})",
ACCOUNT));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
});
ctx.run();
}
// error case ledger > max seq via hash
// idk why this case will happen in reality
TEST_F(RPCAccountHandlerTest, NonExistLedgerViaLedgerHash2)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
// mock fetchLedgerByHash return ledger but seq is 31 > 30
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 31);
ON_CALL(*rawBackendPtr, fetchLedgerByHash)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerByHash).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_hash": "{}"
}})",
ACCOUNT,
LEDGERHASH));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
});
ctx.run();
}
// error case ledger > max seq via index
TEST_F(RPCAccountHandlerTest, NonExistLedgerViaLedgerIndex2)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
// no need to check from db,call fetchLedgerBySequence 0 time
// differ from previous logic
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(0);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_index": "31"
}})",
ACCOUNT));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "lgrNotFound");
EXPECT_EQ(err.at("error_message").as_string(), "ledgerNotFound");
});
ctx.run();
}
// error case account not exist
TEST_F(RPCAccountHandlerTest, NonExistAccount)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
ON_CALL(*rawBackendPtr, fetchLedgerByHash)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerByHash).Times(1);
// fetch account object return emtpy
ON_CALL(*rawBackendPtr, doFetchLedgerObject)
.WillByDefault(Return(std::optional<Blob>{}));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"ledger_hash": "{}"
}})",
ACCOUNT,
LEDGERHASH));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto const handler = AnyHandler{AccountChannelsHandler{mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_FALSE(output);
auto const err = RPC::makeError(output.error());
EXPECT_EQ(err.at("error").as_string(), "actNotFound");
EXPECT_EQ(err.at("error_message").as_string(), "accountNotFound");
});
ctx.run();
}
// normal case when only provide account
TEST_F(RPCAccountHandlerTest, DefaultParameterTest)
{
constexpr static auto correntOutput = R"({
"account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"ledger_hash":"4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652",
"ledger_index":30,
"validated":true,
"limit":50,
"channels":[
{
"channel_id":"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321",
"account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"account_destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
"amount":"100",
"balance":"10",
"settle_delay":32,
"public_key":"aBMxWrnPUnvwZPfsmTyVizxEGsGheAu3Tsn6oPRgyjgvd2NggFxz",
"public_key_hex":"020000000000000000000000000000000000000000000000000000000000000000"
},
{
"channel_id":"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322",
"account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"account_destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
"amount":"100",
"balance":"10",
"settle_delay":32,
"public_key":"aBMxWrnPUnvwZPfsmTyVizxEGsGheAu3Tsn6oPRgyjgvd2NggFxz",
"public_key_hex":"020000000000000000000000000000000000000000000000000000000000000000"
}
]
})";
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
// fetch account object return something
auto account = GetAccountIDWithString(ACCOUNT);
auto accountKk = ripple::keylet::account(account).key;
auto owneDirKk = ripple::keylet::ownerDir(account).key;
auto fake = Blob{'f', 'a', 'k', 'e'};
// return a non empty account
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(accountKk, testing::_, testing::_))
.WillByDefault(Return(fake));
// return owner index containing 2 indexes
ripple::STObject ownerDir = CreateOwnerDirLedgerObject(
{ripple::uint256{INDEX1}, ripple::uint256{INDEX2}}, INDEX1);
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(owneDirKk, testing::_, testing::_))
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
// return two payment channel objects
std::vector<Blob> bbs;
ripple::STObject channel1 = CreatePaymentChannelLedgerObject(
ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
bbs.push_back(channel1.getSerializer().peekData());
bbs.push_back(channel1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObjects).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}"
}})",
ACCOUNT));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{AccountChannelsHandler{this->mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_TRUE(output);
EXPECT_EQ(json::parse(correntOutput), *output);
});
ctx.run();
}
// normal case : limit is used
TEST_F(RPCAccountHandlerTest, UseLimit)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
// fetch account object return something
auto account = GetAccountIDWithString(ACCOUNT);
auto accountKk = ripple::keylet::account(account).key;
auto owneDirKk = ripple::keylet::ownerDir(account).key;
auto fake = Blob{'f', 'a', 'k', 'e'};
// return a non empty account
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(accountKk, testing::_, testing::_))
.WillByDefault(Return(fake));
// return owner index
std::vector<ripple::uint256> indexes;
std::vector<Blob> bbs;
auto repetitions = 50;
while (repetitions--)
{
indexes.push_back(ripple::uint256{INDEX1});
ripple::STObject channel = CreatePaymentChannelLedgerObject(
ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
bbs.push_back(channel.getSerializer().peekData());
}
ripple::STObject ownerDir = CreateOwnerDirLedgerObject(indexes, INDEX1);
// it should not appear in return marker,marker is the current page
ownerDir.setFieldU64(ripple::sfIndexNext, 99);
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(owneDirKk, testing::_, testing::_))
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObjects).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit": 20
}})",
ACCOUNT));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{AccountChannelsHandler{this->mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_TRUE(output);
EXPECT_EQ((*output).as_object().at("channels").as_array().size(), 20);
EXPECT_THAT(
(*output).as_object().at("marker").as_string().c_str(),
EndsWith(",0"));
});
ctx.run();
}
// normal case : destination is used
TEST_F(RPCAccountHandlerTest, UseDestination)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
// fetch account object return something
auto account = GetAccountIDWithString(ACCOUNT);
auto accountKk = ripple::keylet::account(account).key;
auto owneDirKk = ripple::keylet::ownerDir(account).key;
auto fake = Blob{'f', 'a', 'k', 'e'};
// return a non empty account
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(accountKk, testing::_, testing::_))
.WillByDefault(Return(fake));
// return owner index
std::vector<ripple::uint256> indexes;
std::vector<Blob> bbs;
// 10 pay channel to ACCOUNT2
auto repetitions = 10;
while (repetitions--)
{
indexes.push_back(ripple::uint256{INDEX1});
ripple::STObject channel = CreatePaymentChannelLedgerObject(
ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
bbs.push_back(channel.getSerializer().peekData());
}
// 20 pay channel to ACCOUNT3
repetitions = 20;
while (repetitions--)
{
indexes.push_back(ripple::uint256{INDEX1});
ripple::STObject channel = CreatePaymentChannelLedgerObject(
ACCOUNT, ACCOUNT3, 100, 10, 32, TXNID, 28);
bbs.push_back(channel.getSerializer().peekData());
}
ripple::STObject ownerDir = CreateOwnerDirLedgerObject(indexes, INDEX1);
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(owneDirKk, testing::_, testing::_))
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObjects).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit": 30,
"destination_account":"{}"
}})",
ACCOUNT,
ACCOUNT3));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{AccountChannelsHandler{this->mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_TRUE(output);
EXPECT_EQ((*output).as_object().at("channels").as_array().size(), 20);
});
ctx.run();
}
// normal case : but the lines is emtpy
TEST_F(RPCAccountHandlerTest, EmptyChannel)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
// fetch account object return something
auto account = GetAccountIDWithString(ACCOUNT);
auto accountKk = ripple::keylet::account(account).key;
auto owneDirKk = ripple::keylet::ownerDir(account).key;
auto fake = Blob{'f', 'a', 'k', 'e'};
// return a non empty account
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(accountKk, testing::_, testing::_))
.WillByDefault(Return(fake));
// return owner index
ripple::STObject ownerDir = CreateOwnerDirLedgerObject({}, INDEX1);
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(owneDirKk, testing::_, testing::_))
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}"
}})",
ACCOUNT));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{AccountChannelsHandler{this->mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_TRUE(output);
EXPECT_EQ((*output).as_object().at("channels").as_array().size(), 0);
});
ctx.run();
}
// Return expiration cancel_offer source_tag destination_tag when available
TEST_F(RPCAccountHandlerTest, OptionalResponseField)
{
constexpr static auto correntOutput = R"({
"account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"ledger_hash":"4BC50C9B0D8515D3EAAE1E74B29A95804346C491EE1A95BF25E4AAB854A6A652",
"ledger_index":30,
"validated":true,
"limit":50,
"channels":[
{
"channel_id":"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC321",
"account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"account_destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
"amount":"100",
"balance":"10",
"settle_delay":32,
"public_key":"aBMxWrnPUnvwZPfsmTyVizxEGsGheAu3Tsn6oPRgyjgvd2NggFxz",
"public_key_hex":"020000000000000000000000000000000000000000000000000000000000000000",
"expiration": 100,
"cancel_after": 200,
"source_tag": 300,
"destination_tag": 400
},
{
"channel_id":"E6DBAFC99223B42257915A63DFC6B0C032D4070F9A574B255AD97466726FC322",
"account":"rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn",
"account_destination":"rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun",
"amount":"100",
"balance":"10",
"settle_delay":32,
"public_key":"aBMxWrnPUnvwZPfsmTyVizxEGsGheAu3Tsn6oPRgyjgvd2NggFxz",
"public_key_hex":"020000000000000000000000000000000000000000000000000000000000000000",
"expiration": 100,
"cancel_after": 200,
"source_tag": 300,
"destination_tag": 400
}
]
})";
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
// fetch account object return something
auto account = GetAccountIDWithString(ACCOUNT);
auto accountKk = ripple::keylet::account(account).key;
auto owneDirKk = ripple::keylet::ownerDir(account).key;
auto fake = Blob{'f', 'a', 'k', 'e'};
// return a non empty account
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(accountKk, testing::_, testing::_))
.WillByDefault(Return(fake));
// return owner index
ripple::STObject ownerDir = CreateOwnerDirLedgerObject(
{ripple::uint256{INDEX1}, ripple::uint256{INDEX2}}, INDEX1);
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(owneDirKk, testing::_, testing::_))
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(2);
// return two payment channel objects
std::vector<Blob> bbs;
ripple::STObject channel1 = CreatePaymentChannelLedgerObject(
ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
channel1.setFieldU32(ripple::sfExpiration, 100);
channel1.setFieldU32(ripple::sfCancelAfter, 200);
channel1.setFieldU32(ripple::sfSourceTag, 300);
channel1.setFieldU32(ripple::sfDestinationTag, 400);
bbs.push_back(channel1.getSerializer().peekData());
bbs.push_back(channel1.getSerializer().peekData());
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObjects).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}"
}})",
ACCOUNT));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{AccountChannelsHandler{this->mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_TRUE(output);
EXPECT_EQ(json::parse(correntOutput), *output);
});
ctx.run();
}
// normal case : test marker output correct
TEST_F(RPCAccountHandlerTest, MarkerOutput)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
auto account = GetAccountIDWithString(ACCOUNT);
auto accountKk = ripple::keylet::account(account).key;
auto ownerDirKk = ripple::keylet::ownerDir(account).key;
constexpr static auto nextPage = 99;
constexpr static auto limit = 15;
auto ownerDir2Kk =
ripple::keylet::page(ripple::keylet::ownerDir(account), nextPage).key;
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
// fetch account object return something
auto fake = Blob{'f', 'a', 'k', 'e'};
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(accountKk, testing::_, testing::_))
.WillByDefault(Return(fake));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
std::vector<Blob> bbs;
ripple::STObject channel1 = CreatePaymentChannelLedgerObject(
ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
// owner dir contains 10 indexes
int objectsCount = 10;
std::vector<ripple::uint256> indexes;
while (objectsCount != 0)
{
// return owner index
indexes.push_back(ripple::uint256{INDEX1});
objectsCount--;
}
// return 15 objects
objectsCount = 15;
while (objectsCount != 0)
{
bbs.push_back(channel1.getSerializer().peekData());
objectsCount--;
}
ripple::STObject ownerDir = CreateOwnerDirLedgerObject(indexes, INDEX1);
ownerDir.setFieldU64(ripple::sfIndexNext, nextPage);
// first page 's next page is 99
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(ownerDirKk, testing::_, testing::_))
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
ripple::STObject ownerDir2 = CreateOwnerDirLedgerObject(indexes, INDEX1);
// second page's next page is 0
ownerDir2.setFieldU64(ripple::sfIndexNext, 0);
ON_CALL(
*rawBackendPtr,
doFetchLedgerObject(ownerDir2Kk, testing::_, testing::_))
.WillByDefault(Return(ownerDir2.getSerializer().peekData()));
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObjects).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit": {}
}})",
ACCOUNT,
limit));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{AccountChannelsHandler{this->mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_TRUE(output);
EXPECT_EQ(
(*output).as_object().at("marker").as_string().c_str(),
fmt::format("{},{}", INDEX1, nextPage));
EXPECT_EQ((*output).as_object().at("channels").as_array().size(), 15);
});
ctx.run();
}
// normal case : handler marker correctly
TEST_F(RPCAccountHandlerTest, MarkerInput)
{
MockBackend* rawBackendPtr =
static_cast<MockBackend*>(mockBackendPtr.get());
mockBackendPtr->updateRange(10); // min
mockBackendPtr->updateRange(30); // max
auto account = GetAccountIDWithString(ACCOUNT);
auto accountKk = ripple::keylet::account(account).key;
constexpr static auto nextPage = 99;
constexpr static auto limit = 15;
auto ownerDirKk =
ripple::keylet::page(ripple::keylet::ownerDir(account), nextPage).key;
auto ledgerinfo = CreateLedgerInfo(LEDGERHASH, 30);
ON_CALL(*rawBackendPtr, fetchLedgerBySequence)
.WillByDefault(Return(ledgerinfo));
EXPECT_CALL(*rawBackendPtr, fetchLedgerBySequence).Times(1);
// fetch account object return something
auto fake = Blob{'f', 'a', 'k', 'e'};
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(accountKk, testing::_, testing::_))
.WillByDefault(Return(fake));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObject).Times(3);
std::vector<Blob> bbs;
ripple::STObject channel1 = CreatePaymentChannelLedgerObject(
ACCOUNT, ACCOUNT2, 100, 10, 32, TXNID, 28);
int objectsCount = limit;
std::vector<ripple::uint256> indexes;
while (objectsCount != 0)
{
// return owner index
indexes.push_back(ripple::uint256{INDEX1});
bbs.push_back(channel1.getSerializer().peekData());
objectsCount--;
}
ripple::STObject ownerDir = CreateOwnerDirLedgerObject(indexes, INDEX1);
ownerDir.setFieldU64(ripple::sfIndexNext, 0);
ON_CALL(
*rawBackendPtr, doFetchLedgerObject(ownerDirKk, testing::_, testing::_))
.WillByDefault(Return(ownerDir.getSerializer().peekData()));
ON_CALL(*rawBackendPtr, doFetchLedgerObjects).WillByDefault(Return(bbs));
EXPECT_CALL(*rawBackendPtr, doFetchLedgerObjects).Times(1);
auto const input = json::parse(fmt::format(
R"({{
"account": "{}",
"limit": {},
"marker": "{},{}"
}})",
ACCOUNT,
limit,
INDEX1,
nextPage));
boost::asio::spawn(ctx, [&, this](boost::asio::yield_context yield) {
auto handler = AnyHandler{AccountChannelsHandler{this->mockBackendPtr}};
auto const output = handler.process(input, yield);
ASSERT_TRUE(output);
EXPECT_TRUE((*output).as_object().if_contains("marker") == nullptr);
// the first item is the marker itself, so the result will have limit-1
// items
EXPECT_EQ(
(*output).as_object().at("channels").as_array().size(), limit - 1);
});
ctx.run();
}

2
unittests/rpc/handlers/impl/FakesAndMocks.h
View File

@@ -122,7 +122,7 @@ public:
}
Result
process(Input input, boost::asio::yield_context* ptrYield) const
process(Input input, boost::asio::yield_context& yield) const
{
return Output{
input.hello + '_' + std::to_string(input.limit.value_or(0))};