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