def _collect_from_instrcutions(self,
current_instruction: InstructionWrapper,
callpath: str = '') -> None:
if callpath == '':
callpath = str(current_instruction)
else:
callpath = f"{callpath}->{current_instruction}"
# travel down to the leaf elements of the instruction tree
# which are artefacts
for child in current_instruction.instructionchildren:
self._collect_from_instrcutions(child, callpath)
# Artefacts do implement the method '_collect'.
if '_collect' in dir(current_instruction.instruction):
self._collect_and_document(current_instruction.instruction,
callpath=callpath)
# if the current instruction contains a "placeholdername" attribute this means
# there is a placeholder for the global placeholder dictionary which needs to be
# filled with the result of the current collector, so that following collectors
# can use this information for their own collection process, like for example the
# machine name.
if current_instruction.placeholdername != '':
Placeholder.update_placeholder(
current_instruction.placeholdername,
current_instruction.instruction.data[0].collecteddata)
Collector._logger.info(
f"Stored artefact data '{current_instruction.instruction.data}' as placeholder "
f"'{current_instruction.placeholdername}'.")
else:
Collector._logger.debug(callpath)
def test_update_placeolder_with_value_which_contains_placeholder(self):
"""
Should accept the placeholder.
"""
expected_placeholer = f"{Placeholder.PLACEHOLDER_START}test_placeholder{Placeholder.PLACEHOLDER_END}"
expected_placeholder_value = "test_value"
Placeholder.update_placeholder(placeholdername=expected_placeholer, placeholdervalue=expected_placeholder_value)
actual_value = Placeholder._instruction_placeholders[expected_placeholer]
self.assertEqual(expected_placeholder_value, actual_value)
def test_update_placeholder_with_new_placeholder(self):
"""
Should add the new placeholder to the global placeholders dicitionary.
"""
expected_placeholer = "test_placeholder"
expected_placeholder_value = "test_value"
Placeholder.update_placeholder(placeholdername=expected_placeholer, placeholdervalue=expected_placeholder_value)
actual_value = Placeholder._instruction_placeholders[expected_placeholer]
self.assertEqual(expected_placeholder_value, actual_value)
def _init_instructions(self,
current: Element = None,
parentinstruction=None,
instructionid: int = 0):
"""
Parses the instructions xml file and initializes the artefact collectors in memory.
Artefact xml elements need to have the attribute "module". If not, they are been ignored.
:param current: Current xml element. Needed for recursive traversal.
:param parentinstruction: Parent to be stored for current so later the collector can call back
parent for context information.
:param instructionid: Id of the current instruction which is an iterating integer starting with 0
for the first found collector.
:return: object of type InstructionWrapper
"""
if current is None:
current = self._get_first_instruction_element()
currentinstruction = getattr(
importlib.import_module(
current.attributes[XmlParser.MODULE_ATTRIBUTE].nodeValue),
current.tagName)(parent=parentinstruction,
parameters=XmlParser._get_parameter_attributes(
current.attributes))
currentinstruction.protocol = self._protocol
placeholder_name = XmlParser._get_placeholder_name(current)
# If there is a placeholder in the element store it for later use in the global placeholders
if placeholder_name is not None and placeholder_name != "":
Placeholder.update_placeholder(
placeholder_name, f"{Placeholder.PLACEHOLDER_START}"
f"{placeholder_name}"
f"{Placeholder.PLACEHOLDER_END}")
instructionwrapper = InstructionWrapper(
instruction=currentinstruction,
parentinstrutction=parentinstruction,
instructionid=instructionid,
placeholdername=placeholder_name)
for child in current.childNodes:
if type(child) is Element:
instructionwrapper_child = self._init_instructions(
current=child,
parentinstruction=currentinstruction,
instructionid=instructionid + 1)
XmlParser._logger.debug(
f"Adding '{instructionwrapper_child.instructionname}' with "
f"id {instructionwrapper_child.instructionid} as child of "
f"'{instructionwrapper.instructionname}' with id {instructionwrapper.instructionid}."
)
instructionwrapper.addchild(instructionwrapper_child)
return instructionwrapper
def test_update_placeholder_with_defined_placeholder(self):
"""
Should overwrite the placeholder already defined with the new value.
"""
expected_placeholer = "test_placeholder"
expected_placeholder_value = "test_value"
expected_placeholder_new_value = "test_value_new"
Placeholder.update_placeholder(placeholdername=expected_placeholer,
placeholdervalue=expected_placeholder_value)
Placeholder.update_placeholder(placeholdername=expected_placeholer,
placeholdervalue=expected_placeholder_new_value)
actual_value = Placeholder._instruction_placeholders[expected_placeholer]
self.assertEqual(expected_placeholder_new_value, actual_value)
def test_get_metadata_with_metadata_with_placeholder(self):
"""
Should return the metadata value, but the placeholder is replaced with the correct placeholder
value.
:return:
"""
from businesslogic.placeholders import Placeholder
expected_metadata = {"Metadata1": "!@placeholder@!"}
expected_metadata_key = "Metadata1"
expected_metadata_value = "placeholdervalue"
Placeholder.update_placeholder(
placeholdername="placeholder",
placeholdervalue=expected_metadata_value)
actual_metadata = CollectionMetaData(metadata=expected_metadata)
actual_metadata_value = actual_metadata.get_metadata(
expected_metadata_key)
self.assertEqual(expected_metadata_value, actual_metadata_value)
def cache_parameters(cls, attributes: UserDict = None) -> None:
for attributename in attributes.keys():
attributevalue = Placeholder.replace_placeholders(attributes[attributename])
Placeholder.update_placeholder(attributename, attributevalue)
SourceBase._logger.debug(
f"Source: Cached source parameter '{attributename}'. Parameter value: '{attributevalue}'")
"""