feat: Implement and use LedgerCacheInterface (#1955)

For #1200

tests/common/util/MockBackend.hpp

@@ -21,6 +21,7 @@
 
 #include "data/BackendInterface.hpp"
 #include "data/DBHelpers.hpp"
+#include "data/LedgerCache.hpp"
 #include "data/Types.hpp"
 #include "util/newconfig/ConfigDefinition.hpp"
 
@@ -36,10 +37,8 @@
 #include <string>
 #include <vector>
 
-using namespace data;
-
 struct MockBackend : public BackendInterface {
-    MockBackend(util::config::ClioConfigDefinition)
+    MockBackend(util::config::ClioConfigDefinition) : BackendInterface(cache_)
     {
     }
 
@@ -65,32 +64,32 @@ struct MockBackend : public BackendInterface {
     );
 
     MOCK_METHOD(
-        std::optional<TransactionAndMetadata>,
+        std::optional<data::TransactionAndMetadata>,
         fetchTransaction,
         (ripple::uint256 const&, boost::asio::yield_context),
         (const, override)
     );
 
     MOCK_METHOD(
-        std::vector<TransactionAndMetadata>,
+        std::vector<data::TransactionAndMetadata>,
         fetchTransactions,
         (std::vector<ripple::uint256> const&, boost::asio::yield_context),
         (const, override)
     );
 
     MOCK_METHOD(
-        TransactionsAndCursor,
+        data::TransactionsAndCursor,
         fetchAccountTransactions,
         (ripple::AccountID const&,
          std::uint32_t const,
          bool,
-         std::optional<TransactionsCursor> const&,
+         std::optional<data::TransactionsCursor> const&,
          boost::asio::yield_context),
         (const, override)
     );
 
     MOCK_METHOD(
-        std::vector<TransactionAndMetadata>,
+        std::vector<data::TransactionAndMetadata>,
         fetchAllTransactionsInLedger,
         (std::uint32_t const, boost::asio::yield_context),
         (const, override)
@@ -104,25 +103,25 @@ struct MockBackend : public BackendInterface {
     );
 
     MOCK_METHOD(
-        std::optional<NFT>,
+        std::optional<data::NFT>,
         fetchNFT,
         (ripple::uint256 const&, std::uint32_t const, boost::asio::yield_context),
         (const, override)
     );
 
     MOCK_METHOD(
-        TransactionsAndCursor,
+        data::TransactionsAndCursor,
         fetchNFTTransactions,
         (ripple::uint256 const&,
          std::uint32_t const,
          bool const,
-         std::optional<TransactionsCursor> const&,
+         std::optional<data::TransactionsCursor> const&,
          boost::asio::yield_context),
         (const, override)
     );
 
     MOCK_METHOD(
-        NFTsAndCursor,
+        data::NFTsAndCursor,
         fetchNFTsByIssuer,
         (ripple::AccountID const& issuer,
          std::optional<std::uint32_t> const& taxon,
@@ -134,7 +133,7 @@ struct MockBackend : public BackendInterface {
     );
 
     MOCK_METHOD(
-        std::vector<Blob>,
+        std::vector<data::Blob>,
         doFetchLedgerObjects,
         (std::vector<ripple::uint256> const&, std::uint32_t const, boost::asio::yield_context),
         (const, override)
@@ -148,7 +147,7 @@ struct MockBackend : public BackendInterface {
     );
 
     MOCK_METHOD(
-        std::optional<Blob>,
+        std::optional<data::Blob>,
         doFetchLedgerObject,
         (ripple::uint256 const&, std::uint32_t const, boost::asio::yield_context),
         (const, override)
@@ -162,7 +161,7 @@ struct MockBackend : public BackendInterface {
     );
 
     MOCK_METHOD(
-        std::vector<LedgerObject>,
+        std::vector<data::LedgerObject>,
         fetchLedgerDiff,
         (std::uint32_t const, boost::asio::yield_context),
         (const, override)
@@ -182,7 +181,12 @@ struct MockBackend : public BackendInterface {
         (const, override)
     );
 
-    MOCK_METHOD(std::optional<LedgerRange>, hardFetchLedgerRange, (boost::asio::yield_context), (const, override));
+    MOCK_METHOD(
+        std::optional<data::LedgerRange>,
+        hardFetchLedgerRange,
+        (boost::asio::yield_context),
+        (const, override)
+    );
 
     MOCK_METHOD(void, writeLedger, (ripple::LedgerHeader const&, std::string&&), (override));
 
@@ -218,7 +222,7 @@ struct MockBackend : public BackendInterface {
     MOCK_METHOD(void, writeMPTHolders, (std::vector<MPTHolderData> const&), (override));
 
     MOCK_METHOD(
-        MPTHoldersAndCursor,
+        data::MPTHoldersAndCursor,
         fetchMPTHolders,
         (ripple::uint192 const& mptID,
          std::uint32_t const,
@@ -229,4 +233,7 @@ struct MockBackend : public BackendInterface {
     );
 
     MOCK_METHOD(void, writeMigratorStatus, (std::string const&, std::string const&), (override));
+
+protected:
+    data::LedgerCache cache_;  // TODO: this should probably be injected and MockLedgerCache instead
 };

tests/common/util/MockLedgerCache.hpp

@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 /*
     This file is part of clio: https://github.com/XRPLF/clio
-    Copyright (c) 2023, the clio developers.
+    Copyright (c) 2025, the clio developers.
 
     Permission to use, copy, modify, and distribute this software for any
     purpose with or without fee is hereby granted, provided that the above
@@ -19,6 +19,7 @@
 
 #pragma once
 
+#include "data/LedgerCacheInterface.hpp"
 #include "data/Types.hpp"
 
 #include <gmock/gmock.h>
@@ -29,36 +30,46 @@
 #include <optional>
 #include <vector>
 
-struct MockCache {
-    virtual ~MockCache() = default;
-
+struct MockLedgerCache : data::LedgerCacheInterface {
     MOCK_METHOD(void, updateImp, (std::vector<data::LedgerObject> const& a, uint32_t b, bool c), ());
 
-    virtual void
-    update(std::vector<data::LedgerObject> const& a, uint32_t b, bool c = false)
+    void
+    update(std::vector<data::LedgerObject> const& a, uint32_t b, bool c = false) override
     {
         updateImp(a, b, c);
     }
 
-    MOCK_METHOD(std::optional<data::Blob>, get, (ripple::uint256 const& a, uint32_t b), (const));
+    MOCK_METHOD(std::optional<data::Blob>, get, (ripple::uint256 const& a, uint32_t b), (const, override));
 
-    MOCK_METHOD(std::optional<data::LedgerObject>, getSuccessor, (ripple::uint256 const& a, uint32_t b), (const));
+    MOCK_METHOD(
+        std::optional<data::LedgerObject>,
+        getSuccessor,
+        (ripple::uint256 const& a, uint32_t b),
+        (const, override)
+    );
 
-    MOCK_METHOD(std::optional<data::LedgerObject>, getPredecessor, (ripple::uint256 const& a, uint32_t b), (const));
+    MOCK_METHOD(
+        std::optional<data::LedgerObject>,
+        getPredecessor,
+        (ripple::uint256 const& a, uint32_t b),
+        (const, override)
+    );
 
-    MOCK_METHOD(void, setDisabled, (), ());
+    MOCK_METHOD(void, setDisabled, (), (override));
 
-    MOCK_METHOD(bool, isDisabled, (), (const));
+    MOCK_METHOD(bool, isDisabled, (), (const, override));
 
-    MOCK_METHOD(void, setFull, (), ());
+    MOCK_METHOD(void, setFull, (), (override));
 
-    MOCK_METHOD(bool, isFull, (), (const));
+    MOCK_METHOD(bool, isFull, (), (const, override));
 
-    MOCK_METHOD(uint32_t, latestLedgerSequence, (), (const));
+    MOCK_METHOD(uint32_t, latestLedgerSequence, (), (const, override));
 
-    MOCK_METHOD(size_t, size, (), (const));
+    MOCK_METHOD(size_t, size, (), (const, override));
 
-    MOCK_METHOD(float, getObjectHitRate, (), (const));
+    MOCK_METHOD(float, getObjectHitRate, (), (const, override));
 
-    MOCK_METHOD(float, getSuccessorHitRate, (), (const));
+    MOCK_METHOD(float, getSuccessorHitRate, (), (const, override));
+
+    MOCK_METHOD(void, waitUntilCacheContainsSeq, (uint32_t), (override));
 };