Env.h

#ifndef XRPL_TEST_JTX_ENV_H_INCLUDED
#define XRPL_TEST_JTX_ENV_H_INCLUDED
 
#include <test/jtx/AbstractClient.h>
#include <test/jtx/Account.h>
#include <test/jtx/JTx.h>
#include <test/jtx/ManualTimeKeeper.h>
#include <test/jtx/amount.h>
#include <test/jtx/envconfig.h>
#include <test/jtx/require.h>
#include <test/jtx/tags.h>
#include <test/jtx/vault.h>
#include <test/unit_test/SuiteJournal.h>
 
#include <xrpld/app/ledger/Ledger.h>
#include <xrpld/app/ledger/OpenLedger.h>
#include <xrpld/app/main/Application.h>
#include <xrpld/app/paths/Pathfinder.h>
#include <xrpld/core/Config.h>
 
#include <xrpl/basics/Log.h>
#include <xrpl/basics/chrono.h>
#include <xrpl/beast/utility/Journal.h>
#include <xrpl/json/json_value.h>
#include <xrpl/json/to_string.h>
#include <xrpl/protocol/ApiVersion.h>
#include <xrpl/protocol/Feature.h>
#include <xrpl/protocol/Indexes.h>
#include <xrpl/protocol/Issue.h>
#include <xrpl/protocol/STAmount.h>
#include <xrpl/protocol/STObject.h>
#include <xrpl/protocol/STTx.h>
 
#include <functional>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>
 
namespace ripple {
namespace test {
namespace jtx {
 
template <class... Args>
std::array<Account, 1 + sizeof...(Args)>
noripple(Account const& account, Args const&... args)
{
    return {{account, args...}};
}
 
inline FeatureBitset
testable_amendments()
{
    static FeatureBitset const ids = [] {
        auto const& sa = allAmendments();
        std::vector<uint256> feats;
        feats.reserve(sa.size());
        for (auto const& [s, vote] : sa)
        {
            (void)vote;
            if (auto const f = getRegisteredFeature(s))
                feats.push_back(*f);
            else
                Throw<std::runtime_error>(
                    "Unknown feature: " + s + "  in allAmendments.");
        }
        return FeatureBitset(feats);
    }();
    return ids;
}
 
//------------------------------------------------------------------------------
 
class SuiteLogs : public Logs
{
    beast::unit_test::suite& suite_;
 
public:
    explicit SuiteLogs(beast::unit_test::suite& suite)
        : Logs(beast::severities::kError), suite_(suite)
    {
    }
 
    ~SuiteLogs() override = default;
 
    std::unique_ptr<beast::Journal::Sink>
    makeSink(
        std::string const& partition,
        beast::severities::Severity threshold) override
    {
        return std::make_unique<SuiteJournalSink>(partition, threshold, suite_);
    }
};
 
//------------------------------------------------------------------------------
 
class Env
{
public:
    beast::unit_test::suite& test;
 
    Account const& master = Account::master;
 
    struct ParsedResult
    {
        std::optional<TER> ter{};
        // RPC errors tend to return either a "code" and a "message" (sometimes
        // with an "error" that corresponds to the "code"), or with an "error"
        // and an "exception". However, this structure allows all possible
        // combinations.
        std::optional<error_code_i> rpcCode{};
        std::string rpcMessage;
        std::string rpcError;
        std::string rpcException;
    };
 
private:
    struct AppBundle
    {
        Application* app = nullptr;
        std::unique_ptr<Application> owned;
        ManualTimeKeeper* timeKeeper = nullptr;
        std::thread thread;
        std::unique_ptr<AbstractClient> client;
 
        AppBundle() = default;
        AppBundle(
            beast::unit_test::suite& suite,
            std::unique_ptr<Config> config,
            std::unique_ptr<Logs> logs,
            beast::severities::Severity thresh);
        ~AppBundle();
    };
 
    AppBundle bundle_;
 
public:
    beast::Journal const journal;
 
    Env() = delete;
    Env&
    operator=(Env const&) = delete;
    Env(Env const&) = delete;
 
    // VFALCO Could wrap the suite::log in a Journal here
    Env(beast::unit_test::suite& suite_,
        std::unique_ptr<Config> config,
        FeatureBitset features,
        std::unique_ptr<Logs> logs = nullptr,
        beast::severities::Severity thresh = beast::severities::kError)
        : test(suite_)
        , bundle_(suite_, std::move(config), std::move(logs), thresh)
        , journal{bundle_.app->journal("Env")}
    {
        memoize(Account::master);
        Pathfinder::initPathTable();
        foreachFeature(
            features, [&appFeats = app().config().features](uint256 const& f) {
                appFeats.insert(f);
            });
    }
 
    Env(beast::unit_test::suite& suite_,
        FeatureBitset features,
        std::unique_ptr<Logs> logs = nullptr)
        : Env(suite_, envconfig(), features, std::move(logs))
    {
    }
 
    Env(beast::unit_test::suite& suite_,
        std::unique_ptr<Config> config,
        std::unique_ptr<Logs> logs = nullptr,
        beast::severities::Severity thresh = beast::severities::kError)
        : Env(suite_,
              std::move(config),
              testable_amendments(),
              std::move(logs),
              thresh)
    {
    }
 
    Env(beast::unit_test::suite& suite_) : Env(suite_, envconfig())
    {
    }
 
    virtual ~Env() = default;
 
    Application&
    app()
    {
        return *bundle_.app;
    }
 
    Application const&
    app() const
    {
        return *bundle_.app;
    }
 
    ManualTimeKeeper&
    timeKeeper()
    {
        return *bundle_.timeKeeper;
    }
 
    NetClock::time_point
    now()
    {
        return timeKeeper().now();
    }
 
    AbstractClient&
    client()
    {
        return *bundle_.client;
    }
 
    template <class... Args>
    Json::Value
    rpc(unsigned apiVersion,
        std::unordered_map<std::string, std::string> const& headers,
        std::string const& cmd,
        Args&&... args);
 
    template <class... Args>
    Json::Value
    rpc(unsigned apiVersion, std::string const& cmd, Args&&... args);
 
    template <class... Args>
    Json::Value
    rpc(std::unordered_map<std::string, std::string> const& headers,
        std::string const& cmd,
        Args&&... args);
 
    template <class... Args>
    Json::Value
    rpc(std::string const& cmd, Args&&... args);
 
    std::shared_ptr<OpenView const>
    current() const
    {
        return app().openLedger().current();
    }
 
    std::shared_ptr<ReadView const>
    closed();
 
    bool
    close(
        NetClock::time_point closeTime,
        std::optional<std::chrono::milliseconds> consensusDelay = std::nullopt);
 
    template <class Rep, class Period>
    bool
    close(std::chrono::duration<Rep, Period> const& elapsed)
    {
        // VFALCO Is this the correct time?
        return close(now() + elapsed);
    }
 
    bool
    close()
    {
        // VFALCO Is this the correct time?
        return close(std::chrono::seconds(5));
    }
 
    void
    trace(int howMany = -1)
    {
        trace_ = howMany;
    }
 
    void
    notrace()
    {
        trace_ = 0;
    }
 
    void
    set_parse_failure_expected(bool b)
    {
        parseFailureExpected_ = b;
    }
 
    void
    disable_sigs()
    {
        app().checkSigs(false);
    }
 
    // set rpc retries
    void
    set_retries(unsigned r = 5)
    {
        retries_ = r;
    }
 
    // get rpc retries
    unsigned
    retries() const
    {
        return retries_;
    }
 
    void
    memoize(Account const& account);
 
    Account const&
    lookup(AccountID const& id) const;
 
    Account const&
    lookup(std::string const& base58ID) const;
    PrettyAmount
    balance(Account const& account) const;
 
    std::uint32_t
    seq(Account const& account) const;
 
    // VFALCO NOTE This should return a unit-less amount
    PrettyAmount
    balance(Account const& account, Asset const& asset) const;
 
    PrettyAmount
    balance(Account const& account, Issue const& issue) const;
 
    PrettyAmount
    balance(Account const& account, MPTIssue const& mptIssue) const;
 
    PrettyAmount
    limit(Account const& account, Issue const& issue) const;
 
    std::uint32_t
    ownerCount(Account const& account) const;
 
    std::shared_ptr<SLE const>
    le(Account const& account) const;
 
    std::shared_ptr<SLE const>
    le(Keylet const& k) const;
 
    template <class JsonValue, class... FN>
    JTx
    jt(JsonValue&& jv, FN const&... fN)
    {
        JTx jt(std::forward<JsonValue>(jv));
        invoke(jt, fN...);
        autofill(jt);
        jt.stx = st(jt);
        return jt;
    }
 
    template <class JsonValue, class... FN>
    JTx
    jtnofill(JsonValue&& jv, FN const&... fN)
    {
        JTx jt(std::forward<JsonValue>(jv));
        invoke(jt, fN...);
        autofill_sig(jt);
        jt.stx = st(jt);
        return jt;
    }
 
    template <class JsonValue, class... FN>
    Json::Value
    json(JsonValue&& jv, FN const&... fN)
    {
        auto tj = jt(std::forward<JsonValue>(jv), fN...);
        return std::move(tj.jv);
    }
 
    template <class... Args>
    void
    require(Args const&... args)
    {
        jtx::required(args...)(*this);
    }
 
    static ParsedResult
    parseResult(Json::Value const& jr);
 
    virtual void
    submit(JTx const& jt);
 
    void
    sign_and_submit(JTx const& jt, Json::Value params = Json::nullValue);
 
    void
    postconditions(
        JTx const& jt,
        ParsedResult const& parsed,
        Json::Value const& jr = Json::Value());
 
    template <class JsonValue, class... FN>
    Env&
    apply(JsonValue&& jv, FN const&... fN)
    {
        submit(jt(std::forward<JsonValue>(jv), fN...));
        return *this;
    }
 
    template <class JsonValue, class... FN>
    Env&
    operator()(JsonValue&& jv, FN const&... fN)
    {
        return apply(std::forward<JsonValue>(jv), fN...);
    }
    TER
    ter() const
    {
        return ter_;
    }
 
    std::shared_ptr<STObject const>
    meta();
 
    std::shared_ptr<STTx const>
    tx() const;
 
    void
    enableFeature(uint256 const feature);
 
    void
    disableFeature(uint256 const feature);
 
    bool
    enabled(uint256 feature) const
    {
        return current()->rules().enabled(feature);
    }
 
private:
    void
    fund(bool setDefaultRipple, STAmount const& amount, Account const& account);
 
    void
    fund_arg(STAmount const& amount, Account const& account)
    {
        fund(true, amount, account);
    }
 
    template <std::size_t N>
    void
    fund_arg(STAmount const& amount, std::array<Account, N> const& list)
    {
        for (auto const& account : list)
            fund(false, amount, account);
    }
 
public:
    template <class Arg, class... Args>
    void
    fund(STAmount const& amount, Arg const& arg, Args const&... args)
    {
        fund_arg(amount, arg);
        if constexpr (sizeof...(args) > 0)
            fund(amount, args...);
    }
 
    void
    trust(STAmount const& amount, Account const& account);
 
    template <class... Accounts>
    void
    trust(
        STAmount const& amount,
        Account const& to0,
        Account const& to1,
        Accounts const&... toN)
    {
        trust(amount, to0);
        trust(amount, to1, toN...);
    }
    std::shared_ptr<STTx const>
    ust(JTx const& jt);
 
protected:
    int trace_ = 0;
    TestStopwatch stopwatch_;
    uint256 txid_;
    TER ter_ = tesSUCCESS;
    bool parseFailureExpected_ = false;
    unsigned retries_ = 5;
 
    Json::Value
    do_rpc(
        unsigned apiVersion,
        std::vector<std::string> const& args,
        std::unordered_map<std::string, std::string> const& headers = {});
 
    void
    autofill_sig(JTx& jt);
 
    virtual void
    autofill(JTx& jt);
 
    std::shared_ptr<STTx const>
    st(JTx const& jt);
 
    // Invoke funclets on stx
    // Note: The STTx may not be modified
    template <class... FN>
    void
    invoke(STTx& stx, FN const&... fN)
    {
        (fN(*this, stx), ...);
    }
 
    // Invoke funclets on jt
    template <class... FN>
    void
    invoke(JTx& jt, FN const&... fN)
    {
        (fN(*this, jt), ...);
    }
 
    // Map of account IDs to Account
    std::unordered_map<AccountID, Account> map_;
};
 
template <class... Args>
Json::Value
Env::rpc(
    unsigned apiVersion,
    std::unordered_map<std::string, std::string> const& headers,
    std::string const& cmd,
    Args&&... args)
{
    return do_rpc(
        apiVersion,
        std::vector<std::string>{cmd, std::forward<Args>(args)...},
        headers);
}
 
template <class... Args>
Json::Value
Env::rpc(unsigned apiVersion, std::string const& cmd, Args&&... args)
{
    return rpc(
        apiVersion,
        std::unordered_map<std::string, std::string>(),
        cmd,
        std::forward<Args>(args)...);
}
 
template <class... Args>
Json::Value
Env::rpc(
    std::unordered_map<std::string, std::string> const& headers,
    std::string const& cmd,
    Args&&... args)
{
    return do_rpc(
        RPC::apiCommandLineVersion,
        std::vector<std::string>{cmd, std::forward<Args>(args)...},
        headers);
}
 
template <class... Args>
Json::Value
Env::rpc(std::string const& cmd, Args&&... args)
{
    return rpc(
        std::unordered_map<std::string, std::string>(),
        cmd,
        std::forward<Args>(args)...);
}
 
}  // namespace jtx
}  // namespace test
}  // namespace ripple
 
#endif