TestServiceRegistry.h

#pragma once
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/base_uint.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/core/HashRouter.h>
#include <xrpl/core/NetworkIDService.h>
#include <xrpl/core/ServiceRegistry.h>
#include <xrpl/ledger/PendingSaves.h>
#include <xrpl/server/LoadFeeTrack.h>
 
#include <boost/asio/io_context.hpp>
 
#include <helpers/TestFamily.h>
#include <helpers/TestSink.h>
 
#include <cstdint>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
 
namespace xrpl::test {

class TestLogs : public Logs
{
public:
    explicit TestLogs(beast::Severity level = beast::Severity::Warning) : Logs(level)
    {
    }
 
    std::unique_ptr<beast::Journal::Sink>
    makeSink(std::string const&, beast::Severity threshold) override
    {
        return std::make_unique<TestSink>(threshold);
    }
};

class TestNetworkIDService final : public NetworkIDService
{
public:
    explicit TestNetworkIDService(std::uint32_t networkID = 0) : networkID_(networkID)
    {
    }
 
    [[nodiscard]] std::uint32_t
    getNetworkID() const noexcept override
    {
        return networkID_;
    }
 
private:
    std::uint32_t networkID_;
};

class TestServiceRegistry : public ServiceRegistry
{
    TestLogs logs_{beast::Severity::Warning};
    boost::asio::io_context ioContext_;
    TestFamily family_{logs_.journal("TestFamily")};
    LoadFeeTrack feeTrack_{logs_.journal("LoadFeeTrack")};
    TestNetworkIDService networkIDService_;
    HashRouter hashRouter_{HashRouter::Setup{}, stopwatch()};
    NodeCache tempNodeCache_{
        "TempNodeCache",
        16384,
        std::chrono::minutes{1},
        stopwatch(),
        logs_.journal("TaggedCache")};
    CachedSLEs cachedSLEs_{
        "CachedSLEs",
        16384,
        std::chrono::minutes{1},
        stopwatch(),
        logs_.journal("TaggedCache")};
    PendingSaves pendingSaves_;
    std::optional<uint256> trapTxID_;
 
public:
    TestServiceRegistry() = default;
    ~TestServiceRegistry() override = default;
 
    // Core infrastructure services
    CollectorManager&
    getCollectorManager() override
    {
        throw std::logic_error("TestServiceRegistry::getCollectorManager() not implemented");
    }
 
    Family&
    getNodeFamily() override
    {
        return family_;
    }
 
    TimeKeeper&
    getTimeKeeper() override
    {
        throw std::logic_error("TestServiceRegistry::timeKeeper() not implemented");
    }
 
    JobQueue&
    getJobQueue() override
    {
        throw std::logic_error("TestServiceRegistry::getJobQueue() not implemented");
    }
 
    NodeCache&
    getTempNodeCache() override
    {
        return tempNodeCache_;
    }
 
    CachedSLEs&
    getCachedSLEs() override
    {
        return cachedSLEs_;
    }
 
    NetworkIDService&
    getNetworkIDService() override
    {
        return networkIDService_;
    }
 
    // Protocol and validation services
    AmendmentTable&
    getAmendmentTable() override
    {
        throw std::logic_error("TestServiceRegistry::getAmendmentTable() not implemented");
    }
 
    HashRouter&
    getHashRouter() override
    {
        return hashRouter_;
    }
 
    LoadFeeTrack&
    getFeeTrack() override
    {
        return feeTrack_;
    }
 
    LoadManager&
    getLoadManager() override
    {
        throw std::logic_error("TestServiceRegistry::getLoadManager() not implemented");
    }
 
    RCLValidations&
    getValidations() override
    {
        throw std::logic_error("TestServiceRegistry::getValidations() not implemented");
    }
 
    ValidatorList&
    getValidators() override
    {
        throw std::logic_error("TestServiceRegistry::validators() not implemented");
    }
 
    ValidatorSite&
    getValidatorSites() override
    {
        throw std::logic_error("TestServiceRegistry::validatorSites() not implemented");
    }
 
    ManifestCache&
    getValidatorManifests() override
    {
        throw std::logic_error("TestServiceRegistry::validatorManifests() not implemented");
    }
 
    ManifestCache&
    getPublisherManifests() override
    {
        throw std::logic_error("TestServiceRegistry::publisherManifests() not implemented");
    }
 
    // Network services
    Overlay&
    getOverlay() override
    {
        throw std::logic_error("TestServiceRegistry::overlay() not implemented");
    }
 
    Cluster&
    getCluster() override
    {
        throw std::logic_error("TestServiceRegistry::cluster() not implemented");
    }
 
    PeerReservationTable&
    getPeerReservations() override
    {
        throw std::logic_error("TestServiceRegistry::peerReservations() not implemented");
    }
 
    resource::Manager&
    getResourceManager() override
    {
        throw std::logic_error("TestServiceRegistry::getResourceManager() not implemented");
    }
 
    // Storage services
    node_store::Database&
    getNodeStore() override
    {
        throw std::logic_error("TestServiceRegistry::getNodeStore() not implemented");
    }
 
    SHAMapStore&
    getSHAMapStore() override
    {
        throw std::logic_error("TestServiceRegistry::getSHAMapStore() not implemented");
    }
 
    RelationalDatabase&
    getRelationalDatabase() override
    {
        throw std::logic_error("TestServiceRegistry::getRelationalDatabase() not implemented");
    }
 
    // Ledger services
    InboundLedgers&
    getInboundLedgers() override
    {
        throw std::logic_error("TestServiceRegistry::getInboundLedgers() not implemented");
    }
 
    InboundTransactions&
    getInboundTransactions() override
    {
        throw std::logic_error("TestServiceRegistry::getInboundTransactions() not implemented");
    }
 
    TaggedCache<uint256, AcceptedLedger>&
    getAcceptedLedgerCache() override
    {
        throw std::logic_error("TestServiceRegistry::getAcceptedLedgerCache() not implemented");
    }
 
    LedgerMaster&
    getLedgerMaster() override
    {
        throw std::logic_error("TestServiceRegistry::getLedgerMaster() not implemented");
    }
 
    LedgerCleaner&
    getLedgerCleaner() override
    {
        throw std::logic_error("TestServiceRegistry::getLedgerCleaner() not implemented");
    }
 
    LedgerReplayer&
    getLedgerReplayer() override
    {
        throw std::logic_error("TestServiceRegistry::getLedgerReplayer() not implemented");
    }
 
    PendingSaves&
    getPendingSaves() override
    {
        return pendingSaves_;
    }
 
    OpenLedger&
    getOpenLedger() override
    {
        throw std::logic_error("TestServiceRegistry::openLedger() not implemented");
    }
 
    OpenLedger const&
    getOpenLedger() const override
    {
        throw std::logic_error("TestServiceRegistry::openLedger() const not implemented");
    }
 
    // Transaction and operation services
    NetworkOPs&
    getOPs() override
    {
        throw std::logic_error("TestServiceRegistry::getOPs() not implemented");
    }
 
    OrderBookDB&
    getOrderBookDB() override
    {
        throw std::logic_error("TestServiceRegistry::getOrderBookDB() not implemented");
    }
 
    TransactionMaster&
    getMasterTransaction() override
    {
        throw std::logic_error("TestServiceRegistry::getMasterTransaction() not implemented");
    }
 
    TxQ&
    getTxQ() override
    {
        throw std::logic_error("TestServiceRegistry::getTxQ() not implemented");
    }
 
    PathRequestManager&
    getPathRequestManager() override
    {
        throw std::logic_error("TestServiceRegistry::getPathRequestManager() not implemented");
    }
 
    // Server services
    ServerHandler&
    getServerHandler() override
    {
        throw std::logic_error("TestServiceRegistry::getServerHandler() not implemented");
    }
 
    perf::PerfLog&
    getPerfLog() override
    {
        throw std::logic_error("TestServiceRegistry::getPerfLog() not implemented");
    }
 
    // Configuration and state
    bool
    isStopping() const override
    {
        return false;
    }
 
    beast::Journal
    getJournal(std::string const& name) override
    {
        return logs_.journal(name);
    }
 
    boost::asio::io_context&
    getIOContext() override
    {
        return ioContext_;
    }
 
    Logs&
    getLogs() override
    {
        return logs_;
    }
 
    std::optional<uint256> const&
    getTrapTxID() const override
    {
        return trapTxID_;
    }
 
    DatabaseCon&
    getWalletDB() override
    {
        throw std::logic_error("TestServiceRegistry::getWalletDB() not implemented");
    }
 
    // Temporary: Get the underlying Application
    Application&
    getApp() override
    {
        throw std::logic_error(
            "TestServiceRegistry::app() not implemented - no Application available in tests");
    }
};
 
}  // namespace xrpl::test