def validate_cim_xml(cim_xml_str, root_elem_name=None):
"""
Validate a CIM-XML string against the CIM-XML DTD, optionally
requiring a particular XML root element.
If the validation succeeds, the function returns. Otherwise,
`CIMXMLValidationError` is raised and its exception message is the
(possible multi-line) output of the `xmllint` command.
Parameters:
cim_xml_str (string): CIM-XML string to be validated.
root_elem_name (string): Name of XML element that is expected as the root
element in the CIM-XML string to be validated.
`None` means no checking for a particular root element is performed.
Raises:
CIMXMLValidationError: CIM-XML validation error
"""
# The DOCTYPE instruction needs the DTD file with forward slashes.
# Also, the xmllint used on Windows requires forward slashes and complains
# with "Could not parse DTD tests\dtd\DSP0203_2.3.1.dtd" if invoked
# with backslashes.
dtd_file_fw = DTD_FILE.replace('\\', '/')
# Make sure the validator checks the specified root element, if any
if root_elem_name is not None:
cim_xml_str = u'<!DOCTYPE {0} SYSTEM "{1}">\n{2}'. \
format(root_elem_name, dtd_file_fw, cim_xml_str)
xmllint_cmd = 'xmllint --valid --noout -'
else:
xmllint_cmd = 'xmllint --dtdvalid {0} --noout -'.format(dtd_file_fw)
p = Popen(xmllint_cmd, stdout=PIPE, stderr=STDOUT, stdin=PIPE, shell=True)
cim_xml_str = _ensure_bytes(cim_xml_str)
p.stdin.write(cim_xml_str)
p.stdin.close()
status = p.wait()
if status != 0:
out_lines = p.stdout.readlines()
p.stdout.close()
output = _ensure_unicode(b'\n'.join(out_lines))
raise CIMXMLValidationError(output)
p.stdout.close()
def assertXMLEqual(s_act, s_exp, entity):
"""
Assert that the two XML fragments are equal, tolerating the following
variations:
* whitespace outside of element content and attribute values.
* order of attributes.
* order of certain child elements (see `sort_elements` in this
function).
Parameters:
* s_act and s_exp are string representations of an XML fragment. The
strings may be Unicode strings or UTF-8 encoded byte strings.
The strings may contain an encoding declaration even when
they are Unicode strings.
Note: An encoding declaration is the `encoding` attribute in the
XML declaration (aka XML processing statement), e.g.:
<?xml version="1.0" encoding="utf-8" ?>
* entity (string): A human readable identification for what is compared.
"""
# Make sure that None values are already excluded by the caller
assert isinstance(s_act, (six.text_type, six.binary_type))
assert isinstance(s_exp, (six.text_type, six.binary_type))
# Ensure Unicode strings and remove encoding from XML declaration
encoding_pattern = re.compile(
r'^<\?xml +(([a-zA-Z0-9_]+=".*")?) +' +
r'encoding="utf-8" +(([a-zA-Z0-9_]+=".*")?) *\?>')
encoding_repl = r'<?xml \1 \3 ?>'
s_act = re.sub(encoding_pattern, encoding_repl, _ensure_unicode(s_act))
s_exp = re.sub(encoding_pattern, encoding_repl, _ensure_unicode(s_exp))
parser = etree.XMLParser(remove_blank_text=True)
try:
# Note: lxml.etree.XML() has issues with unicode strings as input,
# so we pass UTF-8 encoded byte strings. See lxml bug
# https://bugs.launchpad.net/lxml/+bug/1902364 for a similar issue
# with lxml.etree.fromstring().
x_act = etree.XML(_ensure_bytes(s_act), parser=parser)
x_exp = etree.XML(_ensure_bytes(s_exp), parser=parser)
except etree.XMLSyntaxError as exc:
raise AssertionError("XML cannot be validated for %s: %s" %
(entity, exc))
def sort_embedded(root, sort_elements):
"""
Helper function for `sort_children()`, in support of embedded
objects. This function invokes sort_children() on each embedded
object in `root`, after unembedding the embedded object.
Parameters:
root (etree.Element):
XML tree of the CIM-XML representation of the CIM element that
contains an embedded CIM object (e.g. the CIM element may be
an INSTANCE XML element and one of its PROPERTY child elements
has a value that is an embedded CIM instance).
"""
emb_elems = root.xpath("//*[@EmbeddedObject or @EMBEDDEDOBJECT]"
"/*[local-name() = 'VALUE' or "
"local-name() = 'VALUE.ARRAY']")
for emb_elem in emb_elems:
elem = xml_unembed(emb_elem.text)
sort_children(elem, sort_elements)
emb_elem.text = xml_embed(elem)
def sort_children(root, sort_elements):
"""
Sort certain elements in the `root` parameter to facilitate
comparison of two XML documents.
In addition, make sure this is also applied to any embedded
objects (in their unembedded state).
"""
sort_embedded(root, sort_elements)
for tag, attr in sort_elements:
# elems is a list of elements with this tag name
elems = root.xpath("//*[local-name() = $tag]", tag=tag)
if elems:
parent = elems[0].getparent()
first = None
after = None
for i, p in enumerate(parent):
# TODO 6/18 AM: Loop above should probably be on elems
if p.tag == tag and first is None:
first = i
if p.tag != tag and first is not None:
after = i
# The following changes the original XML tree:
# The following pylint warning can safely be disabled, see
# https://stackoverflow.com/a/25314665
# pylint: disable=cell-var-from-loop
parent[first:after] = sorted(elems,
key=lambda e: e.attrib[attr])
sort_elements = [
# Sort sibling elements with <first> tag by its <second> attribute
("IPARAMVALUE", "NAME"),
("PROPERTY", "NAME"),
("PROPERTY.ARRAY", "NAME"),
("PARAMETER", "NAME"),
("KEYBINDING", "NAME"),
]
sort_children(x_act, sort_elements)
sort_children(x_exp, sort_elements)
ns_act = _ensure_unicode(etree.tostring(x_act))
ns_exp = _ensure_unicode(etree.tostring(x_exp))
checker = doctestcompare.LXMLOutputChecker()
# This tolerates differences in whitespace and attribute order
if not checker.check_output(ns_act, ns_exp, 0):
diff = checker.output_difference(doctest.Example("", ns_exp), ns_act,
0)
raise AssertionError("XML is not as expected in %s: %s" %
(entity, diff))