Validate Rules¶
Control:
Rule |
Desc |
---|---|
type |
Direct type |
required |
Param is required |
default |
Default value if param is empty |
dest |
Direct key for result |
required_with |
Required with other key |
location |
Which location to read value for request |
skip |
Skip all of the filters |
Other:
Rule |
Desc |
---|---|
json |
Json deserialize value |
callback |
Custom callback function |
Fields:
Rule |
Desc |
---|---|
eq_key |
Field equal to another field |
neq_key |
Field not equal to another field |
gt_key |
Field greater than another field |
gte_key |
Field greater than or equal to another field |
lt_key |
Field less than another field |
lte_key |
Field less than or equal to another field |
Network:
Rule |
Desc |
---|---|
ipv4 |
Internet protocol address IPv4 |
ipv6 |
Internet protocol address IPv6 |
mac |
Media access control address MAC |
url_encode |
Url encode with urllib.parse.quote |
url_decode |
Url decode with urllib.parse.unquote |
Strings:
Rule |
Desc |
---|---|
len |
Content length for string or array |
trim |
Trim space characters |
reg |
Regex expression |
contains |
Contains |
contains_any |
Contains any items |
excludes |
Excludes |
startswith |
Starts with |
not_startswith |
Not start with |
not_endswith |
Not end with |
endswith |
Ends with |
lower |
Lowercase |
upper |
Uppercase |
Split |
Split string with special character |
Format:
Rule |
Desc |
---|---|
fmt |
date or datetime format |
latitude |
Latitude |
longitude |
Longitude |
structure |
Describe substructure for array or dict |
multi |
Value is array |
deep |
Find value from substructure |
enum |
Enum value |
alpha |
Alpha only |
alphanum |
Alpha or numeric |
numeric |
Numeric |
number |
Number only |
Email address for RFC5322 |
Comparison:
Rule |
Desc |
---|---|
eq |
Equals |
neq |
Not equal |
gt |
Greater than |
gte |
Greater than or equal |
lt |
Less than |
lte |
Less than or equal |
location¶
By default, pre-request try to parse values form flask.Request.values and flask.Request.json. Use location to specify location to get values. current support [“args”, “form”, “values”, “headers”, “cookies”, “json”]
params = {
"Access-Token": Rule(location="headers"),
"userId": Rule(location=["cookies", "headers", "args"])
}
deep¶
By default, pre-request can parse value from complex structure. we can use deep=False to turn off this feature, pre-request will parse values from top level.
params = {
"userInfo": {
"userId": Rule(type=int, required=False),
"socialInfo": {
"gender": Rule(type=int, enum=[1, 2], default=1),
"age": Rule(type=int, gte=18, lt=80),
"country": Rule(required=True, deep=False)
}
}
}
type¶
pre-request try to convert value to special type.
params = {
"userId": Rule(type=int)
}
skip¶
pre-request will skip validate value at this field. we will put origin value in the result structure.
params = {
"userName": Rule(skip=True)
}
multi¶
if you set multi=True, we will check every items in array. otherwise it will be regarded as a whole。
params = {
"userIds": Rule(type=int, multi=True)
}
structure¶
You can use structure field to define sub structure in array. This field will be only valid in multi=True.
params = {
"friends": Rule(multi=True, structure={
"userId": Rule(type=int, required=True),
"userName": Rule(type=str, required=True)
})
}
required¶
pre-request validate the value is not None or user do not input this value. Specially, if user don’t input this value and skip=True, pre-request will fill it with missing type.
params = {
"profile": Rule(required=False)
}
required_with¶
The field under validation must be present and not empty only if any of the other specified fields are present.
params = {
"nickName": Rule(required=False),
"profile": Rule(required=False, required_with="nickName")
}
default¶
pre-request will fill the default value into the field only if the field is not required and current value is None
params = {
"nickName": Rule(required=False, default="张三")
}
split¶
pre-request will split origin string value with special char and the check rule will filter to every value in the result array。
params = {
"userId": Rule(int, split=",")
}
trim¶
pre-request will try to remove the space characters at the beginning and end of the string.
params = {
"nickName": Rule(trim=True)
}
enum¶
Ensure that the parameters entered by the user are within the specified specific value range.
params = {
"gender": Rule(direct_type=int, enum=[1, 2])
}
reg¶
Use regular expressions to verity that the user input string meets the requirements.
params = {
"tradeDate": Rule(reg=r"^[1-9]\d{3}-(0[1-9]|1[0-2])-(0[1-9]|[1-2][0-9]|3[0-1])$")
}
contains¶
Ensure that the field entered by the user contain all of the special value.
params = {
"content": Rule(contains=["你好", "再见"])
}
contains_any¶
Ensure that the field entered by the user contain any of the special value.
params = {
"content": Rule(contains_any=["你好", "再见"])
}
excludes¶
Ensure that the field entered by the user can not contain any of special value.
params = {
"content": Rule(excludes=["张三", "李四"])
}
startswith¶
Ensure that the input string value must be start with special substring
params = {
"nickName": Rule(startswith="CN")
}
not_endswith¶
Ensure that the input string value must be not start with special substring
params = {
"nickName": Rule(not_startswith="USA")
}
endswith¶
Ensure that the input string value must be end with special substring
params = {
"email": Rule(endswith="@eastwu.cn")
}
not_endswith¶
Ensure that the input string value must be not end with special substring
params = {
"email": Rule(not_endswith="@eastwu.cn")
}
lower¶
pre-request will convert all characters in the string to lowercase style.
params = {
"nickName": Rule(lower=True)
}
upper¶
pre-request will convert all characters in the string to uppercase style.
params = {
"country": Rule(upper=True)
}
ipv4/ipv6¶
Ensure that the field entered by the user conform to the ipv4/6 format.
params = {
"ip4": Rule(ipv4=True)
"ip6": Rule(ipv6=True)
}
mac¶
Ensure that the field entered by the user conform to the MAC address format.
params = {
"macAddress": Rule(mac=True)
}
url_encode¶
Encode url by function urllib.parse.quote. This rule is only valid for parameters of type str. You can select the encoding type through the encoding parameter.
params = {
"url": Rule(type=str, url_encode=True, encoding="GB2312")
}
url_decode¶
Decode url by function urllib.parse.unquote. This rule is only valid for parameters of type str. You can select the encoding type through the encoding parameter.
params = {
"url": Rule(type=str, url_decode=True, encoding="GB2312")
}
alpha¶
Check that a string can oly consist of letters.
params = {
"p": Rule(type=str, alpha=True)
}
alphanum¶
Check that a string can oly consist of letters or numeric.
params = {
"p": Rule(type=str, alphanum=True)
}
numeric¶
Check that a string can oly consist of numeric.
params = {
"p": Rule(type=str, numeric=True)
}
number¶
Check that a string can oly consist of number.
params = {
"p": Rule(type=str, number=True)
}
email¶
Check that a string is valid email address.
params = {
"p": Rule(type=str, email=True)
}
fmt¶
Provides the style when the string is converted to datetime or date type. This is valid only on type=datetime.datetime
params = {
"birthday": Rule(type=datetime.datetime, fmt="%Y-%m-%d"),
"otherDate": Rule(type=datetime.date, fmt="%Y-%m-%d")
}
latitude / longitude¶
Ensure that the field entered by the user conform to the latitude/longitude format.
params = {
"latitude": Rule(latitude=True),
"longitude": Rule(longitude=True)
}
eq / eq_key¶
Used to check whether the user input parameter is equal to another value or another parameter.
params = {
"userId": Rule(eq=10086),
"userId2": Rule(eq_key="userId")
}
neq / neq_key¶
Used to check whether the user input parameter is not equal to another value or another parameter.
params = {
"userId": Rule(neq=0),
"forbidUserId": Rule(neq_key="userId")
}
gt / gt_key¶
Used to check whether the user input parameter is great than another value or another parameter.
params = {
"kidAge": Rule(type=int, gt=0),
"fatherAge": Rule(type=int, gt_key="kidAge")
}
gte / gte_key¶
Used to check whether the user input parameter is great than or equal to another value or another parameter.
params = {
"kidAge": Rule(type=int, gte=0),
"brotherAge": Rule(type=int, gte_key="kidAge")
}
lt / lt_key¶
Used to check whether the user input parameter is less than another value or another parameter.
params = {
"fatherAge": Rule(type=int, lt=100),
"kidAge": Rule(type=int, lt_key="fatherAge")
}
lte / lte_key¶
Used to check whether the user input parameter is less than or equal to another value or another parameter.
params = {
"fatherAge": Rule(type=int, lte=100),
"kidAge": Rule(type=int, lte_key="fatherAge")
}
dest¶
We will convert the key of the parameter to another value specified.
params = {
"userId": Rule(type=int, dest="user_id")
}
json¶
We will try to use the json.loads method to parse the value of the parameter to convert it into a list or dict type.
callback¶
If the filters we provide cannot meet your needs, you can pass in the parse function you defied through the callback method.
def hand(value):
if value <= 10:
raise ParamsValueError("'userId' must be greater than 10")
return value + 100
params = {
"userId": Rule(type=int, callback=hand)
}