def test_rule_allowed_patterns(self):
"""Parse an xml element with a text value not compliant to the provided regexpattern, and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_rule_allowed_patterns.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 0
def test_rule_optional_subelements(self):
"""Parse an xml element with an invalid subelement and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_rule_optional_subelements.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 1
if len(validation_result) > 0:
assert validation_result[0]["message_id"] == "0005"
def test_rule_obligatory_attributes(self):
"""Parse an xml element with a missing obligatory attribute and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_rule_obligatory_attributes.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 1
if len(validation_result) > 0:
assert validation_result[0]["message_id"] == "0004"
def test_root_element_namespace_evaluation(self):
"""Parse an xml document, evaluate the root element and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_root_element_namespace_evaluation.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 1
if len(validation_result) == 1:
assert validation_result[0]["message_id"] == "s0002"
def test_non_wellformed_input_file(self):
"""Parse a non-wellformed XML document and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_non_wellformed_input_file.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 1
if len(validation_result) == 1:
assert validation_result[0]["message_id"] == "e0001"
def test_attribute_definition_allowed_values(self):
"""Parse an xml element with a non-allowed attribute value, and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_attribute_definition_allowed_values.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 1
if len(validation_result) > 0:
assert validation_result[0]["message_id"] == "0012"
def test_rule_allowed_values(self):
"""Parse an xml element which has an invalid text value and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_rule_allowed_values.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 1
if len(validation_result) > 0:
assert validation_result[0]["message_id"] == "0010"
def test_ruleset_condition_reference_elements(self):
"""Parse an xml element where the conditions for the defined reference element are not met and check if the validation rule is rightly skipped.
These tests starting with "test_ruleset_condition" are meant to assert whether the conditions set for applying a ruleset are correctly evaluated.
"""
validation_result = validify.validate(
"validify/tests/test_rule_condition_reference_elements.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 0
def test_ruleset_condition_attribute_values(self):
"""Parse an xml element with an invalid attribute value and check if the validation rule is skipped correctly.
These tests starting with "test_ruleset_condition" are meant to assert whether the conditions set for applying a ruleset are correctly evaluated.
"""
validation_result = validify.validate(
"validify/tests/test_rule_condition_attribute_values.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 0
def test_non_valid_elementtree_input(self):
"""Pass a non-valid value (string) as ElementTree input parameter. Ensure that the resulting exception is handled."""
validation_result = validify.validate(
input_elementtree="1234",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 1
if len(validation_result) == 1:
assert validation_result[0]["message_id"] == "e0002"
def test_attribute_definition_allowed_patterns(self):
"""Parse an xml element with an attribute value not compliant to the provided regexpattern, and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_attribute_definition_allowed_patterns.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 2
if len(validation_result) == 2:
assert validation_result[0]["message_id"] == "0012"
assert validation_result[1]["message_id"] == "0013"
def test_rule_character_content_allowed(self):
"""Parse an xml element which has character content (while not allowed in the rule definition) and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_rule_character_content_allowed.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 2
if len(validation_result) == 2:
assert validation_result[0]["message_id"] == "0008"
assert validation_result[1]["message_id"] == "0009"
def test_rule_max_occurence(self):
"""Parse an xml element which occurs more often than allowed, and ensure that the correct validation message is applied."""
validation_result = validify.validate(
"validify/tests/test_rule_max_occurence.xml",
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 3
if len(validation_result) == 3:
assert validation_result[0]["message_id"] == "0007"
assert validation_result[1]["message_id"] == "0007"
assert validation_result[2]["message_id"] == "0007"
def test_elementtree_input(self):
"""Parse an ElementTree object, and ensure that rules are correctly applied to the document elements.
See ./test_valid_elementtree_input.xml for an XML representation of the ElementTree example object.
"""
xml_root_element = etree.Element("test_example")
xml_test_element = etree.SubElement(xml_root_element, "value_test")
xml_test_element.text = "invalid value"
xml_tree = etree.ElementTree(xml_root_element)
validation_result = validify.validate(
input_elementtree=xml_tree,
validation_rules=compile_test_rules(),
log_to_console=False)
assert len(validation_result) == 1
if len(validation_result) == 1:
assert validation_result[0]["message_id"] == "0010"
def validate(input_file=None, input_elementtree=None, xmlns_def=None, validation_rules=None, message_lang=None, log_to_console=True, log_debug=False):
"""Validate a given xml file according to the supplied validation rules and return validation messages as a dictionary.
All elements in the xml file will be processed.
Since version 0.0.11, an etree.ElementTree object (parameter 'input_elementtree') can also be passed, instead of an input file string.
For a documentation of parameters, see https://github.com/olivergoetze/validify.
"""
if xmlns_def is None:
xmlns_def = {}
if validation_rules is None:
validation_rules = compile_test_rules()
log_message("No validation rules defined; using example rules for validation.", "warn", log_to_console)
message_lang_options = ["de", "en"]
if message_lang is None:
message_lang = "de"
log_message("No message language option delivered; using standard value 'de'.", "info", log_to_console)
elif message_lang not in message_lang_options:
message_lang = "de"
log_message("Non-valid message language option delivered; using standard value 'de'.", "warn", log_to_console)
validation_messages = []
validation_results = []
if input_file is not None or input_elementtree is not None:
try:
if input_file is not None:
xml_in = etree.parse(input_file)
else:
xml_in = input_elementtree
xml_root_element = xml_in.getroot()
assess_root_element(xml_root_element, validation_rules, validation_messages, validation_results, message_lang)
xml_elements = xml_in.findall("//{*}*")
xml_elements = [xml_root_element] + xml_elements
for xml_element in xml_elements:
xml_element_sourceline = xml_element.sourceline # get original source line before applying normalize-space
normalize_space.parse_xml_content(xml_element) # apply normalize-space so only actual character content is found
validation_results = assess_element_structure(xml_element, xml_element_sourceline, xmlns_def, validation_rules, validation_messages, validation_results, message_lang, log_to_console, log_debug)
except etree.XMLSyntaxError as e:
message_id = "e0001"
message_text = messages.get_message_by_id(message_id, message_lang).format(input_file, e)
validation_messages.append(message_text)
validation_results.append({"message_id": message_id, "message_text": message_text, "element_name": "",
"element_local_name": "", "element_sourceline": "",
"element_path": ""})
except AttributeError as e:
message_id = "e0002"
message_text = messages.get_message_by_id(message_id, message_lang).format(e)
validation_messages.append(message_text)
validation_results.append({"message_id": message_id, "message_text": message_text, "element_name": "",
"element_local_name": "", "element_sourceline": "",
"element_path": ""})
# Aggregate and output validation messages
if len(validation_messages) > 0:
if input_file is not None: # log only when the input is a file and not an ElementTree.
log_message("Validation results for file '{}':".format(input_file), "info", log_to_console)
aggregated_validation_messages = collections.Counter(validation_messages)
for validation_message in aggregated_validation_messages:
log_message("{} ({} occurences)".format(validation_message, aggregated_validation_messages[validation_message]), "info", log_to_console)
return validation_results
