def test_condition_partial(self):
def max_range(sequence, range_limit):
return max(sequence) - min(sequence) <= range_limit
f = wraps(max_range)(partial(max_range, range_limit=10))
for obj in f, V.Condition(f):
self._testValidation(obj,
valid=[xrange(11), xrange(1000, 1011)],
invalid=[xrange(12), [0, 1, 2, 3, 4, 11]])
def test_ignore_optional_property_errors_parse_parameter(self):
schema = {
"+foo": "number",
"?bar": "boolean",
"?nested": [{
"+baz": "string",
"?zoo": "number",
}]
}
invalid_required = [
{"foo": "2", "bar": True},
]
invalid_optional = [
{"foo": 3, "bar": "nan"},
{"foo": 3.1, "nested": [{"baz": "x", "zoo": "12"}]},
{"foo": 0, "nested": [{"baz": 1, "zoo": 2}]},
]
adapted = [
{"foo": 3},
{"foo": 3.1, "nested": [{"baz": "x"}]},
{"foo": 0},
]
for _ in xrange(3):
self._testValidation(V.parse(schema, ignore_optional_property_errors=False),
invalid=invalid_required + invalid_optional)
self._testValidation(V.parse(schema, ignore_optional_property_errors=True),
invalid=invalid_required,
adapted=zip(invalid_optional, adapted))
def test_parsing_required_properties(self):
get_schema = lambda: {
"foo": V.Nullable("number"),
"?nested": [V.Nullable({
"baz": "string"
})]
}
valid = [{"foo": 3, "nested": [None]}]
missing_properties = [{}, {"foo": 3, "nested": [{}]}]
for _ in xrange(3):
with V.parsing(required_properties=False):
self._testValidation(get_schema(),
valid=valid + missing_properties)
with V.parsing(required_properties=True):
self._testValidation(get_schema(),
valid=valid, invalid=missing_properties)
# gotcha: calling parse() with required_properties=True is not
# equivalent to the above call because the V.Nullable() calls in
# get_schema have already called implicitly parse() without parameters.
if V.Object.REQUIRED_PROPERTIES:
self._testValidation(V.parse(get_schema(), required_properties=True),
invalid=[missing_properties[1]])
else:
self._testValidation(V.parse(get_schema(), required_properties=True),
valid=[missing_properties[1]])
def test_additional_properties_parse_parameter(self):
schema = {"?bar": "boolean", "?nested": [{"?baz": "integer"}]}
values = [{"x1": "yes"}, {"bar": True, "nested": [{"x1": "yes"}]}]
for _ in xrange(3):
self._testValidation(V.parse(schema, additional_properties=True),
valid=values)
self._testValidation(V.parse(schema, additional_properties=False),
invalid=values)
self._testValidation(V.parse(
schema, additional_properties=V.Object.REMOVE),
adapted=[(values[0], {}),
(values[1], {
"bar": True,
"nested": [{}]
})])
self._testValidation(V.parse(schema,
additional_properties="string"),
valid=values,
invalid=[{
"x1": 42
}, {
"bar": True,
"nested": [{
"x1": 42
}]
}])
def test_parsing_required_properties(self):
get_schema = lambda: {
"foo": V.Nullable("number"),
"?nested": [V.Nullable({"baz": "string"})]
}
valid = [{"foo": 3, "nested": [None]}]
missing_properties = [{}, {"foo": 3, "nested": [{}]}]
for _ in xrange(3):
with V.parsing(required_properties=False):
self._testValidation(get_schema(),
valid=valid + missing_properties)
with V.parsing(required_properties=True):
self._testValidation(get_schema(),
valid=valid,
invalid=missing_properties)
# gotcha: calling parse() with required_properties=True is not
# equivalent to the above call because the V.Nullable() calls in
# get_schema have already called implicitly parse() without parameters.
if V.Object.REQUIRED_PROPERTIES:
self._testValidation(V.parse(get_schema(),
required_properties=True),
invalid=[missing_properties[1]])
else:
self._testValidation(V.parse(get_schema(),
required_properties=True),
valid=[missing_properties[1]])
def test_parsing_additional_properties(self):
get_schema = lambda: {
"?bar": "boolean",
"?nested": [V.Nullable({"?baz": "integer"})]
}
values = [{"x1": "yes"}, {"bar": True, "nested": [{"x1": "yes"}]}]
for _ in xrange(3):
with V.parsing(additional_properties=True):
self._testValidation(get_schema(), valid=values)
with V.parsing(additional_properties=False):
self._testValidation(get_schema(), invalid=values)
# gotcha: calling parse() with additional_properties=False is not
# equivalent to the above call because the V.Nullable() calls in
# get_schema have already called implicitly parse() without parameters.
# The 'additional_properties' parameter effectively is applied at
# the top level dict only
self._testValidation(V.parse(get_schema(),
additional_properties=False),
invalid=values[:1],
valid=values[1:])
with V.parsing(additional_properties=V.Object.REMOVE):
self._testValidation(get_schema(),
adapted=[(values[0], {}),
(values[1], {
"bar": True,
"nested": [{}]
})])
# same gotcha as above
self._testValidation(V.parse(
get_schema(), additional_properties=V.Object.REMOVE),
adapted=[(values[0], {}),
(values[1], values[1])])
with V.parsing(additional_properties="string"):
self._testValidation(get_schema(),
valid=values,
invalid=[{
"x1": 42
}, {
"bar": True,
"nested": [{
"x1": 42
}]
}])
# same gotcha as above
self._testValidation(V.parse(get_schema(),
additional_properties="string"),
invalid=[{
"x1": 42
}],
valid=[{
"bar": True,
"nested": [{
"x1": 42
}]
}])
def test_required_properties_parse_parameter(self):
schema = {
"foo": "number",
"?bar": "boolean",
"?nested": [{
"baz": "string"
}]
}
missing_properties = [{}, {"bar": True}, {"foo": 3, "nested": [{}]}]
for _ in xrange(3):
self._testValidation(V.parse(schema, required_properties=True),
invalid=missing_properties)
self._testValidation(V.parse(schema, required_properties=False),
valid=missing_properties)
def test_required_properties_parse_parameter(self):
schema = {
"foo": "number",
"?bar": "boolean",
"?nested": [{
"baz": "string"
}]
}
missing_properties = [{}, {"bar": True}, {"foo": 3, "nested": [{}]}]
for _ in xrange(3):
self._testValidation(V.parse(schema, required_properties=True),
invalid=missing_properties)
self._testValidation(V.parse(schema, required_properties=False),
valid=missing_properties)
def test_parsing_additional_properties(self):
get_schema = lambda: {
"?bar": "boolean",
"?nested": [V.Nullable({
"?baz": "integer"
})]
}
values = [{"x1": "yes"},
{"bar": True, "nested": [{"x1": "yes"}]}]
for _ in xrange(3):
with V.parsing(additional_properties=True):
self._testValidation(get_schema(), valid=values)
with V.parsing(additional_properties=False):
self._testValidation(get_schema(), invalid=values)
# gotcha: calling parse() with additional_properties=False is not
# equivalent to the above call because the V.Nullable() calls in
# get_schema have already called implicitly parse() without parameters.
# The 'additional_properties' parameter effectively is applied at
# the top level dict only
self._testValidation(V.parse(get_schema(), additional_properties=False),
invalid=values[:1], valid=values[1:])
with V.parsing(additional_properties=V.Object.REMOVE):
self._testValidation(get_schema(),
adapted=[(values[0], {}),
(values[1], {"bar": True, "nested": [{}]})])
# same gotcha as above
self._testValidation(V.parse(get_schema(), additional_properties=V.Object.REMOVE),
adapted=[(values[0], {}),
(values[1], values[1])])
with V.parsing(additional_properties="string"):
self._testValidation(get_schema(),
valid=values,
invalid=[{"x1": 42},
{"bar": True, "nested": [{"x1": 42}]}])
# same gotcha as above
self._testValidation(V.parse(get_schema(), additional_properties="string"),
invalid=[{"x1": 42}],
valid=[{"bar": True, "nested": [{"x1": 42}]}])
def test_additional_properties_parse_parameter(self):
schema = {
"?bar": "boolean",
"?nested": [{
"?baz": "integer"
}]
}
values = [{"x1": "yes"},
{"bar": True, "nested": [{"x1": "yes"}]}]
for _ in xrange(3):
self._testValidation(V.parse(schema, additional_properties=True),
valid=values)
self._testValidation(V.parse(schema, additional_properties=False),
invalid=values)
self._testValidation(V.parse(schema, additional_properties=V.Object.REMOVE),
adapted=[(values[0], {}),
(values[1], {"bar": True, "nested": [{}]})])
self._testValidation(V.parse(schema, additional_properties="string"),
valid=values,
invalid=[{"x1": 42},
{"bar": True, "nested": [{"x1": 42}]}])
def test_parsing_ignore_optional_property_errors(self):
get_schema = lambda: V.Nullable({
"+foo": "number",
"?bar": "boolean",
"?nested": [{
"+baz": "string",
"?zoo": "number",
}]
})
invalid_required = [
{"foo": "2", "bar": True},
]
invalid_optional = [
{"foo": 3, "bar": "nan"},
{"foo": 3.1, "nested": [{"baz": "x", "zoo": "12"}]},
{"foo": 0, "nested": [{"baz": 1, "zoo": 2}]},
]
adapted = [
{"foo": 3},
{"foo": 3.1, "nested": [{"baz": "x"}]},
{"foo": 0},
]
for _ in xrange(3):
with V.parsing(ignore_optional_property_errors=False):
self._testValidation(get_schema(),
invalid=invalid_required + invalid_optional)
with V.parsing(ignore_optional_property_errors=True):
self._testValidation(get_schema(),
invalid=invalid_required,
adapted=zip(invalid_optional, adapted))
# gotcha: calling parse() with ignore_optional_property_errors=True
# is not equivalent to the above call because the V.Nullable() calls in
# get_schema have already called implicitly parse() without parameters.
self._testValidation(V.parse(get_schema(), ignore_optional_property_errors=False),
invalid=invalid_required + invalid_optional)
self._testValidation(V.parse(get_schema(), ignore_optional_property_errors=True),
invalid=invalid_required + invalid_optional)
