xrpld
Loading...
Searching...
No Matches
ServerDefinitions_test.cpp
1#include <test/jtx/Env.h>
2
3#include <xrpld/rpc/handlers/server_info/ServerDefinitions.h>
4
5#include <xrpl/beast/unit_test/suite.h>
6#include <xrpl/protocol/LedgerFormats.h>
7#include <xrpl/protocol/SOTemplate.h>
8#include <xrpl/protocol/TxFlags.h>
9#include <xrpl/protocol/jss.h>
10
11#include <set>
12#include <string>
13
14namespace xrpl::test {
15
16class ServerDefinitions_test : public beast::unit_test::Suite
17{
18public:
19 void
20 testServerDefinitions()
21 {
22 testcase("server_definitions");
23
24 using namespace test::jtx;
25
26 {
27 Env env(*this);
28 auto const result = env.rpc("server_definitions");
29 BEAST_EXPECT(!result[jss::result].isMember(jss::error));
30 BEAST_EXPECT(result[jss::result][jss::status] == "success");
31 BEAST_EXPECT(result[jss::result].isMember(jss::FIELDS));
32 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
33 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_RESULTS));
34 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_TYPES));
35 BEAST_EXPECT(result[jss::result].isMember(jss::TYPES));
36 BEAST_EXPECT(result[jss::result].isMember(jss::hash));
37
38 // test a random element of each result
39 // (testing the whole output would be difficult to maintain)
40
41 {
42 auto const firstField = result[jss::result][jss::FIELDS][0u];
43 BEAST_EXPECT(firstField[0u].asString() == "Invalid");
44 BEAST_EXPECT(firstField[1][jss::isSerialized].asBool() == false);
45 BEAST_EXPECT(firstField[1][jss::isSigningField].asBool() == false);
46 BEAST_EXPECT(firstField[1][jss::isVLEncoded].asBool() == false);
47 BEAST_EXPECT(firstField[1][jss::nth].asInt() == -1);
48 BEAST_EXPECT(firstField[1][jss::type].asString() == "Unknown");
49 }
50
51 {
52 auto const field = result[jss::result][jss::FIELDS][6u];
53 BEAST_EXPECT(field[0u].asString() == "LedgerEntryType");
54 BEAST_EXPECT(field[1][jss::isSerialized].asBool() == true);
55 BEAST_EXPECT(field[1][jss::isSigningField].asBool() == true);
56 BEAST_EXPECT(field[1][jss::isVLEncoded].asBool() == false);
57 BEAST_EXPECT(field[1][jss::nth].asUInt() == 1);
58 BEAST_EXPECT(field[1][jss::type].asString() == "UInt16");
59 }
60
61 // check exception SFields
62 {
63 auto const fieldExists = [&](std::string name) {
64 for (auto& field : result[jss::result][jss::FIELDS])
65 {
66 if (field[0u].asString() == name)
67 {
68 return true;
69 }
70 }
71 return false;
72 };
73 BEAST_EXPECT(fieldExists("Generic"));
74 BEAST_EXPECT(fieldExists("Invalid"));
75 BEAST_EXPECT(fieldExists("ObjectEndMarker"));
76 BEAST_EXPECT(fieldExists("ArrayEndMarker"));
77 BEAST_EXPECT(fieldExists("taker_gets_funded"));
78 BEAST_EXPECT(fieldExists("taker_pays_funded"));
79 BEAST_EXPECT(fieldExists("hash"));
80 BEAST_EXPECT(fieldExists("index"));
81 }
82
83 // verify no duplicate field names in FIELDS array
84 {
85 std::set<std::string> fieldNames;
86 for (auto const& field : result[jss::result][jss::FIELDS])
87 {
88 auto const name = field[0u].asString();
89 BEAST_EXPECT(fieldNames.insert(name).second);
90 }
91 }
92
93 // test that base_uint types are replaced with "Hash" prefix
94 {
95 auto const types = result[jss::result][jss::TYPES];
96 BEAST_EXPECT(types.isMember("Hash128") && types["Hash128"].asUInt() == 4);
97 BEAST_EXPECT(types.isMember("Hash160") && types["Hash160"].asUInt() == 17);
98 BEAST_EXPECT(types.isMember("Hash192") && types["Hash192"].asUInt() == 21);
99 BEAST_EXPECT(types.isMember("Hash256") && types["Hash256"].asUInt() == 5);
100 BEAST_EXPECT(types.isMember("Hash384") && types["Hash384"].asUInt() == 22);
101 BEAST_EXPECT(types.isMember("Hash512") && types["Hash512"].asUInt() == 23);
102 }
103
104 BEAST_EXPECT(
105 result[jss::result][jss::LEDGER_ENTRY_TYPES]["AccountRoot"].asUInt() == 97);
106 BEAST_EXPECT(
107 result[jss::result][jss::TRANSACTION_RESULTS]["tecDIR_FULL"].asUInt() == 121);
108 BEAST_EXPECT(result[jss::result][jss::TRANSACTION_TYPES]["Payment"].asUInt() == 0);
109 BEAST_EXPECT(result[jss::result][jss::TYPES]["AccountID"].asUInt() == 8);
110
111 // test the properties of the LEDGER_ENTRY_FLAGS section
112 {
113 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
114 json::Value const& leFlags = result[jss::result][jss::LEDGER_ENTRY_FLAGS];
115
116 // sanity test the mapped value of a few arbitrarily chosen flags
117 BEAST_EXPECT(leFlags["AccountRoot"]["lsfDisallowXRP"] == 0x00080000);
118 BEAST_EXPECT(leFlags["AccountRoot"]["lsfDepositAuth"] == 0x01000000);
119 BEAST_EXPECT(leFlags["AccountRoot"]["lsfAllowTrustLineClawback"] == 0x80000000);
120
121 BEAST_EXPECT(leFlags["RippleState"]["lsfHighFreeze"] == 0x00800000);
122 BEAST_EXPECT(leFlags["RippleState"]["lsfAMMNode"] == 0x01000000);
123
124 BEAST_EXPECT(leFlags["DirNode"]["lsfNFTokenBuyOffers"] == 0x00000001);
125 BEAST_EXPECT(leFlags["MPTokenIssuance"]["lsfMPTCanTrade"] == 0x00000010);
126 BEAST_EXPECT(leFlags["Credential"]["lsfAccepted"] == 0x00010000);
127 BEAST_EXPECT(leFlags["Loan"]["lsfLoanImpaired"] == 0x00020000);
128 BEAST_EXPECT(leFlags["Vault"]["lsfVaultPrivate"] == 0x00010000);
129 BEAST_EXPECT(leFlags["MPToken"]["lsfMPTAuthorized"] == 0x00000002);
130 }
131
132 // validate the correctness of few chosen transaction flags
133 {
134 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FLAGS));
135 json::Value const& txFlags = result[jss::result][jss::TRANSACTION_FLAGS];
136
137 BEAST_EXPECT(txFlags["universal"]["tfFullyCanonicalSig"] == 0x80000000);
138 BEAST_EXPECT(txFlags["universal"]["tfInnerBatchTxn"] == 0x40000000);
139
140 BEAST_EXPECT(txFlags["AccountSet"]["tfRequireAuth"] == 0x00040000);
141 BEAST_EXPECT(txFlags["AccountSet"]["tfAllowXRP"] == 0x00200000);
142
143 BEAST_EXPECT(txFlags["MPTokenIssuanceSet"]["tfMPTLock"] == 0x00000001);
144 BEAST_EXPECT(txFlags["MPTokenIssuanceSet"]["tfMPTUnlock"] == 0x00000002);
145
146 BEAST_EXPECT(txFlags["AMMDeposit"]["tfLPToken"] == 0x00010000);
147 BEAST_EXPECT(txFlags["AMMDeposit"]["tfLimitLPToken"] == 0x00400000);
148 }
149
150 // validate the correctness of the AccountSpecificFlags section
151 {
152 BEAST_EXPECT(result[jss::result].isMember(jss::ACCOUNT_SET_FLAGS));
153 json::Value const& asFlags = result[jss::result][jss::ACCOUNT_SET_FLAGS];
154
155 BEAST_EXPECT(asFlags["asfDisallowXRP"] == 3);
156 BEAST_EXPECT(asFlags["asfGlobalFreeze"] == 7);
157 BEAST_EXPECT(asFlags["asfDisallowIncomingNFTokenOffer"] == 12);
158 BEAST_EXPECT(asFlags["asfDisallowIncomingTrustline"] == 15);
159 }
160
161 // test the response fields of the TRANSACTION_FORMATS section
162 {
163 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FORMATS));
164 json::Value const& txnFormats = result[jss::result][jss::TRANSACTION_FORMATS];
165
166 // first validate the contents of "common"
167 {
168 BEAST_EXPECT(txnFormats.isMember("common"));
169 json::Value const& section = txnFormats["common"];
170
171 BEAST_EXPECT(section[0u][jss::name] == "TransactionType");
172 BEAST_EXPECT(section[0u][jss::optionality] == SoeRequired);
173
174 BEAST_EXPECT(section[1u][jss::name] == "Flags");
175 BEAST_EXPECT(section[1u][jss::optionality] == SoeOptional);
176
177 BEAST_EXPECT(section[2u][jss::name] == "SourceTag");
178 BEAST_EXPECT(section[2u][jss::optionality] == SoeOptional);
179
180 BEAST_EXPECT(section[3u][jss::name] == "Account");
181 BEAST_EXPECT(section[3u][jss::optionality] == SoeRequired);
182
183 BEAST_EXPECT(section[4u][jss::name] == "Sequence");
184 BEAST_EXPECT(section[4u][jss::optionality] == SoeRequired);
185
186 BEAST_EXPECT(section[5u][jss::name] == "PreviousTxnID");
187 BEAST_EXPECT(section[5u][jss::optionality] == SoeOptional);
188
189 BEAST_EXPECT(section[6u][jss::name] == "LastLedgerSequence");
190 BEAST_EXPECT(section[6u][jss::optionality] == SoeOptional);
191
192 BEAST_EXPECT(section[7u][jss::name] == "AccountTxnID");
193 BEAST_EXPECT(section[7u][jss::optionality] == SoeOptional);
194
195 BEAST_EXPECT(section[8u][jss::name] == "Fee");
196 BEAST_EXPECT(section[8u][jss::optionality] == SoeRequired);
197
198 BEAST_EXPECT(section[9u][jss::name] == "OperationLimit");
199 BEAST_EXPECT(section[9u][jss::optionality] == SoeOptional);
200
201 BEAST_EXPECT(section[10u][jss::name] == "Memos");
202 BEAST_EXPECT(section[10u][jss::optionality] == SoeOptional);
203
204 BEAST_EXPECT(section[11u][jss::name] == "SigningPubKey");
205 BEAST_EXPECT(section[11u][jss::optionality] == SoeRequired);
206
207 BEAST_EXPECT(section[12u][jss::name] == "TicketSequence");
208 BEAST_EXPECT(section[12u][jss::optionality] == SoeOptional);
209
210 BEAST_EXPECT(section[13u][jss::name] == "TxnSignature");
211 BEAST_EXPECT(section[13u][jss::optionality] == SoeOptional);
212
213 BEAST_EXPECT(section[14u][jss::name] == "Signers");
214 BEAST_EXPECT(section[14u][jss::optionality] == SoeOptional);
215
216 BEAST_EXPECT(section[15u][jss::name] == "NetworkID");
217 BEAST_EXPECT(section[15u][jss::optionality] == SoeOptional);
218
219 BEAST_EXPECT(section[16u][jss::name] == "Delegate");
220 BEAST_EXPECT(section[16u][jss::optionality] == SoeOptional);
221 }
222
223 // validate the contents of four arbitrarily selected transactions validate the
224 // format of the OracleSet transaction
225 {
226 BEAST_EXPECT(txnFormats.isMember("OracleSet"));
227 json::Value const& section = txnFormats["OracleSet"];
228
229 BEAST_EXPECT(section[0u][jss::name] == "OracleDocumentID");
230 BEAST_EXPECT(section[0u][jss::optionality] == SoeRequired);
231
232 BEAST_EXPECT(section[1u][jss::name] == "Provider");
233 BEAST_EXPECT(section[1u][jss::optionality] == SoeOptional);
234
235 BEAST_EXPECT(section[2u][jss::name] == "URI");
236 BEAST_EXPECT(section[2u][jss::optionality] == SoeOptional);
237
238 BEAST_EXPECT(section[3u][jss::name] == "AssetClass");
239 BEAST_EXPECT(section[3u][jss::optionality] == SoeOptional);
240
241 BEAST_EXPECT(section[4u][jss::name] == "LastUpdateTime");
242 BEAST_EXPECT(section[4u][jss::optionality] == SoeRequired);
243
244 BEAST_EXPECT(section[5u][jss::name] == "PriceDataSeries");
245 BEAST_EXPECT(section[5u][jss::optionality] == SoeRequired);
246 }
247
248 // validate the format of the PermissionedDomainDelete transaction
249 {
250 BEAST_EXPECT(txnFormats.isMember("PermissionedDomainDelete"));
251 json::Value const& section = txnFormats["PermissionedDomainDelete"];
252
253 BEAST_EXPECT(section[0u][jss::name] == "DomainID");
254 BEAST_EXPECT(section[0u][jss::optionality] == SoeRequired);
255 }
256
257 // validate the format of the Clawback transaction
258 {
259 BEAST_EXPECT(txnFormats.isMember("Clawback"));
260 json::Value const& section = txnFormats["Clawback"];
261
262 BEAST_EXPECT(section[0u][jss::name] == "Amount");
263 BEAST_EXPECT(section[0u][jss::optionality] == SoeRequired);
264
265 BEAST_EXPECT(section[1u][jss::name] == "Holder");
266 BEAST_EXPECT(section[1u][jss::optionality] == SoeOptional);
267 }
268
269 // validate the format of the SetFee transaction
270 {
271 BEAST_EXPECT(txnFormats.isMember("SetFee"));
272 json::Value const& section = txnFormats["SetFee"];
273
274 BEAST_EXPECT(section[0u][jss::name] == "LedgerSequence");
275 BEAST_EXPECT(section[0u][jss::optionality] == SoeOptional);
276
277 BEAST_EXPECT(section[1u][jss::name] == "BaseFee");
278 BEAST_EXPECT(section[1u][jss::optionality] == SoeOptional);
279
280 BEAST_EXPECT(section[2u][jss::name] == "ReferenceFeeUnits");
281 BEAST_EXPECT(section[2u][jss::optionality] == SoeOptional);
282
283 BEAST_EXPECT(section[3u][jss::name] == "ReserveBase");
284 BEAST_EXPECT(section[3u][jss::optionality] == SoeOptional);
285
286 BEAST_EXPECT(section[4u][jss::name] == "ReserveIncrement");
287 BEAST_EXPECT(section[4u][jss::optionality] == SoeOptional);
288
289 BEAST_EXPECT(section[5u][jss::name] == "BaseFeeDrops");
290 BEAST_EXPECT(section[5u][jss::optionality] == SoeOptional);
291
292 BEAST_EXPECT(section[6u][jss::name] == "ReserveBaseDrops");
293 BEAST_EXPECT(section[6u][jss::optionality] == SoeOptional);
294
295 BEAST_EXPECT(section[7u][jss::name] == "ReserveIncrementDrops");
296 BEAST_EXPECT(section[7u][jss::optionality] == SoeOptional);
297 }
298 }
299
300 // test the properties of the LEDGER_ENTRY_FORMATS section in server_definitions
301 // response
302 {
303 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
304
305 // Note: For the purposes of software maintenance, this test does not exhaustively
306 // validate all the LEDGER_ENTRY_FORMATS
307
308 // check "common" first
309 {
310 json::Value const& observedCommonLedgerEntry =
311 result[jss::result][jss::LEDGER_ENTRY_FORMATS]["common"];
312
313 BEAST_EXPECT(observedCommonLedgerEntry[0u][jss::name] == "LedgerIndex");
314 BEAST_EXPECT(observedCommonLedgerEntry[0u][jss::optionality] == SoeOptional);
315
316 BEAST_EXPECT(observedCommonLedgerEntry[1u][jss::name] == "LedgerEntryType");
317 BEAST_EXPECT(observedCommonLedgerEntry[1u][jss::optionality] == SoeRequired);
318
319 BEAST_EXPECT(observedCommonLedgerEntry[2u][jss::name] == "Flags");
320 BEAST_EXPECT(observedCommonLedgerEntry[2u][jss::optionality] == SoeRequired);
321 }
322
323 // test the contents of an arbitrary ledger-entry (DID)
324 {
325 json::Value const& observedDIDLedgerEntry =
326 result[jss::result][jss::LEDGER_ENTRY_FORMATS]["DID"];
327
328 BEAST_EXPECT(observedDIDLedgerEntry[0u][jss::name] == "Account");
329 BEAST_EXPECT(observedDIDLedgerEntry[0u][jss::optionality] == SoeRequired);
330
331 BEAST_EXPECT(observedDIDLedgerEntry[1u][jss::name] == "DIDDocument");
332 BEAST_EXPECT(observedDIDLedgerEntry[1u][jss::optionality] == SoeOptional);
333
334 BEAST_EXPECT(observedDIDLedgerEntry[2u][jss::name] == "URI");
335 BEAST_EXPECT(observedDIDLedgerEntry[2u][jss::optionality] == SoeOptional);
336
337 BEAST_EXPECT(observedDIDLedgerEntry[3u][jss::name] == "Data");
338 BEAST_EXPECT(observedDIDLedgerEntry[3u][jss::optionality] == SoeOptional);
339
340 BEAST_EXPECT(observedDIDLedgerEntry[4u][jss::name] == "OwnerNode");
341 BEAST_EXPECT(observedDIDLedgerEntry[4u][jss::optionality] == SoeRequired);
342
343 BEAST_EXPECT(observedDIDLedgerEntry[5u][jss::name] == "PreviousTxnID");
344 BEAST_EXPECT(observedDIDLedgerEntry[5u][jss::optionality] == SoeRequired);
345
346 BEAST_EXPECT(observedDIDLedgerEntry[6u][jss::name] == "PreviousTxnLgrSeq");
347 BEAST_EXPECT(observedDIDLedgerEntry[6u][jss::optionality] == SoeRequired);
348 }
349
350 // test the contents of an arbitrary ledger-entry (NegativeUNL)
351 {
352 json::Value const& observedNunlLedgerEntry =
353 result[jss::result][jss::LEDGER_ENTRY_FORMATS]["NegativeUNL"];
354
355 BEAST_EXPECT(observedNunlLedgerEntry[0u][jss::name] == "DisabledValidators");
356 BEAST_EXPECT(observedNunlLedgerEntry[0u][jss::optionality] == SoeOptional);
357
358 BEAST_EXPECT(observedNunlLedgerEntry[1u][jss::name] == "ValidatorToDisable");
359 BEAST_EXPECT(observedNunlLedgerEntry[1u][jss::optionality] == SoeOptional);
360
361 BEAST_EXPECT(observedNunlLedgerEntry[2u][jss::name] == "ValidatorToReEnable");
362 BEAST_EXPECT(observedNunlLedgerEntry[2u][jss::optionality] == SoeOptional);
363
364 BEAST_EXPECT(observedNunlLedgerEntry[3u][jss::name] == "PreviousTxnID");
365 BEAST_EXPECT(observedNunlLedgerEntry[3u][jss::optionality] == SoeOptional);
366
367 BEAST_EXPECT(observedNunlLedgerEntry[4u][jss::name] == "PreviousTxnLgrSeq");
368 BEAST_EXPECT(observedNunlLedgerEntry[4u][jss::optionality] == SoeOptional);
369 }
370 }
371
372 // Exhaustive test: verify all transaction flags from getAllTxFlags() appear in the
373 // output
374 {
375 json::Value const& txFlags = result[jss::result][jss::TRANSACTION_FLAGS];
376
377 for (auto const& [txName, flagMap] : getAllTxFlags())
378 {
379 BEAST_EXPECT(txFlags.isMember(txName));
380 if (txFlags.isMember(txName))
381 {
382 for (auto const& [flagName, flagValue] : flagMap)
383 {
384 BEAST_EXPECT(txFlags[txName].isMember(flagName));
385 if (txFlags[txName].isMember(flagName))
386 {
387 BEAST_EXPECT(txFlags[txName][flagName].asUInt() == flagValue);
388 }
389 }
390 }
391 }
392 }
393
394 // Exhaustive test: verify all ledger entry flags from getAllLedgerFlags() appear in the
395 // output
396 {
397 json::Value const& leFlags = result[jss::result][jss::LEDGER_ENTRY_FLAGS];
398
399 for (auto const& [ledgerType, flagMap] : getAllLedgerFlags())
400 {
401 BEAST_EXPECT(leFlags.isMember(ledgerType));
402 if (leFlags.isMember(ledgerType))
403 {
404 for (auto const& [flagName, flagValue] : flagMap)
405 {
406 BEAST_EXPECT(leFlags[ledgerType].isMember(flagName));
407 if (leFlags[ledgerType].isMember(flagName))
408 {
409 BEAST_EXPECT(leFlags[ledgerType][flagName].asUInt() == flagValue);
410 }
411 }
412 }
413 }
414 }
415
416 // Exhaustive test: verify all AccountSet flags from getAsfFlagMap() appear in the
417 // output
418 {
419 json::Value const& asFlags = result[jss::result][jss::ACCOUNT_SET_FLAGS];
420
421 for (auto const& [flagName, flagValue] : getAsfFlagMap())
422 {
423 BEAST_EXPECT(asFlags.isMember(flagName));
424 if (asFlags.isMember(flagName))
425 {
426 BEAST_EXPECT(asFlags[flagName].asInt() == flagValue);
427 }
428 }
429 }
430
431 // test providing the same hash
432 {
433 Env env(*this);
434 auto const firstResult = env.rpc("server_definitions");
435 auto const hash = firstResult[jss::result][jss::hash].asString();
436 auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
437
438 auto const result = env.rpc("json", "server_definitions", hashParam);
439 BEAST_EXPECT(!result[jss::result].isMember(jss::error));
440 BEAST_EXPECT(result[jss::result][jss::status] == "success");
441 BEAST_EXPECT(!result[jss::result].isMember(jss::FIELDS));
442 BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
443 BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
444 BEAST_EXPECT(!result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
445 BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_RESULTS));
446 BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_TYPES));
447 BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_FLAGS));
448 BEAST_EXPECT(!result[jss::result].isMember(jss::TRANSACTION_FORMATS));
449 BEAST_EXPECT(!result[jss::result].isMember(jss::TYPES));
450 BEAST_EXPECT(result[jss::result].isMember(jss::hash));
451 }
452
453 // test providing a different hash
454 {
455 Env env(*this);
456 std::string const hash =
457 "54296160385A27154BFA70A239DD8E8FD4CC2DB7BA32D970BA3A5B132CF749"
458 "D1";
459 auto const hashParam = std::string("{ ") + "\"hash\": \"" + hash + "\"}";
460
461 auto const result = env.rpc("json", "server_definitions", hashParam);
462 BEAST_EXPECT(!result[jss::result].isMember(jss::error));
463 BEAST_EXPECT(result[jss::result][jss::status] == "success");
464 BEAST_EXPECT(result[jss::result].isMember(jss::FIELDS));
465 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_TYPES));
466 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FLAGS));
467 BEAST_EXPECT(result[jss::result].isMember(jss::LEDGER_ENTRY_FORMATS));
468 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_RESULTS));
469 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_TYPES));
470 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FLAGS));
471 BEAST_EXPECT(result[jss::result].isMember(jss::TRANSACTION_FORMATS));
472 BEAST_EXPECT(result[jss::result].isMember(jss::TYPES));
473 BEAST_EXPECT(result[jss::result].isMember(jss::hash));
474 }
475 }
476 }
477
478 void
479 testGetServerDefinitionsJson()
480 {
481 testcase("getServerDefinitionsJson");
482
483 auto const& defs = getServerDefinitionsJson();
484 for (auto const& field :
485 {jss::ACCOUNT_SET_FLAGS,
486 jss::FIELDS,
487 jss::LEDGER_ENTRY_FLAGS,
488 jss::LEDGER_ENTRY_FORMATS,
489 jss::LEDGER_ENTRY_TYPES,
490 jss::TRANSACTION_FLAGS,
491 jss::TRANSACTION_FORMATS,
492 jss::TRANSACTION_RESULTS,
493 jss::TRANSACTION_TYPES,
494 jss::TYPES,
495 jss::hash})
496 {
497 BEAST_EXPECT(defs.isMember(field));
498 }
499
500 // verify it returns the same hash as the RPC handler
501 using namespace test::jtx;
502 Env env(*this);
503 auto const rpcResult = env.rpc("server_definitions");
504 BEAST_EXPECT(defs[jss::hash] == rpcResult[jss::result][jss::hash]);
505 }
506
507 void
508 run() override
509 {
510 testServerDefinitions();
511 testGetServerDefinitionsJson();
512 }
513};
514
515BEAST_DEFINE_TESTSUITE(ServerDefinitions, rpc, xrpl);
516
517} // namespace xrpl::test
beast::unit_test::Suite
A testsuite class.
Definition suite.h:50
beast::unit_test::Suite::testcase
TestcaseT testcase
Memberspace for declaring test cases.
Definition suite.h:149
json::Value
Represents a JSON value.
Definition json_value.h:130
json::Value::asString
std::string asString() const
Returns the unquoted string value.
Definition json_value.cpp:483
json::Value::isMember
bool isMember(char const *key) const
Return true if the object has a member named key.
Definition json_value.cpp:1036
xrpl::test::ServerDefinitions_test
Definition ServerDefinitions_test.cpp:17
xrpl::test::ServerDefinitions_test::testGetServerDefinitionsJson
void testGetServerDefinitionsJson()
Definition ServerDefinitions_test.cpp:479
xrpl::test::ServerDefinitions_test::testServerDefinitions
void testServerDefinitions()
Definition ServerDefinitions_test.cpp:20
xrpl::test::ServerDefinitions_test::run
void run() override
Runs the suite.
Definition ServerDefinitions_test.cpp:508
xrpl::test::jtx::Env
A transaction testing environment.
Definition Env.h:143
xrpl::test::jtx::Env::rpc
json::Value rpc(unsigned apiVersion, std::unordered_map< std::string, std::string > const &headers, std::string const &cmd, Args &&... args)
Execute an RPC command.
Definition Env.h:864
std::set::insert
T insert(T... args)
xrpl::test::BEAST_DEFINE_TESTSUITE
BEAST_DEFINE_TESTSUITE(AMMClawback, app, xrpl)
xrpl
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
Definition algorithm.h:5
xrpl::SoeOptional
@ SoeOptional
Definition SOTemplate.h:19
xrpl::SoeRequired
@ SoeRequired
Definition SOTemplate.h:18
xrpl::getServerDefinitionsJson
json::Value const & getServerDefinitionsJson()
Definition ServerDefinitions.cpp:379
xrpl::getAllTxFlags
FlagMapPairList const & getAllTxFlags()
Definition TxFlags.h:306
xrpl::getAllLedgerFlags
std::vector< std::pair< std::string, LedgerFlagMap > > const & getAllLedgerFlags()
Definition LedgerFormats.h:261
xrpl::getAsfFlagMap
std::map< std::string, FlagValue > const & getAsfFlagMap()
Definition TxFlags.h:432
Generated by doxygen 1.16.1