rippled
AccountInfo_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/protocol/Feature.h>
21 #include <ripple/protocol/jss.h>
22 #include <test/jtx.h>
23 
24 #include <ripple/resource/Charge.h>
25 #include <ripple/resource/Fees.h>
26 #include <ripple/rpc/GRPCHandlers.h>
27 #include <test/jtx/WSClient.h>
28 #include <test/rpc/GRPCTestClientBase.h>
29 
30 namespace ripple {
31 namespace test {
32 
33 class AccountInfo_test : public beast::unit_test::suite
34 {
35 public:
36  void
37  testErrors()
38  {
39  using namespace jtx;
40  Env env(*this);
41  {
42  // account_info with no account.
43  auto const info = env.rpc("json", "account_info", "{ }");
44  BEAST_EXPECT(
45  info[jss::result][jss::error_message] ==
46  "Missing field 'account'.");
47  }
48  {
49  // account_info with a malformed account sting.
50  auto const info = env.rpc(
51  "json",
52  "account_info",
53  "{\"account\": "
54  "\"n94JNrQYkDrpt62bbSR7nVEhdyAvcJXRAsjEkFYyqRkh9SUTYEqV\"}");
55  BEAST_EXPECT(
56  info[jss::result][jss::error_message] == "Disallowed seed.");
57  }
58  {
59  // account_info with an account that's not in the ledger.
60  Account const bogie{"bogie"};
61  auto const info = env.rpc(
62  "json",
63  "account_info",
64  std::string("{ ") + "\"account\": \"" + bogie.human() + "\"}");
65  BEAST_EXPECT(
66  info[jss::result][jss::error_message] == "Account not found.");
67  }
68  }
69 
70  // Test the "signer_lists" argument in account_info.
71  void
72  testSignerLists()
73  {
74  using namespace jtx;
75  Env env(*this);
76  Account const alice{"alice"};
77  env.fund(XRP(1000), alice);
78 
79  auto const withoutSigners =
80  std::string("{ ") + "\"account\": \"" + alice.human() + "\"}";
81 
82  auto const withSigners = std::string("{ ") + "\"account\": \"" +
83  alice.human() + "\", " + "\"signer_lists\": true }";
84 
85  // Alice has no SignerList yet.
86  {
87  // account_info without the "signer_lists" argument.
88  auto const info = env.rpc("json", "account_info", withoutSigners);
89  BEAST_EXPECT(
90  info.isMember(jss::result) &&
91  info[jss::result].isMember(jss::account_data));
92  BEAST_EXPECT(!info[jss::result][jss::account_data].isMember(
93  jss::signer_lists));
94  }
95  {
96  // account_info with the "signer_lists" argument.
97  auto const info = env.rpc("json", "account_info", withSigners);
98  BEAST_EXPECT(
99  info.isMember(jss::result) &&
100  info[jss::result].isMember(jss::account_data));
101  auto const& data = info[jss::result][jss::account_data];
102  BEAST_EXPECT(data.isMember(jss::signer_lists));
103  auto const& signerLists = data[jss::signer_lists];
104  BEAST_EXPECT(signerLists.isArray());
105  BEAST_EXPECT(signerLists.size() == 0);
106  }
107 
108  // Give alice a SignerList.
109  Account const bogie{"bogie"};
110 
111  Json::Value const smallSigners = signers(alice, 2, {{bogie, 3}});
112  env(smallSigners);
113  {
114  // account_info without the "signer_lists" argument.
115  auto const info = env.rpc("json", "account_info", withoutSigners);
116  BEAST_EXPECT(
117  info.isMember(jss::result) &&
118  info[jss::result].isMember(jss::account_data));
119  BEAST_EXPECT(!info[jss::result][jss::account_data].isMember(
120  jss::signer_lists));
121  }
122  {
123  // account_info with the "signer_lists" argument.
124  auto const info = env.rpc("json", "account_info", withSigners);
125  BEAST_EXPECT(
126  info.isMember(jss::result) &&
127  info[jss::result].isMember(jss::account_data));
128  auto const& data = info[jss::result][jss::account_data];
129  BEAST_EXPECT(data.isMember(jss::signer_lists));
130  auto const& signerLists = data[jss::signer_lists];
131  BEAST_EXPECT(signerLists.isArray());
132  BEAST_EXPECT(signerLists.size() == 1);
133  auto const& signers = signerLists[0u];
134  BEAST_EXPECT(signers.isObject());
135  BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 2);
136  auto const& signerEntries = signers[sfSignerEntries.jsonName];
137  BEAST_EXPECT(signerEntries.size() == 1);
138  auto const& entry0 = signerEntries[0u][sfSignerEntry.jsonName];
139  BEAST_EXPECT(entry0[sfSignerWeight.jsonName] == 3);
140  }
141 
142  // Give alice a big signer list
143  Account const demon{"demon"};
144  Account const ghost{"ghost"};
145  Account const haunt{"haunt"};
146  Account const jinni{"jinni"};
147  Account const phase{"phase"};
148  Account const shade{"shade"};
149  Account const spook{"spook"};
150 
151  Json::Value const bigSigners = signers(
152  alice,
153  4,
154  {
155  {bogie, 1},
156  {demon, 1},
157  {ghost, 1},
158  {haunt, 1},
159  {jinni, 1},
160  {phase, 1},
161  {shade, 1},
162  {spook, 1},
163  });
164  env(bigSigners);
165  {
166  // account_info with the "signer_lists" argument.
167  auto const info = env.rpc("json", "account_info", withSigners);
168  BEAST_EXPECT(
169  info.isMember(jss::result) &&
170  info[jss::result].isMember(jss::account_data));
171  auto const& data = info[jss::result][jss::account_data];
172  BEAST_EXPECT(data.isMember(jss::signer_lists));
173  auto const& signerLists = data[jss::signer_lists];
174  BEAST_EXPECT(signerLists.isArray());
175  BEAST_EXPECT(signerLists.size() == 1);
176  auto const& signers = signerLists[0u];
177  BEAST_EXPECT(signers.isObject());
178  BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 4);
179  auto const& signerEntries = signers[sfSignerEntries.jsonName];
180  BEAST_EXPECT(signerEntries.size() == 8);
181  for (unsigned i = 0u; i < 8; ++i)
182  {
183  auto const& entry = signerEntries[i][sfSignerEntry.jsonName];
184  BEAST_EXPECT(entry.size() == 2);
185  BEAST_EXPECT(entry.isMember(sfAccount.jsonName));
186  BEAST_EXPECT(entry[sfSignerWeight.jsonName] == 1);
187  }
188  }
189  }
190 
191  // Test the "signer_lists" argument in account_info, version 2 API.
192  void
193  testSignerListsV2()
194  {
195  using namespace jtx;
196  Env env(*this);
197  Account const alice{"alice"};
198  env.fund(XRP(1000), alice);
199 
200  auto const withoutSigners = std::string("{ ") +
201  "\"jsonrpc\": \"2.0\", "
202  "\"ripplerpc\": \"2.0\", "
203  "\"id\": 5, "
204  "\"method\": \"account_info\", "
205  "\"params\": { "
206  "\"account\": \"" +
207  alice.human() + "\"}}";
208 
209  auto const withSigners = std::string("{ ") +
210  "\"jsonrpc\": \"2.0\", "
211  "\"ripplerpc\": \"2.0\", "
212  "\"id\": 6, "
213  "\"method\": \"account_info\", "
214  "\"params\": { "
215  "\"account\": \"" +
216  alice.human() + "\", " + "\"signer_lists\": true }}";
217  // Alice has no SignerList yet.
218  {
219  // account_info without the "signer_lists" argument.
220  auto const info = env.rpc("json2", withoutSigners);
221  BEAST_EXPECT(
222  info.isMember(jss::result) &&
223  info[jss::result].isMember(jss::account_data));
224  BEAST_EXPECT(!info[jss::result][jss::account_data].isMember(
225  jss::signer_lists));
226  BEAST_EXPECT(
227  info.isMember(jss::jsonrpc) && info[jss::jsonrpc] == "2.0");
228  BEAST_EXPECT(
229  info.isMember(jss::ripplerpc) && info[jss::ripplerpc] == "2.0");
230  BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 5);
231  }
232  {
233  // account_info with the "signer_lists" argument.
234  auto const info = env.rpc("json2", withSigners);
235  BEAST_EXPECT(
236  info.isMember(jss::result) &&
237  info[jss::result].isMember(jss::account_data));
238  auto const& data = info[jss::result][jss::account_data];
239  BEAST_EXPECT(data.isMember(jss::signer_lists));
240  auto const& signerLists = data[jss::signer_lists];
241  BEAST_EXPECT(signerLists.isArray());
242  BEAST_EXPECT(signerLists.size() == 0);
243  BEAST_EXPECT(
244  info.isMember(jss::jsonrpc) && info[jss::jsonrpc] == "2.0");
245  BEAST_EXPECT(
246  info.isMember(jss::ripplerpc) && info[jss::ripplerpc] == "2.0");
247  BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 6);
248  }
249  {
250  // Do both of the above as a batch job
251  auto const info = env.rpc(
252  "json2", '[' + withoutSigners + ", " + withSigners + ']');
253  BEAST_EXPECT(
254  info[0u].isMember(jss::result) &&
255  info[0u][jss::result].isMember(jss::account_data));
256  BEAST_EXPECT(!info[0u][jss::result][jss::account_data].isMember(
257  jss::signer_lists));
258  BEAST_EXPECT(
259  info[0u].isMember(jss::jsonrpc) &&
260  info[0u][jss::jsonrpc] == "2.0");
261  BEAST_EXPECT(
262  info[0u].isMember(jss::ripplerpc) &&
263  info[0u][jss::ripplerpc] == "2.0");
264  BEAST_EXPECT(info[0u].isMember(jss::id) && info[0u][jss::id] == 5);
265 
266  BEAST_EXPECT(
267  info[1u].isMember(jss::result) &&
268  info[1u][jss::result].isMember(jss::account_data));
269  auto const& data = info[1u][jss::result][jss::account_data];
270  BEAST_EXPECT(data.isMember(jss::signer_lists));
271  auto const& signerLists = data[jss::signer_lists];
272  BEAST_EXPECT(signerLists.isArray());
273  BEAST_EXPECT(signerLists.size() == 0);
274  BEAST_EXPECT(
275  info[1u].isMember(jss::jsonrpc) &&
276  info[1u][jss::jsonrpc] == "2.0");
277  BEAST_EXPECT(
278  info[1u].isMember(jss::ripplerpc) &&
279  info[1u][jss::ripplerpc] == "2.0");
280  BEAST_EXPECT(info[1u].isMember(jss::id) && info[1u][jss::id] == 6);
281  }
282 
283  // Give alice a SignerList.
284  Account const bogie{"bogie"};
285 
286  Json::Value const smallSigners = signers(alice, 2, {{bogie, 3}});
287  env(smallSigners);
288  {
289  // account_info without the "signer_lists" argument.
290  auto const info = env.rpc("json2", withoutSigners);
291  BEAST_EXPECT(
292  info.isMember(jss::result) &&
293  info[jss::result].isMember(jss::account_data));
294  BEAST_EXPECT(!info[jss::result][jss::account_data].isMember(
295  jss::signer_lists));
296  BEAST_EXPECT(
297  info.isMember(jss::jsonrpc) && info[jss::jsonrpc] == "2.0");
298  BEAST_EXPECT(
299  info.isMember(jss::ripplerpc) && info[jss::ripplerpc] == "2.0");
300  BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 5);
301  }
302  {
303  // account_info with the "signer_lists" argument.
304  auto const info = env.rpc("json2", withSigners);
305  BEAST_EXPECT(
306  info.isMember(jss::result) &&
307  info[jss::result].isMember(jss::account_data));
308  auto const& data = info[jss::result][jss::account_data];
309  BEAST_EXPECT(data.isMember(jss::signer_lists));
310  auto const& signerLists = data[jss::signer_lists];
311  BEAST_EXPECT(signerLists.isArray());
312  BEAST_EXPECT(signerLists.size() == 1);
313  auto const& signers = signerLists[0u];
314  BEAST_EXPECT(signers.isObject());
315  BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 2);
316  auto const& signerEntries = signers[sfSignerEntries.jsonName];
317  BEAST_EXPECT(signerEntries.size() == 1);
318  auto const& entry0 = signerEntries[0u][sfSignerEntry.jsonName];
319  BEAST_EXPECT(entry0[sfSignerWeight.jsonName] == 3);
320  BEAST_EXPECT(
321  info.isMember(jss::jsonrpc) && info[jss::jsonrpc] == "2.0");
322  BEAST_EXPECT(
323  info.isMember(jss::ripplerpc) && info[jss::ripplerpc] == "2.0");
324  BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 6);
325  }
326 
327  // Give alice a big signer list
328  Account const demon{"demon"};
329  Account const ghost{"ghost"};
330  Account const haunt{"haunt"};
331  Account const jinni{"jinni"};
332  Account const phase{"phase"};
333  Account const shade{"shade"};
334  Account const spook{"spook"};
335 
336  Json::Value const bigSigners = signers(
337  alice,
338  4,
339  {
340  {bogie, 1},
341  {demon, 1},
342  {ghost, 1},
343  {haunt, 1},
344  {jinni, 1},
345  {phase, 1},
346  {shade, 1},
347  {spook, 1},
348  });
349  env(bigSigners);
350  {
351  // account_info with the "signer_lists" argument.
352  auto const info = env.rpc("json2", withSigners);
353  BEAST_EXPECT(
354  info.isMember(jss::result) &&
355  info[jss::result].isMember(jss::account_data));
356  auto const& data = info[jss::result][jss::account_data];
357  BEAST_EXPECT(data.isMember(jss::signer_lists));
358  auto const& signerLists = data[jss::signer_lists];
359  BEAST_EXPECT(signerLists.isArray());
360  BEAST_EXPECT(signerLists.size() == 1);
361  auto const& signers = signerLists[0u];
362  BEAST_EXPECT(signers.isObject());
363  BEAST_EXPECT(signers[sfSignerQuorum.jsonName] == 4);
364  auto const& signerEntries = signers[sfSignerEntries.jsonName];
365  BEAST_EXPECT(signerEntries.size() == 8);
366  for (unsigned i = 0u; i < 8; ++i)
367  {
368  auto const& entry = signerEntries[i][sfSignerEntry.jsonName];
369  BEAST_EXPECT(entry.size() == 2);
370  BEAST_EXPECT(entry.isMember(sfAccount.jsonName));
371  BEAST_EXPECT(entry[sfSignerWeight.jsonName] == 1);
372  }
373  BEAST_EXPECT(
374  info.isMember(jss::jsonrpc) && info[jss::jsonrpc] == "2.0");
375  BEAST_EXPECT(
376  info.isMember(jss::ripplerpc) && info[jss::ripplerpc] == "2.0");
377  BEAST_EXPECT(info.isMember(jss::id) && info[jss::id] == 6);
378  }
379  }
380 
381  // gRPC stuff
382  class GetAccountInfoClient : public GRPCTestClientBase
383  {
384  public:
385  org::xrpl::rpc::v1::GetAccountInfoRequest request;
386  org::xrpl::rpc::v1::GetAccountInfoResponse reply;
387 
388  explicit GetAccountInfoClient(std::string const& port)
389  : GRPCTestClientBase(port)
390  {
391  }
392 
393  void
394  GetAccountInfo()
395  {
396  status = stub_->GetAccountInfo(&context, request, &reply);
397  }
398  };
399 
400  void
401  testSimpleGrpc()
402  {
403  testcase("gRPC simple");
404 
405  using namespace jtx;
406  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
407  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
408  Env env(*this, std::move(config));
409  Account const alice{"alice"};
410  env.fund(drops(1000 * 1000 * 1000), alice);
411 
412  {
413  // most simple case
414  GetAccountInfoClient client(grpcPort);
415  client.request.mutable_account()->set_address(alice.human());
416  client.GetAccountInfo();
417  if (!BEAST_EXPECT(client.status.ok()))
418  {
419  return;
420  }
421  BEAST_EXPECT(
422  client.reply.account_data().account().value().address() ==
423  alice.human());
424  }
425  {
426  GetAccountInfoClient client(grpcPort);
427  client.request.mutable_account()->set_address(alice.human());
428  client.request.set_queue(true);
429  client.request.mutable_ledger()->set_sequence(3);
430  client.GetAccountInfo();
431  if (!BEAST_EXPECT(client.status.ok()))
432  return;
433  BEAST_EXPECT(
434  client.reply.account_data()
435  .balance()
436  .value()
437  .xrp_amount()
438  .drops() == 1000 * 1000 * 1000);
439  BEAST_EXPECT(
440  client.reply.account_data().account().value().address() ==
441  alice.human());
442  BEAST_EXPECT(
443  client.reply.account_data().sequence().value() ==
444  env.seq(alice));
445  BEAST_EXPECT(client.reply.queue_data().txn_count() == 0);
446  }
447  }
448 
449  void
450  testErrorsGrpc()
451  {
452  testcase("gRPC errors");
453 
454  using namespace jtx;
455  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
456  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
457  Env env(*this, std::move(config));
458  auto getClient = [&grpcPort]() {
459  return GetAccountInfoClient(grpcPort);
460  };
461  Account const alice{"alice"};
462  env.fund(drops(1000 * 1000 * 1000), alice);
463 
464  {
465  // bad address
466  auto client = getClient();
467  client.request.mutable_account()->set_address("deadbeef");
468  client.GetAccountInfo();
469  BEAST_EXPECT(!client.status.ok());
470  }
471  {
472  // no account
473  Account const bogie{"bogie"};
474  auto client = getClient();
475  client.request.mutable_account()->set_address(bogie.human());
476  client.GetAccountInfo();
477  BEAST_EXPECT(!client.status.ok());
478  }
479  {
480  // bad ledger_index
481  auto client = getClient();
482  client.request.mutable_account()->set_address(alice.human());
483  client.request.mutable_ledger()->set_sequence(0);
484  client.GetAccountInfo();
485  BEAST_EXPECT(!client.status.ok());
486  }
487  }
488 
489  void
490  testSignerListsGrpc()
491  {
492  testcase("gRPC singer lists");
493 
494  using namespace jtx;
495  std::unique_ptr<Config> config = envconfig(addGrpcConfig);
496  std::string grpcPort = *(*config)["port_grpc"].get<std::string>("port");
497  Env env(*this, std::move(config));
498  auto getClient = [&grpcPort]() {
499  return GetAccountInfoClient(grpcPort);
500  };
501 
502  Account const alice{"alice"};
503  env.fund(drops(1000 * 1000 * 1000), alice);
504 
505  {
506  auto client = getClient();
507  client.request.mutable_account()->set_address(alice.human());
508  client.request.set_signer_lists(true);
509  client.GetAccountInfo();
510  if (!BEAST_EXPECT(client.status.ok()))
511  return;
512  BEAST_EXPECT(client.reply.signer_list().signer_entries_size() == 0);
513  }
514 
515  // Give alice a SignerList.
516  Account const bogie{"bogie"};
517  Json::Value const smallSigners = signers(alice, 2, {{bogie, 3}});
518  env(smallSigners);
519  {
520  auto client = getClient();
521  client.request.mutable_account()->set_address(alice.human());
522  client.request.set_signer_lists(false);
523  client.GetAccountInfo();
524  if (!BEAST_EXPECT(client.status.ok()))
525  return;
526  BEAST_EXPECT(client.reply.signer_list().signer_entries_size() == 0);
527  }
528  {
529  auto client = getClient();
530  client.request.mutable_account()->set_address(alice.human());
531  client.request.set_signer_lists(true);
532  client.GetAccountInfo();
533  if (!BEAST_EXPECT(client.status.ok()))
534  {
535  return;
536  }
537  BEAST_EXPECT(
538  client.reply.account_data().owner_count().value() == 1);
539  BEAST_EXPECT(client.reply.signer_list().signer_entries_size() == 1);
540  }
541 
542  // Give alice a big signer list
543  Account const demon{"demon"};
544  Account const ghost{"ghost"};
545  Account const haunt{"haunt"};
546  Account const jinni{"jinni"};
547  Account const phase{"phase"};
548  Account const shade{"shade"};
549  Account const spook{"spook"};
550  Json::Value const bigSigners = signers(
551  alice,
552  4,
553  {
554  {bogie, 1},
555  {demon, 1},
556  {ghost, 1},
557  {haunt, 1},
558  {jinni, 1},
559  {phase, 1},
560  {shade, 1},
561  {spook, 1},
562  });
563  env(bigSigners);
564 
565  std::set<std::string> accounts;
566  accounts.insert(bogie.human());
567  accounts.insert(demon.human());
568  accounts.insert(ghost.human());
569  accounts.insert(haunt.human());
570  accounts.insert(jinni.human());
571  accounts.insert(phase.human());
572  accounts.insert(shade.human());
573  accounts.insert(spook.human());
574  {
575  auto client = getClient();
576  client.request.mutable_account()->set_address(alice.human());
577  client.request.set_signer_lists(true);
578  client.GetAccountInfo();
579  if (!BEAST_EXPECT(client.status.ok()))
580  {
581  return;
582  }
583  BEAST_EXPECT(
584  client.reply.account_data().owner_count().value() == 1);
585  auto& signerList = client.reply.signer_list();
586  BEAST_EXPECT(signerList.signer_quorum().value() == 4);
587  BEAST_EXPECT(signerList.signer_entries_size() == 8);
588  for (int i = 0; i < 8; ++i)
589  {
590  BEAST_EXPECT(
591  signerList.signer_entries(i).signer_weight().value() == 1);
592  BEAST_EXPECT(
593  accounts.erase(signerList.signer_entries(i)
594  .account()
595  .value()
596  .address()) == 1);
597  }
598  BEAST_EXPECT(accounts.size() == 0);
599  }
600  }
601 
602  void
603  run() override
604  {
605  testErrors();
606  testSignerLists();
607  testSignerListsV2();
608  testSimpleGrpc();
609  testErrorsGrpc();
610  testSignerListsGrpc();
611  }
612 };
613 
614 BEAST_DEFINE_TESTSUITE(AccountInfo, app, ripple);
615 
616 } // namespace test
617 } // namespace ripple
ripple::sfSignerWeight
const SF_UINT16 sfSignerWeight
ripple::test::jtx::XRP
const XRP_t XRP
Converts to XRP Issue or STAmount.
Definition: amount.cpp:105
ripple::test::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(AccountDelete, app, ripple)
std::string
STL class.
ripple::test::jtx::drops
PrettyAmount drops(Integer i)
Returns an XRP PrettyAmount, which is trivially convertible to STAmount.
Definition: amount.h:241
ripple::test::AccountInfo_test::run
void run() override
Definition: AccountInfo_test.cpp:603
ripple::test::AccountInfo_test::testSignerListsV2
void testSignerListsV2()
Definition: AccountInfo_test.cpp:193
ripple::test::GRPCTestClientBase::stub_
std::unique_ptr< org::xrpl::rpc::v1::XRPLedgerAPIService::Stub > stub_
Definition: GRPCTestClientBase.h:44
std::set::size
T size(T... args)
ripple::test::jtx::addGrpcConfig
std::unique_ptr< Config > addGrpcConfig(std::unique_ptr< Config >)
add a grpc address and port to config
Definition: envconfig.cpp:113
ripple::test::AccountInfo_test::GetAccountInfoClient::request
org::xrpl::rpc::v1::GetAccountInfoRequest request
Definition: AccountInfo_test.cpp:385
ripple::test::jtx::envconfig
std::unique_ptr< Config > envconfig()
creates and initializes a default configuration for jtx::Env
Definition: envconfig.h:49
ripple::test::AccountInfo_test::testErrorsGrpc
void testErrorsGrpc()
Definition: AccountInfo_test.cpp:450
ripple::SField::jsonName
const Json::StaticString jsonName
Definition: SField.h:133
ripple::test::GRPCTestClientBase::status
grpc::Status status
Definition: GRPCTestClientBase.h:42
ripple::test::GRPCTestClientBase
Definition: GRPCTestClientBase.h:29
ripple::sfSignerQuorum
const SF_UINT32 sfSignerQuorum
ripple::test::AccountInfo_test::GetAccountInfoClient::GetAccountInfoClient
GetAccountInfoClient(std::string const &port)
Definition: AccountInfo_test.cpp:388
ripple::test::AccountInfo_test
Definition: AccountInfo_test.cpp:33
ripple::test::AccountInfo_test::testSignerListsGrpc
void testSignerListsGrpc()
Definition: AccountInfo_test.cpp:490
ripple::test::AccountInfo_test::GetAccountInfoClient::reply
org::xrpl::rpc::v1::GetAccountInfoResponse reply
Definition: AccountInfo_test.cpp:386
std::set::erase
T erase(T... args)
ripple::test::AccountInfo_test::testSimpleGrpc
void testSimpleGrpc()
Definition: AccountInfo_test.cpp:401
ripple::test::AccountInfo_test::testSignerLists
void testSignerLists()
Definition: AccountInfo_test.cpp:72
ripple::test::AccountInfo_test::GetAccountInfoClient
Definition: AccountInfo_test.cpp:382
ripple::sfSignerEntry
const SField sfSignerEntry
ripple::test::GRPCTestClientBase::context
grpc::ClientContext context
Definition: GRPCTestClientBase.h:43
ripple::test::AccountInfo_test::GetAccountInfoClient::GetAccountInfo
void GetAccountInfo()
Definition: AccountInfo_test.cpp:394
ripple::sfSignerEntries
const SField sfSignerEntries
ripple
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition: RCLCensorshipDetector.h:29
std::set::insert
T insert(T... args)
ripple::test::jtx::Env::fund
void fund(bool setDefaultRipple, STAmount const &amount, Account const &account)
Definition: Env.cpp:219
ripple::test::jtx::Account
Immutable cryptographic account descriptor.
Definition: Account.h:37
ripple::sfAccount
const SF_ACCOUNT sfAccount
std::unique_ptr
STL class.
ripple::test::AccountInfo_test::testErrors
void testErrors()
Definition: AccountInfo_test.cpp:37
std::set< std::string >
ripple::test::jtx::Env
A transaction testing environment.
Definition: Env.h:115
ripple::test::jtx::Env::rpc
Json::Value rpc(std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition: Env.h:684
Json::Value
Represents a JSON value.
Definition: json_value.h:145
Generated by   doxygen 1.8.17