Env.h

//------------------------------------------------------------------------------
/*
    This file is part of rippled: https://github.com/ripple/rippled
    Copyright (c) 2012, 2013 Ripple Labs Inc.
 
    Permission to use, copy, modify, and/or distribute this software for any
    purpose  with  or without fee is hereby granted, provided that the above
    copyright notice and this permission notice appear in all copies.
 
    THE  SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
    WITH  REGARD  TO  THIS  SOFTWARE  INCLUDING  ALL  IMPLIED  WARRANTIES  OF
    MERCHANTABILITY  AND  FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
    ANY  SPECIAL ,  DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
    WHATSOEVER  RESULTING  FROM  LOSS  OF USE, DATA OR PROFITS, WHETHER IN AN
    ACTION  OF  CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
 
#ifndef RIPPLE_TEST_JTX_ENV_H_INCLUDED
#define RIPPLE_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 <xrpld/rpc/detail/RPCHelpers.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/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, 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