xrpld
Loading...
Searching...
No Matches
AccountCurrencies_test.cpp
1
2#include <test/jtx/Env.h>
3#include <test/jtx/amount.h>
4#include <test/jtx/pay.h>
5#include <test/jtx/trust.h>
6
7#include <xrpl/beast/unit_test/suite.h>
8#include <xrpl/json/json_value.h>
9#include <xrpl/json/to_string.h>
10#include <xrpl/protocol/ErrorCodes.h>
11#include <xrpl/protocol/TxFlags.h>
12#include <xrpl/protocol/UintTypes.h>
13#include <xrpl/protocol/jss.h>
14
15#include <algorithm>
16#include <cstddef>
17#include <optional>
18#include <vector>
19
20namespace xrpl {
21
23{
24 void
26 {
27 testcase("Bad input to account_currencies");
28
29 using namespace test::jtx;
30 Env env{*this};
31
32 auto const alice = Account{"alice"};
33 env.fund(XRP(10000), alice);
34 env.close();
35
36 { // invalid ledger (hash)
37 json::Value params;
38 params[jss::account] = Account{"bob"}.human();
39 params[jss::ledger_hash] = 1;
40 auto const result =
41 env.rpc("json", "account_currencies", to_string(params))[jss::result];
42 BEAST_EXPECT(result[jss::error] == "invalidParams");
43 BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
44 BEAST_EXPECT(
45 result[jss::error_message] == "Invalid field 'ledger_hash', not hex string.");
46 }
47
48 { // missing account field
49 auto const result = env.rpc("json", "account_currencies", "{}")[jss::result];
50 BEAST_EXPECT(result[jss::error] == "invalidParams");
51 BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
52 BEAST_EXPECT(result[jss::error_message] == "Missing field 'account'.");
53 }
54
55 {
56 // invalid ledger is reported before a missing or invalid account
57 auto const testInvalidLedger = [&](json::Value params) {
58 params[jss::ledger_hash] = 1;
59 auto const result =
60 env.rpc("json", "account_currencies", to_string(params))[jss::result];
61 BEAST_EXPECT(result[jss::error] == "invalidParams");
62 BEAST_EXPECT(result[jss::error_code] == RpcInvalidParams);
63 BEAST_EXPECT(
64 result[jss::error_message] == "Invalid field 'ledger_hash', not hex string.");
65 };
66
67 testInvalidLedger(json::Value{json::ValueType::Object});
68
69 for (auto const& field : {jss::account, jss::ident})
70 {
71 json::Value params;
72 params[field] = 1;
73 testInvalidLedger(params);
74
75 params[field] = "llIIOO";
76 testInvalidLedger(params);
77 }
78 }
79
80 {
81 // test account non-string
82 auto const testInvalidAccountParam = [&](auto const& param) {
83 json::Value params;
84 params[jss::account] = param;
85 auto jrr = env.rpc("json", "account_currencies", to_string(params))[jss::result];
86 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
87 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
88 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'account'.");
89 };
90
91 testInvalidAccountParam(1);
92 testInvalidAccountParam(1.1);
93 testInvalidAccountParam(true);
94 testInvalidAccountParam(json::Value(json::ValueType::Null));
95 testInvalidAccountParam(json::Value(json::ValueType::Object));
96 testInvalidAccountParam(json::Value(json::ValueType::Array));
97 }
98
99 {
100 // test ident non-string
101 auto const testInvalidIdentParam = [&](auto const& param) {
102 json::Value params;
103 params[jss::ident] = param;
104 auto jrr = env.rpc("json", "account_currencies", to_string(params))[jss::result];
105 BEAST_EXPECT(jrr[jss::error] == "invalidParams");
106 BEAST_EXPECT(jrr[jss::error_code] == RpcInvalidParams);
107 BEAST_EXPECT(jrr[jss::error_message] == "Invalid field 'ident'.");
108 };
109
110 testInvalidIdentParam(1);
111 testInvalidIdentParam(1.1);
112 testInvalidIdentParam(true);
113 testInvalidIdentParam(json::Value(json::ValueType::Null));
114 testInvalidIdentParam(json::Value(json::ValueType::Object));
115 testInvalidIdentParam(json::Value(json::ValueType::Array));
116 }
117
118 {
119 json::Value params;
120 params[jss::account] = "llIIOO"; // these are invalid in bitcoin alphabet
121 auto const result =
122 env.rpc("json", "account_currencies", to_string(params))[jss::result];
123 BEAST_EXPECT(result[jss::error] == "actMalformed");
124 BEAST_EXPECT(result[jss::error_code] == RpcActMalformed);
125 BEAST_EXPECT(result[jss::error_message] == "Account malformed.");
126 BEAST_EXPECT(result.isMember(jss::ledger_current_index));
127 BEAST_EXPECT(result[jss::validated] == false);
128 }
129
130 {
131 // Cannot use a seed as account
132 json::Value params;
133 params[jss::account] = "Bob";
134 auto const result =
135 env.rpc("json", "account_currencies", to_string(params))[jss::result];
136 BEAST_EXPECT(result[jss::error] == "actMalformed");
137 BEAST_EXPECT(result[jss::error_code] == RpcActMalformed);
138 BEAST_EXPECT(result[jss::error_message] == "Account malformed.");
139 }
140
141 { // ask for nonexistent account
142 json::Value params;
143 params[jss::account] = Account{"bob"}.human();
144 auto const result =
145 env.rpc("json", "account_currencies", to_string(params))[jss::result];
146 BEAST_EXPECT(result[jss::error] == "actNotFound");
147 BEAST_EXPECT(result[jss::error_code] == RpcActNotFound);
148 BEAST_EXPECT(result[jss::error_message] == "Account not found.");
149 }
150 }
151
152 void
154 {
155 testcase("Basic request for account_currencies");
156
157 using namespace test::jtx;
158 Env env{*this};
159
160 auto const alice = Account{"alice"};
161 auto const gw = Account{"gateway"};
162 env.fund(XRP(10000), alice, gw);
163 char currencySuffix{'A'};
164 std::vector<std::optional<IOU>> gwCurrencies(26); // A - Z
165 std::ranges::generate(gwCurrencies, [&] {
166 auto gwc = gw[std::string("US") + currencySuffix++];
167 env(trust(alice, gwc(100)));
168 return gwc;
169 });
170 env.close();
171
172 json::Value params;
173 params[jss::account] = alice.human();
174 auto result = env.rpc("json", "account_currencies", to_string(params))[jss::result];
175
176 auto const arrayCheck = [&result](
177 json::StaticString const& fld,
178 std::vector<std::optional<IOU>> const& expected) -> bool {
179 bool stat = result.isMember(fld) && result[fld].isArray() &&
180 result[fld].size() == expected.size();
181 for (size_t i = 0; stat && i < expected.size(); ++i)
182 {
183 stat &= (to_string(expected[i].value().currency) == result[fld][i].asString());
184 }
185 return stat;
186 };
187
188 BEAST_EXPECT(arrayCheck(jss::receive_currencies, gwCurrencies));
189 BEAST_EXPECT(arrayCheck(jss::send_currencies, {}));
190
191 // now form a payment for each currency
192 for (auto const& c : gwCurrencies)
193 env(pay(gw, alice, c.value()(50))); // NOLINT(bugprone-unchecked-optional-access)
194
195 // send_currencies should be populated now
196 result = env.rpc("json", "account_currencies", to_string(params))[jss::result];
197 BEAST_EXPECT(arrayCheck(jss::receive_currencies, gwCurrencies));
198 BEAST_EXPECT(arrayCheck(jss::send_currencies, gwCurrencies));
199
200 // freeze the USD trust line and verify that the receive currencies
201 // does not change
202 env(trust(alice, gw["USD"](100), tfSetFreeze));
203 result = env.rpc("account_lines", alice.human());
204 for (auto const& l : result[jss::lines])
205 BEAST_EXPECT(l[jss::freeze].asBool() == (l[jss::currency] == "USD"));
206 result = env.rpc("json", "account_currencies", to_string(params))[jss::result];
207 BEAST_EXPECT(arrayCheck(jss::receive_currencies, gwCurrencies));
208 BEAST_EXPECT(arrayCheck(jss::send_currencies, gwCurrencies));
209 // clear the freeze
210 env(trust(alice, gw["USD"](100), tfClearFreeze));
211
212 // make a payment that exhausts the trustline from alice to gw for USA
213 env(pay(gw, alice, gw["USA"](50)));
214 // USA should now be missing from receive_currencies
215 result = env.rpc("json", "account_currencies", to_string(params))[jss::result];
216 decltype(gwCurrencies)
217 const gwCurrenciesNoUSA(gwCurrencies.begin() + 1, gwCurrencies.end());
218 BEAST_EXPECT(arrayCheck(jss::receive_currencies, gwCurrenciesNoUSA));
219 BEAST_EXPECT(arrayCheck(jss::send_currencies, gwCurrencies));
220
221 // add trust from gw to alice and then exhaust that trust line
222 // so that send_currencies for alice will now omit USA
223 env(trust(gw, alice["USA"](100)));
224 env(pay(alice, gw, alice["USA"](200)));
225 result = env.rpc("json", "account_currencies", to_string(params))[jss::result];
226 BEAST_EXPECT(arrayCheck(jss::receive_currencies, gwCurrencies));
227 BEAST_EXPECT(arrayCheck(jss::send_currencies, gwCurrenciesNoUSA));
228 }
229
230public:
231 void
232 run() override
233 {
234 testBadInput();
235 testBasic();
236 }
237};
238
239BEAST_DEFINE_TESTSUITE(AccountCurrencies, rpc, xrpl);
240
241} // namespace xrpl
T begin(T... args)
A testsuite class.
Definition suite.h:52
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:155
Lightweight wrapper to tag static string.
Definition json_value.h:52
Represents a JSON value.
Definition json_value.h:121
void run() override
Runs the suite.
T end(T... args)
T generate(T... args)
@ Array
array value (ordered list)
Definition json_value.h:32
@ Object
object value (collection of name/value pairs).
Definition json_value.h:33
@ Null
'null' value
Definition json_value.h:26
The api_version numbers this server serves.
Definition ApiVersion.h:26
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
@ RpcActNotFound
Definition ErrorCodes.h:53
@ RpcActMalformed
Definition ErrorCodes.h:73
@ RpcInvalidParams
Definition ErrorCodes.h:67
std::string to_string(BaseUInt< Bits, Tag > const &a)
Definition base_uint.h:658
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)