ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-07-25 16:10:57 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
2701ca416f62dde31aa073d8a5d2d3b986115255
rippled/src/test/consensus/Validations_test.cpp
Alex Kremer a830ab10ef style: More clang-tidy identifier renaming (#7290)
2026-05-20 21:31:15 +00:00

1060 lines
37 KiB
C++
Raw Blame History

#include <test/csf/Validation.h>
#include <test/csf/ledgers.h>
#include <test/unit_test/SuiteJournal.h>
#include <xrpld/consensus/Validations.h>
#include <xrpl/basics/UnorderedContainers.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/basics/tagged_integer.h>
#include <xrpl/beast/clock/abstract_clock.h>
#include <xrpl/beast/clock/manual_clock.h>
#include <xrpl/beast/unit_test/suite.h>
#include <chrono>
#include <cstddef>
#include <cstdint>
#include <functional>
#include <optional>
#include <utility>
#include <vector>
namespace xrpl::test::csf {
class Validations_test : public beast::unit_test::Suite
{
using clock_type = beast::AbstractClock<std::chrono::steady_clock> const;
// Helper to convert steady_clock to a reasonable NetClock
// This allows a single manual clock in the unit tests
static NetClock::time_point
toNetClock(clock_type const& c)
{
// We don't care about the actual epochs, but do want the
// generated NetClock time to be well past its epoch to ensure
// any subtractions are positive
using namespace std::chrono;
return NetClock::time_point(
duration_cast<NetClock::duration>(c.now().time_since_epoch() + 86400s));
}
// Represents a node that can issue validations
class Node
{
clock_type const& c_;
PeerID nodeID_;
bool trusted_ = true;
std::size_t signIdx_{1};
std::optional<std::uint32_t> loadFee_;
public:
Node(PeerID nodeID, clock_type const& c) : c_(c), nodeID_(nodeID)
{
}
void
untrust()
{
trusted_ = false;
}
void
trust()
{
trusted_ = true;
}
void
setLoadFee(std::uint32_t fee)
{
loadFee_ = fee;
}
[[nodiscard]] PeerID
nodeID() const
{
return nodeID_;
}
void
advanceKey()
{
signIdx_++;
}
[[nodiscard]] PeerKey
currKey() const
{
return std::make_pair(nodeID_, signIdx_);
}
[[nodiscard]] PeerKey
masterKey() const
{
return std::make_pair(nodeID_, 0);
}
[[nodiscard]] NetClock::time_point
now() const
{
return toNetClock(c_);
}
// Issue a new validation with given sequence number and id and
// with signing and seen times offset from the common clock
[[nodiscard]] Validation
validate(
Ledger::ID id,
Ledger::Seq seq,
NetClock::duration signOffset,
NetClock::duration seenOffset,
bool full) const
{
Validation v{
id,
seq,
now() + signOffset,
now() + seenOffset,
currKey(),
nodeID_,
full,
loadFee_};
if (trusted_)
v.setTrusted();
return v;
}
[[nodiscard]] Validation
validate(Ledger ledger, NetClock::duration signOffset, NetClock::duration seenOffset) const
{
return validate(ledger.id(), ledger.seq(), signOffset, seenOffset, true);
}
[[nodiscard]] Validation
validate(Ledger ledger) const
{
return validate(
ledger.id(), ledger.seq(), NetClock::duration{0}, NetClock::duration{0}, true);
}
[[nodiscard]] Validation
partial(Ledger ledger) const
{
return validate(
ledger.id(), ledger.seq(), NetClock::duration{0}, NetClock::duration{0}, false);
}
};
// Generic Validations adaptor
class Adaptor
{
clock_type& c_;
LedgerOracle& oracle_;
public:
// Non-locking mutex to avoid locks in generic Validations
struct Mutex
{
void
lock()
{
}
void
unlock()
{
}
};
using Validation = csf::Validation;
using Ledger = csf::Ledger;
Adaptor(clock_type& c, LedgerOracle& o) : c_{c}, oracle_{o}
{
}
[[nodiscard]] NetClock::time_point
now() const
{
return toNetClock(c_);
}
std::optional<Ledger>
acquire(Ledger::ID const& id)
{
return oracle_.lookup(id);
}
};
// Specialize generic Validations using the above types
using TestValidations = Validations<Adaptor>;
// Gather the dependencies of TestValidations in a single class and provide
// accessors for simplifying test logic
class TestHarness
{
ValidationParms p_;
beast::ManualClock<std::chrono::steady_clock> clock_;
TestValidations tv_;
PeerID nextNodeId_{0};
public:
explicit TestHarness(LedgerOracle& o) : tv_(p_, clock_, clock_, o)
{
}
ValStatus
add(Validation const& v)
{
return tv_.add(v.nodeID(), v);
}
TestValidations&
vals()
{
return tv_;
}
Node
makeNode()
{
return Node(nextNodeId_++, clock_);
}
ValidationParms
parms() const
{
return p_;
}
auto&
clock()
{
return clock_;
}
};
Ledger const genesisLedger_{Ledger::MakeGenesis{}};
void
testAddValidation()
{
using namespace std::chrono_literals;
testcase("Add validation");
LedgerHistoryHelper h;
Ledger const ledgerA = h["a"];
Ledger ledgerAB = h["ab"];
Ledger ledgerAZ = h["az"];
Ledger ledgerABC = h["abc"];
Ledger const ledgerABCD = h["abcd"];
Ledger const ledgerABCDE = h["abcde"];
{
TestHarness harness(h.oracle);
Node n = harness.makeNode();
auto const v = n.validate(ledgerA);
// Add a current validation
BEAST_EXPECT(ValStatus::Current == harness.add(v));
// Re-adding violates the increasing seq requirement for full
// validations
BEAST_EXPECT(ValStatus::BadSeq == harness.add(v));
harness.clock().advance(1s);
BEAST_EXPECT(ValStatus::Current == harness.add(n.validate(ledgerAB)));
// Test the node changing signing key
// Confirm old ledger on hand, but not new ledger
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerAB.id()) == 1);
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerABC.id()) == 0);
// Rotate signing keys
n.advanceKey();
harness.clock().advance(1s);
// Cannot re-do the same full validation sequence
BEAST_EXPECT(ValStatus::Conflicting == harness.add(n.validate(ledgerAB)));
// Cannot send the same partial validation sequence
BEAST_EXPECT(ValStatus::Conflicting == harness.add(n.partial(ledgerAB)));
// Now trusts the newest ledger too
harness.clock().advance(1s);
BEAST_EXPECT(ValStatus::Current == harness.add(n.validate(ledgerABC)));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerAB.id()) == 1);
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerABC.id()) == 1);
// Processing validations out of order should ignore the older
// validation
harness.clock().advance(2s);
auto const valABCDE = n.validate(ledgerABCDE);
harness.clock().advance(4s);
auto const valABCD = n.validate(ledgerABCD);
BEAST_EXPECT(ValStatus::Current == harness.add(valABCD));
BEAST_EXPECT(ValStatus::Stale == harness.add(valABCDE));
}
{
// Process validations out of order with shifted times
TestHarness harness(h.oracle);
Node const n = harness.makeNode();
// Establish a new current validation
BEAST_EXPECT(ValStatus::Current == harness.add(n.validate(ledgerA)));
// Process a validation that has "later" seq but early sign time
BEAST_EXPECT(ValStatus::Stale == harness.add(n.validate(ledgerAB, -1s, -1s)));
// Process a validation that has a later seq and later sign
// time
BEAST_EXPECT(ValStatus::Current == harness.add(n.validate(ledgerABC, 1s, 1s)));
}
{
// Test stale on arrival validations
TestHarness harness(h.oracle);
Node const n = harness.makeNode();
BEAST_EXPECT(
ValStatus::Stale ==
harness.add(n.validate(ledgerA, -harness.parms().validationCurrentEarly, 0s)));
BEAST_EXPECT(
ValStatus::Stale ==
harness.add(n.validate(ledgerA, harness.parms().validationCurrentWall, 0s)));
BEAST_EXPECT(
ValStatus::Stale ==
harness.add(n.validate(ledgerA, 0s, harness.parms().validationCurrentLocal)));
}
{
// Test that full or partials cannot be sent for older sequence
// numbers, unless time-out has happened
for (bool doFull : {true, false})
{
TestHarness harness(h.oracle);
Node n = harness.makeNode();
auto process = [&](Ledger& lgr) {
if (doFull)
return harness.add(n.validate(lgr));
return harness.add(n.partial(lgr));
};
BEAST_EXPECT(ValStatus::Current == process(ledgerABC));
harness.clock().advance(1s);
BEAST_EXPECT(ledgerAB.seq() < ledgerABC.seq());
BEAST_EXPECT(ValStatus::BadSeq == process(ledgerAB));
// If we advance far enough for AB to expire, we can fully
// validate or partially validate that sequence number again
BEAST_EXPECT(ValStatus::Conflicting == process(ledgerAZ));
harness.clock().advance(harness.parms().validationSetExpires + 1ms);
BEAST_EXPECT(ValStatus::Current == process(ledgerAZ));
}
}
}
void
testOnStale()
{
testcase("Stale validation");
// Verify validation becomes stale based solely on time passing, but
// use different functions to trigger the check for staleness
LedgerHistoryHelper h;
Ledger ledgerA = h["a"];
Ledger const ledgerAB = h["ab"];
using Trigger = std::function<void(TestValidations&)>;
std::vector<Trigger> const triggers = {
[&](TestValidations& vals) { vals.currentTrusted(); },
[&](TestValidations& vals) { vals.getCurrentNodeIDs(); },
[&](TestValidations& vals) { vals.getPreferred(genesisLedger_); },
[&](TestValidations& vals) { vals.getNodesAfter(ledgerA, ledgerA.id()); }};
for (Trigger const& trigger : triggers)
{
TestHarness harness(h.oracle);
Node const n = harness.makeNode();
BEAST_EXPECT(ValStatus::Current == harness.add(n.validate(ledgerAB)));
trigger(harness.vals());
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 1);
BEAST_EXPECT(
harness.vals().getPreferred(genesisLedger_) ==
std::make_pair(ledgerAB.seq(), ledgerAB.id()));
harness.clock().advance(harness.parms().validationCurrentLocal);
// trigger check for stale
trigger(harness.vals());
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 0);
BEAST_EXPECT(harness.vals().getPreferred(genesisLedger_) == std::nullopt);
}
}
void
testGetNodesAfter()
{
// Test getting number of nodes working on a validation descending
// a prescribed one. This count should only be for trusted nodes, but
// includes partial and full validations
using namespace std::chrono_literals;
testcase("Get nodes after");
LedgerHistoryHelper h;
Ledger const ledgerA = h["a"];
Ledger const ledgerAB = h["ab"];
Ledger const ledgerABC = h["abc"];
Ledger const ledgerAD = h["ad"];
TestHarness harness(h.oracle);
Node const trustedNode1 = harness.makeNode();
Node const trustedNode2 = harness.makeNode();
Node const trustedNode3 = harness.makeNode();
Node notTrustedNode = harness.makeNode();
notTrustedNode.untrust();
// first round a,b,c agree, d has is partial
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode1.validate(ledgerA)));
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode2.validate(ledgerA)));
BEAST_EXPECT(ValStatus::Current == harness.add(notTrustedNode.validate(ledgerA)));
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode3.partial(ledgerA)));
for (Ledger const& ledger : {ledgerA, ledgerAB, ledgerABC, ledgerAD})
BEAST_EXPECT(harness.vals().getNodesAfter(ledger, ledger.id()) == 0);
harness.clock().advance(5s);
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode1.validate(ledgerAB)));
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode2.validate(ledgerABC)));
BEAST_EXPECT(ValStatus::Current == harness.add(notTrustedNode.validate(ledgerAB)));
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode3.partial(ledgerABC)));
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerA, ledgerA.id()) == 3);
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAB, ledgerAB.id()) == 2);
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerABC, ledgerABC.id()) == 0);
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerAD.id()) == 0);
// If given a ledger inconsistent with the id, is still able to check using slower method
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerA.id()) == 1);
BEAST_EXPECT(harness.vals().getNodesAfter(ledgerAD, ledgerAB.id()) == 2);
}
void
testCurrentTrusted()
{
using namespace std::chrono_literals;
testcase("Current trusted validations");
LedgerHistoryHelper h;
Ledger const ledgerA = h["a"];
Ledger const ledgerB = h["b"];
Ledger const ledgerAC = h["ac"];
TestHarness harness(h.oracle);
Node const a = harness.makeNode();
Node b = harness.makeNode();
b.untrust();
BEAST_EXPECT(ValStatus::Current == harness.add(a.validate(ledgerA)));
BEAST_EXPECT(ValStatus::Current == harness.add(b.validate(ledgerB)));
// Only a is trusted
BEAST_EXPECT(harness.vals().currentTrusted().size() == 1);
BEAST_EXPECT(harness.vals().currentTrusted()[0].ledgerID() == ledgerA.id());
BEAST_EXPECT(harness.vals().currentTrusted()[0].seq() == ledgerA.seq());
harness.clock().advance(3s);
for (auto const& node : {a, b})
BEAST_EXPECT(ValStatus::Current == harness.add(node.validate(ledgerAC)));
// New validation for a
BEAST_EXPECT(harness.vals().currentTrusted().size() == 1);
BEAST_EXPECT(harness.vals().currentTrusted()[0].ledgerID() == ledgerAC.id());
BEAST_EXPECT(harness.vals().currentTrusted()[0].seq() == ledgerAC.seq());
// Pass enough time for it to go stale
harness.clock().advance(harness.parms().validationCurrentLocal);
BEAST_EXPECT(harness.vals().currentTrusted().empty());
}
void
testGetCurrentPublicKeys()
{
using namespace std::chrono_literals;
testcase("Current public keys");
LedgerHistoryHelper h;
Ledger const ledgerA = h["a"];
Ledger const ledgerAC = h["ac"];
TestHarness harness(h.oracle);
Node a = harness.makeNode(), b = harness.makeNode();
b.untrust();
for (auto const& node : {a, b})
BEAST_EXPECT(ValStatus::Current == harness.add(node.validate(ledgerA)));
{
hash_set<PeerID> const expectedKeys = {a.nodeID(), b.nodeID()};
BEAST_EXPECT(harness.vals().getCurrentNodeIDs() == expectedKeys);
}
harness.clock().advance(3s);
// Change keys and issue partials
a.advanceKey();
b.advanceKey();
for (auto const& node : {a, b})
BEAST_EXPECT(ValStatus::Current == harness.add(node.partial(ledgerAC)));
{
hash_set<PeerID> const expectedKeys = {a.nodeID(), b.nodeID()};
BEAST_EXPECT(harness.vals().getCurrentNodeIDs() == expectedKeys);
}
// Pass enough time for them to go stale
harness.clock().advance(harness.parms().validationCurrentLocal);
BEAST_EXPECT(harness.vals().getCurrentNodeIDs().empty());
}
void
testTrustedByLedgerFunctions()
{
// Test the Validations functions that calculate a value by ledger ID
using namespace std::chrono_literals;
testcase("By ledger functions");
// Several Validations functions return a set of values associated
// with trusted ledgers sharing the same ledger ID. The tests below
// exercise this logic by saving the set of trusted Validations, and
// verifying that the Validations member functions all calculate the
// proper transformation of the available ledgers.
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode(), b = harness.makeNode(), c = harness.makeNode(),
d = harness.makeNode(), e = harness.makeNode();
c.untrust();
// Mix of load fees
a.setLoadFee(12);
b.setLoadFee(1);
c.setLoadFee(12);
e.setLoadFee(12);
hash_map<std::pair<Ledger::ID, Ledger::Seq>, std::vector<Validation>> trustedValidations;
//----------------------------------------------------------------------
// checkers
auto sorted = [](auto vec) {
std::sort(vec.begin(), vec.end());
return vec;
};
auto compare = [&]() {
for (auto& it : trustedValidations)
{
auto const& id = it.first.first;
auto const& seq = it.first.second;
auto const& expectedValidations = it.second;
BEAST_EXPECT(harness.vals().numTrustedForLedger(id) == expectedValidations.size());
BEAST_EXPECT(
sorted(harness.vals().getTrustedForLedger(id, seq)) ==
sorted(expectedValidations));
std::uint32_t const baseFee = 0;
std::vector<uint32_t> expectedFees;
expectedFees.reserve(expectedValidations.size());
for (auto const& val : expectedValidations)
{
expectedFees.push_back(val.loadFee().value_or(baseFee));
}
BEAST_EXPECT(sorted(harness.vals().fees(id, baseFee)) == sorted(expectedFees));
}
};
//----------------------------------------------------------------------
Ledger const ledgerA = h["a"];
Ledger const ledgerB = h["b"];
Ledger const ledgerAC = h["ac"];
// Add a dummy ID to cover unknown ledger identifiers
trustedValidations[{Ledger::ID{100}, Ledger::Seq{100}}] = {};
// first round a,b,c agree
for (auto const& node : {a, b, c})
{
auto const val = node.validate(ledgerA);
BEAST_EXPECT(ValStatus::Current == harness.add(val));
if (val.trusted())
trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
}
// d disagrees
{
auto const val = d.validate(ledgerB);
BEAST_EXPECT(ValStatus::Current == harness.add(val));
trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
}
// e only issues partials
{
BEAST_EXPECT(ValStatus::Current == harness.add(e.partial(ledgerA)));
}
harness.clock().advance(5s);
// second round, a,b,c move to ledger 2
for (auto const& node : {a, b, c})
{
auto const val = node.validate(ledgerAC);
BEAST_EXPECT(ValStatus::Current == harness.add(val));
if (val.trusted())
trustedValidations[{val.ledgerID(), val.seq()}].emplace_back(val);
}
// d now thinks ledger 1, but cannot re-issue a previously used seq
// and attempting it should generate a conflict.
{
BEAST_EXPECT(ValStatus::Conflicting == harness.add(d.partial(ledgerA)));
}
// e only issues partials
{
BEAST_EXPECT(ValStatus::Current == harness.add(e.partial(ledgerAC)));
}
compare();
}
void
testExpire()
{
// Verify expiring clears out validations stored by ledger
testcase("Expire validations");
SuiteJournal j("Validations_test", *this);
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node const a = harness.makeNode();
constexpr Ledger::Seq kOne(1);
constexpr Ledger::Seq kTwo(2);
// simple cases
Ledger const ledgerA = h["a"];
BEAST_EXPECT(ValStatus::Current == harness.add(a.validate(ledgerA)));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 1);
harness.vals().expire(j);
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 1);
harness.clock().advance(harness.parms().validationSetExpires);
harness.vals().expire(j);
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 0);
// use setSeqToKeep to keep the validation from expire
Ledger const ledgerB = h["ab"];
BEAST_EXPECT(ValStatus::Current == harness.add(a.validate(ledgerB)));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerB.id()) == 1);
harness.vals().setSeqToKeep(ledgerB.seq(), ledgerB.seq() + kOne);
harness.clock().advance(harness.parms().validationSetExpires);
harness.vals().expire(j);
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerB.id()) == 1);
// change toKeep
harness.vals().setSeqToKeep(ledgerB.seq() + kOne, ledgerB.seq() + kTwo);
// advance clock slowly
int const loops =
harness.parms().validationSetExpires / harness.parms().validationFRESHNESS + 1;
for (int i = 0; i < loops; ++i)
{
harness.clock().advance(harness.parms().validationFRESHNESS);
harness.vals().expire(j);
}
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerB.id()) == 0);
// Allow the validation with high seq to expire
Ledger const ledgerC = h["abc"];
BEAST_EXPECT(ValStatus::Current == harness.add(a.validate(ledgerC)));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerC.id()) == 1);
harness.vals().setSeqToKeep(ledgerC.seq() - kOne, ledgerC.seq());
harness.clock().advance(harness.parms().validationSetExpires);
harness.vals().expire(j);
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerC.id()) == 0);
}
void
testFlush()
{
// Test final flush of validations
using namespace std::chrono_literals;
testcase("Flush validations");
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node const trustedNode1 = harness.makeNode();
Node const trustedNode2 = harness.makeNode();
Node notTrustedNode = harness.makeNode();
notTrustedNode.untrust();
Ledger const ledgerA = h["a"];
Ledger const ledgerAB = h["ab"];
hash_map<PeerID, Validation> expected;
for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode})
{
auto const val = node.validate(ledgerA);
BEAST_EXPECT(ValStatus::Current == harness.add(val));
expected.emplace(node.nodeID(), val);
}
// Send in a new validation for a, saving the new one into the expected
// map after setting the proper prior ledger ID it replaced
harness.clock().advance(1s);
auto newVal = trustedNode1.validate(ledgerAB);
BEAST_EXPECT(ValStatus::Current == harness.add(newVal));
expected.find(trustedNode1.nodeID())->second = newVal;
}
void
testGetPreferredLedger()
{
using namespace std::chrono_literals;
testcase("Preferred Ledger");
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node const trustedNode1 = harness.makeNode();
Node const trustedNode2 = harness.makeNode();
Node const trustedNode3 = harness.makeNode();
Node notTrustedNode = harness.makeNode();
notTrustedNode.untrust();
Ledger const ledgerA = h["a"];
Ledger const ledgerB = h["b"];
Ledger const ledgerAC = h["ac"];
Ledger const ledgerACD = h["acd"];
using Seq = Ledger::Seq;
auto pref = [](Ledger ledger) { return std::make_pair(ledger.seq(), ledger.id()); };
// Empty (no ledgers)
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == std::nullopt);
// Single ledger
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode1.validate(ledgerB)));
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
// Minimum valid sequence
BEAST_EXPECT(harness.vals().getPreferred(ledgerA, Seq{10}) == ledgerA.id());
// Untrusted doesn't impact preferred ledger
// (ledgerB has tie-break over ledgerA)
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode2.validate(ledgerA)));
BEAST_EXPECT(ValStatus::Current == harness.add(notTrustedNode.validate(ledgerA)));
BEAST_EXPECT(ledgerB.id() > ledgerA.id());
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerB));
BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerB));
// Partial does break ties
BEAST_EXPECT(ValStatus::Current == harness.add(trustedNode3.partial(ledgerA)));
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerA));
harness.clock().advance(5s);
// Parent of preferred-> stick with ledger
for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
BEAST_EXPECT(ValStatus::Current == harness.add(node.validate(ledgerAC)));
// Parent of preferred stays put
BEAST_EXPECT(harness.vals().getPreferred(ledgerA) == pref(ledgerA));
// Earlier different chain, switch
BEAST_EXPECT(harness.vals().getPreferred(ledgerB) == pref(ledgerAC));
// Later on chain, stays where it is
BEAST_EXPECT(harness.vals().getPreferred(ledgerACD) == pref(ledgerACD));
// Any later grandchild or different chain is preferred
harness.clock().advance(5s);
for (auto const& node : {trustedNode1, trustedNode2, notTrustedNode, trustedNode3})
BEAST_EXPECT(ValStatus::Current == harness.add(node.validate(ledgerACD)));
for (auto const& ledger : {ledgerA, ledgerB, ledgerACD})
BEAST_EXPECT(harness.vals().getPreferred(ledger) == pref(ledgerACD));
}
void
testGetPreferredLCL()
{
using namespace std::chrono_literals;
testcase("Get preferred LCL");
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node const a = harness.makeNode();
Ledger const ledgerA = h["a"];
Ledger const ledgerB = h["b"];
Ledger const ledgerC = h["c"];
using ID = Ledger::ID;
using Seq = Ledger::Seq;
hash_map<ID, std::uint32_t> peerCounts;
// No trusted validations or counts sticks with current ledger
BEAST_EXPECT(harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) == ledgerA.id());
++peerCounts[ledgerB.id()];
// No trusted validations, rely on peer counts
BEAST_EXPECT(harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) == ledgerB.id());
++peerCounts[ledgerC.id()];
// No trusted validations, tied peers goes with larger ID
BEAST_EXPECT(ledgerC.id() > ledgerB.id());
BEAST_EXPECT(harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) == ledgerC.id());
peerCounts[ledgerC.id()] += 1000;
// Single trusted always wins over peer counts
BEAST_EXPECT(ValStatus::Current == harness.add(a.validate(ledgerA)));
BEAST_EXPECT(harness.vals().getPreferredLCL(ledgerA, Seq{0}, peerCounts) == ledgerA.id());
BEAST_EXPECT(harness.vals().getPreferredLCL(ledgerB, Seq{0}, peerCounts) == ledgerA.id());
BEAST_EXPECT(harness.vals().getPreferredLCL(ledgerC, Seq{0}, peerCounts) == ledgerA.id());
// Stick with current ledger if trusted validation ledger has too old
// of a sequence
BEAST_EXPECT(harness.vals().getPreferredLCL(ledgerB, Seq{2}, peerCounts) == ledgerB.id());
}
void
testAcquireValidatedLedger()
{
using namespace std::chrono_literals;
testcase("Acquire validated ledger");
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node const a = harness.makeNode();
Node const b = harness.makeNode();
using ID = Ledger::ID;
using Seq = Ledger::Seq;
// Validate the ledger before it is actually available
Validation const val = a.validate(ID{2}, Seq{2}, 0s, 0s, true);
BEAST_EXPECT(ValStatus::Current == harness.add(val));
// Validation is available
BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{2}) == 1);
// but ledger based data is not
BEAST_EXPECT(harness.vals().getNodesAfter(genesisLedger_, ID{0}) == 0);
// Initial preferred branch falls back to the ledger we are trying to
// acquire
BEAST_EXPECT(harness.vals().getPreferred(genesisLedger_) == std::make_pair(Seq{2}, ID{2}));
// After adding another unavailable validation, the preferred ledger
// breaks ties via higher ID
BEAST_EXPECT(ValStatus::Current == harness.add(b.validate(ID{3}, Seq{2}, 0s, 0s, true)));
BEAST_EXPECT(harness.vals().getPreferred(genesisLedger_) == std::make_pair(Seq{2}, ID{3}));
// Create the ledger
Ledger const ledgerAB = h["ab"];
// Now it should be available
BEAST_EXPECT(harness.vals().getNodesAfter(genesisLedger_, ID{0}) == 1);
// Create a validation that is not available
harness.clock().advance(5s);
Validation const val2 = a.validate(ID{4}, Seq{4}, 0s, 0s, true);
BEAST_EXPECT(ValStatus::Current == harness.add(val2));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{4}) == 1);
BEAST_EXPECT(
harness.vals().getPreferred(genesisLedger_) ==
std::make_pair(ledgerAB.seq(), ledgerAB.id()));
// Another node requesting that ledger still doesn't change things
Validation const val3 = b.validate(ID{4}, Seq{4}, 0s, 0s, true);
BEAST_EXPECT(ValStatus::Current == harness.add(val3));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ID{4}) == 2);
BEAST_EXPECT(
harness.vals().getPreferred(genesisLedger_) ==
std::make_pair(ledgerAB.seq(), ledgerAB.id()));
// Switch to validation that is available
harness.clock().advance(5s);
Ledger const ledgerABCDE = h["abcde"];
BEAST_EXPECT(ValStatus::Current == harness.add(a.partial(ledgerABCDE)));
BEAST_EXPECT(ValStatus::Current == harness.add(b.partial(ledgerABCDE)));
BEAST_EXPECT(
harness.vals().getPreferred(genesisLedger_) ==
std::make_pair(ledgerABCDE.seq(), ledgerABCDE.id()));
}
void
testNumTrustedForLedger()
{
testcase("NumTrustedForLedger");
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node const a = harness.makeNode();
Node const b = harness.makeNode();
Ledger const ledgerA = h["a"];
BEAST_EXPECT(ValStatus::Current == harness.add(a.partial(ledgerA)));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 0);
BEAST_EXPECT(ValStatus::Current == harness.add(b.validate(ledgerA)));
BEAST_EXPECT(harness.vals().numTrustedForLedger(ledgerA.id()) == 1);
}
void
testSeqEnforcer()
{
testcase("SeqEnforcer");
using Seq = Ledger::Seq;
using namespace std::chrono;
beast::ManualClock<steady_clock> clock;
SeqEnforcer<Seq> enforcer;
ValidationParms const p;
BEAST_EXPECT(enforcer(clock.now(), Seq{1}, p));
BEAST_EXPECT(enforcer(clock.now(), Seq{10}, p));
BEAST_EXPECT(!enforcer(clock.now(), Seq{5}, p));
BEAST_EXPECT(!enforcer(clock.now(), Seq{9}, p));
clock.advance(p.validationSetExpires - 1ms);
BEAST_EXPECT(!enforcer(clock.now(), Seq{1}, p));
clock.advance(2ms);
BEAST_EXPECT(enforcer(clock.now(), Seq{1}, p));
}
void
testTrustChanged()
{
testcase("TrustChanged");
using namespace std::chrono;
auto checker = [this](
TestValidations& vals,
hash_set<PeerID> const& listed,
std::vector<Validation> const& trustedVals) {
Ledger::ID const testID =
trustedVals.empty() ? this->genesisLedger_.id() : trustedVals[0].ledgerID();
Ledger::Seq const testSeq =
trustedVals.empty() ? this->genesisLedger_.seq() : trustedVals[0].seq();
BEAST_EXPECT(vals.currentTrusted() == trustedVals);
BEAST_EXPECT(vals.getCurrentNodeIDs() == listed);
BEAST_EXPECT(
vals.getNodesAfter(this->genesisLedger_, genesisLedger_.id()) ==
trustedVals.size());
if (trustedVals.empty())
{
BEAST_EXPECT(vals.getPreferred(this->genesisLedger_) == std::nullopt);
}
else
{
BEAST_EXPECT(vals.getPreferred(this->genesisLedger_)->second == testID);
}
BEAST_EXPECT(vals.getTrustedForLedger(testID, testSeq) == trustedVals);
BEAST_EXPECT(vals.numTrustedForLedger(testID) == trustedVals.size());
};
{
// Trusted to untrusted
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node const a = harness.makeNode();
Ledger const ledgerAB = h["ab"];
Validation const v = a.validate(ledgerAB);
BEAST_EXPECT(ValStatus::Current == harness.add(v));
hash_set<PeerID> const listed({a.nodeID()});
std::vector<Validation> trustedVals({v});
checker(harness.vals(), listed, trustedVals);
trustedVals.clear();
harness.vals().trustChanged({}, {a.nodeID()});
checker(harness.vals(), listed, trustedVals);
}
{
// Untrusted to trusted
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node a = harness.makeNode();
a.untrust();
Ledger const ledgerAB = h["ab"];
Validation const v = a.validate(ledgerAB);
BEAST_EXPECT(ValStatus::Current == harness.add(v));
hash_set<PeerID> const listed({a.nodeID()});
std::vector<Validation> trustedVals;
checker(harness.vals(), listed, trustedVals);
trustedVals.push_back(v);
harness.vals().trustChanged({a.nodeID()}, {});
checker(harness.vals(), listed, trustedVals);
}
{
// Trusted but not acquired -> untrusted
LedgerHistoryHelper h;
TestHarness harness(h.oracle);
Node const a = harness.makeNode();
Validation const v = a.validate(Ledger::ID{2}, Ledger::Seq{2}, 0s, 0s, true);
BEAST_EXPECT(ValStatus::Current == harness.add(v));
hash_set<PeerID> const listed({a.nodeID()});
std::vector<Validation> trustedVals({v});
auto& vals = harness.vals();
BEAST_EXPECT(vals.currentTrusted() == trustedVals);
// NOLINTNEXTLINE(bugprone-unchecked-optional-access)
BEAST_EXPECT(vals.getPreferred(genesisLedger_)->second == v.ledgerID());
BEAST_EXPECT(vals.getNodesAfter(genesisLedger_, genesisLedger_.id()) == 0);
trustedVals.clear();
harness.vals().trustChanged({}, {a.nodeID()});
// make acquiring ledger available
h["ab"];
BEAST_EXPECT(vals.currentTrusted() == trustedVals);
BEAST_EXPECT(vals.getPreferred(genesisLedger_) == std::nullopt);
BEAST_EXPECT(vals.getNodesAfter(genesisLedger_, genesisLedger_.id()) == 0);
}
}
void
run() override
{
testAddValidation();
testOnStale();
testGetNodesAfter();
testCurrentTrusted();
testGetCurrentPublicKeys();
testTrustedByLedgerFunctions();
testExpire();
testFlush();
testGetPreferredLedger();
testGetPreferredLCL();
testAcquireValidatedLedger();
testNumTrustedForLedger();
testSeqEnforcer();
testTrustChanged();
}
};
BEAST_DEFINE_TESTSUITE(Validations, consensus, xrpl);
} // namespace xrpl::test::csf
Reference in New Issue View Git Blame Copy Permalink