Example #1
0
def test_parse_schema():
    hello = {"hello": "safestr&required"}
    sche_inputs = {
        "get": {"name": "name&default='world'"},
        "post_login": {
            "name": "name&default='world'",
            "password": "******"
        }
    }
    sche_outputs = {
        "get": hello,
        "post_login": hello
    }

    class Hello(Resource):

        schema_inputs = sche_inputs
        schema_outputs = sche_outputs
        output_types = [Flask]

        def get(self, name):
            pass

        def post_login(self, name, password):
            pass

    app = Flask(__name__)
    app.debug = True
    api = Api(app)
    api.add_resource(Hello)

    assert Hello.schema_inputs == validater.parse(sche_inputs)
    assert Hello.schema_outputs == validater.parse(sche_outputs)
    assert Hello.output_types == [Flask]
Example #2
0
def test_custom_validaters():
    assert "year" in my_validaters
    assert "list" in my_validaters
    assert "abs" in my_validaters

    # parse schema with custom_validaters
    parse([{"year": "year&required"}], my_validaters)

    data = {
        'year': ['2016', '1984'],
        'list': [[], [None], [123, 456]],
        'abs': [1, -1, 0, -100]
    }
    expect = {
        'year': ['2016', '1984'],
        'list': [[], [None], [123, 456]],
        'abs': [1, 1, 0, 100]
    }
    for sche, objs in data.items():
        schema = parse(sche, my_validaters)
        for i, obj in enumerate(objs):
            err, val = validate(obj, schema)
            assert not err
            assert val == expect[sche][i]

    with pytest.raises(Exception):
        sche = parse('abs&required&debug', my_validaters)
        validate(object(), sche)

    remove_validater("year", my_validaters)
    remove_validater("list", my_validaters)
    remove_validater("abs", my_validaters)
    assert "year" not in my_validaters
    assert "list" not in my_validaters
    assert "abs" not in my_validaters
Example #3
0
def test_date():
    dt = datetime.datetime(2016, 1, 1)
    d = datetime.datetime(2016, 1, 1).date()
    s = "2016-01-01"
    err, val = validate(d, parse("date&output"))
    assert not err
    assert val == s
    err, val = validate(dt, parse("date&output"))
    assert not err
    assert val == s
    err, val = validate(s, parse("date&output"))
    assert not err
    assert val == s

    err, val = validate(d, parse("date&input"))
    assert not err
    assert val == d
    err, val = validate(dt, parse("date&input"))
    assert not err
    assert val == d
    err, val = validate(s, parse("date&input"))
    assert not err
    assert val == d

    err, val = validate(d, parse("date"))
    assert not err
    assert val == s
    err, val = validate(dt, parse("date"))
    assert not err
    assert val == s
    err, val = validate(s, parse("date"))
    assert not err
    assert val == d
Example #4
0
def test_schema_will_not_modified():
    sche = {'data': ("int&required", "input a number")}
    origin = copy.deepcopy(sche)
    parsed = parse(sche)
    assert sche == origin
    assert parsed != origin

    sche = [("int&required", "input a number")]
    origin = copy.deepcopy(sche)
    parsed = parse(sche)
    assert sche == origin
    assert parsed != origin
Example #5
0
def test_validate_schema_callable_default():
    import random
    num = random.randint(0, 1)
    sche = parse({'validater': 'int', 'args': (0, 1), 'default': lambda: num})
    err, val = validate(None, sche)
    assert not err
    assert val == num
Example #6
0
def _parse_schema(schema):
    for action, sche in schema.items():
        if sche is not None:
            try:
                schema[action] = validater.parse(sche)
            except Exception as ex:
                ex.args += (action,)
                raise
Example #7
0
def test_validate_deep_schema():
    sche = parse({"user": {'userid': 'int&required'}})
    err, val = validate({"user": {"userid": "123"}}, sche)
    assert not err
    assert val == {"user": {"userid": 123}}

    err, val = validate({"user": {"userid": None}}, sche)
    assert err and "required" in dict(err)["user.userid"]
    assert val == {"user": {"userid": None}}
Example #8
0
def test_validate_single_schema():
    sche = parse('int&required')
    err, val = validate('123', sche)
    assert not err
    assert val == 123
    err, val = validate(None, sche)
    assert err and 'required' in dict(err)['']
    assert val is None
    err, val = validate('abc', sche)
    assert err and 'int' in dict(err)['']
    assert val is None
Example #9
0
def test_validate_empty_value():
    # empty value is not always None, depends on validater
    # string type's empty value is ""
    err, val = validate(None, parse('str'))
    assert not err
    assert val == str("")

    err, val = validate(None, parse('unicode'))
    assert not err
    assert val == ""

    err, val = validate(None, parse('url'))
    assert not err
    assert val == ""

    # treat empty string as None
    err, val = validate(str(''), parse('str&required'))
    assert err and err == [('', 'required')]
    assert val == str("")

    err, val = validate('', parse('unicode&required'))
    assert err and err == [('', 'required')]
    assert val == ""

    err, val = validate('', parse('url&required'))
    assert err and err == [('', 'required')]
    assert val == ""
Example #10
0
def test_validate_custom_types():
    class User(object):

        def __init__(self, userid):
            self.userid = userid

    sche = parse({
        'userid': "int&required",
        'friends': [{'userid': "int&required"}]})
    jack, f1, f2 = User(0), User(1), User(2)
    jack.friends = [f1, f2]
    err, val = validate(jack, sche, proxy_types=[User])
    assert not err
    assert val == {'userid': 0,
                   'friends': [{'userid': 1}, {'userid': 2}]}
Example #11
0
def test_validate_simple_schema_has_default_value():
    sche = parse({'userid': 'int&required&default=0'})
    err, val = validate({'userid': None}, sche)
    assert not err
    assert val == {'userid': 0}
    err, val = validate({}, sche)
    assert not err
    assert val == {'userid': 0}

    sche = parse({'userid': 'int&default=0'})
    err, val = validate({'userid': None}, sche)
    assert not err
    assert val == {'userid': 0}
    err, val = validate({}, sche)
    assert not err
    assert val == {'userid': 0}

    sche = parse({'userid': 'int&default=None'})
    err, val = validate({'userid': None}, sche)
    assert not err
    assert val == {'userid': None}
    err, val = validate({}, sche)
    assert not err
    assert val == {'userid': None}
Example #12
0
def test_reuse_schema_snippet():
    snippet = {"name": "str"}
    schema = {
        "user1": snippet,
        "user2": snippet,
    }
    sche = parse(schema)
    assert sche['user1']['name'] == parse("str")
    assert sche['user2']['name'] == parse("str")
    # parse a parsed schema shouldn't cause exception
    assert parse(parse(schema)) == parse(schema)
Example #13
0
def test_validate_simple_schema():
    sche = parse({'userid': 'int&required'})
    err, val = validate({'userid': '123'}, sche)
    assert not err
    assert val['userid'] == 123

    err, val = validate({'userid': None}, sche)
    assert err and 'required' in dict(err)['userid']
    assert val == {'userid': None}

    err, val = validate({}, sche)
    assert err and 'required' in dict(err)['userid']
    assert val == {'userid': None}

    err, val = validate(None, sche)
    assert err and 'must be dict' in dict(err)['']
    assert val == {}
Example #14
0
def test_validate_list_schema():
    sche = parse({'userid': ['int&required']})
    err, val = validate({'userid': []}, sche)
    assert not err
    assert val == {'userid': []}

    err, val = validate({'userid': ['123', '456']}, sche)
    assert not err
    assert val == {'userid': [123, 456]}

    err, val = validate({'userid': ['x123', 'x456']}, sche)
    assert err and set(['userid[0]', 'userid[1]']) == set(dict(err))
    assert val == {'userid': [None, None]}

    err, val = validate({}, sche)
    assert err and 'must be list' in dict(err)['userid']
    assert val == {'userid': []}

    err, val = validate({'userid': '123'}, sche)
    assert err and 'must be list' in dict(err)['userid']
    assert val == {'userid': []}
Example #15
0
def test_datetime():
    d = datetime.datetime(2016, 1, 1)
    s = "2016-01-01T00:00:00.000000Z"
    err, val = validate(d, parse("datetime&output"))
    assert not err
    assert val == s
    err, val = validate(s, parse("datetime&output"))
    assert not err
    assert val == s

    err, val = validate(d, parse("datetime&input"))
    assert not err
    assert val == d
    err, val = validate(s, parse("datetime&input"))
    assert not err
    assert val == d

    err, val = validate(d, parse("datetime"))
    assert not err
    assert val == s
    err, val = validate(s, parse("datetime"))
    assert not err
    assert val == d
Example #16
0
def test_validate_err():
    for sche, v in data_err.items():
        sche = parse(sche + "&required")
        for x in v:
            err, val = validate(x, sche)
            assert err, "%s: %s" % (sche, x)
Example #17
0
def test_parse_error():
    with pytest.raises(SchemaError):
        parse({'vali': 'int', 'required': True})
    with pytest.raises(SchemaError):
        parse("&required")
    with pytest.raises(SchemaError):
        parse("int&")
    with pytest.raises(SchemaError):
        parse("_unknown_validater")
    with pytest.raises(SchemaError):
        parse("int(abc)")
    with pytest.raises(SchemaError):
        parse("int&default=abc")
    with pytest.raises(SchemaError):
        parse("int&required=true")
    # note: sche is a tuple
    sche = {"userid": "int&required=true"},
    with pytest.raises(SchemaError):
        parse(sche)
Example #18
0
def test_parse():

    snippet = parse_snippet("int&required")
    sche = parse({'userid': "int&required"})
    assert sche['userid'].data == snippet

    sche = parse({'userid': ["int&required"]})
    assert sche['userid'][0].data == snippet

    sche = parse({'userid': {'userid': "int&required"}})
    assert sche['userid']['userid'].data == snippet

    sche = parse({'userid': [{'userid': "int&required"}]})
    assert sche['userid'][0]['userid'].data == snippet

    sche = parse({'email': ("email&required", "邮箱地址")})
    assert sche['email'].data == parse_snippet(("email&required", "邮箱地址"))

    sche = parse([{'userid': "int&required"}])
    assert sche[0]['userid'].data == snippet

    sche = parse("int&required")
    assert sche.data == snippet

    sche = parse(["int&required"])
    assert sche[0].data == snippet

    sche = parse([[["int&required"]]])
    assert sche[0][0][0].data == snippet

    sche = parse({'validater': 'int'})
    assert sche.data == {'validater': 'int'}

    sche = parse([{'validater': 'int'}])
    assert sche[0].data == {'validater': 'int'}

    sche = parse({'userid': {'validater': 'int'}})
    assert sche['userid'].data == {'validater': 'int'}
Example #19
0
def test_validate_deep_list_schema_error():
    sche = parse([{'nums': ['int']}])
    err, val = validate([{'nums': ['x123', 'x456']}, {'nums': 'x'}, 'x'], sche)
    expect = set(['[0].nums[0]', '[0].nums[1]', '[1].nums', '[2]'])
    assert expect == set(dict(err))