def test_using_too_many_field(self):
from asobibi import ConstructionError
from asobibi import schema
Schema = schema("Schema", [("val0", {}), ("val1", {})])
with pytest.raises(ConstructionError) as e:
e.expected_regexp = "too many"
self._getTarget()("Validator", [((Schema.val0, Schema.val1), lambda k, val0: True)])
def test_failure2(self):
schema = self._getComplexSchema()
target = schema({"person":
{"first_name": "first-name"},
"address":
{"prefecture": "tokyo"}})
assert target.validate() is not True
def test_it(self):
from asobibi.exceptions import ValidationError
from asobibi.translations import SystemMessage, DisplayMessage
from asobibi.construct import ErrorList
SystemMessage("unicode", fmt="{value} is not strict unicode.", mapping={"value": "----"})
DisplayMessage("unicode", fmt=u"入力してください {field}", mapping={"field": "----"})
def strict_unicode(name, x):
if x is None or x == "":
raise ValidationError({"name": "unicode", "field": name, "value": x})
from asobibi import schema, field
StrictUnicode = field(converters=[strict_unicode])
Person = schema("Person", [StrictUnicode("first_name"), StrictUnicode("last_name")])
person = Person()
self.assertFalse(person.validate())
self.assertEquals(str(person.errors),
str(ErrorList({'first_name': ['first_name is Missing.'],
'last_name': ['last_name is Missing.']})))
self.assertEquals(unicode(person.errors),
unicode(ErrorList({'first_name': [u'first_name がみつかりません'],
'last_name': [u'last_name がみつかりません']})))
person = Person(first_name="test", last_name="")
self.assertFalse(person.validate())
self.assertEquals(str(person.errors),
str(ErrorList({'last_name': [' is not strict unicode.']})))
self.assertEquals(unicode(person.errors),
unicode(ErrorList({"last_name": [u"入力してください last_name"]})))
def _get_schema(self):
from asobibi import schema
from asobibi import Op, Int
def positive(k, x):
assert x >= 0
return x
return schema("Point", [("x", {Op.converters: [Int]}),
("y", {Op.converters: [Int, positive]}), ])
def test_it(self):
schema = self._getTarget()
Schema = schema("Schema", [("a", {}), ("b", {}), ("c", {}), ("d", {})])
complete = Schema(a=1)
assert complete.validate() is not True
partial = Schema.partial(a=1)
assert partial.validate() is True
assert dict(partial.result) == {"a": 1}
def _getComplexSchema(self):
from asobibi import schema
from asobibi import Op, Unicode, as_converter
def capitalize(k, string):
return u"".join(x.capitalize() for x in string.split("-"))
Address = schema("Address",
[("prefecture", {Op.converters: [Unicode, capitalize]}),
("city", {Op.converters: [Unicode, capitalize]}),
("address_1", {}),
("address_2", {Op.required: False, Op.initial: None}),
])
Person = schema("Person",
[("first_name", {Op.converters: [Unicode, capitalize]}),
("last_name", {Op.converters: [Unicode, capitalize]})])
Account = schema("Account",
[("person", {Op.converters: [as_converter(Person)]}),
("address", {Op.converters: [as_converter(Address)]})])
return Account
def _get_A(self):
from asobibi import schema
from asobibi import Op, Unicode, as_converter
Pair = schema("Pair", [("left", {Op.converters: [Unicode, lambda k, x: x.capitalize()]}),
("right", {Op.converters: [Unicode, lambda k, x: x.capitalize()]}),
])
E = schema("E", [("f", {Op.converters: [as_converter(Pair)]})])
D = schema("D", [("e", {Op.converters: [as_converter(E)]})])
C = schema("C", [("d", {Op.converters: [as_converter(D)]})])
B = schema("B", [("c", {Op.converters: [as_converter(C)]})])
A = schema("A", [("b", {Op.converters: [as_converter(B)]})])
return A
def test_it(self):
schema = self._getComplexSchema()
target = schema({"person":
{"first_name": "first-name",
"last_name": "last-name", },
"address":
{"prefecture": "tokyo",
"city": "chiyoda-ku",
"address_1": "chiyoda 1-1",
}
})
assert target.validate() is True
assert target.result ==\
{"person":
{"first_name": "FirstName",
"last_name": "LastName", },
"address":
{"prefecture": "Tokyo",
"city": "ChiyodaKu",
"address_1": "chiyoda 1-1",
"address_2": None}
}
def test_failure(self):
schema = self._getComplexSchema()
target = schema()
assert target.validate() is not True
def _get_schema(self):
from asobibi import schema
return schema("Schema", [("val", {})])
raise ValidationError(params)
return x
@c.validation_from_condition
def not_empty(x):
return x != ""
Unicode = field(converters=[c.Unicode, not_empty])
# schema definition
Submit = schema(
"Submit",
(Unicode("mail", initial="sample@mail", converters=[tiny_email]),
Unicode("password"),
Unicode("confirm")
))
submit = Submit(mail="foo", password="******", confirm="@")
assert submit.validate() == False
submit = Submit(mail="*****@*****.**", password="******", confirm="@")
assert submit.validate()
assert submit.result["mail"] == "*****@*****.**"
assert submit.password == "@"
assert submit.confirm == "@"
# validator definition
