def test_add_error_root(self):
changed = deepcopy(input_meta)
meta = Meta(changed)
meta.add_error("additional", "changed")
assert meta.get() == {
"err": ["existing", "additional"],
"val": "changed",
"rem": [{
"type": "x"
}],
}
def test_add_error_nested_existing(self):
data = {"field": input_meta}
changed = deepcopy(data)
meta = Meta(changed)
meta.enter("field").add_error("additional", "changed")
assert meta.enter("field").get() == {
"err": ["existing", "additional"],
"val": "changed",
"rem": [{
"type": "x"
}],
}
def test_get_multiple_event_errors(self):
# XXX: Value is only added to the first error, which is usually the
# normalization error.
assert Meta(merged_meta).get_event_errors() == [
{
"type": "existing",
"value": "changed"
},
{
"type": "additional"
},
]
def test_get_missing(self):
assert Meta({}).raw() == {}
assert Meta({}).get() == {}
assert Meta({}).get_errors() == []
def test_stringify_error(self):
meta = Meta()
meta.add_error(ValueError("invalid stuff"), "changed")
assert list(meta.iter_errors()) == [["invalid stuff", {}]]
def test_merge_missing(self):
data = {}
meta = Meta(data)
assert meta.merge(Meta(other_meta)) == other_meta[""]
assert data == other_meta
def test_get_empty(self):
assert Meta({"": {}}).raw() == {"": {}}
assert Meta({"": {}}).get() == {}
assert list(Meta({"": {}}).iter_errors()) == []
assert Meta({"": {}}).get_event_errors() == []
def test_merge_new(self):
meta = Meta()
assert meta.merge(Meta(other_meta)) == other_meta[""]
assert meta.raw() == other_meta
def test_get_missing(self):
assert Meta({}).raw() == {}
assert Meta({}).get() == {}
assert list(Meta({}).iter_errors()) == []
assert Meta({}).get_event_errors() == []
def test_create_nested_missing(self):
data = {}
meta = Meta(data)
assert meta.enter("field").create() == {}
assert data == {"field": {"": {}}}
def test_merge_nested_missing(self):
data = {}
meta = Meta(data)
assert meta.enter("field").merge(Meta(other_meta)) == other_meta[""]
assert data == {"field": other_meta}
def test_merge_root(self):
changed = deepcopy(input_meta)
meta = Meta(changed)
assert meta.merge(Meta(other_meta)) == merged_meta[""]
assert changed == merged_meta
def test_get_nested_missing(self):
data = {}
assert Meta(data).enter("field").raw() == {}
assert Meta(data).enter("field").get() == {}
assert list(Meta(data).enter("field").iter_errors()) == []
assert Meta(data).enter("field").get_event_errors() == []
def test_create_root(self):
changed = deepcopy(input_meta)
meta = Meta(changed)
# should be idempotent
assert meta.create() == input_meta[""]
assert changed == input_meta
def test_merge_empty(self):
data = {"": {}}
meta = Meta(data)
assert meta.merge(Meta(other_meta)) == other_meta[""]
assert data == other_meta
def test_create_empty(self):
data = {"": {}}
meta = Meta(data)
assert meta.create() == {}
assert data == {"": {}}
def test_get_new(self):
assert Meta().raw() == {}
assert Meta().get() == {}
assert list(Meta().iter_errors()) == []
assert Meta().get_event_errors() == []
def test_create_nested_existing(self):
data = {"field": input_meta}
changed = deepcopy(data)
meta = Meta(changed)
assert meta.enter("field").create() == input_meta[""]
assert changed == data
def test_create_new(self):
meta = Meta()
assert meta.create() == {}
assert meta.raw() == {"": {}}
def test_merge_nested_existing(self):
data = {"field": input_meta}
changed = deepcopy(data)
meta = Meta(changed)
assert meta.enter("field").merge(Meta(other_meta)) == merged_meta[""]
assert changed == {"field": merged_meta}
def test_add_error_new(self):
meta = Meta()
meta.add_error("additional", "changed")
assert meta.raw() == {"": {"err": ["additional"], "val": "changed"}}
def test_get_none(self):
assert Meta({"": None}).raw() == {"": None}
assert Meta({"": None}).get() == {}
assert list(Meta({"": None}).iter_errors()) == []
assert Meta({"": None}).get_event_errors() == []
def test_create_missing(self):
data = {}
meta = Meta(data)
assert meta.create() == {}
assert data == {"": {}}
def test_merge_none(self):
data = {"": None}
meta = Meta(data)
assert meta.merge(Meta(other_meta)) == other_meta[""]
assert data == other_meta
def test_add_error_missing(self):
data = {}
meta = Meta(data)
meta.add_error("additional", "changed")
assert data == {"": {"err": ["additional"], "val": "changed"}}
def test_get_none(self):
assert Meta({'': None}).raw() == {'': None}
assert Meta({'': None}).get() == {}
assert Meta({'': None}).get_errors() == []
def test_create_none(self):
data = {"": None}
meta = Meta(data)
assert meta.create() == {}
assert data == {"": {}}
def test_get_nested_index(self):
data = {"0": input_meta}
assert Meta(data).enter(0).raw() == input_meta
assert Meta(data).enter(0).get() == input_meta[""]
assert list(Meta(data).enter(0).iter_errors()) == [["existing", {}]]
def validate_and_default_interface(data, interface, name=None, meta=None,
strip_nones=True, raise_on_invalid=False):
"""
Modify data to conform to named interface's schema.
Takes the object in `data` and checks it against the schema for
`interface`, removing or defaulting any keys that do not pass validation
and adding defaults for any keys that are required by (and have a default
value in) the schema.
Returns whether the resulting modified data is valid against the schema and
a list of any validation errors encountered in processing.
"""
if meta is None:
meta = Meta()
is_valid = True
needs_revalidation = False
errors = []
validator = validator_for_interface(interface)
if validator is None:
return (True, [])
schema = validator.schema
# Strip Nones so we don't have to take null into account for all schemas.
if strip_nones and isinstance(data, dict):
for k in data.keys():
if data[k] is None:
del data[k]
# Values that are missing entirely, but are required and should be defaulted
if 'properties' in schema and 'required' in schema and isinstance(data, dict):
for p in schema['required']:
if p not in data:
if p in schema['properties'] and 'default' in schema['properties'][p]:
default = schema['properties'][p]['default']
data[p] = default() if callable(default) else default
else:
meta.add_error(EventError.MISSING_ATTRIBUTE, data={'name': p})
errors.append({'type': EventError.MISSING_ATTRIBUTE, 'name': p})
validator_errors = list(validator.iter_errors(data))
keyed_errors = [e for e in reversed(validator_errors) if len(e.path)]
if len(validator_errors) > len(keyed_errors):
needs_revalidation = True
# Values that need to be defaulted or deleted because they are not valid.
for key, group in groupby(keyed_errors, lambda e: e.path[0]):
ve = six.next(group)
is_max = ve.validator.startswith('max')
if is_max:
error_type = EventError.VALUE_TOO_LONG
elif key == 'environment':
error_type = EventError.INVALID_ENVIRONMENT
else:
error_type = EventError.INVALID_DATA
meta.enter(key).add_error(error_type, data[key])
errors.append({'type': error_type, 'name': name or key, 'value': data[key]})
if 'default' in ve.schema:
default = ve.schema['default']
data[key] = default() if callable(default) else default
else:
needs_revalidation = True
del data[key]
if needs_revalidation:
is_valid = validator.is_valid(data)
return is_valid, errors
def test_create_nested_index(self):
data = {}
meta = Meta(data)
assert meta.enter(0).create() == {}
assert data == {"0": {"": {}}}
