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 handle_validation(root_path: str, input_files: list, rule_definition: str):
"""Übergebene Liste von Input-Dateien an validify übergeben, Validierungsergebnisse pro Datei als List sammeln und in Gesamt-Liste zusammennführen.
Überführen in ein Pandas DataFrame und Aggregrieren der Validierungsergebnisse (mehrere Vorkommen zusammenfassen).
Übergabe der Validierungsergebnisse an Template-Erzeugung.
"""
timer_start = datetime.datetime.now()
# Zurücksetzen des Prozessierungs-Status:
write_processing_status(root_path=root_path,
processing_step=None,
status_message=None,
error_status=0)
error_status = 0
validation_rules_findbuch = eadddb_findbuch.compile_validation_rules()
validation_rules_tektonik = eadddb_tektonik.compile_validation_rules()
ext = [".xml", ".XML"]
validation_results = []
input_files_count = len(input_files)
for input_file_i, input_file in enumerate(input_files):
if handle_thread_actions.load_from_xml("stop_thread",
root_path) is True:
break
validation_progress = int((input_file_i / input_files_count) * 100)
write_processing_status(
root_path=root_path,
processing_step=validation_progress,
status_message="Validierung läuft für Datei {} ({}/{})".format(
input_file, input_file_i + 1, input_files_count),
error_status=error_status)
if input_file.endswith(tuple(ext)):
validation_results_single = []
if rule_definition == "eadddb_findbuch":
validation_results_single = validify.validate(
input_file,
validation_rules=validation_rules_findbuch,
log_to_console=False)
elif rule_definition == "eadddb_tektonik":
validation_results_single = validify.validate(
input_file,
validation_rules=validation_rules_tektonik,
log_to_console=False)
for item in validation_results_single:
item.update({"input_file": input_file})
validation_results.extend(validation_results_single)
timer_end = datetime.datetime.now()
processing_duration = timer_end - timer_start
logger.debug("Prozessierungsdauer (Validierung - validify): {}".format(
processing_duration))
# Aggregrieren der Validierungsergebnisse (mehrere Vorkommen zusammenfassen)
timer_start = datetime.datetime.now()
aggregated_validation_results = []
if len(validation_results) > 0:
validation_results_dataframe = pd.DataFrame(validation_results)
validation_results_dataframe[
'aggregated_details'] = validation_results_dataframe[
"element_local_name"].astype(
str
) + ";" + validation_results_dataframe["input_file"].astype(
str) + ";" + validation_results_dataframe[
"element_sourceline"].astype(
str) + ";" + validation_results_dataframe[
"element_path"].astype(str)
aggregated_validation_results = (validation_results_dataframe.groupby(
['message_id',
'element_name']).agg(set).reset_index().to_dict('r'))
timer_end = datetime.datetime.now()
processing_duration = timer_end - timer_start
logger.debug("Prozessierungsdauer (Validierung - pandas): {}".format(
processing_duration))
# Serialisierung der Validierungsergebnisse
timer_start = datetime.datetime.now()
serialize_validation_results.export_to_html(aggregated_validation_results)
timer_end = datetime.datetime.now()
write_processing_status(root_path=root_path,
processing_step=100,
status_message="Validierung abgeschlossen.",
error_status=error_status)
processing_duration = timer_end - timer_start
logger.debug(
"Prozessierungsdauer (Validierung - HTML-Serialisierung): {}".format(
processing_duration))
