ARCHIVE/clio
1
0
Fork 0
mirror of https://github.com/XRPLF/clio.git synced 2025-11-20 11:45:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement the Clamp modifier (#740)

Browse Source 
Fixes #750
This commit is contained in:
Alex Kremer
2023-07-10 16:09:20 +01:00
committed by GitHub
parent 271323b0f4
commit ba8e7188ca
23 changed files with 523 additions and 359 deletions
Download Patch File Download Diff File Expand all files Collapse all files

174
unittests/rpc/BaseTests.cpp
View File

@@ -21,6 +21,8 @@
#include <rpc/Factories.h>
#include <rpc/common/AnyHandler.h>
#include <rpc/common/MetaProcessors.h>
#include <rpc/common/Modifiers.h>
#include <rpc/common/Specs.h>
#include <rpc/common/Validators.h>
@@ -36,6 +38,8 @@ using namespace std;
using namespace RPC;
using namespace RPC::validation;
using namespace RPC::meta;
using namespace RPC::modifiers;
namespace json = boost::json;
@@ -92,31 +96,31 @@ TEST_F(RPCBaseTest, TypeValidator)
"bool": true,
"arr": []
})");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
{
auto failingInput = json::parse(R"({ "uint": "a string" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
{
auto failingInput = json::parse(R"({ "int": "a string" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
{
auto failingInput = json::parse(R"({ "str": 1234 })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
{
auto failingInput = json::parse(R"({ "double": "a string" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
{
auto failingInput = json::parse(R"({ "bool": "a string" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
{
auto failingInput = json::parse(R"({ "arr": "a string" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
}
@@ -128,13 +132,13 @@ TEST_F(RPCBaseTest, TypeValidatorMultipleTypes)
};
auto passingInput = json::parse(R"({ "test": "1234" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto passingInput2 = json::parse(R"({ "test": 1234 })");
ASSERT_TRUE(spec.validate(passingInput2));
ASSERT_TRUE(spec.process(passingInput2));
auto failingInput = json::parse(R"({ "test": true })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
TEST_F(RPCBaseTest, RequiredValidator)
@@ -144,13 +148,13 @@ TEST_F(RPCBaseTest, RequiredValidator)
};
auto passingInput = json::parse(R"({ "required": "present" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto passingInput2 = json::parse(R"({ "required": true })");
ASSERT_TRUE(spec.validate(passingInput2));
ASSERT_TRUE(spec.process(passingInput2));
auto failingInput = json::parse(R"({})");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
TEST_F(RPCBaseTest, BetweenValidator)
@@ -160,19 +164,19 @@ TEST_F(RPCBaseTest, BetweenValidator)
};
auto passingInput = json::parse(R"({ "amount": 15 })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto passingInput2 = json::parse(R"({ "amount": 10 })");
ASSERT_TRUE(spec.validate(passingInput2));
ASSERT_TRUE(spec.process(passingInput2));
auto passingInput3 = json::parse(R"({ "amount": 20 })");
ASSERT_TRUE(spec.validate(passingInput3));
ASSERT_TRUE(spec.process(passingInput3));
auto failingInput = json::parse(R"({ "amount": 9 })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
auto failingInput2 = json::parse(R"({ "amount": 21 })");
ASSERT_FALSE(spec.validate(failingInput2));
ASSERT_FALSE(spec.process(failingInput2));
}
TEST_F(RPCBaseTest, OneOfValidator)
@@ -182,13 +186,13 @@ TEST_F(RPCBaseTest, OneOfValidator)
};
auto passingInput = json::parse(R"({ "currency": "XRP" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto passingInput2 = json::parse(R"({ "currency": "USD" })");
ASSERT_TRUE(spec.validate(passingInput2));
ASSERT_TRUE(spec.process(passingInput2));
auto failingInput = json::parse(R"({ "currency": "PRX" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
TEST_F(RPCBaseTest, EqualToValidator)
@@ -198,10 +202,10 @@ TEST_F(RPCBaseTest, EqualToValidator)
};
auto passingInput = json::parse(R"({ "exact": "CaseSensitive" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "exact": "Different" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
TEST_F(RPCBaseTest, ArrayAtValidator)
@@ -218,16 +222,16 @@ TEST_F(RPCBaseTest, ArrayAtValidator)
// clang-format on
auto passingInput = json::parse(R"({ "arr": [{"limit": 42}] })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "arr": [{"limit": "not int"}] })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
failingInput = json::parse(R"({ "arr": [{"limit": 42}] ,"arr2": "not array type" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
failingInput = json::parse(R"({ "arr": [] })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
TEST_F(RPCBaseTest, IfTypeValidator)
@@ -253,28 +257,28 @@ TEST_F(RPCBaseTest, IfTypeValidator)
// if json object pass
auto passingInput = json::parse(R"({ "mix": {"limit": 42, "limit2": 22} })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
// if string pass
passingInput = json::parse(R"({ "mix": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
// if json object fail at first requirement
auto failingInput = json::parse(R"({ "mix": {"limit": "not int"} })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
// if json object fail at second requirement
failingInput = json::parse(R"({ "mix": {"limit": 22, "limit2": "y"} })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
// if string fail
failingInput = json::parse(R"({ "mix": "not hash" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
// type check fail
failingInput = json::parse(R"({ "mix": 1213 })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
failingInput = json::parse(R"({ "mix": {"limit": 42, "limit2": 22} , "mix2": 1213 })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
TEST_F(RPCBaseTest, WithCustomError)
@@ -284,19 +288,19 @@ TEST_F(RPCBaseTest, WithCustomError)
WithCustomError{Uint256HexStringValidator, RPC::Status{ripple::rpcBAD_FEATURE, "MyCustomError"}}},
{"other", WithCustomError{Type<std::string>{}, RPC::Status{ripple::rpcALREADY_MULTISIG, "MyCustomError2"}}}};
auto const passingInput = json::parse(
auto passingInput = json::parse(
R"({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC", "other": "1"})");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput =
json::parse(R"({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515B"})");
auto err = spec.validate(failingInput);
auto err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "MyCustomError");
ASSERT_EQ(err.error(), ripple::rpcBAD_FEATURE);
failingInput = json::parse(R"({ "other": 1})");
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "MyCustomError2");
ASSERT_EQ(err.error(), ripple::rpcALREADY_MULTISIG);
@@ -318,10 +322,10 @@ TEST_F(RPCBaseTest, CustomValidator)
};
auto passingInput = json::parse(R"({ "taker": "r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "taker": "wrongformat" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
TEST_F(RPCBaseTest, NotSupported)
@@ -332,13 +336,13 @@ TEST_F(RPCBaseTest, NotSupported)
};
auto passingInput = json::parse(R"({ "taker": 2 })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "taker": 123 })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
failingInput = json::parse(R"({ "taker": 2, "getter": 2 })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
}
TEST_F(RPCBaseTest, LedgerIndexValidator)
@@ -347,21 +351,21 @@ TEST_F(RPCBaseTest, LedgerIndexValidator)
{"ledgerIndex", LedgerIndexValidator},
};
auto passingInput = json::parse(R"({ "ledgerIndex": "validated" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
passingInput = json::parse(R"({ "ledgerIndex": "256" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
passingInput = json::parse(R"({ "ledgerIndex": 256 })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "ledgerIndex": "wrongformat" })");
auto err = spec.validate(failingInput);
auto err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "ledgerIndexMalformed");
failingInput = json::parse(R"({ "ledgerIndex": true })");
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "ledgerIndexMalformed");
}
@@ -372,20 +376,20 @@ TEST_F(RPCBaseTest, AccountValidator)
{"account", AccountValidator},
};
auto failingInput = json::parse(R"({ "account": 256 })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
failingInput = json::parse(R"({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jp" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
failingInput = json::parse(R"({ "account": "02000000000000000000000000000000000000000000000000000000000000000" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
auto passingInput = json::parse(R"({ "account": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
passingInput =
json::parse(R"({ "account": "020000000000000000000000000000000000000000000000000000000000000000" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
}
TEST_F(RPCBaseTest, AccountMarkerValidator)
@@ -394,32 +398,32 @@ TEST_F(RPCBaseTest, AccountMarkerValidator)
{"marker", AccountMarkerValidator},
};
auto failingInput = json::parse(R"({ "marker": 256 })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
failingInput = json::parse(R"({ "marker": "testtest" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
failingInput = json::parse(R"({ "marker": "ABAB1234:1H" })");
ASSERT_FALSE(spec.validate(failingInput));
ASSERT_FALSE(spec.process(failingInput));
auto passingInput = json::parse(R"({ "account": "ABAB1234:123" })");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
}
TEST_F(RPCBaseTest, Uint256HexStringValidator)
{
auto const spec = RpcSpec{{"transaction", Uint256HexStringValidator}};
auto const passingInput =
auto passingInput =
json::parse(R"({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC983515BC"})");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "transaction": 256})");
auto err = spec.validate(failingInput);
auto err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "transactionNotString");
failingInput = json::parse(R"({ "transaction": "1B8590C01B0006EDFA9ED60296DD052DC5E90F99659B25014D08E1BC"})");
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "transactionMalformed");
}
@@ -428,18 +432,18 @@ TEST_F(RPCBaseTest, CurrencyValidator)
{
auto const spec = RpcSpec{{"currency", CurrencyValidator}};
auto passingInput = json::parse(R"({ "currency": "GBP"})");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
passingInput = json::parse(R"({ "currency": "0158415500000000C1F76FF6ECB0BAC600000000"})");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "currency": 256})");
auto err = spec.validate(failingInput);
auto err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "currencyNotString");
failingInput = json::parse(R"({ "currency": "12314"})");
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "malformedCurrency");
}
@@ -448,15 +452,15 @@ TEST_F(RPCBaseTest, IssuerValidator)
{
auto const spec = RpcSpec{{"issuer", IssuerValidator}};
auto passingInput = json::parse(R"({ "issuer": "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn"})");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "issuer": 256})");
auto err = spec.validate(failingInput);
auto err = spec.process(failingInput);
ASSERT_FALSE(err);
ASSERT_EQ(err.error().message, "issuerNotString");
failingInput = json::parse(fmt::format(R"({{ "issuer": "{}"}})", toBase58(ripple::noAccount())));
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
}
@@ -476,18 +480,18 @@ TEST_F(RPCBaseTest, SubscribeStreamValidator)
"book_changes"
]
})");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "streams": 256})");
auto err = spec.validate(failingInput);
auto err = spec.process(failingInput);
ASSERT_FALSE(err);
failingInput = json::parse(R"({ "streams": ["test"]})");
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
failingInput = json::parse(R"({ "streams": [123]})");
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
}
@@ -496,17 +500,35 @@ TEST_F(RPCBaseTest, SubscribeAccountsValidator)
auto const spec = RpcSpec{{"accounts", SubscribeAccountsValidator}};
auto passingInput =
json::parse(R"({ "accounts": ["rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn","rLEsXccBGNR3UPuPu2hUXPjziKC3qKSBun"]})");
ASSERT_TRUE(spec.validate(passingInput));
ASSERT_TRUE(spec.process(passingInput));
auto failingInput = json::parse(R"({ "accounts": 256})");
auto err = spec.validate(failingInput);
auto err = spec.process(failingInput);
ASSERT_FALSE(err);
failingInput = json::parse(R"({ "accounts": ["test"]})");
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
failingInput = json::parse(R"({ "accounts": [123]})");
err = spec.validate(failingInput);
err = spec.process(failingInput);
ASSERT_FALSE(err);
}
TEST_F(RPCBaseTest, ClampingModifier)
{
auto spec = RpcSpec{
{"amount", Clamp<uint32_t>{10u, 20u}},
};
auto passingInput = json::parse(R"({ "amount": 15 })");
ASSERT_TRUE(spec.process(passingInput));
auto passingInput2 = json::parse(R"({ "amount": 5 })");
ASSERT_TRUE(spec.process(passingInput2));
ASSERT_EQ(passingInput2.at("amount").as_uint64(), 10u); // clamped
auto passingInput3 = json::parse(R"({ "amount": 25 })");
ASSERT_TRUE(spec.process(passingInput3));
ASSERT_EQ(passingInput3.at("amount").as_uint64(), 20u); // clamped
}