Status_test.cpp

#include <xrpld/rpc/Status.h>
 
#include <xrpl/basics/contract.h>
#include <xrpl/beast/unit_test/suite.h>
#include <xrpl/json/json_value.h>
#include <xrpl/protocol/ErrorCodes.h>
#include <xrpl/protocol/TER.h>
#include <xrpl/protocol/jss.h>
 
#include <algorithm>
#include <cstddef>
#include <exception>
#include <string>
 
namespace xrpl::RPC {
 
class codeString_test : public beast::unit_test::Suite
{
private:
    template <typename Type>
    std::string
    codeString(Type t)
    {
        return Status(t).codeString();
    }
 
    void
    testOk()
    {
        testcase("OK");
        {
            auto s = codeString(Status());
            expect(s.empty(), "String for OK status");
        }
 
        {
            auto s = codeString(Status::kOK);
            expect(s.empty(), "String for OK status");
        }
 
        {
            auto s = codeString(0);
            expect(s.empty(), "String for 0 status");
        }
 
        {
            auto s = codeString(tesSUCCESS);
            expect(s.empty(), "String for tesSUCCESS");
        }
 
        {
            auto s = codeString(RpcSuccess);
            expect(s.empty(), "String for rpcSUCCESS");
        }
    }
 
    void
    testError()
    {
        testcase("error");
        {
            auto s = codeString(23);
            expect(s == "23", s);
        }
 
        {
            auto s = codeString(temBAD_AMOUNT);
            expect(s == "temBAD_AMOUNT: Malformed: Bad amount.", s);
        }
 
        {
            auto s = codeString(RpcBadSyntax);
            expect(s == "badSyntax: Syntax error.", s);
        }
    }
 
public:
    void
    run() override
    {
        testOk();
        testError();
    }
};
 
BEAST_DEFINE_TESTSUITE(codeString, rpc, RPC);
 
class fillJson_test : public beast::unit_test::Suite
{
private:
    json::Value value_;
 
    template <typename Type>
    void
    fillJson(Type t)
    {
        value_.clear();
        Status(t).fillJson(value_);
    }
 
    void
    testOk()
    {
        testcase("OK");
        fillJson(Status());
        expect(!value_, "Value for empty status");
 
        fillJson(0);
        expect(!value_, "Value for 0 status");
 
        fillJson(Status::kOK);
        expect(!value_, "Value for OK status");
 
        fillJson(tesSUCCESS);
        expect(!value_, "Value for tesSUCCESS");
 
        fillJson(RpcSuccess);
        expect(!value_, "Value for rpcSUCCESS");
    }
 
    template <typename Type>
    void
    expectFill(
        std::string const& label,
        Type status,
        Status::Strings messages,
        std::string const& message)
    {
        value_.clear();
        fillJson(Status(status, messages));
 
        auto prefix = label + ": ";
        expect(bool(value_), prefix + "No value");
 
        auto error = value_[jss::error];
        expect(bool(error), prefix + "No error.");
 
        auto code = error[jss::code].asInt();
        expect(
            status == code,
            prefix + "Wrong status " + std::to_string(code) + " != " + std::to_string(status));
 
        auto m = error[jss::message].asString();
        expect(m == message, m + " != " + message);
 
        auto d = error[jss::data];
        size_t const s1 = d.size();
        size_t const s2 = messages.size();
        expect(
            s1 == s2,
            prefix + "Data sizes differ " + std::to_string(s1) + " != " + std::to_string(s2));
        for (auto i = 0; i < std::min(s1, s2); ++i)
        {
            auto ds = d[i].asString();
            expect(ds == messages[i], prefix + ds + " != " + messages[i]);
        }
    }
 
    void
    testError()
    {
        testcase("error");
        expectFill("temBAD_AMOUNT", temBAD_AMOUNT, {}, "temBAD_AMOUNT: Malformed: Bad amount.");
 
        expectFill(
            "RpcBadSyntax",
            RpcBadSyntax,
            {"An error.", "Another error."},
            "badSyntax: Syntax error.");
 
        expectFill("integer message", 23, {"Stuff."}, "23");
    }
 
    void
    testThrow()
    {
        testcase("throw");
        try
        {
            Throw<Status>(Status(temBAD_PATH, {"path=sdcdfd"}));
        }
        catch (Status const& s)
        {
            expect(s.toTER() == temBAD_PATH, "temBAD_PATH wasn't thrown");
            auto msgs = s.messages();
            expect(msgs.size() == 1, "Wrong number of messages");
            expect(msgs[0] == "path=sdcdfd", msgs[0]);
        }
        catch (std::exception const&)
        {
            expect(false, "Didn't catch a Status");
        }
    }
 
public:
    void
    run() override
    {
        testOk();
        testError();
        testThrow();
    }
};
 
BEAST_DEFINE_TESTSUITE(fillJson, rpc, RPC);
 
}  // namespace xrpl::RPC