ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2025-12-06 17:27:55 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
e4b17d1cf2c43e33128dd70b6036fe10f38b0c0d
rippled/src/test/rpc/AccountOffers_test.cpp

340 lines
13 KiB
C++
Raw Blame History

//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2016 Ripple Labs Inc.
Permission to use, copy, modify, and/or 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 <ripple/protocol/jss.h>
#include <test/jtx.h>
namespace ripple {
namespace test {
class AccountOffers_test : public beast::unit_test::suite
{
public:
// test helper
static bool
checkArraySize(Json::Value const& val, unsigned int size)
{
return val.isArray() && val.size() == size;
}
// test helper
static bool
checkMarker(Json::Value const& val)
{
return val.isMember(jss::marker) && val[jss::marker].isString() &&
val[jss::marker].asString().size() > 0;
}
void
testNonAdminMinLimit()
{
using namespace jtx;
Env env{*this, envconfig(no_admin)};
Account const gw("G1");
auto const USD_gw = gw["USD"];
Account const bob("bob");
auto const USD_bob = bob["USD"];
env.fund(XRP(10000), gw, bob);
env.trust(USD_gw(1000), bob);
// this is to provide some USD from gw in the
// bob account so that it can rightly
// make offers that give those USDs
env(pay(gw, bob, USD_gw(10)));
unsigned const offer_count = 12u;
for (auto i = 0u; i < offer_count; i++)
{
Json::Value jvo = offer(bob, XRP(100 + i), USD_gw(1));
jvo[sfExpiration.fieldName] = 10000000u;
env(jvo);
}
// make non-limited RPC call
auto const jro_nl =
env.rpc("account_offers", bob.human())[jss::result][jss::offers];
BEAST_EXPECT(checkArraySize(jro_nl, offer_count));
// now make a low-limit query, should get "corrected"
// to a min of 10 results with a marker set since there
// are more than 10 total
Json::Value jvParams;
jvParams[jss::account] = bob.human();
jvParams[jss::limit] = 1u;
auto const jrr_l = env.rpc(
"json", "account_offers", jvParams.toStyledString())[jss::result];
auto const& jro_l = jrr_l[jss::offers];
BEAST_EXPECT(checkMarker(jrr_l));
// 9u is the expected size, since one account object is a trustline
BEAST_EXPECT(checkArraySize(jro_l, 9u));
}
void
testSequential(bool asAdmin)
{
using namespace jtx;
Env env{*this, asAdmin ? envconfig() : envconfig(no_admin)};
Account const gw("G1");
auto const USD_gw = gw["USD"];
Account const bob("bob");
auto const USD_bob = bob["USD"];
env.fund(XRP(10000), gw, bob);
env.trust(USD_gw(1000), bob);
// this is to provide some USD from gw in the
// bob account so that it can rightly
// make offers that give those USDs
env(pay(gw, bob, USD_gw(10)));
env(offer(bob, XRP(100), USD_bob(1)));
env(offer(bob, XRP(200), USD_gw(2)));
env(offer(bob, XRP(30), USD_gw(6)));
// make the RPC call
auto const jroOuter =
env.rpc("account_offers", bob.human())[jss::result][jss::offers];
if (BEAST_EXPECT(checkArraySize(jroOuter, 3u)))
{
// Note that the returned offers are sorted by index, not by
// order of insertion or by sequence number. There is no
// guarantee that their order will not change in the future
// if the sequence numbers or the account IDs change.
BEAST_EXPECT(jroOuter[0u][jss::quality] == "100000000");
BEAST_EXPECT(jroOuter[0u][jss::taker_gets][jss::currency] == "USD");
BEAST_EXPECT(
jroOuter[0u][jss::taker_gets][jss::issuer] == gw.human());
BEAST_EXPECT(jroOuter[0u][jss::taker_gets][jss::value] == "2");
BEAST_EXPECT(jroOuter[0u][jss::taker_pays] == "200000000");
BEAST_EXPECT(jroOuter[1u][jss::quality] == "100000000");
BEAST_EXPECT(jroOuter[1u][jss::taker_gets][jss::currency] == "USD");
BEAST_EXPECT(
jroOuter[1u][jss::taker_gets][jss::issuer] == bob.human());
BEAST_EXPECT(jroOuter[1u][jss::taker_gets][jss::value] == "1");
BEAST_EXPECT(jroOuter[1u][jss::taker_pays] == "100000000");
BEAST_EXPECT(jroOuter[2u][jss::quality] == "5000000");
BEAST_EXPECT(jroOuter[2u][jss::taker_gets][jss::currency] == "USD");
BEAST_EXPECT(
jroOuter[2u][jss::taker_gets][jss::issuer] == gw.human());
BEAST_EXPECT(jroOuter[2u][jss::taker_gets][jss::value] == "6");
BEAST_EXPECT(jroOuter[2u][jss::taker_pays] == "30000000");
}
{
// now make a limit (= 1) query for the same data
Json::Value jvParams;
jvParams[jss::account] = bob.human();
jvParams[jss::limit] = 1u;
auto const jrr_l_1 = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
auto const& jro_l_1 = jrr_l_1[jss::offers];
// there is a difference in the validation of the limit param
// between admin and non-admin requests. with admin requests, the
// limit parameter is NOT subject to sane defaults, but with a
// non-admin there are pre-configured limit ranges applied. That's
// why we have different BEAST_EXPECT()s here for the two scenarios
BEAST_EXPECT(checkArraySize(jro_l_1, asAdmin ? 1u : 3u));
BEAST_EXPECT(
asAdmin ? checkMarker(jrr_l_1)
: (!jrr_l_1.isMember(jss::marker)));
if (asAdmin)
{
BEAST_EXPECT(jroOuter[0u] == jro_l_1[0u]);
// second item...with previous marker passed
jvParams[jss::marker] = jrr_l_1[jss::marker];
auto const jrr_l_2 = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
auto const& jro_l_2 = jrr_l_2[jss::offers];
BEAST_EXPECT(checkMarker(jrr_l_2));
BEAST_EXPECT(checkArraySize(jro_l_2, 1u));
BEAST_EXPECT(jroOuter[1u] == jro_l_2[0u]);
// last item...with previous marker passed
jvParams[jss::marker] = jrr_l_2[jss::marker];
jvParams[jss::limit] = 10u;
auto const jrr_l_3 = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
auto const& jro_l_3 = jrr_l_3[jss::offers];
BEAST_EXPECT(!jrr_l_3.isMember(jss::marker));
BEAST_EXPECT(checkArraySize(jro_l_3, 1u));
BEAST_EXPECT(jroOuter[2u] == jro_l_3[0u]);
}
else
{
BEAST_EXPECT(jroOuter == jro_l_1);
}
}
{
// now make a limit (= 0) query for the same data
// since we operate on the admin port, the limit
// value of 0 is not adjusted into tuned ranges for admin requests
// so we literally get 0 elements in that case. For non-admin
// requests, we get limit defaults applied thus all our results
// come back (we are below the min results limit)
Json::Value jvParams;
jvParams[jss::account] = bob.human();
jvParams[jss::limit] = 0u;
auto const jrr = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
auto const& jro = jrr[jss::offers];
if (asAdmin)
{
// limit == 0 is invalid
BEAST_EXPECT(jrr.isMember(jss::error_message));
}
else
{
// Call should enforce min limit of 10
BEAST_EXPECT(checkArraySize(jro, 3u));
BEAST_EXPECT(!jrr.isMember(jss::marker));
}
}
}
void
testBadInput()
{
using namespace jtx;
Env env(*this);
Account const gw("G1");
auto const USD_gw = gw["USD"];
Account const bob("bob");
auto const USD_bob = bob["USD"];
env.fund(XRP(10000), gw, bob);
env.trust(USD_gw(1000), bob);
{
// no account field
auto const jrr = env.rpc("account_offers");
BEAST_EXPECT(jrr[jss::error] == "badSyntax");
BEAST_EXPECT(jrr[jss::status] == "error");
BEAST_EXPECT(jrr[jss::error_message] == "Syntax error.");
}
{
// empty string account
Json::Value jvParams;
jvParams[jss::account] = "";
auto const jrr = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
BEAST_EXPECT(jrr[jss::error] == "badSeed");
BEAST_EXPECT(jrr[jss::status] == "error");
BEAST_EXPECT(jrr[jss::error_message] == "Disallowed seed.");
}
{
// bogus account value
auto const jrr =
env.rpc("account_offers", "rNOT_AN_ACCOUNT")[jss::result];
BEAST_EXPECT(jrr[jss::error] == "actNotFound");
BEAST_EXPECT(jrr[jss::status] == "error");
BEAST_EXPECT(jrr[jss::error_message] == "Account not found.");
}
{
// bad limit
Json::Value jvParams;
jvParams[jss::account] = bob.human();
jvParams[jss::limit] = "0"; // NOT an integer
auto const jrr = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
BEAST_EXPECT(jrr[jss::error] == "invalidParams");
BEAST_EXPECT(jrr[jss::status] == "error");
BEAST_EXPECT(
jrr[jss::error_message] ==
"Invalid field 'limit', not unsigned integer.");
}
{
// invalid marker
Json::Value jvParams;
jvParams[jss::account] = bob.human();
jvParams[jss::marker] = "NOT_A_MARKER";
auto const jrr = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
BEAST_EXPECT(jrr[jss::error] == "invalidParams");
BEAST_EXPECT(jrr[jss::status] == "error");
BEAST_EXPECT(jrr[jss::error_message] == "Invalid parameters.");
}
{
// invalid marker - not a string
Json::Value jvParams;
jvParams[jss::account] = bob.human();
jvParams[jss::marker] = 1;
auto const jrr = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
BEAST_EXPECT(jrr[jss::error] == "invalidParams");
BEAST_EXPECT(jrr[jss::status] == "error");
BEAST_EXPECT(
jrr[jss::error_message] ==
"Invalid field 'marker', not string.");
}
{
// ask for a bad ledger index
Json::Value jvParams;
jvParams[jss::account] = bob.human();
jvParams[jss::ledger_index] = 10u;
auto const jrr = env.rpc(
"json",
"account_offers",
jvParams.toStyledString())[jss::result];
BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
BEAST_EXPECT(jrr[jss::status] == "error");
BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
}
}
void
run() override
{
testSequential(true);
testSequential(false);
testBadInput();
testNonAdminMinLimit();
}
};
BEAST_DEFINE_TESTSUITE(AccountOffers, app, ripple);
} // namespace test
} // namespace ripple
Reference in New Issue View Git Blame Copy Permalink