def tracked_kickstart_elements_tracking_test(self):
"""Test tracking of elements."""
appended_elements = [
self._element1, self._element2, self._element3, self._element4,
self._element5, self._element6, self._element7
]
elements = TrackedKickstartElements()
for element in appended_elements:
elements.append(element)
processed_elements = elements.get_and_process_elements(
commands=["network"], sections=["pre"], addons=["pony"])
unprocessed_elements = elements.unprocessed_elements
# still keeping order of elements
self.assertEqual(unprocessed_elements,
[self._element5, self._element6, self._element7])
# nothing is missing
self.assertEqual(
set(elements.all_elements),
set.union(set(processed_elements), set(unprocessed_elements)))
# elements once processed remain processed if you just get them
elements.get_elements(commands=["network"],
sections=["pre"],
addons=["pony"])
self.assertEqual(elements.unprocessed_elements, unprocessed_elements)
# processing some more elements - firewall command
firewall_elements = elements.get_and_process_elements(
commands=["firewall"])
self.assertEqual(
set(elements.unprocessed_elements),
set.difference(set(unprocessed_elements), set(firewall_elements)))
self.assertEqual(elements.unprocessed_elements,
[self._element6, self._element7])
def tracked_kickstart_elements_dump_kickstart_test(self):
"""Test dumping of elements into kickstart."""
appended_elements = [
self._element1, self._element2, self._element3, self._element4,
self._element5, self._element6, self._element7
]
elements = TrackedKickstartElements()
for element in appended_elements:
elements.append(element)
dumped_ks = elements.get_kickstart_from_elements(elements.all_elements)
self.assertEqual(dumped_ks, self._expected_ks_content)
def tracked_kickstart_elements_get_refs_kickstart_test(self):
"""Test getting of element references."""
appended_elements = [
self._element1, self._element2, self._element3, self._element4,
self._element5, self._element6, self._element7
]
elements = TrackedKickstartElements()
for element in appended_elements:
elements.append(element)
element_refs = elements.get_references_from_elements(
elements.all_elements)
self.assertEqual(element_refs, self._expected_element_refs)
def __init__(self,
handler,
valid_sections=None,
missing_include_is_fatal=True):
"""Initialize the parser.
:param valid_sections: list of valid section names (including '%')
:type valid_sections: list(str)
:param missing_include_is_fatal: raise KickstartError if included file
is not found
:type missing_include_is_fatal: bool
"""
self._valid_sections = valid_sections or []
# calls setupSections
super().__init__(handler,
missingIncludeIsFatal=missing_include_is_fatal)
self._current_ks_filename = self.unknown_filename
self._result = TrackedKickstartElements()
def tracked_kickstart_elements_filter_test(self):
"""Test filtering of elements."""
expected_elements = [
self._element1, self._element2, self._element3, self._element4,
self._element5, self._element6, self._element7
]
elements = TrackedKickstartElements()
for element in expected_elements:
elements.append(element)
self.assertEqual(elements.all_elements, expected_elements)
# filtering
network_commands = elements.get_elements(commands=["network"])
self.assertEqual(network_commands, [self._element2, self._element3])
pony_addon = elements.get_elements(addons=["pony"])
self.assertEqual(pony_addon, [self._element4])
pre_sections = elements.get_elements(sections=["pre"])
self.assertEqual(pre_sections, [self._element1])
# addon is not considered a section
addon_sections = elements.get_elements(sections=["addon"])
self.assertEqual(addon_sections, [])
mixed_elements = elements.get_elements(commands=["network"],
sections=["pre", "post"],
addons=["pony"])
self.assertEqual(mixed_elements, [
self._element1, self._element2, self._element3, self._element4,
self._element7
])
# nothing required - nothing got
self.assertEqual(elements.get_elements(), [])
def _reset(self):
self._result = TrackedKickstartElements()
self.setupSections()