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_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_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 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_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_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_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 _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_success(self):
resources_state = etree_to_str(fixture.complete_state_resources(
etree.fromstring("""
<resources>
<resource id="A" role="Started" nodes_running_on="1">
<node name="node1" id="1" cached="false" />
</resource>
</resources>
""")
))
self.config.runner.pcmk.wait(timeout=10)
self.config.runner.pcmk.load_state(resources=resources_state)
self.lib_action(self.env_assist.get_env(), "A", wait="10")
self.env_assist.assert_reports([
fixture.info(
self.report_code_pcmk_success,
resource_id="A",
stdout="pcmk std out",
stderr="pcmk std err",
),
fixture.report_resource_running(
"A",
{"Started": ["node1"]}
),
])
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_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_group_running(self):
resources_state = fixture.complete_state_resources(etree.fromstring("""
<resources>
<group id="G" number_resources="2">
<resource id="R1" role="Started" nodes_running_on="1">
<node name="node1" id="1" cached="false" />
</resource>
<resource id="R2" role="Started" nodes_running_on="1">
<node name="node1" id="1" cached="false" />
</resource>
</group>
</resources>
"""))
self.config.runner.pcmk.load_state(
resources=etree_to_str(resources_state)
)
resource.group_add(
self.env_assist.get_env(),
"G",
["R1", "R2"],
wait=self.timeout,
)
self.env_assist.assert_reports([
fixture.report_resource_running(
"G",
{"Started": ["node1"]}
),
])
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_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 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_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_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_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_node_pattern(self):
lib._append_level_element(
self.tree, "2", TARGET_TYPE_REGEXP, "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_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_node_attribute(self):
lib._append_level_element(
self.tree, 3, TARGET_TYPE_ATTRIBUTE, ("name%@x", "val%@x"), ["d1"],
)
assert_xml_equal(
"""
<fencing-topology>
<fencing-level
id="fl-namex-3"
devices="d1"
index="3"
target-attribute="name%@x" target-value="val%@x"
/>
</fencing-topology>
""",
etree_to_str(self.tree)
)
def test_keep_empty_nvset(self):
xml_pre = """
<resource>
<instance_attributes id="iattrs">
<nvpair id="iattrs-a" name="a" value="b"/>
</instance_attributes>
</resource>
"""
xml_post = """
<resource>
<instance_attributes id="iattrs" />
</resource>
"""
xml = etree.fromstring(xml_pre)
nvset_element = xml.find("instance_attributes")
id_provider = IdProvider(nvset_element)
nvpair.update_nvset(nvset_element, {"a": ""}, id_provider)
assert_xml_equal(xml_post, etree_to_str(xml))
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)
)
def test_index(self):
element = etree.Element("new", attr="test")
lib.append_when_useful(self.parent, element, index=1)
assert_xml_equal(
"""
<root>
<parent-A>
<element-A1 />
<new attr="test" />
<element-A2 attr="test" />
</parent-A>
<parent-B>
<element-B1 attr="test"/>
<element-B2 />
</parent-B>
</root>
""",
etree_to_str(self.tree)
)
def test_no_adjacent(self):
cib_before = self.cib_resources
cib_after = """
<resources>
<group id="G">
<primitive id="RG1" />
<primitive id="RG2" />
<primitive id="RG3" />
<primitive id="R3" />
<primitive id="R1" />
</group>
<primitive id="R2" />
</resources>
"""
cib = etree.fromstring(cib_before)
relation.move_resources_to_group(
_resource(cib, "G"),
_resources(cib, "R3", "R1")
)
assert_xml_equal(cib_after, etree_to_str(cib))
def test_update_existing_nvset(self):
nvpair.arrange_first_nvset(
"nvset",
self.root,
{
"attr": "10",
"new_one": "20",
"test": "0",
"attr2": ""
},
self.id_provider
)
assert_xml_equal(
"""
<nvset id="nvset">
<nvpair id="nvset-attr" name="attr" value="10"/>
<notnvpair id="nvset-test" name="test" value="0"/>
<nvpair id="nvset-new_one" name="new_one" value="20"/>
<nvpair id="nvset-test-1" name="test" value="0"/>
</nvset>
""",
etree_to_str(self.nvset)
)
def push_cib(lib_env, custom_cib=None, wait=False):
i, expected_call = call_queue.take(CALL_TYPE_PUSH_CIB)
if custom_cib is None and expected_call.custom_cib:
raise AssertionError(
(
"Trying to call env.push_cib (call no. {0}) without "
"a custom cib but a custom cib was expected"
).format(i)
)
if custom_cib is not None and not expected_call.custom_cib:
raise AssertionError(
(
"Trying to call env.push_cib (call no. {0}) with a custom "
"cib but no custom cib was expected"
).format(i)
)
assert_xml_equal(
expected_call.cib_xml,
etree_to_str(lib_env.cib),
(
"Trying to call env.push_cib (call no. {0}) but cib in env does"
" not match\n\n"
).format(i)
)
if wait != expected_call.wait:
raise AssertionError(
(
"Trying to call env.push_cib (call no. {0}) with 'wait' == "
"{1} but it was expected 'wait' == {2}"
).format(i, wait, expected_call.wait)
)
if expected_call.exception:
raise expected_call.exception
def test_move_from_another_group(self):
# pylint: disable=no-self-use
cib_before = """
<resources>
<group id="G">
<primitive id="RG1" />
<primitive id="RG2" />
<primitive id="RG3" />
</group>
<group id="X">
<primitive id="R1" />
<primitive id="R2" />
</group>
<primitive id="R3" />
</resources>
"""
cib_after = """
<resources>
<group id="G">
<primitive id="RG1" />
<primitive id="RG2" />
<primitive id="RG3" />
<primitive id="R2" />
</group>
<group id="X">
<primitive id="R1" />
</group>
<primitive id="R3" />
</resources>
"""
cib = etree.fromstring(cib_before)
relation.move_resources_to_group(
_resource(cib, "G"),
_resources(cib, "R2"),
)
assert_xml_equal(cib_after, etree_to_str(cib))
def test_success(self):
lib.remove_device_from_all_levels(self.tree, "d3")
assert_xml_equal(
"""
<fencing-topology>
<fencing-level
id="fl1" index="1" devices="d1,d2" target="nodeA"
/>
<fencing-level
id="fl3" index="1" devices="d2,d1" target="nodeB"
/>
<fencing-level
id="fl5" index="1" devices="d4" target-pattern="node\\d+"
/>
<fencing-level
id="fl6" index="2" devices="d1" target-pattern="node\\d+"
/>
<fencing-level
id="fl7" index="3" devices="d4"
target-attribute="fencing" target-value="improved"
/>
<fencing-level
id="fl8" index="4" devices="d5"
target-attribute="fencing" target-value="improved"
/>
<fencing-level
id="fl9" index="3" devices="dR" target-pattern="node-R.*"
/>
<fencing-level
id="fl10" index="4" devices="dR-special"
target-attribute="fencing" target-value="remote-special"
/>
</fencing-topology>
""",
etree_to_str(self.tree),
)
def test_move_from_another_group(self):
# pylint: disable=no-self-use
cib_before = """
<resources>
<group id="G">
<primitive id="RG1" />
<primitive id="RG2" />
<primitive id="RG3" />
</group>
<group id="X">
<primitive id="R1" />
<primitive id="R2" />
</group>
<primitive id="R3" />
</resources>
"""
cib_after = """
<resources>
<group id="G">
<primitive id="RG1" />
<primitive id="RG2" />
<primitive id="RG3" />
<primitive id="R2" />
</group>
<group id="X">
<primitive id="R1" />
</group>
<primitive id="R3" />
</resources>
"""
cib = etree.fromstring(cib_before)
hierarchy.move_resources_to_group(
_resource(cib, "G"),
_resources(cib, "R2"),
)
assert_xml_equal(cib_after, etree_to_str(cib))
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 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_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 assert_element_content(section_element, expected_xml):
assert_xml_equal(etree_to_str(section_element), expected_xml)
def assert_xml_equal(self, expected):
assert_xml_equal(expected, etree_to_str(self.el))
def test_remove_element_without_parent(self):
lib.remove_one_element(self.root)
assert_xml_equal("<root><sub/></root>", etree_to_str(self.root))
def _prepare_state(state):
return etree_to_str(
fixture.complete_state_resources(etree.fromstring(state)))
def test_success(self):
lib.remove_all_levels(self.tree)
assert_xml_equal("<fencing-topology />", etree_to_str(self.tree))
def test_no_such_device(self):
original_xml = etree_to_str(self.tree)
lib.remove_device_from_all_levels(self.tree, "dX")
assert_xml_equal(original_xml, etree_to_str(self.tree))
def assert_unmanaged(pre, post):
resource = etree.fromstring(pre)
common.unmanage(resource, IdProvider(resource))
assert_xml_equal(post, etree_to_str(resource))
def test_rule(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,
{},
{},
nvset_rule=BoolExpr(
BOOL_AND,
[
RscExpr("ocf", "pacemaker", "Dummy"),
OpExpr("start", None),
BoolExpr(
BOOL_OR,
[
NodeAttrExpr(
NODE_ATTR_OP_DEFINED, "attr1", None, None
),
NodeAttrExpr(
NODE_ATTR_OP_GT,
"attr2",
"5",
NODE_ATTR_TYPE_NUMBER,
),
],
),
],
),
)
assert_xml_equal(
"""
<context id="a">
<meta_attributes id="a-meta_attributes">
<rule id="a-meta_attributes-rule"
boolean-op="and" score="INFINITY"
>
<rsc_expression
id="a-meta_attributes-rule-rsc-ocf-pacemaker-Dummy"
class="ocf" provider="pacemaker" type="Dummy"
/>
<op_expression id="a-meta_attributes-rule-op-start"
name="start"
/>
<rule id="a-meta_attributes-rule-rule"
boolean-op="or" score="0"
>
<expression id="a-meta_attributes-rule-rule-expr"
operation="defined" attribute="attr1"
/>
<expression id="a-meta_attributes-rule-rule-expr-1"
attribute="attr2" operation="gt"
type="number" value="5"
/>
</rule>
</rule>
</meta_attributes>
</context>
""",
etree_to_str(context_element),
)
def _find_all_in(cib_tree, element_xpath):
element_list = cib_tree.xpath(element_xpath)
if not element_list:
raise AssertionError("Cannot find '{0}' in given cib:\n{1}".format(
element_xpath, etree_to_str(cib_tree)))
return element_list
def test_found(self):
assert_xml_equal(
etree_to_str(node._get_node_by_uname(self.nodes, "name-test1")),
"""<node id="id-test1" uname="name-test1" />""",
)
def test_node_already_exists(self):
assert_xml_equal(
etree_to_str(node._ensure_node_exists(self.nodes, "name-test1")),
etree_to_str(self.node1),
)
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 assert_cib(tree, expected_xml):
xml = etree.fromstring('<root id="X"/>')
rule.rule_to_cib(xml, IdProvider(xml), tree)
assert_xml_equal('<root id="X">' + expected_xml + "</root>",
etree_to_str(xml))
def test_remove_element_with_parent(self):
lib.remove_one_element(self.sub)
assert_xml_equal("<root/>", etree_to_str(self.root))
def load_state(self,
name="runner.pcmk.load_state",
filename="crm_mon.minimal.xml",
resources=None,
raw_resources=None,
nodes=None,
stdout="",
stderr="",
returncode=0):
"""
Create call for loading pacemaker state.
string name -- key of the call
string filename -- points to file with the status in the content
string resources -- xml - resources section, will be put to state
string nodes -- iterable of node dicts
string stdout -- crm_mon's stdout
string stderr -- crm_mon's stderr
int returncode -- crm_mon's returncode
"""
if ((resources or raw_resources is not None or nodes)
and (stdout or stderr or returncode)):
raise AssertionError(
"Cannot specify resources or nodes when stdout, stderr or "
"returncode is specified")
if resources and raw_resources is not None:
raise AssertionError(
"Cannot use 'resources' and 'raw_resources' together")
if (stdout or stderr or returncode):
self.__calls.place(
name,
RunnerCall("crm_mon --one-shot --as-xml --inactive",
stdout=stdout,
stderr=stderr,
returncode=returncode))
return
state = etree.fromstring(open(rc(filename)).read())
if raw_resources is not None:
resources = fixture_state_resources_xml(**raw_resources)
if resources:
state.append(complete_state_resources(etree.fromstring(resources)))
if nodes:
nodes_element = state.find("./nodes")
for node in nodes:
nodes_element.append(
etree.fromstring(fixture_state_node_xml(**node)))
# set correct number of nodes and resources into the status
resources_count = len(
state.xpath(" | ".join([
"./resources/bundle",
"./resources/clone",
"./resources/group",
"./resources/resource",
])))
nodes_count = len(state.findall("./nodes/node"))
state.find("./summary/nodes_configured").set("number",
str(nodes_count))
state.find("./summary/resources_configured").set(
"number", str(resources_count))
self.__calls.place(
name,
RunnerCall(
"crm_mon --one-shot --as-xml --inactive",
stdout=etree_to_str(state),
))
def test_node_missing_and_gets_created(self):
assert_xml_equal(
etree_to_str(
node._ensure_node_exists(self.nodes,
"name-test2", self.state)),
etree_to_str(self.node2))
def _cannot_multireplace(tag, parent_xpath, cib_tree):
return AssertionError(
("Cannot replace '{element}' in '{parent}' because '{parent}'"
" contains more than one '{element}' in given cib:\n{cib}").format(
element=tag, parent=parent_xpath, cib=etree_to_str(cib_tree)))
