rippled
LedgerData_test.cpp
1 //------------------------------------------------------------------------------
2 /*
3  This file is part of rippled: https://github.com/ripple/rippled
4  Copyright (c) 2016 Ripple Labs Inc.
5 
6  Permission to use, copy, modify, and/or distribute this software for any
7  purpose with or without fee is hereby granted, provided that the above
8  copyright notice and this permission notice appear in all copies.
9 
10  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 //==============================================================================
19 
20 #include <ripple/basics/StringUtilities.h>
21 #include <ripple/protocol/jss.h>
22 #include <test/jtx.h>
23 
24 namespace ripple {
25 
26 class LedgerData_test : public beast::unit_test::suite
27 {
28 public:
29  // test helper
30  static bool
31  checkArraySize(Json::Value const& val, unsigned int size)
32  {
33  return val.isArray() && val.size() == size;
34  }
35 
36  // test helper
37  static bool
38  checkMarker(Json::Value const& val)
39  {
40  return val.isMember(jss::marker) && val[jss::marker].isString() &&
41  val[jss::marker].asString().size() > 0;
42  }
43 
44  void
45  testCurrentLedgerToLimits(bool asAdmin)
46  {
47  using namespace test::jtx;
48  Env env{*this, asAdmin ? envconfig() : envconfig(no_admin)};
49  Account const gw{"gateway"};
50  auto const USD = gw["USD"];
51  env.fund(XRP(100000), gw);
52 
53  int const max_limit = 256; // would be 2048 for binary requests, no
54  // need to test that here
55 
56  for (auto i = 0; i < max_limit + 10; i++)
57  {
58  Account const bob{std::string("bob") + std::to_string(i)};
59  env.fund(XRP(1000), bob);
60  }
61  env.close();
62 
63  // with no limit specified, we get the max_limit if the total number of
64  // accounts is greater than max, which it is here
65  Json::Value jvParams;
66  jvParams[jss::ledger_index] = "current";
67  jvParams[jss::binary] = false;
68  {
69  auto const jrr = env.rpc(
70  "json",
71  "ledger_data",
72  boost::lexical_cast<std::string>(jvParams))[jss::result];
73  BEAST_EXPECT(
74  jrr[jss::ledger_current_index].isIntegral() &&
75  jrr[jss::ledger_current_index].asInt() > 0);
76  BEAST_EXPECT(checkMarker(jrr));
77  BEAST_EXPECT(checkArraySize(jrr[jss::state], max_limit));
78  }
79 
80  // check limits values around the max_limit (+/- 1)
81  for (auto delta = -1; delta <= 1; delta++)
82  {
83  jvParams[jss::limit] = max_limit + delta;
84  auto const jrr = env.rpc(
85  "json",
86  "ledger_data",
87  boost::lexical_cast<std::string>(jvParams))[jss::result];
88  BEAST_EXPECT(checkArraySize(
89  jrr[jss::state],
90  (delta > 0 && !asAdmin) ? max_limit : max_limit + delta));
91  }
92  }
93 
94  void
95  testCurrentLedgerBinary()
96  {
97  using namespace test::jtx;
98  Env env{*this, envconfig(no_admin)};
99  Account const gw{"gateway"};
100  auto const USD = gw["USD"];
101  env.fund(XRP(100000), gw);
102 
103  int const num_accounts = 10;
104 
105  for (auto i = 0; i < num_accounts; i++)
106  {
107  Account const bob{std::string("bob") + std::to_string(i)};
108  env.fund(XRP(1000), bob);
109  }
110  env.close();
111 
112  // with no limit specified, we should get all of our fund entries
113  // plus three more related to the gateway setup
114  Json::Value jvParams;
115  jvParams[jss::ledger_index] = "current";
116  jvParams[jss::binary] = true;
117  auto const jrr = env.rpc(
118  "json",
119  "ledger_data",
120  boost::lexical_cast<std::string>(jvParams))[jss::result];
121  BEAST_EXPECT(
122  jrr[jss::ledger_current_index].isIntegral() &&
123  jrr[jss::ledger_current_index].asInt() > 0);
124  BEAST_EXPECT(!jrr.isMember(jss::marker));
125  BEAST_EXPECT(checkArraySize(jrr[jss::state], num_accounts + 3));
126  }
127 
128  void
129  testBadInput()
130  {
131  using namespace test::jtx;
132  Env env{*this};
133  Account const gw{"gateway"};
134  auto const USD = gw["USD"];
135  Account const bob{"bob"};
136 
137  env.fund(XRP(10000), gw, bob);
138  env.trust(USD(1000), bob);
139 
140  {
141  // bad limit
142  Json::Value jvParams;
143  jvParams[jss::limit] = "0"; // NOT an integer
144  auto const jrr = env.rpc(
145  "json",
146  "ledger_data",
147  boost::lexical_cast<std::string>(jvParams))[jss::result];
148  BEAST_EXPECT(jrr[jss::error] == "invalidParams");
149  BEAST_EXPECT(jrr[jss::status] == "error");
150  BEAST_EXPECT(
151  jrr[jss::error_message] ==
152  "Invalid field 'limit', not integer.");
153  }
154 
155  {
156  // invalid marker
157  Json::Value jvParams;
158  jvParams[jss::marker] = "NOT_A_MARKER";
159  auto const jrr = env.rpc(
160  "json",
161  "ledger_data",
162  boost::lexical_cast<std::string>(jvParams))[jss::result];
163  BEAST_EXPECT(jrr[jss::error] == "invalidParams");
164  BEAST_EXPECT(jrr[jss::status] == "error");
165  BEAST_EXPECT(
166  jrr[jss::error_message] ==
167  "Invalid field 'marker', not valid.");
168  }
169 
170  {
171  // invalid marker - not a string
172  Json::Value jvParams;
173  jvParams[jss::marker] = 1;
174  auto const jrr = env.rpc(
175  "json",
176  "ledger_data",
177  boost::lexical_cast<std::string>(jvParams))[jss::result];
178  BEAST_EXPECT(jrr[jss::error] == "invalidParams");
179  BEAST_EXPECT(jrr[jss::status] == "error");
180  BEAST_EXPECT(
181  jrr[jss::error_message] ==
182  "Invalid field 'marker', not valid.");
183  }
184 
185  {
186  // ask for a bad ledger index
187  Json::Value jvParams;
188  jvParams[jss::ledger_index] = 10u;
189  auto const jrr = env.rpc(
190  "json",
191  "ledger_data",
192  boost::lexical_cast<std::string>(jvParams))[jss::result];
193  BEAST_EXPECT(jrr[jss::error] == "lgrNotFound");
194  BEAST_EXPECT(jrr[jss::status] == "error");
195  BEAST_EXPECT(jrr[jss::error_message] == "ledgerNotFound");
196  }
197  }
198 
199  void
200  testMarkerFollow()
201  {
202  using namespace test::jtx;
203  Env env{*this, envconfig(no_admin)};
204  Account const gw{"gateway"};
205  auto const USD = gw["USD"];
206  env.fund(XRP(100000), gw);
207 
208  int const num_accounts = 20;
209 
210  for (auto i = 0; i < num_accounts; i++)
211  {
212  Account const bob{std::string("bob") + std::to_string(i)};
213  env.fund(XRP(1000), bob);
214  }
215  env.close();
216 
217  // with no limit specified, we should get all of our fund entries
218  // plus three more related to the gateway setup
219  Json::Value jvParams;
220  jvParams[jss::ledger_index] = "current";
221  jvParams[jss::binary] = false;
222  auto jrr = env.rpc(
223  "json",
224  "ledger_data",
225  boost::lexical_cast<std::string>(jvParams))[jss::result];
226  auto const total_count = jrr[jss::state].size();
227 
228  // now make request with a limit and loop until we get all
229  jvParams[jss::limit] = 5;
230  jrr = env.rpc(
231  "json",
232  "ledger_data",
233  boost::lexical_cast<std::string>(jvParams))[jss::result];
234  BEAST_EXPECT(checkMarker(jrr));
235  auto running_total = jrr[jss::state].size();
236  while (jrr.isMember(jss::marker))
237  {
238  jvParams[jss::marker] = jrr[jss::marker];
239  jrr = env.rpc(
240  "json",
241  "ledger_data",
242  boost::lexical_cast<std::string>(jvParams))[jss::result];
243  running_total += jrr[jss::state].size();
244  }
245  BEAST_EXPECT(running_total == total_count);
246  }
247 
248  void
249  testLedgerHeader()
250  {
251  using namespace test::jtx;
252  Env env{*this};
253  env.fund(XRP(100000), "alice");
254  env.close();
255 
256  // Ledger header should be present in the first query
257  {
258  // Closed ledger with non binary form
259  Json::Value jvParams;
260  jvParams[jss::ledger_index] = "closed";
261  auto jrr = env.rpc(
262  "json",
263  "ledger_data",
264  boost::lexical_cast<std::string>(jvParams))[jss::result];
265  if (BEAST_EXPECT(jrr.isMember(jss::ledger)))
266  BEAST_EXPECT(
267  jrr[jss::ledger][jss::ledger_hash] ==
268  to_string(env.closed()->info().hash));
269  }
270  {
271  // Closed ledger with binary form
272  Json::Value jvParams;
273  jvParams[jss::ledger_index] = "closed";
274  jvParams[jss::binary] = true;
275  auto jrr = env.rpc(
276  "json",
277  "ledger_data",
278  boost::lexical_cast<std::string>(jvParams))[jss::result];
279  if (BEAST_EXPECT(jrr.isMember(jss::ledger)))
280  {
281  auto data =
282  strUnHex(jrr[jss::ledger][jss::ledger_data].asString());
283  if (BEAST_EXPECT(data))
284  {
285  Serializer s(data->data(), data->size());
286  std::uint32_t seq = 0;
287  BEAST_EXPECT(s.getInteger<std::uint32_t>(seq, 0));
288  BEAST_EXPECT(seq == 3);
289  }
290  }
291  }
292  {
293  // Current ledger with binary form
294  Json::Value jvParams;
295  jvParams[jss::binary] = true;
296  auto jrr = env.rpc(
297  "json",
298  "ledger_data",
299  boost::lexical_cast<std::string>(jvParams))[jss::result];
300  BEAST_EXPECT(jrr.isMember(jss::ledger));
301  BEAST_EXPECT(!jrr[jss::ledger].isMember(jss::ledger_data));
302  }
303  }
304 
305  void
306  testLedgerType()
307  {
308  // Put a bunch of different LedgerEntryTypes into a ledger
309  using namespace test::jtx;
310  using namespace std::chrono;
311  Env env{*this, envconfig(validator, "")};
312 
313  Account const gw{"gateway"};
314  auto const USD = gw["USD"];
315  env.fund(XRP(100000), gw);
316 
317  int const num_accounts = 10;
318 
319  for (auto i = 0; i < num_accounts; i++)
320  {
321  Account const bob{std::string("bob") + std::to_string(i)};
322  env.fund(XRP(1000), bob);
323  }
324  env(offer(Account{"bob0"}, USD(100), XRP(100)));
325  env.trust(Account{"bob2"}["USD"](100), Account{"bob3"});
326 
327  auto majorities = getMajorityAmendments(*env.closed());
328  for (int i = 0; i <= 256; ++i)
329  {
330  env.close();
331  majorities = getMajorityAmendments(*env.closed());
332  if (!majorities.empty())
333  break;
334  }
335  env(signers(
336  Account{"bob0"}, 1, {{Account{"bob1"}, 1}, {Account{"bob2"}, 1}}));
337  env(ticket::create(env.master, 1));
338 
339  {
340  Json::Value jv;
341  jv[jss::TransactionType] = jss::EscrowCreate;
342  jv[jss::Flags] = tfUniversal;
343  jv[jss::Account] = Account{"bob5"}.human();
344  jv[jss::Destination] = Account{"bob6"}.human();
345  jv[jss::Amount] = XRP(50).value().getJson(JsonOptions::none);
346  jv[sfFinishAfter.fieldName] = NetClock::time_point{env.now() + 10s}
347  .time_since_epoch()
348  .count();
349  env(jv);
350  }
351 
352  {
353  Json::Value jv;
354  jv[jss::TransactionType] = jss::PaymentChannelCreate;
355  jv[jss::Flags] = tfUniversal;
356  jv[jss::Account] = Account{"bob6"}.human();
357  jv[jss::Destination] = Account{"bob7"}.human();
358  jv[jss::Amount] = XRP(100).value().getJson(JsonOptions::none);
359  jv[jss::SettleDelay] = NetClock::duration{10s}.count();
360  jv[sfPublicKey.fieldName] = strHex(Account{"bob6"}.pk().slice());
361  jv[sfCancelAfter.fieldName] = NetClock::time_point{env.now() + 300s}
362  .time_since_epoch()
363  .count();
364  env(jv);
365  }
366 
367  env(check::create("bob6", "bob7", XRP(100)));
368 
369  // bob9 DepositPreauths bob4 and bob8.
370  env(deposit::auth(Account{"bob9"}, Account{"bob4"}));
371  env(deposit::auth(Account{"bob9"}, Account{"bob8"}));
372  env.close();
373 
374  // Now fetch each type
375  auto makeRequest = [&env](Json::StaticString t) {
376  Json::Value jvParams;
377  jvParams[jss::ledger_index] = "current";
378  jvParams[jss::type] = t;
379  return env.rpc(
380  "json",
381  "ledger_data",
382  boost::lexical_cast<std::string>(jvParams))[jss::result];
383  };
384 
385  { // jvParams[jss::type] = "account";
386  auto const jrr = makeRequest(jss::account);
387  BEAST_EXPECT(checkArraySize(jrr[jss::state], 12));
388  for (auto const& j : jrr[jss::state])
389  BEAST_EXPECT(j["LedgerEntryType"] == jss::AccountRoot);
390  }
391 
392  { // jvParams[jss::type] = "amendments";
393  auto const jrr = makeRequest(jss::amendments);
394  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
395  for (auto const& j : jrr[jss::state])
396  BEAST_EXPECT(j["LedgerEntryType"] == jss::Amendments);
397  }
398 
399  { // jvParams[jss::type] = "check";
400  auto const jrr = makeRequest(jss::check);
401  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
402  for (auto const& j : jrr[jss::state])
403  BEAST_EXPECT(j["LedgerEntryType"] == jss::Check);
404  }
405 
406  { // jvParams[jss::type] = "directory";
407  auto const jrr = makeRequest(jss::directory);
408  BEAST_EXPECT(checkArraySize(jrr[jss::state], 9));
409  for (auto const& j : jrr[jss::state])
410  BEAST_EXPECT(j["LedgerEntryType"] == jss::DirectoryNode);
411  }
412 
413  { // jvParams[jss::type] = "fee";
414  auto const jrr = makeRequest(jss::fee);
415  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
416  for (auto const& j : jrr[jss::state])
417  BEAST_EXPECT(j["LedgerEntryType"] == jss::FeeSettings);
418  }
419 
420  { // jvParams[jss::type] = "hashes";
421  auto const jrr = makeRequest(jss::hashes);
422  BEAST_EXPECT(checkArraySize(jrr[jss::state], 2));
423  for (auto const& j : jrr[jss::state])
424  BEAST_EXPECT(j["LedgerEntryType"] == jss::LedgerHashes);
425  }
426 
427  { // jvParams[jss::type] = "offer";
428  auto const jrr = makeRequest(jss::offer);
429  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
430  for (auto const& j : jrr[jss::state])
431  BEAST_EXPECT(j["LedgerEntryType"] == jss::Offer);
432  }
433 
434  { // jvParams[jss::type] = "signer_list";
435  auto const jrr = makeRequest(jss::signer_list);
436  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
437  for (auto const& j : jrr[jss::state])
438  BEAST_EXPECT(j["LedgerEntryType"] == jss::SignerList);
439  }
440 
441  { // jvParams[jss::type] = "state";
442  auto const jrr = makeRequest(jss::state);
443  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
444  for (auto const& j : jrr[jss::state])
445  BEAST_EXPECT(j["LedgerEntryType"] == jss::RippleState);
446  }
447 
448  { // jvParams[jss::type] = "ticket";
449  auto const jrr = makeRequest(jss::ticket);
450  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
451  for (auto const& j : jrr[jss::state])
452  BEAST_EXPECT(j["LedgerEntryType"] == jss::Ticket);
453  }
454 
455  { // jvParams[jss::type] = "escrow";
456  auto const jrr = makeRequest(jss::escrow);
457  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
458  for (auto const& j : jrr[jss::state])
459  BEAST_EXPECT(j["LedgerEntryType"] == jss::Escrow);
460  }
461 
462  { // jvParams[jss::type] = "payment_channel";
463  auto const jrr = makeRequest(jss::payment_channel);
464  BEAST_EXPECT(checkArraySize(jrr[jss::state], 1));
465  for (auto const& j : jrr[jss::state])
466  BEAST_EXPECT(j["LedgerEntryType"] == jss::PayChannel);
467  }
468 
469  { // jvParams[jss::type] = "deposit_preauth";
470  auto const jrr = makeRequest(jss::deposit_preauth);
471  BEAST_EXPECT(checkArraySize(jrr[jss::state], 2));
472  for (auto const& j : jrr[jss::state])
473  BEAST_EXPECT(j["LedgerEntryType"] == jss::DepositPreauth);
474  }
475 
476  { // jvParams[jss::type] = "misspelling";
477  Json::Value jvParams;
478  jvParams[jss::ledger_index] = "current";
479  jvParams[jss::type] = "misspelling";
480  auto const jrr = env.rpc(
481  "json",
482  "ledger_data",
483  boost::lexical_cast<std::string>(jvParams))[jss::result];
484  BEAST_EXPECT(jrr.isMember("error"));
485  BEAST_EXPECT(jrr["error"] == "invalidParams");
486  BEAST_EXPECT(jrr["error_message"] == "Invalid field 'type'.");
487  }
488  }
489 
490  void
491  run() override
492  {
493  testCurrentLedgerToLimits(true);
494  testCurrentLedgerToLimits(false);
495  testCurrentLedgerBinary();
496  testBadInput();
497  testMarkerFollow();
498  testLedgerHeader();
499  testLedgerType();
500  }
501 };
502 
503 BEAST_DEFINE_TESTSUITE_PRIO(LedgerData, app, ripple, 1);
504 
505 } // namespace ripple
ripple::getMajorityAmendments
majorityAmendments_t getMajorityAmendments(ReadView const &view)
Definition: View.cpp:550
std::string
STL class.
ripple::makeRequest
auto makeRequest(bool crawlPublic, bool comprEnabled, bool vpReduceRelayEnabled) -> request_type
Make outbound http request.
Definition: Handshake.cpp:356
Json::Value::isString
bool isString() const
Definition: json_value.cpp:1009
ripple::LedgerData_test::testLedgerHeader
void testLedgerHeader()
Definition: LedgerData_test.cpp:249
std::string::size
T size(T... args)
ripple::SField::fieldName
const std::string fieldName
Definition: SField.h:129
std::chrono::duration
ripple::strUnHex
boost::optional< Blob > strUnHex(std::size_t strSize, Iterator begin, Iterator end)
Definition: StringUtilities.h:49
ripple::to_string
std::string to_string(ListDisposition disposition)
Definition: ValidatorList.cpp:45
ripple::Serializer::getInteger
bool getInteger(Integer &number, int offset)
Definition: Serializer.h:125
ripple::LedgerData_test
Definition: LedgerData_test.cpp:26
std::chrono::time_point::time_since_epoch
T time_since_epoch(T... args)
ripple::LedgerData_test::checkMarker
static bool checkMarker(Json::Value const &val)
Definition: LedgerData_test.cpp:38
ripple::JsonOptions::none
@ none
ripple::LedgerData_test::checkArraySize
static bool checkArraySize(Json::Value const &val, unsigned int size)
Definition: LedgerData_test.cpp:31
ripple::BEAST_DEFINE_TESTSUITE_PRIO
BEAST_DEFINE_TESTSUITE_PRIO(TrustAndBalance, app, ripple, 1)
std::to_string
T to_string(T... args)
std::chrono::time_point
Json::Value::size
UInt size() const
Number of values in array or object.
Definition: json_value.cpp:706
Json::Value::isMember
bool isMember(const char *key) const
Return true if the object has a member named key.
Definition: json_value.cpp:932
ripple::LedgerData_test::testCurrentLedgerBinary
void testCurrentLedgerBinary()
Definition: LedgerData_test.cpp:95
std::uint32_t
ripple::tfUniversal
const std::uint32_t tfUniversal
Definition: TxFlags.h:49
Json::Value::isArray
bool isArray() const
Definition: json_value.cpp:1015
ripple::Serializer
Definition: Serializer.h:39
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
Json::StaticString
Lightweight wrapper to tag static string.
Definition: json_value.h:60
ripple::LedgerData_test::run
void run() override
Definition: LedgerData_test.cpp:491
ripple::LedgerData_test::testBadInput
void testBadInput()
Definition: LedgerData_test.cpp:129
std::chrono::duration::count
T count(T... args)
ripple::sfCancelAfter
const SF_UINT32 sfCancelAfter
ripple::sfFinishAfter
const SF_UINT32 sfFinishAfter
ripple::strHex
std::string strHex(FwdIt begin, FwdIt end)
Definition: strHex.h:45
ripple::LedgerData_test::testLedgerType
void testLedgerType()
Definition: LedgerData_test.cpp:306
ripple::LedgerData_test::testMarkerFollow
void testMarkerFollow()
Definition: LedgerData_test.cpp:200
ripple::LedgerData_test::testCurrentLedgerToLimits
void testCurrentLedgerToLimits(bool asAdmin)
Definition: LedgerData_test.cpp:45
ripple::sfPublicKey
const SF_VL sfPublicKey
Json::Value
Represents a JSON value.
Definition: json_value.h:145
Json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition: json_value.cpp:469
std::chrono
Generated by   doxygen 1.8.17