1#include <test/jtx/TestSuite.h>
2#include <test/unit_test/FileDirGuard.h>
4#include <xrpld/core/Config.h>
6#include <xrpl/basics/FileUtilities.h>
7#include <xrpl/beast/unit_test/suite.h>
8#include <xrpl/config/BasicConfig.h>
9#include <xrpl/config/Constants.h>
10#include <xrpl/protocol/SystemParameters.h>
11#include <xrpl/protocol/XRPAmount.h>
12#include <xrpl/server/Port.h>
14#include <boost/lexical_cast/bad_lexical_cast.hpp>
39 static constexpr char const* kConfigContentsTemplate = R
"xrpldConfig(
67#-------------------------------------------------------------------------------
72# This is primary persistent datastore for xrpld. This includes transaction
73# metadata, account states, and ledger headers. Helpful information can be
74# found on https://xrpl.org/capacity-planning.html#node-db-type
75# delete old ledgers while maintaining at least 2000. Do not require an
76# external administrative command to initiate deletion.
79path=/Users/dummy/xrpld/config/db/rocksdb
90# This needs to be an absolute directory reference, not a relative one.
91# Modify this value as required.
93/Users/dummy/xrpld/config/log/debug.log
101# Where to find some other servers speaking the XRPL protocol.
106# Turn down default logging to save disk space in the long run.
107# Valid values here are trace, debug, info, warning, error, and fatal
109{{ "command": "log_level", "severity": "warning" }}
111# Defaults to 1 ("yes") so that certificates will be validated. To allow the use
112# of self-signed certificates for development or internal use, set to 0 ("no").
120 std::string dbPathSection = dbPath.empty() ? "" :
"[database_path]\n" + dbPath;
122 validatorsFile.
empty() ?
"" :
"[validators_file]\n" + validatorsFile;
123 return std::format(kConfigContentsTemplate, dbPathSection, valFileSection);
139envVar(
char const* name)
141 if (
char const*
const value =
std::getenv(name); value !=
nullptr)
167 setenv(name, value->c_str(), 1);
183 : name_(name), saved_(envVar(name))
188 EnvVarGuard(EnvVarGuard
const&) =
delete;
190 operator=(EnvVarGuard
const&) =
delete;
222 bool useCounter =
true,
272 using namespace std::filesystem;
276 catch (std::exception& e)
289n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7
290n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj
291n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C
292n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS
293n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA
296nHUhG1PgAG8H8myUENypM35JgfqXAKNQvRVVAFDRzJrny5eZN8d5
297nHBu9PTL9dn2GuZtdW4U2WzBwffyX9qsQCd9CNU4Z5YG3PQfViM8
298nHUPDdcdb2Y5DZAJne4c2iabFuAP3F34xZUgYQT2NH7qfkdapgnz
300[validator_list_sites]
301recommended-xrpl-validators.com
302more-xrpl-validators.net
30503E74EE14CB525AFBB9F1B7D86CD58ECC4B91452294B42AB4E78F260BD905C091D
306030775A669685BD6ABCEBD80385921C7851783D991A8055FD21D2F3966C96F1B56
308[validator_list_threshold]
321 beast::unit_test::Suite& test,
323 Path const& validatorsFileName,
324 bool useCounter =
true)
328 Path(validatorsFileName.
empty() ? Config::kValidatorsFileName : validatorsFileName),
340 [[nodiscard]] std::string
381 BEAST_EXPECT(c.
legacy(
"not_in_file").empty());
382 c.
legacy(
"not_in_file",
"new_value");
383 BEAST_EXPECT(c.
legacy(
"not_in_file") ==
"new_value");
397 for (
auto const& configFile : configFiles)
402 Path const f = td.file(std::string{configFile});
403 std::ofstream o(f.string());
409 c.
setup(
"",
true,
false,
true);
413 "/Users/dummy/xrpld/config/log/debug.log");
419 auto const home = detail::envVar(
"HOME");
420 auto const xdgConfigHome = detail::envVar(
"XDG_CONFIG_HOME");
422 for (
auto const& configFile : configFiles)
437 detail::EnvVarGuard
const homeGuard(
"HOME", tc.path());
438 detail::EnvVarGuard
const xdgGuard(
"XDG_CONFIG_HOME", tc.path());
443 p = tc.file(
systemName() +
"/" + std::string{configFile});
444 std::ofstream o(p.string());
450 c.setup(
"",
true,
false,
true);
454 "/Users/dummy/xrpld/config/log/debug.log");
458 BEAST_EXPECT(detail::envVar(
"HOME") == home);
459 BEAST_EXPECT(detail::envVar(
"XDG_CONFIG_HOME") == xdgConfigHome);
468 detail::EnvVarGuard
const homeGuard(
"HOME", tc.path());
469 detail::EnvVarGuard
const xdgGuard(
"XDG_CONFIG_HOME", std::nullopt);
472 std::string s =
".config";
478 p = tc.file(s +
"/" + std::string{configFile});
479 std::ofstream o(p.string());
485 c.setup(
"",
true,
false,
true);
489 "/Users/dummy/xrpld/config/log/debug.log");
493 BEAST_EXPECT(detail::envVar(
"HOME") == home);
494 BEAST_EXPECT(detail::envVar(
"XDG_CONFIG_HOME") == xdgConfigHome);
508 constexpr char const* cc =
"[database_path]\n{}\n";
511 Path const dataDirRel(
"test_data_dir");
512 Path const dataDirAbs(cwd / dataDirRel);
516 c.loadFromString(
std::format(cc, dataDirAbs.string()));
522 c.loadFromString(
std::format(cc, dataDirRel.string()));
530 c.loadFromString(
"");
537 detail::DirGuard
const g0(*
this,
"test_db");
538 Path const dataDirRel(
"test_data_dir");
539 Path const dataDirAbs(cwd / g0.subdir() / dataDirRel);
540 detail::FileCfgGuard
const g(
542 auto const& c(g.config());
543 BEAST_EXPECT(g.dataDirExists());
544 BEAST_EXPECT(g.configFileExists());
549 std::string
const dbPath(
"my_db");
551 auto const& c(g.config());
552 std::string
const nativeDbPath =
absolute(
Path(dbPath)).string();
553 BEAST_EXPECT(g.dataDirExists());
554 BEAST_EXPECT(g.configFileExists());
560 auto const& c(g.config());
561 std::string
const nativeDbPath =
563 BEAST_EXPECT(g.dataDirExists());
564 BEAST_EXPECT(g.configFileExists());
577 "eyJ2YWxpZGF0aW9uX3ByaXZhdGVfa2V5IjoiOWVkNDVmODY2MjQxY2MxOGEyNzQ3Yj"
578 "U0Mzg3YzA2MjU5MDc5NzJmNGU3MTkwMjMxZmFhOTM3NDU3ZmE5ZGFmNiIsIm1hbmlm"
579 "ZXN0IjoiSkFBQUFBRnhJZTFGdHdtaW12R3RIMmlDY01KcUM5Z1ZGS2lsR2Z3MS92Q3"
580 "hIWFhMcGxjMkduTWhBa0UxYWdxWHhCd0R3RGJJRDZPTVNZdU0wRkRBbHBBZ05rOFNL"
581 "Rm43TU8yZmRrY3dSUUloQU9uZ3U5c0FLcVhZb3VKK2wyVjBXK3NBT2tWQitaUlM2UF"
582 "NobEpBZlVzWGZBaUJzVkpHZXNhYWRPSmMvYUFab2tTMXZ5bUdtVnJsSFBLV1gzWXl3"
583 "dTZpbjhIQVNRS1B1Z0JENjdrTWFSRkd2bXBBVEhsR0tKZHZERmxXUFl5NUFxRGVkRn"
584 "Y1VEphMncwaTIxZXEzTVl5d0xWSlpuRk9yN0Mwa3cyQWlUelNDakl6ZGl0UTg9In0"
589 static constexpr char const* kConfigTemplate = R
"xrpldConfig(
597 auto const expectedError =
598 "Cannot have both [validation_seed] "
599 "and [validator_token] config sections";
608 BEAST_EXPECT(error == expectedError);
617 auto const load = [](Config& c, std::string
const& toLoad) {
620 c.loadFromString(toLoad);
622 catch (std::runtime_error
const& e)
624 return std::string(e.
what());
626 return std::string();
631 BEAST_EXPECT(load(c,
"[network_id]\n10000\n").
empty());
632 BEAST_EXPECT(c.networkId == 10000);
638 BEAST_EXPECT(load(c,
"[network_id]\n# 10000\n").
empty());
645 load(c,
"[network_id]\n10000\n[network_id]\n21337\n") ==
646 "[network_id] requires exactly one value, not 2");
658 c.loadFromString(R
"xrpldConfig(
663 catch (std::runtime_error
const& e)
668 BEAST_EXPECT(error.
empty());
669 BEAST_EXPECT(c.networkId == 0);
673 c.loadFromString(R
"xrpldConfig(
676 catch (std::runtime_error
const& e)
681 BEAST_EXPECT(error.
empty());
682 BEAST_EXPECT(c.networkId == 0);
686 c.loadFromString(R
"xrpldConfig(
691 catch (std::runtime_error
const& e)
696 BEAST_EXPECT(error.
empty());
697 BEAST_EXPECT(c.networkId == 255);
701 c.loadFromString(R
"xrpldConfig(
711 BEAST_EXPECT(error.
empty());
712 BEAST_EXPECT(c.networkId == 10000);
720 using namespace std::filesystem;
723 constexpr char const* cc =
"[validators_file]\n{}\n";
725 std::string
const missingPath =
"/no/way/this/path/exists";
726 auto const expectedError =
727 "The file specified in [validators_file] does not exist: " + missingPath;
733 catch (std::runtime_error
const& e)
737 BEAST_EXPECT(error == expectedError);
741 detail::ValidatorsTxtGuard
const vtg(*
this,
"test_cfg",
"validators.cfg");
743 constexpr char const* cc =
"[validators_file]\n{}\n";
745 auto const expectedError =
746 "Invalid file specified in [validators_file]: " + invalidFile.
string();
750 c.loadFromString(
std::format(cc, invalidFile.string()));
752 catch (std::runtime_error
const& e)
756 BEAST_EXPECT(error == expectedError);
761 std::string
const toLoad(R
"xrpldConfig(
763n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7
764n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj
765n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C
768nHUhG1PgAG8H8myUENypM35JgfqXAKNQvRVVAFDRzJrny5eZN8d5
769nHBu9PTL9dn2GuZtdW4U2WzBwffyX9qsQCd9CNU4Z5YG3PQfViM8
771 c.loadFromString(toLoad);
774 BEAST_EXPECT(c.validatorListThreshold == std::nullopt);
779 std::string
const toLoad(R
"xrpldConfig(
780[validator_list_sites]
782trust-these-validators.gov
785021A99A537FDEBC34E4FCA03B39BEADD04299BB19E85097EC92B15A3518801E566
787[validator_list_threshold]
790 c.loadFromString(toLoad);
796 "trust-these-validators.gov");
800 "021A99A537FDEBC34E4FCA03B39BEADD04299BB19E85097EC92B15A3518801"
804 BEAST_EXPECT(c.validatorListThreshold == std::size_t(1));
809 std::string
const toLoad(R
"xrpldConfig(
810[validator_list_sites]
812trust-these-validators.gov
815021A99A537FDEBC34E4FCA03B39BEADD04299BB19E85097EC92B15A3518801E566
817[validator_list_threshold]
820 c.loadFromString(toLoad);
826 "trust-these-validators.gov");
830 "021A99A537FDEBC34E4FCA03B39BEADD04299BB19E85097EC92B15A3518801"
834 BEAST_EXPECT(c.validatorListThreshold == std::nullopt);
840 std::string
const toLoad(R
"xrpldConfig(
841[validator_list_sites]
843trust-these-validators.gov
846021A99A537FDEBC34E4FCA03B39BEADD04299BB19E85097EC92B15A3518801E566
848[validator_list_threshold]
852 auto const expectedError =
853 "Value in config section [validator_list_threshold] exceeds "
854 "the number of configured list keys";
857 c.loadFromString(toLoad);
860 catch (std::runtime_error
const& e)
864 BEAST_EXPECT(error == expectedError);
869 std::string
const toLoad(R
"xrpldConfig(
870[validator_list_sites]
872trust-these-validators.gov
875021A99A537FDEBC34E4FCA03B39BEADD04299BB19E85097EC92B15A3518801E566
877[validator_list_threshold]
881 auto const expectedError =
882 "Config section [validator_list_threshold] should contain "
886 c.loadFromString(toLoad);
889 catch (std::runtime_error
const& e)
893 BEAST_EXPECT(error == expectedError);
898 std::string
const toLoad(R
"xrpldConfig(
899[validator_list_sites]
901trust-these-validators.gov
904021A99A537FDEBC34E4FCA03B39BEADD04299BB19E85097EC92B15A3518801E566
906[validator_list_threshold]
912 c.loadFromString(toLoad);
915 catch (std::bad_cast& e)
925 std::string
const toLoad(R
"xrpldConfig(
926[validator_list_sites]
928trust-these-validators.gov
931 auto const expectedError =
"[validator_list_keys] config section is missing";
934 c.loadFromString(toLoad);
937 catch (std::runtime_error
const& e)
941 BEAST_EXPECT(error == expectedError);
945 detail::ValidatorsTxtGuard
const vtg(*
this,
"test_cfg",
"validators.cfg");
946 BEAST_EXPECT(vtg.validatorsFileExists());
948 constexpr char const* cc =
"[validators_file]\n{}\n";
949 c.loadFromString(
std::format(cc, vtg.validatorsFile()));
955 BEAST_EXPECT(c.validatorListThreshold == 2);
960 std::string
const valFileName =
"validators.txt";
961 detail::ValidatorsTxtGuard
const vtg(*
this,
"test_cfg", valFileName);
962 detail::FileCfgGuard
const rcg(
964 BEAST_EXPECT(vtg.validatorsFileExists());
965 BEAST_EXPECT(rcg.configFileExists());
966 auto const& c(rcg.config());
972 BEAST_EXPECT(c.validatorListThreshold == 2);
977 detail::ValidatorsTxtGuard
const vtg(*
this,
"test_cfg",
"validators.txt");
978 auto const valFilePath =
".." / vtg.subdir() /
"validators.txt";
979 detail::FileCfgGuard
const rcg(
981 BEAST_EXPECT(vtg.validatorsFileExists());
982 BEAST_EXPECT(rcg.configFileExists());
983 auto const& c(rcg.config());
989 BEAST_EXPECT(c.validatorListThreshold == 2);
993 detail::ValidatorsTxtGuard
const vtg(*
this,
"test_cfg",
"validators.txt");
994 detail::FileCfgGuard
const rcg(
996 BEAST_EXPECT(vtg.validatorsFileExists());
997 BEAST_EXPECT(rcg.configFileExists());
998 auto const& c(rcg.config());
1004 BEAST_EXPECT(c.validatorListThreshold == 2);
1010 BEAST_EXPECT(vtg.validatorsFileExists());
1012 *
this, vtg.subdir(),
"validators.txt",
false);
1013 BEAST_EXPECT(vtgDefault.validatorsFileExists());
1016 BEAST_EXPECT(rcg.configFileExists());
1017 auto const& c(rcg.config());
1023 BEAST_EXPECT(c.validatorListThreshold == 2);
1028 constexpr char const* cc = R
"xrpldConfig(
1033n949f75evCHwgyP4fPVgaHqNHxUVN15PsJEZ3B3HnXPcPjcZAoy7
1034n9MD5h24qrQqiyBC8aeqqCWvpiBiYQ3jxSr91uiDvmrkyHRdYLUj
1035n9L81uNCaPgtUJfaHh89gmdvXKAmSt5Gdsw2g1iPWaPkAHW5Nm4C
1036n9KiYM9CgngLvtRCQHZwgC2gjpdaZcCcbt3VboxiNFcKuwFVujzS
1037n9LdgEtkmGB9E2h3K4Vp7iGUaKuq23Zr32ehxiU8FWY7xoxbWTSA
1040nHB1X37qrniVugfQcuBTAjswphC1drx7QjFFojJPZwKHHnt8kU7v
1041nHUkAWDR4cB8AgPg7VXMX6et8xRTQb2KJfgv1aBEXozwrawRKgMB
1043[validator_list_sites]
1045trust-these-validators.gov
1047[validator_list_keys]
1048021A99A537FDEBC34E4FCA03B39BEADD04299BB19E85097EC92B15A3518801E566
1050 detail::ValidatorsTxtGuard const vtg(*
this,
"test_cfg",
"validators.cfg");
1051 BEAST_EXPECT(vtg.validatorsFileExists());
1053 c.loadFromString(
std::format(cc, vtg.validatorsFile()));
1059 BEAST_EXPECT(c.validatorListThreshold == 2);
1064 constexpr char const* cc = R
"xrpldConfig(
1068[validator_list_threshold]
1072 detail::ValidatorsTxtGuard const vtg(*
this,
"test_cfg",
"validators.cfg");
1073 BEAST_EXPECT(vtg.validatorsFileExists());
1074 auto const expectedError =
1075 "Config section [validator_list_threshold] should contain "
1076 "single value only";
1080 c.loadFromString(
std::format(cc, vtg.validatorsFile()));
1083 catch (std::runtime_error
const& e)
1087 BEAST_EXPECT(error == expectedError);
1094 constexpr char const* cc =
"[validators_file]\n{}\n";
1096 detail::ValidatorsTxtGuard
const vtg(*
this,
"test_cfg",
"validators.cfg");
1097 BEAST_EXPECT(vtg.validatorsFileExists());
1098 auto const expectedError =
1099 "The file specified in [validators_file] does not contain a "
1100 "[validators], [validator_keys] or [validator_list_keys] "
1102 vtg.validatorsFile();
1103 std::ofstream
const o(vtg.validatorsFile());
1107 c2.loadFromString(
std::format(cc, vtg.validatorsFile()));
1109 catch (std::runtime_error
const& e)
1113 BEAST_EXPECT(error == expectedError);
1133 BEAST_EXPECT(!config.
quiet());
1134 BEAST_EXPECT(!config.
silent());
1146 BEAST_EXPECT(config.
quiet());
1147 BEAST_EXPECT(!config.
silent());
1159 BEAST_EXPECT(config.quiet());
1160 BEAST_EXPECT(config.silent());
1161 BEAST_EXPECT(!config.standalone());
1162 BEAST_EXPECT(config.ledgerHistory == 256);
1172 BEAST_EXPECT(config.
quiet());
1173 BEAST_EXPECT(config.
silent());
1185 BEAST_EXPECT(!config.quiet());
1186 BEAST_EXPECT(!config.silent());
1187 BEAST_EXPECT(config.standalone());
1188 BEAST_EXPECT(config.ledgerHistory == 0);
1198 BEAST_EXPECT(config.
quiet());
1199 BEAST_EXPECT(!config.
silent());
1211 BEAST_EXPECT(config.quiet());
1212 BEAST_EXPECT(config.silent());
1213 BEAST_EXPECT(config.standalone());
1214 BEAST_EXPECT(config.ledgerHistory == 0);
1224 BEAST_EXPECT(config.quiet());
1225 BEAST_EXPECT(config.silent());
1226 BEAST_EXPECT(config.standalone());
1227 BEAST_EXPECT(config.ledgerHistory == 0);
1236 auto const& conf = cfg.
config();
1244 BEAST_EXPECT(
rpc.adminNetsV4.size() +
rpc.adminNetsV6.size() == 2);
1261 BEAST_EXPECT(
false);
1276 std::string
const toLoad(
1299 cfg.loadFromString(toLoad);
1318 std::string
const toLoad(
1339 anotherserversansport
1340 anotherserverwithport:12
1350 2001:db8:3333:4444:5555:6666:7777:8888:12345
1351 [2001:db8:3333:4444:5555:6666:7777:8888]:1
1355 cfg.loadFromString(toLoad);
1366 BEAST_EXPECT(cfg.ips[0] == "r.ripple.com 51235");
1368 BEAST_EXPECT(cfg.ipsFixed[0] ==
"s1.ripple.com 51235");
1369 BEAST_EXPECT(cfg.ipsFixed[1] ==
"s2.ripple.com 51235");
1370 BEAST_EXPECT(cfg.ipsFixed[2] ==
"anotherserversansport");
1371 BEAST_EXPECT(cfg.ipsFixed[3] ==
"anotherserverwithport 12");
1372 BEAST_EXPECT(cfg.ipsFixed[4] ==
"1.1.1.1 1");
1373 BEAST_EXPECT(cfg.ipsFixed[5] ==
"1.1.1.1 1");
1374 BEAST_EXPECT(cfg.ipsFixed[6] ==
"12.34.12.123 12345");
1375 BEAST_EXPECT(cfg.ipsFixed[7] ==
"12.34.12.123 12345");
1378 BEAST_EXPECT(cfg.ipsFixed[8] ==
"::");
1379 BEAST_EXPECT(cfg.ipsFixed[9] ==
"2001:db8::");
1380 BEAST_EXPECT(cfg.ipsFixed[10] ==
"::1");
1381 BEAST_EXPECT(cfg.ipsFixed[11] ==
"::1:12345");
1382 BEAST_EXPECT(cfg.ipsFixed[12] ==
"[::1]:12345");
1383 BEAST_EXPECT(cfg.ipsFixed[13] ==
"2001:db8:3333:4444:5555:6666:7777:8888:12345");
1384 BEAST_EXPECT(cfg.ipsFixed[14] ==
"[2001:db8:3333:4444:5555:6666:7777:8888]:1");
1390 struct TestCommentData
1401 .line =
"password = aaaa\\#bbbb",
1402 .field =
"password",
1403 .expect =
"aaaa#bbbb",
1404 .hadComment =
false,
1407 .line =
"password = aaaa#bbbb",
1408 .field =
"password",
1413 .line =
"password = aaaa #bbbb",
1414 .field =
"password",
1420 .line =
"password = #aaaa #bbbb",
1422 .expect =
"password =",
1426 .line =
"password = aaaa\\# #bbbb",
1427 .field =
"password",
1432 .line =
"password = aaaa\\##bbbb",
1433 .field =
"password",
1437 {.line =
"aaaa#bbbb", .field =
"", .expect =
"aaaa", .hadComment =
true},
1438 {.line =
"aaaa\\#bbbb", .field =
"", .expect =
"aaaa#bbbb", .hadComment =
false},
1439 {.line =
"aaaa\\##bbbb", .field =
"", .expect =
"aaaa#", .hadComment =
true},
1440 {.line =
"aaaa #bbbb", .field =
"", .expect =
"aaaa", .hadComment =
true},
1441 {.line =
"1 #comment", .field =
"", .expect =
"1", .hadComment =
true},
1442 {.line =
"#whole thing is comment", .field =
"", .expect =
"", .hadComment =
false},
1444 .line =
" #whole comment with space",
1447 .hadComment =
false,
1452 for (
auto const& t : tests)
1455 s.
append(std::string(t.line));
1456 BEAST_EXPECT(s.hadTrailingComments() == t.hadComment);
1457 if (t.field.empty())
1459 BEAST_EXPECTS(s.legacy() == t.expect, s.legacy());
1464 BEAST_EXPECTS(
set(field, std::string(t.field), s), t.line);
1465 BEAST_EXPECTS(field == t.expect, t.line);
1471 s.append(
"online_delete = 3000");
1472 std::uint32_t od = 0;
1480 s.append(
"online_delete = 2000 #my comment on this");
1481 std::uint32_t od = 0;
1491 using namespace std::string_literals;
1493 s.
append(
"a_string = mystring");
1494 s.
append(
"positive_int = 2");
1495 s.
append(
"negative_int = -3");
1496 s.
append(
"bool_ish = 1");
1499 auto val1 =
"value 1"s;
1500 BEAST_EXPECT(
set(val1,
"a_string", s));
1501 BEAST_EXPECT(val1 ==
"mystring");
1503 auto val2 =
"value 2"s;
1504 BEAST_EXPECT(!
set(val2,
"not_a_key", s));
1505 BEAST_EXPECT(val2 ==
"value 2");
1506 BEAST_EXPECT(!
set(val2,
"default"s,
"not_a_key", s));
1507 BEAST_EXPECT(val2 ==
"default");
1510 BEAST_EXPECT(val3 ==
"mystring");
1512 BEAST_EXPECT(val4.empty());
1514 BEAST_EXPECT(val5 ==
"default");
1516 auto val6 =
"value 6"s;
1518 BEAST_EXPECT(val6 ==
"mystring");
1520 auto val7 =
"value 7"s;
1522 BEAST_EXPECT(val7 ==
"value 7");
1527 BEAST_EXPECT(
set(val1,
"positive_int", s));
1528 BEAST_EXPECT(val1 == 2);
1531 BEAST_EXPECT(
set(val2,
"negative_int", s));
1532 BEAST_EXPECT(val2 == -3);
1535 BEAST_EXPECT(!
set(val3,
"a_string", s));
1536 BEAST_EXPECT(val3 == 3);
1538 auto const val4 =
get<int>(s,
"positive_int");
1539 BEAST_EXPECT(val4 == 2);
1540 auto const val5 =
get<int>(s,
"not_a_key");
1541 BEAST_EXPECT(val5 == 0);
1542 auto const val6 =
get<int>(s,
"not_a_key", 5);
1543 BEAST_EXPECT(val6 == 5);
1544 auto const val7 =
get<int>(s,
"a_string", 6);
1545 BEAST_EXPECT(val7 == 6);
1548 BEAST_EXPECT(
getIfExists(s,
"positive_int", val8));
1549 BEAST_EXPECT(val8 == 2);
1553 BEAST_EXPECT(val9 == 9);
1557 BEAST_EXPECT(val10 == 10);
1559 BEAST_EXPECT(s.
get<
int>(
"not_a_key") == std::nullopt);
1562 [[maybe_unused]]
auto const _ = s.
get<
int>(
"a_string");
1565 catch (boost::bad_lexical_cast&)
1574 BEAST_EXPECT(flag1 ==
true);
1577 BEAST_EXPECT(!
getIfExists(s,
"not_a_key", flag2));
1578 BEAST_EXPECT(flag2 ==
false);
1595 {.unit =
"seconds", .numSeconds = 1, .configVal = 15 * 60, .shouldPass =
false},
1596 {.unit =
"minutes", .numSeconds = 60, .configVal = 14, .shouldPass =
false},
1597 {.unit =
"minutes", .numSeconds = 60, .configVal = 15, .shouldPass =
true},
1598 {.unit =
"hours", .numSeconds = 3600, .configVal = 10, .shouldPass =
true},
1599 {.unit =
"days", .numSeconds = 86400, .configVal = 10, .shouldPass =
true},
1600 {.unit =
"weeks", .numSeconds = 604800, .configVal = 2, .shouldPass =
true},
1601 {.unit =
"months", .numSeconds = 2592000, .configVal = 1, .shouldPass =
false},
1602 {.unit =
"years", .numSeconds = 31536000, .configVal = 1, .shouldPass =
false},
1606 for (
auto& [unit, sec, val, shouldPass] : units)
1609 std::string toLoad(R
"xrpldConfig(
1610[amendment_majority_time]
1618 c.loadFromString(toLoad);
1621 BEAST_EXPECT(c.amendmentMajorityTime.count() == val * sec);
1628 catch (std::runtime_error
const&)
1661 BEAST_EXPECT(!testUnknown(
"none"));
1662 BEAST_EXPECT(!testUnknown(
"0.5"));
1663 BEAST_EXPECT(!testUnknown(
"180 seconds"));
1664 BEAST_EXPECT(!testUnknown(
"9 minutes"));
1667 BEAST_EXPECT(!testUnknown(
"299"));
1673 BEAST_EXPECT(testUnknown(
"1800") == std::chrono::seconds{1800});
1676 BEAST_EXPECT(!testUnknown(
"1801"));
1678 testcase(
"overlay: diverged time");
1681 auto const testDiverged = [](std::string value) -> std::optional<std::chrono::seconds> {
1685 c.loadFromString(
"[overlay]\nmax_diverged_time=" + value);
1686 return c.maxDivergedTime;
1688 catch (std::runtime_error
const&)
1695 BEAST_EXPECT(!testDiverged(
"none"));
1696 BEAST_EXPECT(!testDiverged(
"0.5"));
1697 BEAST_EXPECT(!testDiverged(
"180 seconds"));
1698 BEAST_EXPECT(!testDiverged(
"9 minutes"));
1701 BEAST_EXPECT(!testDiverged(
"0"));
1702 BEAST_EXPECT(!testDiverged(
"59"));
1705 BEAST_EXPECT(testDiverged(
"60") == std::chrono::seconds{60});
1706 BEAST_EXPECT(testDiverged(
"61") == std::chrono::seconds{61});
1707 BEAST_EXPECT(testDiverged(
"899") == std::chrono::seconds{899});
1708 BEAST_EXPECT(testDiverged(
"900") == std::chrono::seconds{900});
1711 BEAST_EXPECT(!testDiverged(
"901"));
1713 testcase(
"overlay: manifest counts");
1717 auto const testCount = [](std::string
const& key,
1718 std::string
const& value) -> std::optional<std::size_t> {
1722 c.loadFromString(
"[overlay]\n" + key +
"=" + value);
1723 return key ==
"max_trusted_count" ? c.maxTrustedCount : c.maxUntrustedCount;
1725 catch (std::runtime_error
const&)
1731 for (
auto const* key : {
"max_untrusted_count",
"max_trusted_count"})
1735 BEAST_EXPECT(!testCount(key,
"none"));
1736 BEAST_EXPECT(!testCount(key,
"0.5"));
1737 BEAST_EXPECT(!testCount(key,
"400 manifests"));
1738 BEAST_EXPECT(!testCount(key,
"-1"));
1741 BEAST_EXPECT(!testCount(key,
"0"));
1742 BEAST_EXPECT(!testCount(key,
"49"));
1745 BEAST_EXPECT(testCount(key,
"50") == 50);
1746 BEAST_EXPECT(testCount(key,
"51") == 51);
1747 BEAST_EXPECT(testCount(key,
"300") == 300);
1748 BEAST_EXPECT(testCount(key,
"400") == 400);
1749 BEAST_EXPECT(testCount(key,
"999") == 999);
1750 BEAST_EXPECT(testCount(key,
"1000") == 1000);
1753 BEAST_EXPECT(!testCount(key,
"1001"));
1759 c.loadFromString(
"[overlay]\nmax_untrusted_count=500");
1760 BEAST_EXPECT(c.maxUntrustedCount == 500);
1761 BEAST_EXPECT(!c.maxTrustedCount);
1765 c.loadFromString(
"[overlay]\nmax_trusted_count=500");
1766 BEAST_EXPECT(c.maxTrustedCount == 500);
1767 BEAST_EXPECT(!c.maxUntrustedCount);
1773 c.loadFromString(
"[overlay]\nmax_untrusted_count=250\nmax_trusted_count=750");
1774 BEAST_EXPECT(c.maxUntrustedCount == 250);
1775 BEAST_EXPECT(c.maxTrustedCount == 750);
1781 c.loadFromString(
"[overlay]\nip_limit=64");
1782 BEAST_EXPECT(!c.maxUntrustedCount);
1783 BEAST_EXPECT(!c.maxTrustedCount);
1789 c.loadFromString(
"");
1790 BEAST_EXPECT(!c.maxUntrustedCount);
1791 BEAST_EXPECT(!c.maxTrustedCount);
1803 setup.accountReserve =
XRPAmount{3'000'017};
1804 setup.ownerReserve =
XRPAmount{700'017};
1805 setup.gasLimit = 123'457;
1806 setup.bytecodeSizeLimit = 23'457;
1807 setup.gasPrice = 7'654'321;
1809 auto const fees = setup.toFees();
1811 BEAST_EXPECT(fees.base == setup.referenceFee);
1812 BEAST_EXPECT(fees.reserve == setup.accountReserve);
1813 BEAST_EXPECT(fees.increment == setup.ownerReserve);
1814 BEAST_EXPECT(fees.gasLimit == setup.gasLimit);
1815 BEAST_EXPECT(fees.bytecodeSizeLimit == setup.bytecodeSizeLimit);
1816 BEAST_EXPECT(fees.gasPrice == setup.gasPrice);
bool unexcept(F &&f, String const &reason)
void pass()
Record a successful test condition.
void fail(String const &reason, char const *file, int line)
Record a failure.
LogOs< char > log
Logging output stream.
TestcaseT testcase
Memberspace for declaring test cases.
void legacy(std::string const §ion, std::string value)
Set a value that is not a key/value pair.
void testSetup(bool explicitPath)
void run() override
Runs the suite.
void testValidatorsFile()
std::filesystem::path Path
static constexpr std::string_view kConfigLegacyName
static constexpr std::string_view kDatabaseDirName
static constexpr std::string_view kConfigFileName
void setup(std::string const &strConf, bool bQuiet, bool bSilent, bool bStandalone)
Set up the configuration and determine the config and data directories.
std::chrono::seconds maxUnknownTime
void loadFromString(std::string const &fileContents)
Load the config from the contents of the string.
std::uint32_t ledgerHistory
Holds a collection of configuration values.
std::optional< T > get(std::string const &name) const
void append(std::vector< std::string > const &lines)
Append a set of lines to this section.
bool expectException(Functor f, std::string const &message="")
auto rmDir(Path const &toRm)
beast::unit_test::Suite & test_
Path const & subdir() const
std::filesystem::path Path
Write an xrpld config file and remove when done.
Config const & config() const
std::string configFile() const
bool configFileExists() const
FileCfgGuard(beast::unit_test::Suite &test, Path subDir, Path const &dbPath, Path const &configFile, Path const &validatorsFile, bool useCounter=true, std::string confContents="")
bool dataDirExists() const
Write a file in a directory and remove when done.
Path const & file() const
FileDirGuard(beast::unit_test::Suite &test, Path subDir, Path file, std::string const &contents, bool useCounter=true, bool create=true)
Write a validators.txt file and remove when done.
std::string validatorsFile() const
bool validatorsFileExists() const
~ValidatorsTxtGuard()=default
ValidatorsTxtGuard(beast::unit_test::Suite &test, Path subDir, Path const &validatorsFileName, bool useCounter=true)
T create_directory(T... args)
T current_path(T... args)
T is_directory(T... args)
std::string valFileContents()
std::string configContents(std::string const &dbPath, std::string const &validatorsFile)
The api_version numbers this server serves.
constexpr XRPAmount
Convert XRP to drops (integral types).
Use hash_* containers for keys that do not need a cryptographically secure hashing algorithm.
bool set(T &target, std::string const &name, Section const §ion)
Set a value from a configuration Section If the named value is not found or doesn't parse as a T,...
ApplyResult apply(ServiceRegistry ®istry, OpenView &view, STTx const &tx, ApplyFlags flags, beast::Journal journal)
Apply a transaction to an OpenView.
void parsePort(ParsedPort &port, Section const §ion, std::ostream &log)
T get(Section const §ion, std::string const &name, T const &defaultValue=T{})
Retrieve a key/value pair from a section.
bool getIfExists(Section const §ion, std::string const &name, T &v)
static std::string const & systemName()
BEAST_DEFINE_TESTSUITE(AccountTxPaging, app, xrpl)
static std::optional< Seed > validationSeed(json::Value const ¶ms)
T regex_replace(T... args)
static constexpr auto kOnlineDelete
std::vector< boost::asio::ip::network_v4 > adminNetsV4
std::vector< boost::asio::ip::network_v6 > adminNetsV6
static constexpr auto kIps
static constexpr auto kPortWssAdmin
static constexpr auto kValidatorListThreshold
static constexpr auto kValidators
static constexpr auto kValidatorListKeys
static constexpr auto kServer
static constexpr auto kPortRpc
static constexpr auto kSslVerify
static constexpr auto kValidatorsFile
static constexpr auto kIpsFixed
static constexpr auto kDatabasePath
static constexpr auto kDebugLogfile
static constexpr auto kValidatorListSites