mirror of
https://github.com/XRPLF/rippled.git
synced 2026-06-02 16:26:48 +00:00
1d42c4f6de
Per XLS-0095, we are taking steps to rename ripple(d) to xrpl(d). This change specifically removes all copyright notices referencing Ripple, XRPLF, and certain affiliated contributors upon mutual agreement, so the notice in the LICENSE.md file applies throughout. Copyright notices referencing external contributions remain as-is. Duplicate verbiage is also removed.
376 lines
11 KiB
C++
376 lines
11 KiB
C++
#include <test/jtx.h>
|
|
#include <test/jtx/Env.h>
|
|
|
|
#include <xrpl/beast/unit_test.h>
|
|
#include <xrpl/beast/unit_test/suite.h>
|
|
#include <xrpl/beast/utility/Journal.h>
|
|
#include <xrpl/beast/utility/temp_dir.h>
|
|
#include <xrpl/protocol/SField.h>
|
|
#include <xrpl/protocol/jss.h>
|
|
|
|
#include <boost/algorithm/string.hpp>
|
|
#include <boost/filesystem.hpp>
|
|
|
|
#include <fstream>
|
|
|
|
namespace ripple {
|
|
|
|
class LedgerLoad_test : public beast::unit_test::suite
|
|
{
|
|
auto static ledgerConfig(
|
|
std::unique_ptr<Config> cfg,
|
|
std::string const& dbPath,
|
|
std::string const& ledger,
|
|
Config::StartUpType type,
|
|
std::optional<uint256> trapTxHash)
|
|
{
|
|
cfg->START_LEDGER = ledger;
|
|
cfg->START_UP = type;
|
|
cfg->TRAP_TX_HASH = trapTxHash;
|
|
assert(!dbPath.empty());
|
|
cfg->legacy("database_path", dbPath);
|
|
return cfg;
|
|
}
|
|
|
|
// setup for test cases
|
|
struct SetupData
|
|
{
|
|
std::string const dbPath;
|
|
std::string ledgerFile{};
|
|
Json::Value ledger{};
|
|
Json::Value hashes{};
|
|
uint256 trapTxHash{};
|
|
};
|
|
|
|
SetupData
|
|
setupLedger(beast::temp_dir const& td)
|
|
{
|
|
using namespace test::jtx;
|
|
SetupData retval = {td.path()};
|
|
|
|
retval.ledgerFile = td.file("ledgerdata.json");
|
|
|
|
Env env{*this};
|
|
std::optional<Account> prev;
|
|
|
|
for (auto i = 0; i < 20; ++i)
|
|
{
|
|
Account acct{"A" + std::to_string(i)};
|
|
env.fund(XRP(10000), acct);
|
|
env.close();
|
|
if (i > 0 && BEAST_EXPECT(prev))
|
|
{
|
|
env.trust(acct["USD"](1000), *prev);
|
|
env(pay(acct, *prev, acct["USD"](5)));
|
|
}
|
|
env(offer(acct, XRP(100), acct["USD"](1)));
|
|
env.close();
|
|
prev.emplace(std::move(acct));
|
|
}
|
|
|
|
retval.ledger = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(
|
|
retval.ledger[jss::ledger][jss::accountState].size() == 102);
|
|
|
|
retval.hashes = [&] {
|
|
for (auto const& it : retval.ledger[jss::ledger][jss::accountState])
|
|
{
|
|
if (it[sfLedgerEntryType.fieldName] == jss::LedgerHashes)
|
|
return it[sfHashes.fieldName];
|
|
}
|
|
return Json::Value{};
|
|
}();
|
|
|
|
BEAST_EXPECT(retval.hashes.size() == 41);
|
|
retval.trapTxHash = [&]() {
|
|
auto const txs = env.rpc(
|
|
"ledger",
|
|
std::to_string(41),
|
|
"tx")[jss::result][jss::ledger][jss::transactions];
|
|
BEAST_EXPECT(txs.isArray() && txs.size() > 0);
|
|
uint256 tmp;
|
|
BEAST_EXPECT(tmp.parseHex(txs[0u][jss::hash].asString()));
|
|
return tmp;
|
|
}();
|
|
|
|
// write this ledger data to a file.
|
|
std::ofstream o(retval.ledgerFile, std::ios::out | std::ios::trunc);
|
|
o << to_string(retval.ledger);
|
|
o.close();
|
|
return retval;
|
|
}
|
|
|
|
void
|
|
testLoad(SetupData const& sd)
|
|
{
|
|
testcase("Load a saved ledger");
|
|
using namespace test::jtx;
|
|
|
|
// create a new env with the ledger file specified for startup
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig,
|
|
sd.dbPath,
|
|
sd.ledgerFile,
|
|
Config::LOAD_FILE,
|
|
std::nullopt),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
auto jrb = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(
|
|
sd.ledger[jss::ledger][jss::accountState].size() ==
|
|
jrb[jss::ledger][jss::accountState].size());
|
|
}
|
|
|
|
void
|
|
testBadFiles(SetupData const& sd)
|
|
{
|
|
testcase("Load ledger: Bad Files");
|
|
using namespace test::jtx;
|
|
using namespace boost::filesystem;
|
|
|
|
// empty path
|
|
except([&] {
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig,
|
|
sd.dbPath,
|
|
"",
|
|
Config::LOAD_FILE,
|
|
std::nullopt),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
});
|
|
|
|
// file does not exist
|
|
except([&] {
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig,
|
|
sd.dbPath,
|
|
"badfile.json",
|
|
Config::LOAD_FILE,
|
|
std::nullopt),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
});
|
|
|
|
// make a corrupted version of the ledger file (last 10 bytes removed).
|
|
boost::system::error_code ec;
|
|
auto ledgerFileCorrupt =
|
|
boost::filesystem::path{sd.dbPath} / "ledgerdata_bad.json";
|
|
copy_file(
|
|
sd.ledgerFile,
|
|
ledgerFileCorrupt,
|
|
copy_options::overwrite_existing,
|
|
ec);
|
|
if (!BEAST_EXPECTS(!ec, ec.message()))
|
|
return;
|
|
auto filesize = file_size(ledgerFileCorrupt, ec);
|
|
if (!BEAST_EXPECTS(!ec, ec.message()))
|
|
return;
|
|
resize_file(ledgerFileCorrupt, filesize - 10, ec);
|
|
if (!BEAST_EXPECTS(!ec, ec.message()))
|
|
return;
|
|
|
|
except([&] {
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig,
|
|
sd.dbPath,
|
|
ledgerFileCorrupt.string(),
|
|
Config::LOAD_FILE,
|
|
std::nullopt),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
});
|
|
}
|
|
|
|
void
|
|
testLoadByHash(SetupData const& sd)
|
|
{
|
|
testcase("Load by hash");
|
|
using namespace test::jtx;
|
|
|
|
// create a new env with the ledger hash specified for startup
|
|
auto ledgerHash = to_string(sd.hashes[sd.hashes.size() - 1]);
|
|
boost::erase_all(ledgerHash, "\"");
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig,
|
|
sd.dbPath,
|
|
ledgerHash,
|
|
Config::LOAD,
|
|
std::nullopt),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
auto jrb = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(jrb[jss::ledger][jss::accountState].size() == 98);
|
|
BEAST_EXPECT(
|
|
jrb[jss::ledger][jss::accountState].size() <=
|
|
sd.ledger[jss::ledger][jss::accountState].size());
|
|
}
|
|
|
|
void
|
|
testReplay(SetupData const& sd)
|
|
{
|
|
testcase("Load and replay by hash");
|
|
using namespace test::jtx;
|
|
|
|
// create a new env with the ledger hash specified for startup
|
|
auto ledgerHash = to_string(sd.hashes[sd.hashes.size() - 1]);
|
|
boost::erase_all(ledgerHash, "\"");
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig,
|
|
sd.dbPath,
|
|
ledgerHash,
|
|
Config::REPLAY,
|
|
std::nullopt),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
auto const jrb = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(jrb[jss::ledger][jss::accountState].size() == 97);
|
|
// in replace mode do not automatically accept the ledger being replayed
|
|
|
|
env.close();
|
|
auto const closed = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(closed[jss::ledger][jss::accountState].size() == 98);
|
|
BEAST_EXPECT(
|
|
closed[jss::ledger][jss::accountState].size() <=
|
|
sd.ledger[jss::ledger][jss::accountState].size());
|
|
}
|
|
|
|
void
|
|
testReplayTx(SetupData const& sd)
|
|
{
|
|
testcase("Load and replay transaction by hash");
|
|
using namespace test::jtx;
|
|
|
|
// create a new env with the ledger hash specified for startup
|
|
auto ledgerHash = to_string(sd.hashes[sd.hashes.size() - 1]);
|
|
boost::erase_all(ledgerHash, "\"");
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig,
|
|
sd.dbPath,
|
|
ledgerHash,
|
|
Config::REPLAY,
|
|
sd.trapTxHash),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
auto const jrb = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(jrb[jss::ledger][jss::accountState].size() == 97);
|
|
// in replace mode do not automatically accept the ledger being replayed
|
|
|
|
env.close();
|
|
auto const closed = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(closed[jss::ledger][jss::accountState].size() == 98);
|
|
BEAST_EXPECT(
|
|
closed[jss::ledger][jss::accountState].size() <=
|
|
sd.ledger[jss::ledger][jss::accountState].size());
|
|
}
|
|
|
|
void
|
|
testReplayTxFail(SetupData const& sd)
|
|
{
|
|
testcase("Load and replay transaction by hash failure");
|
|
using namespace test::jtx;
|
|
|
|
// create a new env with the ledger hash specified for startup
|
|
auto ledgerHash = to_string(sd.hashes[sd.hashes.size() - 1]);
|
|
boost::erase_all(ledgerHash, "\"");
|
|
try
|
|
{
|
|
// will throw an exception, because we cannot load a ledger for
|
|
// replay when trapTxHash is set to an invalid transaction
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig,
|
|
sd.dbPath,
|
|
ledgerHash,
|
|
Config::REPLAY,
|
|
~sd.trapTxHash),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
BEAST_EXPECT(false);
|
|
}
|
|
catch (std::runtime_error const&)
|
|
{
|
|
BEAST_EXPECT(true);
|
|
}
|
|
catch (...)
|
|
{
|
|
BEAST_EXPECT(false);
|
|
}
|
|
}
|
|
|
|
void
|
|
testLoadLatest(SetupData const& sd)
|
|
{
|
|
testcase("Load by keyword");
|
|
using namespace test::jtx;
|
|
|
|
// create a new env with the ledger "latest" specified for startup
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig, sd.dbPath, "latest", Config::LOAD, std::nullopt),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
auto jrb = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(
|
|
sd.ledger[jss::ledger][jss::accountState].size() ==
|
|
jrb[jss::ledger][jss::accountState].size());
|
|
}
|
|
|
|
void
|
|
testLoadIndex(SetupData const& sd)
|
|
{
|
|
testcase("Load by index");
|
|
using namespace test::jtx;
|
|
|
|
// create a new env with specific ledger index at startup
|
|
Env env(
|
|
*this,
|
|
envconfig(
|
|
ledgerConfig, sd.dbPath, "43", Config::LOAD, std::nullopt),
|
|
nullptr,
|
|
beast::severities::kDisabled);
|
|
auto jrb = env.rpc("ledger", "current", "full")[jss::result];
|
|
BEAST_EXPECT(
|
|
sd.ledger[jss::ledger][jss::accountState].size() ==
|
|
jrb[jss::ledger][jss::accountState].size());
|
|
}
|
|
|
|
public:
|
|
void
|
|
run() override
|
|
{
|
|
beast::temp_dir td;
|
|
auto sd = setupLedger(td);
|
|
|
|
// test cases
|
|
testLoad(sd);
|
|
testBadFiles(sd);
|
|
testLoadByHash(sd);
|
|
testReplay(sd);
|
|
testReplayTx(sd);
|
|
testReplayTxFail(sd);
|
|
testLoadLatest(sd);
|
|
testLoadIndex(sd);
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE(LedgerLoad, app, ripple);
|
|
|
|
} // namespace ripple
|