def test_03_validator_error_msg():
request = {"age": 100}
rule = {"age": [R.Integer, R.Between(18, 90)]}
val = Validator(request, rule)
result = val.validate()
errors = val.get_error_messages()
assert not result
assert "age" in errors.keys()
assert "Between" in errors["age"].keys()
request = {"age": 28, "name": "John", "surname": "Krasinski"}
rule = {
"age": [R.Integer, R.Between(18, 50)],
"name": [R.Required()],
"surname": [R.Required(), R.Mail()],
}
val = Validator(request, rule)
result = val.validate()
errors = val.get_error_messages()
# Test General
assert not result
assert len(errors) == 1
assert "surname" in errors.keys()
# Test Error 1
mail_err = errors["surname"]
assert len(mail_err) == 1
assert "Mail" in mail_err.keys()
def test_08_validate_error_msg():
request = {"age": 100}
rule = {"age": [R.Integer, R.Between(18, 90)]}
result, validated_data, errors = validate(request, rule, return_info=True)
assert not result
assert "age" in errors.keys()
assert "Between" in errors["age"].keys()
request = {"age": 28, "name": "John", "surname": "Krasinski"}
rule = {
"age": [R.Integer, R.Between(18, 50)],
"name": [R.Required()],
"surname": [R.Required(), R.Mail()],
}
result, validated_data, errors = validate(request, rule, return_info=True)
# Test General
assert not result
assert len(errors) == 1
assert "surname" in errors.keys()
# Test Error 1
mail_err = errors["surname"]
assert len(mail_err) == 1
assert "Mail" in mail_err.keys()
def test_01_validator_simple():
request = {"age": 23}
rule = {"age": [R.Integer, R.Min(18)]}
result = Validator(request, rule).validate()
assert result
request = {"age": 13}
rule = {"age": [R.Integer, R.Min(18)]}
result = Validator(request, rule).validate()
assert not result
request = {"age": 13}
rule = {"age": [R.Integer, R.Max(18)]}
result = Validator(request, rule).validate()
assert result
request = {"name": "Jon"}
rule = {"name": [R.Required()]}
result = Validator(request, rule).validate()
assert result
request = {"name": ""}
rule = {"name": [R.Required()]}
result = Validator(request, rule).validate()
assert not result
def test_05_validator_empty():
# Checking for empty rules to work
request = {
"age": 53,
"name": "Peter",
"surname": "Griffin",
"profession": "brewer",
"mail": "*****@*****.**",
}
rule = {
"age": "",
"name": [""],
"surname": [],
"profession": [R.Required],
"mail": [R.Required(), R.Mail()],
}
val = Validator(request, rule)
result = val.validate()
assert result
# Testing if other rules still work with empty ones
request["mail"] = "pg.com"
val = Validator(request, rule)
result = val.validate()
assert not result
def test_10_validate_many():
requests = [{"age": 19}, {"age": 20}, {"age": 21}, {"age": 22}]
rule = {"age": [R.Integer, R.Min(18)]}
result = validate_many(requests, rule)
assert result
requests = [{"age": 11}, {"age": 12}, {"age": 13}, {"age": 14}]
rule = {"age": [R.Integer, R.Min(18)]}
result = validate_many(requests, rule)
assert not result
requests = [{"age": 11}, {"age": 12}, {"age": 13}, {"age": 14}]
rule = {"age": [R.Integer, R.Max(18)]}
result = validate_many(requests, rule)
assert result
requests = [{"age": 21}, {"age": 22}, {"age": 23}, {"age": 24}]
rule = {"age": [R.Integer, R.Max(18)]}
result = validate_many(requests, rule)
assert not result
requests = [{"name": "John"}, {"name": "Rob"}, {"name": "Greg"}, {"name": "Tom"}]
rule = {"name": "required|min:3"}
result = validate_many(requests, rule)
assert result
requests = [{"name": "John"}, {"name": ""}, {"name": ""}, {"name": "Tom"}]
rule = {"name": [R.Required()]}
result = validate_many(requests, rule)
assert not result
def test_parser_mixed_01():
# checking abstract university student object rules
rules = {
"name": R.Required(),
"suranme": R.Required,
"university_mail": [R.Required, "mail"],
"faculty_name": [R.Required],
"current_semester": ["required", R.Min(1)],
"credits_amount": [R.Required, R.Between(0, 240)],
"credits_current_semester": [R.Min(0), R.Max(75)],
"debt": [R.Max(0)],
}
parsed_rules_goal = {
"name": [R.Required()],
"suranme": [R.Required()],
"university_mail": [R.Required(), R.Mail()],
"faculty_name": [R.Required()],
"current_semester": [R.Required(), R.Min(1)],
"credits_amount": [R.Required(), R.Between(0, 240)],
"credits_current_semester": [R.Min(0), R.Max(75)],
"debt": [R.Max(0)],
}
parsed_rules = Parser(rules).parse()
assert instances_checker(parsed_rules, parsed_rules_goal)
assert parsed_rules["current_semester"][1].min == 1
assert parsed_rules["credits_amount"][1].min == 0
assert parsed_rules["credits_amount"][1].max == 240
assert parsed_rules["credits_current_semester"][0].min == 0
assert parsed_rules["credits_current_semester"][1].max == 75
assert parsed_rules["debt"][0].max == 0
def test_04_validator_error_msg():
request = {
"age": 53,
"name": "Peter",
"surname": "Griffin",
"profession": "",
"mail": "petergriffin.com",
}
rule = {
"age": [R.Integer, R.Between(18, 50),
R.Required()],
"name": [R.Required()],
"surname": [R.Required()],
"profession": [R.Required, R.Mail],
"mail": [R.Required(), R.Mail()],
}
val = Validator(request, rule)
result = val.validate()
errors = val.get_error_messages()
# Test General
assert not result
assert len(errors) == 3
assert "age" in errors
assert "profession" in errors
assert "mail" in errors
# Test Error 1
age_err = errors["age"]
assert len(age_err) == 1
assert "Between" in age_err
# Test Error 2
profession_err = errors["profession"]
assert len(profession_err) == 2
assert "Required" in profession_err
assert "Mail" in profession_err
# Test Error 3
mail_err = errors["mail"]
assert len(mail_err) == 1
assert "Mail" in mail_err
def test_07_validate_simple():
request = {"age": 23}
rule = {"age": [R.Integer, R.Min(18), R.Max(30)]}
result = validate(request, rule)
assert result
request = {"age": 33}
rule = {"age": [R.Integer, R.Min(18), R.Max(30)]}
result = validate(request, rule)
assert not result
request = {"age": 23, "name": "Jon"}
rule = {"age": [R.Integer, R.Min(18)], "name": [R.Required()]}
result = validate(request, rule)
assert result
request = {"age": 23, "name": ""}
rule = {"age": [R.Integer, R.Min(18), R.Max(30)], "name": [R.Required()]}
result = validate(request, rule)
assert not result
def test_bad_03():
# Bad R class
with pytest.raises(AttributeError):
target_str = [R.Required(), R.Min(18), R.anyclass(30)]
Translator(target_str).translate()
# Random class
with pytest.raises(exc.UnknownTranslatorArgError):
target_str = [R.Required(), R.Min(18), ConnectionError(30)]
Translator(target_str).translate()
# Random texts
with pytest.raises(exc.UnknownTranslatorArgError):
target_str = [123456789, "random text", "bad test", 5.5]
Translator(target_str).translate()
# Bad R class
with pytest.raises(AttributeError):
target_str = [R.Requireds()]
Translator(target_str).translate()
def test_09_validate_error_msg():
request = {
"age": 53,
"name": "Peter",
"surname": "Griffin",
"profession": "",
"mail": "petergriffin.com",
}
rule = {
"age": [R.Integer, R.Between(18, 50),
R.Required()],
"name": [R.Required()],
"surname": [R.Required()],
"profession": [R.Required, R.Mail],
"mail": [R.Required(), R.Mail()],
}
result, validated_data, errors = validate(request, rule, return_info=True)
# Test General
assert not result
assert len(errors) == 3
assert "age" in errors
assert "profession" in errors
assert "mail" in errors
# Test Error 1
age_err = errors["age"]
assert len(age_err) == 1
assert "Between" in age_err
# Test Error 2
profession_err = errors["profession"]
assert len(profession_err) == 2
assert "Required" in profession_err
assert "Mail" in profession_err
# Test Error 3
mail_err = errors["mail"]
assert len(mail_err) == 1
assert "Mail" in mail_err
def test_11_validate_many_errors_msg():
requests = [{"age": 11}, {"age": 12}, {"age": 13}, {"age": 14}]
rule = {"age": [R.Integer, R.Min(18)]}
result, _, errors = validate_many(requests, rule, True)
assert not result
assert 4 == len(errors)
assert "age" in errors[0]
assert "age" in errors[1]
assert "age" in errors[2]
assert "age" in errors[3]
assert "Min" in errors[0]["age"]
assert "Min" in errors[1]["age"]
assert "Min" in errors[2]["age"]
assert "Min" in errors[3]["age"]
assert "Got: 11" in errors[0]["age"]["Min"]
assert "Got: 12" in errors[1]["age"]["Min"]
assert "Got: 13" in errors[2]["age"]["Min"]
assert "Got: 14" in errors[3]["age"]["Min"]
requests = [{"age": 11}, {"age": 12}, {"age": 23}, {"age": 14}]
rule = {"age": [R.Integer, R.Max(18)]}
result, _, errors = validate_many(requests, rule, True)
assert not result
assert 4 == len(errors)
assert {} == errors[0]
assert {} == errors[1]
assert {} == errors[3]
assert "age" in errors[2]
assert "Max" in errors[2]["age"]
assert "Got: 23" in errors[2]["age"]["Max"]
requests = [{"name": "Jon"}, {"name": ""}, {"name": ""}, {"name": "Tom"}]
rule = {"name": [R.Required()]}
result, _, errors = validate_many(requests, rule, True)
assert not result
assert 4 == len(errors)
assert {} == errors[0]
assert "name" in errors[1]
assert "name" in errors[2]
assert {} == errors[3]
assert "Required" in errors[1]["name"]
assert "Required" in errors[2]["name"]
assert "Field was empty" in errors[1]["name"]["Required"]
assert "Field was empty" in errors[2]["name"]["Required"]
def test_parser_arrays_simple():
key1, key2 = "credits_amount", "semester"
min_val, max_val = 10, 100
rules = {key1: [f"between:{min_val},{max_val}"], key2: ["required"]}
parsed_rules = Parser(rules).parse()
assert len(parsed_rules) == 2
assert key1 in parsed_rules.keys()
assert key2 in parsed_rules.keys()
assert isinstance(parsed_rules[key1][0], R.Between)
assert isinstance(parsed_rules[key2][0], R.Required)
assert parsed_rules[key1][0].min == min_val
assert parsed_rules[key1][0].max == max_val
rules = {key1: [R.Required, R.Mail], key2: R.Required}
parsed_rules = Parser(rules).parse()
assert isinstance(parsed_rules[key1][0], R.Required)
assert isinstance(parsed_rules[key1][1], R.Mail)
assert isinstance(parsed_rules[key2][0], R.Required)
min_val, max_val = -31, 1928
rules = {
key1: [R.Required(), R.Max(max_val), R.Min(min_val)],
key2: [R.Mail(), R.Between(min_val, max_val)],
}
parsed_rules = Parser(rules).parse()
assert isinstance(parsed_rules[key1][0], R.Required)
assert isinstance(parsed_rules[key1][1], R.Max)
assert isinstance(parsed_rules[key1][2], R.Min)
assert isinstance(parsed_rules[key2][0], R.Mail)
assert isinstance(parsed_rules[key2][1], R.Between)
assert parsed_rules[key1][1].max == max_val
assert parsed_rules[key1][2].min == min_val
assert parsed_rules[key2][1].min == min_val
assert parsed_rules[key2][1].max == max_val
def test_parser_mixed_02():
# checking abstract football match object rules
rules = {
"team1": "required",
"team2": R.Required,
"team1_goals": ["required", "mail"],
"team2_goals": [R.Required],
"offides": [R.Required()],
"fouls": [R.Required()],
"corner_kicks": "required|min:1",
"penalties": ["max:0"],
"yellow_cards": [R.Required(), R.Between(0, 240)],
"red_cards": [R.Min(0), R.Max(75)],
}
parsed_rules_goal = {
"team1": [R.Required()],
"team2": [R.Required()],
"team1_goals": [R.Required(), R.Mail()],
"team2_goals": [R.Required()],
"offides": [R.Required()],
"fouls": [R.Required()],
"corner_kicks": [R.Required(), R.Min(1)],
"penalties": [R.Max(0)],
"yellow_cards": [R.Required(), R.Between(0, 240)],
"red_cards": [R.Min(0), R.Max(75)],
}
parsed_rules = Parser(rules).parse()
assert instances_checker(parsed_rules, parsed_rules_goal)
assert parsed_rules["corner_kicks"][1].min == 1
assert parsed_rules["yellow_cards"][1].min == 0
assert parsed_rules["yellow_cards"][1].max == 240
assert parsed_rules["red_cards"][0].min == 0
assert parsed_rules["red_cards"][1].max == 75
