def test_no_alerts(self):
# pylint: disable=no-self-use
tree = etree.XML(
"""
<cib>
<configuration/>
</cib>
"""
)
assert_xml_equal(
'<alert id="my-alert" path="/test/path"/>',
etree.tostring(
alert.create_alert(tree, "my-alert", "/test/path")
).decode()
)
assert_xml_equal(
"""
<cib>
<configuration>
<alerts>
<alert id="my-alert" path="/test/path"/>
</alerts>
</configuration>
</cib>
""",
etree.tostring(tree).decode()
)
def test_not_useful_with_attributes(self):
element = etree.Element("new", attr="test")
lib.append_when_useful(self.parent, element, attribs_important=False)
assert_xml_equal(
self.tree_str,
etree_to_str(self.tree)
)
def test_different_parent_not_useful(self):
element = self.tree.find(".//element-B2")
lib.append_when_useful(self.parent, element)
assert_xml_equal(
self.tree_str,
etree_to_str(self.tree)
)
def test_not_useful(self):
element = etree.Element("new")
lib.append_when_useful(self.parent, element)
assert_xml_equal(
self.tree_str,
etree_to_str(self.tree)
)
def _assert_move_last_from_cloned_group(self, clone_type):
# pylint: disable=no-self-use
cib_before = f"""
<resources>
<group id="G">
<primitive id="RG1" />
<primitive id="RG2" />
<primitive id="RG3" />
</group>
<{clone_type} id="X-{clone_type}">
<group id="X">
<primitive id="R1" />
</group>
</{clone_type}>
<primitive id="R3" />
</resources>
"""
cib_after = """
<resources>
<group id="G">
<primitive id="RG1" />
<primitive id="RG2" />
<primitive id="RG3" />
<primitive id="R1" />
</group>
<primitive id="R3" />
</resources>
"""
cib = etree.fromstring(cib_before)
relation.move_resources_to_group(
_resource(cib, "G"),
_resources(cib, "R1"),
)
assert_xml_equal(cib_after, etree_to_str(cib))
def test_already_appended(self):
element = self.tree.find(".//element-A2")
lib.append_when_useful(self.parent, element)
assert_xml_equal(
self.tree_str,
etree_to_str(self.tree)
)
def test_updates_nvset(self):
nvset_element = etree.fromstring("""
<instance_attributes id="iattrs">
<nvpair id="iattrs-a" name="a" value="b"/>
<nvpair id="iattrs-c" name="c" value="d"/>
<nvpair id="iattrs-e" name="e" value="f"/>
</instance_attributes>
""")
id_provider = IdProvider(nvset_element)
nvpair.update_nvset(
nvset_element,
{
"a": "B",
"c": "",
"g": "h",
},
id_provider
)
assert_xml_equal(
"""
<instance_attributes id="iattrs">
<nvpair id="iattrs-a" name="a" value="B"/>
<nvpair id="iattrs-e" name="e" value="f"/>
<nvpair id="iattrs-g" name="g" value="h"/>
</instance_attributes>
""",
etree_to_str(nvset_element)
)
def test_with_id_provider_booked_ids(self):
context_element = etree.fromstring('<context id="a"/>')
provider = IdProvider(context_element)
provider.book_ids("a-instance_attributes", "a-instance_attributes-1-a")
nvpair.append_new_nvset(
"instance_attributes",
context_element,
{
"a": "b",
"c": "d",
},
provider
)
assert_xml_equal(
"""
<context id="a">
<instance_attributes id="a-instance_attributes-1">
<nvpair
id="a-instance_attributes-1-a-1" name="a" value="b"
/>
<nvpair
id="a-instance_attributes-1-c" name="c" value="d"
/>
</instance_attributes>
</context>
""",
etree_to_str(context_element)
)
def test_create_new_nvset_if_does_not_exist(self):
root = etree.Element("root", id="root")
nvpair.arrange_first_nvset(
"nvset",
root,
{
"attr": "10",
"new_one": "20",
"test": "0",
"attr2": ""
},
self.id_provider
)
assert_xml_equal(
"""
<root id="root">
<nvset id="root-nvset">
<nvpair id="root-nvset-attr" name="attr" value="10"/>
<nvpair id="root-nvset-new_one" name="new_one" value="20"/>
<nvpair id="root-nvset-test" name="test" value="0"/>
</nvset>
</root>
""",
etree_to_str(root)
)
def test_without_id(self):
assert_xml_equal(
'<recipient id="alert-recipient-1" value="value1"/>',
etree.tostring(
alert.add_recipient(
self.mock_reporter, self.tree, "alert", "value1"
)
).decode()
)
assert_xml_equal(
"""
<cib>
<configuration>
<alerts>
<alert id="alert" path="/path">
<recipient id="alert-recipient" value="test_val"/>
<recipient id="alert-recipient-1" value="value1"/>
</alert>
</alerts>
</configuration>
</cib>
""",
etree.tostring(self.tree).decode()
)
self.assertEqual([], self.mock_reporter.report_item_list)
def test_append_new_nvset_to_given_element(self):
context_element = etree.fromstring('<context id="a"/>')
id_provider = IdProvider(context_element)
nvpair.append_new_nvset(
"instance_attributes",
context_element,
{
"a": "b",
"c": "d",
},
id_provider
)
assert_xml_equal(
"""
<context id="a">
<instance_attributes id="a-instance_attributes">
<nvpair
id="a-instance_attributes-a" name="a" value="b"
/>
<nvpair
id="a-instance_attributes-c" name="c" value="d"
/>
</instance_attributes>
</context>
""",
etree_to_str(context_element)
)
def test_update_same_value_duplicity_allowed(self):
assert_xml_equal(
'<recipient id="alert-recipient" value="test_val"/>',
etree.tostring(alert.update_recipient(
self.mock_reporter, self.tree, "alert-recipient",
recipient_value="test_val", allow_same_value=True
)).decode()
)
assert_xml_equal(
"""
<cib>
<configuration>
<alerts>
<alert id="alert" path="/path">
<recipient id="alert-recipient" value="test_val"/>
<recipient
id="alert-recipient-1"
value="value1"
description="desc"
/>
</alert>
</alerts>
</configuration>
</cib>
""",
etree.tostring(self.tree).decode()
)
self.assertEqual([], self.mock_reporter.report_item_list)
def test_remove_description(self):
assert_xml_equal(
"""
<recipient id="alert-recipient-1" value="value1"/>
""",
etree.tostring(
alert.update_recipient(
self.mock_reporter, self.tree, "alert-recipient-1",
description=""
)
).decode()
)
assert_xml_equal(
"""
<cib>
<configuration>
<alerts>
<alert id="alert" path="/path">
<recipient id="alert-recipient" value="test_val"/>
<recipient id="alert-recipient-1" value="value1"/>
</alert>
</alerts>
</configuration>
</cib>
""",
etree.tostring(self.tree).decode()
)
self.assertEqual([], self.mock_reporter.report_item_list)
def assert_clone_effect(self, options, xml):
clone.append_new(
self.resources,
IdProvider(self.resources),
self.primitive,
options
)
assert_xml_equal(etree.tostring(self.cib).decode(), xml)
def stdin_xml_check(stdin, command, order_num):
assert_xml_equal(
expected_stdin,
stdin,
(
"Trying to run command no. {0}"
"\n\n '{1}'\n\nwith expected xml stdin.\n"
).format(order_num, command)
)
def test_returns_cib_from_cib_data(self):
cib_filename = "cib-empty.xml"
(self.config
#Value of cib_data is unimportant here. See details in sibling test.
.env.set_cib_data("whatever")
.runner.cib.load(filename=cib_filename)
)
assert_xml_equal(
etree_to_str(self.env_assist.get_env().get_cib()),
open(rc(cib_filename)).read()
)
def test_new_last(self):
lib.get_sub_element(self.root, "new_element", "new_id", None)
assert_xml_equal(
"""
<root>
<sub_element/>
<new_element id="new_id"/>
</root>
""",
etree_to_str(self.root)
)
def test_remove(self):
nvpair.set_nvpair_in_nvset(self.nvset, "attr2", "", self.id_provider)
assert_xml_equal(
"""
<nvset id="nvset">
<nvpair id="nvset-attr" name="attr" value="1"/>
<notnvpair id="nvset-test" name="test" value="0"/>
</nvset>
""",
etree_to_str(self.nvset)
)
def assert_resources_xml_in_cib(self, expected_xml_resources):
xml = get_cib_part(self.temp_cib)
try:
assert_xml_equal(expected_xml_resources, xml.decode())
except AssertionError as e:
raise AssertionError(
"{0}\n\nCopy format ;)\n{1}".format(
e.args[0],
xml_format(xml.decode())
)
)
def test_remove_resource_references_and_empty_remaining_parents(self):
constraint_section = etree.fromstring("""
<constraints>
<rsc_ticket id="t1" ticket="tA">
<resource_set id="rs1">
<resource_ref id="rA"/>
</resource_set>
<resource_set id="rs2">
<resource_ref id="rA"/>
</resource_set>
</rsc_ticket>
<rsc_ticket id="t2" ticket="tA">
<resource_set id="rs3">
<resource_ref id="rA"/>
<resource_ref id="rB"/>
</resource_set>
<resource_set id="rs4">
<resource_ref id="rA"/>
</resource_set>
</rsc_ticket>
<rsc_ticket id="t3" ticket="tB">
<resource_set id="rs5">
<resource_ref id="rA"/>
</resource_set>
</rsc_ticket>
</constraints>
""")
self.assertTrue(ticket.remove_with_resource_set(
constraint_section,
ticket_key="tA",
resource_id="rA"
))
assert_xml_equal(
"""
<constraints>
<rsc_ticket id="t2" ticket="tA">
<resource_set id="rs3">
<resource_ref id="rB"/>
</resource_set>
</rsc_ticket>
<rsc_ticket id="t3" ticket="tB">
<resource_set id="rs5">
<resource_ref id="rA"/>
</resource_set>
</rsc_ticket>
</constraints>
""",
etree.tostring(constraint_section).decode()
)
def test_empty_value_has_no_effect(self):
xml = """
<instance_attributes id="iattrs">
<nvpair id="iattrs-b" name="a" value="b"/>
<nvpair id="iattrs-d" name="c" value="d"/>
<nvpair id="iattrs-f" name="e" value="f"/>
</instance_attributes>
"""
nvset_element = etree.fromstring(xml)
id_provider = IdProvider(nvset_element)
nvpair.update_nvset(nvset_element, {}, id_provider)
assert_xml_equal(xml, etree_to_str(nvset_element))
def test_empty_value_has_no_effect(self):
nvpair.arrange_first_nvset("nvset", self.root, {}, self.id_provider)
assert_xml_equal(
"""
<nvset id="nvset">
<nvpair id="nvset-attr" name="attr" value="1"/>
<nvpair id="nvset-attr2" name="attr2" value="2"/>
<notnvpair id="nvset-test" name="test" value="0"/>
</nvset>
""",
etree_to_str(self.nvset)
)
def test_append_new_nvpair_to_given_element(self):
nvset_element = etree.fromstring('<nvset id="a"/>')
id_provider = IdProvider(nvset_element)
nvpair._append_new_nvpair(nvset_element, "b", "c", id_provider)
assert_xml_equal(
etree_to_str(nvset_element),
"""
<nvset id="a">
<nvpair id="a-b" name="b" value="c"></nvpair>
</nvset>
"""
)
def test_remove_resource_references_and_empty_remaining_parents(self):
constraint_section = etree.fromstring("""
<constraints>
<rsc_ticket id="t1" ticket="tA">
<resource_set id="rs1">
<resource_ref id="rA"/>
</resource_set>
<resource_set id="rs2">
<resource_ref id="rA"/>
</resource_set>
</rsc_ticket>
<rsc_ticket id="t2" ticket="tA">
<resource_set id="rs3">
<resource_ref id="rA"/>
<resource_ref id="rB"/>
</resource_set>
<resource_set id="rs4">
<resource_ref id="rA"/>
</resource_set>
</rsc_ticket>
<rsc_ticket id="t3" ticket="tB">
<resource_set id="rs5">
<resource_ref id="rA"/>
</resource_set>
</rsc_ticket>
</constraints>
""")
self.assertTrue(
ticket.remove_with_resource_set(constraint_section,
ticket_key="tA",
resource_id="rA"))
assert_xml_equal(
"""
<constraints>
<rsc_ticket id="t2" ticket="tA">
<resource_set id="rs3">
<resource_ref id="rB"/>
</resource_set>
</rsc_ticket>
<rsc_ticket id="t3" ticket="tB">
<resource_set id="rs5">
<resource_ref id="rA"/>
</resource_set>
</rsc_ticket>
</constraints>
""",
etree.tostring(constraint_section).decode())
def test_minimal(self):
context_element = etree.fromstring("""<context id="a" />""")
id_provider = IdProvider(context_element)
nvpair_multi.nvset_append_new(context_element, id_provider,
nvpair_multi.NVSET_META, {}, {})
assert_xml_equal(
"""
<context id="a">
<meta_attributes id="a-meta_attributes" />
</context>
""",
etree_to_str(context_element),
)
def test_success(self):
alert.remove_alert(self.tree, "alert")
assert_xml_equal(
"""
<cib>
<configuration>
<alerts>
<alert id="alert-1" path="/next"/>
</alerts>
</configuration>
</cib>
""",
etree.tostring(self.tree).decode())
def test_stonith(self):
self.agent.get_standard.return_value = "stonith"
self.agent.get_provider.return_value = ""
results = primitive.find_primitives_by_agent(
self.resources_section, self.agent
)
expected_results = [
'<primitive class="stonith" type="agent_type" id="r1"/>',
'<primitive class="stonith" type="agent_type" id="r2"/>',
]
self.assertEqual(len(expected_results), len(results))
for i, res in enumerate(results):
assert_xml_equal(expected_results[i], etree.tostring(res).decode())
def test_new_not_append(self):
subelement = lib.get_sub_element(self.root,
"new_element",
"new_id",
append_if_missing=False)
assert_xml_equal(
"""
<root>
<sub_element/>
</root>
""", etree_to_str(self.root))
assert_xml_equal("""<new_element id="new_id" />""",
etree_to_str(subelement))
def test_move_combined_before(self):
lib.move_elements([self.third, self.new2], self.first)
assert_xml_equal(
"""
<root>
<third/>
<new2/>
<first/>
<second/>
</root>
""",
etree_to_str(self.root),
)
def test_add(self):
nvpair.set_nvpair_in_nvset(self.nvset, "test", "0", self.id_provider)
assert_xml_equal(
"""
<nvset id="nvset">
<nvpair id="nvset-attr" name="attr" value="1"/>
<nvpair id="nvset-attr2" name="attr2" value="2"/>
<notnvpair id="nvset-test" name="test" value="0"/>
<nvpair id="nvset-test-1" name="test" value="0"/>
</nvset>
""",
etree_to_str(self.nvset),
)
def test_with_id_provider(self):
nvset_element = etree.fromstring('<nvset id="a"/>')
provider = IdProvider(nvset_element)
provider.book_ids("a-b")
nvpair._append_new_nvpair(nvset_element, "b", "c", provider)
assert_xml_equal(
etree_to_str(nvset_element),
"""
<nvset id="a">
<nvpair id="a-b-1" name="b" value="c"></nvpair>
</nvset>
""",
)
def test_returns_cib_from_cib_data(self):
cib_filename = "cib-empty.xml"
(self.config
# Value of cib_data is unimportant here. See details in sibling test
.env.set_cib_data("whatever",
cib_tempfile=self.tmp_file).runner.cib.load(
filename=cib_filename,
env=dict(CIB_file=self.tmp_file)))
with open(rc(cib_filename)) as cib_file:
assert_xml_equal(
etree_to_str(self.env_assist.get_env().get_cib()),
cib_file.read(),
)
def test_with_id_provider(self):
nvset_element = etree.fromstring('<nvset id="a"/>')
provider = IdProvider(nvset_element)
provider.book_ids("a-b")
nvpair._append_new_nvpair(nvset_element, "b", "c", provider)
assert_xml_equal(
etree_to_str(nvset_element),
"""
<nvset id="a">
<nvpair id="a-b-1" name="b" value="c"></nvpair>
</nvset>
"""
)
def test_dont_create_empty_nvset_if_no_attrs(self, mock_get_node):
mock_get_node.return_value = self.node1
node.update_node_instance_attrs(
self.cib,
self.id_provider,
"rh73-node1",
{},
state_nodes=self.state
)
assert_xml_equal(
etree_to_str(self.node1),
"""<node id="1" uname="rh73-node1" />"""
)
def test_upgraded_lower_version_dont_fail(self, mock_upgrade, mock_get_cib):
expected_cib = '<cib validate-with="pacemaker-2.3.4"/>'
mock_get_cib.return_value = expected_cib
actual_cib, was_upgraded = lib.ensure_cib_version(
self.mock_runner,
self.cib,
Version(2, 3, 5),
fail_if_version_not_met=False,
)
assert_xml_equal(expected_cib, etree.tostring(actual_cib).decode())
self.assertFalse(was_upgraded)
mock_upgrade.assert_called_once_with(self.mock_runner)
mock_get_cib.assert_called_once_with(self.mock_runner)
def test_upgraded_higher_version(self, mock_upgrade, mock_get_cib):
upgraded_cib = '<cib validate-with="pacemaker-2.3.6"/>'
mock_get_cib.return_value = upgraded_cib
assert_xml_equal(
upgraded_cib,
etree.tostring(
lib.ensure_cib_version(
self.mock_runner, self.cib, Version(2, 3, 5)
)
).decode()
)
mock_upgrade.assert_called_once_with(self.mock_runner)
mock_get_cib.assert_called_once_with(self.mock_runner)
def test_upgraded_higher_version(self, mock_upgrade, mock_get_cib):
upgraded_cib = '<cib validate-with="pacemaker-2.3.6"/>'
mock_get_cib.return_value = upgraded_cib
assert_xml_equal(
upgraded_cib,
etree.tostring(
lib.ensure_cib_version(
self.mock_runner, self.cib, Version(2, 3, 5)
)
).decode()
)
mock_upgrade.assert_called_once_with(self.mock_runner)
mock_get_cib.assert_called_once_with(self.mock_runner)
def test_ocf_1_1_valid(self):
# pylint: disable=no-self-use
metadata = """
<resource-agent name="agent">
<version>1.1</version>
<parameters>
<parameter name="test" unique-group="ug1"/>
</parameters>
</resource-agent>
"""
assert_xml_equal(
metadata, etree_to_str(ra.xml._metadata_xml_to_dom(metadata))
)
def test_success(self):
agent_name = ra.const.PACEMAKER_FENCED
metadata = """
<resource-agent name="pacemaker-fenced">
</resource-agent>
"""
self.config.runner.pcmk.load_fenced_metadata(stdout=metadata)
env = self.env_assist.get_env()
assert_xml_equal(
metadata,
etree_to_str(
ra.xml.load_fake_agent_metadata(env.cmd_runner(), agent_name)),
)
def assert_final_order(self,
id_list=None,
adjacent_resource_id=None,
put_after_adjacent=False):
group.place_resource(self.group_element, self.primitive_element,
adjacent_resource_id, put_after_adjacent)
assert_xml_equal(
etree.tostring(self.group_element).decode(), """
<group id="g">
<primitive id="{0}"/>
<primitive id="{1}"/>
<primitive id="{2}"/>
</group>
""".format(*id_list))
def test_dont_create_empty_node_if_deleting(self, mock_get_node):
node4 = etree.fromstring("""<node id="4" />""")
mock_get_node.return_value = node4
node.update_node_instance_attrs(
self.cib,
self.id_provider,
"rh73-node4",
{"x": ""},
state_nodes=self.state,
)
assert_xml_equal(
etree_to_str(self.cib),
self.compile_cib(self.node1, self.node2, self.node3),
)
def test_node_pattern(self):
lib._append_level_element(self.tree, "2", TARGET_TYPE_REGEXP,
r"node-\d+", ["d1", "d2"])
assert_xml_equal(
"""
<fencing-topology>
<fencing-level
id="fl-node-d-2"
devices="d1,d2" index="2" target-pattern="node-\\d+"
/>
</fencing-topology>
""",
etree_to_str(self.tree),
)
def test_success(self):
expected_xml = """
<cib>
<configuration>
<acls>
<acl_role id="role-id">
<acl_permission id="role-permission"/>
</acl_role>
</acls>
</configuration>
</cib>
"""
lib.remove_permission(self.tree, "permission-id")
assert_xml_equal(expected_xml, etree.tostring(self.tree).decode())
def test_autodelete(self):
expected_xml = """
<cib>
<configuration>
<acls>
<acl_group>
<role id="some-role"/>
</acl_group>
</acls>
</configuration>
</cib>
"""
lib.remove_role(self.tree, "role-id", autodelete_users_groups=True)
assert_xml_equal(expected_xml, etree.tostring(self.tree).decode())
def test_autodelete(self):
expected_xml = """
<cib>
<configuration>
<acls>
<acl_group>
<role id="some-role"/>
</acl_group>
</acls>
</configuration>
</cib>
"""
lib.remove_role(self.tree, "role-id", autodelete_users_groups=True)
assert_xml_equal(expected_xml, etree.tostring(self.tree).decode())
def test_success(self):
expected_xml = """
<cib>
<configuration>
<acls>
<acl_role id="role-id">
<acl_permission id="role-permission"/>
</acl_role>
</acls>
</configuration>
</cib>
"""
lib.remove_permission(self.tree, "permission-id")
assert_xml_equal(expected_xml, etree.tostring(self.tree).decode())
def test_new_no_id(self):
assert_xml_equal(
"<new_element/>",
etree_to_str(lib.get_sub_element(self.root, "new_element")),
)
assert_xml_equal(
"""
<root>
<sub_element/>
<new_element/>
</root>
""",
etree_to_str(self.root),
)
def test_move_existing_ids_before(self):
lib.add_obj_ref(
self.tag_el, self.existing_list[2:0:-1], self.existing_list[0],
)
assert_xml_equal(
"""
<tag>
<obj_ref id="e3"/>
<obj_ref id="e2"/>
<obj_ref id="e1"/>
</tag>
""",
etree_to_str(self.tag_el),
)
def test_empty_node(self, mock_get_node):
mock_get_node.return_value = self.node1
node.update_node_instance_attrs(self.cib,
self.id_provider,
"rh73-node1", {"x": "X"},
state_nodes=self.state)
assert_xml_equal(
etree_to_str(self.node1), """
<node id="1" uname="rh73-node1">
<instance_attributes id="nodes-1">
<nvpair id="nodes-1-x" name="x" value="X" />
</instance_attributes>
</node>
""")
def test_node_name(self):
lib._append_level_element(self.tree, 1, TARGET_TYPE_NODE, "node1",
["d1"])
assert_xml_equal(
"""
<fencing-topology>
<fencing-level
id="fl-node1-1"
devices="d1" index="1" target="node1"
/>
</fencing-topology>
""",
etree_to_str(self.tree),
)
def test_success(self):
alert.remove_alert(self.tree, "alert")
assert_xml_equal(
"""
<cib>
<configuration>
<alerts>
<alert id="alert-1" path="/next"/>
</alerts>
</configuration>
</cib>
""",
etree.tostring(self.tree).decode()
)
def test_everything(self):
context_element = etree.fromstring("""<context id="a" />""")
id_provider = IdProvider(context_element)
nvpair_multi.nvset_append_new(
context_element,
id_provider,
Version(3, 5, 0),
nvpair_multi.NVSET_META,
{
"attr1": "value1",
"attr-empty": "",
"attr2": "value2"
},
{
"id": "custom-id",
"score": "INFINITY",
"empty-attr": ""
},
nvset_rule=BoolExpr(
BOOL_AND,
[RscExpr("ocf", "pacemaker", "Dummy"),
OpExpr("start", None)],
),
)
assert_xml_equal(
"""
<context id="a">
<meta_attributes id="custom-id" score="INFINITY">
<rule id="custom-id-rule"
boolean-op="and" score="INFINITY"
>
<rsc_expression id="custom-id-rule-rsc-ocf-pacemaker-Dummy"
class="ocf" provider="pacemaker" type="Dummy"
/>
<op_expression id="custom-id-rule-op-start"
name="start"
/>
</rule>
<nvpair id="custom-id-attr1"
name="attr1" value="value1"
/>
<nvpair id="custom-id-attr2"
name="attr2" value="value2"
/>
</meta_attributes>
</context>
""",
etree_to_str(context_element),
)
def test_success(self):
expected_xml = """
<cib>
<configuration>
<acls>
<acl_target/>
<acl_group>
<role id="some-role"/>
</acl_group>
</acls>
</configuration>
</cib>
"""
lib.remove_role(self.tree, "role-id")
assert_xml_equal(expected_xml, etree.tostring(self.tree).decode())
def assert_resources_xml_in_cib(
self,
expected_xml_resources,
get_cib_part_func=None,
):
self.temp_cib.seek(0)
if get_cib_part_func is not None:
xml = get_cib_part_func(self.temp_cib)
else:
xml = get_cib_part(self.temp_cib)
try:
assert_xml_equal(expected_xml_resources, xml.decode())
except AssertionError as e:
raise AssertionError("{0}\n\nCopy format ;)\n{1}".format(
e.args[0], xml_format(xml.decode())))
def test_success(self):
expected_xml = """
<cib>
<configuration>
<acls>
<acl_target/>
<acl_group>
<role id="some-role"/>
</acl_group>
</acls>
</configuration>
</cib>
"""
lib.remove_role(self.tree, "role-id")
assert_xml_equal(expected_xml, etree.tostring(self.tree).decode())
def test_success(self):
alert.remove_recipient(self.tree, "alert-recipient-2")
assert_xml_equal(
"""
<cib>
<configuration>
<alerts>
<alert id="alert" path="/path">
<recipient id="alert-recipient" value="test_val"/>
</alert>
</alerts>
</configuration>
</cib>
""",
etree.tostring(self.tree).decode())
def test_move_into_after(self):
lib.move_elements([self.new1], self.second, put_after_adjacent=True)
assert_xml_equal(
"""
<root>
<first/>
<second/>
<new1>
<new2/>
</new1>
<third/>
</root>
""",
etree_to_str(self.root),
)
def test_new_with_id(self):
assert_xml_equal(
'<new_element id="new_id"/>',
etree_to_str(
lib.get_sub_element(self.root, "new_element", "new_id")),
)
assert_xml_equal(
"""
<root>
<sub_element/>
<new_element id="new_id"/>
</root>
""",
etree_to_str(self.root),
)
def test_move_inside_after(self):
lib.move_elements(
[self.third, self.first],
self.second,
put_after_adjacent=True,
)
assert_xml_equal(
"""
<root>
<second/>
<third/>
<first/>
</root>
""",
etree_to_str(self.root),
)
def test_different_parent_useful(self):
element = self.tree.find(".//element-B1")
lib.append_when_useful(self.parent, element)
assert_xml_equal(
"""
<root>
<parent-A>
<element-A1 />
<element-A2 attr="test" />
<element-B1 attr="test"/>
</parent-A>
<parent-B>
<element-B2 />
</parent-B>
</root>
""", etree_to_str(self.tree))
