def test_xml_compare():
t1 = XML('<test />')
t2 = XML('<test/>')
assert dxml.xml_compare(t1, t2, sys.stdout.write)
assert dxml.xml_compare(XML('''<hey>
<you>!!</you> </hey>'''), XML('<hey><you>!!</you></hey>'),
sys.stdout.write)
def test_xml_compare():
t1 = XML('<test />')
t2 = XML('<test/>')
assert dxml.xml_compare(t1, t2, sys.stdout.write)
assert dxml.xml_compare(XML('''<hey>
<you>!!</you> </hey>'''), XML('<hey><you>!!</you></hey>'),
sys.stdout.write)
def assertXMLEqual(self, first, second):
first = fromstring(first)
second = fromstring(second)
try:
self.assertTrue(xml_compare(first, second))
except AssertionError:
print(tostring(first))
print(tostring(second))
xml_compare(first, second, print)
raise
def assertXMLEqual(self, first, second):
from lxml.etree import fromstring, tostring
from formencode.doctest_xml_compare import xml_compare
# __import__('ipdb').set_trace()
first = fromstring(first)
second = fromstring(second)
try:
self.assertTrue(xml_compare(first, second))
except AssertionError:
print(tostring(first))
print(tostring(second))
xml_compare(first, second, print)
raise
def test_env_private(self):
env = Environment(private=False)
assert_true(xml_compare(etree.fromstring("""
<environment xmlns="http://www.eeml.org/xsd/0.5.1">
<private>false</private>
</environment>"""), env.toeeml(), reporter=self.fail))
env = Environment(private=True)
assert_true(xml_compare(etree.fromstring("""
<environment xmlns="http://www.eeml.org/xsd/0.5.1">
<private>true</private>
</environment>"""), env.toeeml(), reporter=self.fail))
with self.assertRaises(ValueError):
Environment(private='foobar')
def html_string_compare(astr, bstr):
"""
compare to strings containing html based on html
equivalence. Raises ValueError if the strings are
not equivalent.
"""
def reporter(x):
print x
a = None
b = None
try:
a = etree.HTML(astr)
except:
print a
raise
try:
b = etree.HTML(bstr)
except:
print b
raise
reporter = []
result = xml_compare(a, b, reporter.append)
if not result:
raise ValueError("Comparison failed between actual:\n==================\n%s\n\nexpected:\n==================\n%s\n\nReport:\n%s"
% (astr, bstr, '\n'.join(reporter)))
def runTest(self):
files_to_test = ["instance_xmlns_test.xls"]
for file_to_test in files_to_test:
path_to_excel_file = utils.path_to_text_fixture(file_to_test)
#Get the xform output path:
directory, filename = os.path.split(path_to_excel_file)
root_filename, ext = os.path.splitext(filename)
path_to_output_xform = os.path.join(directory,
root_filename + "_output.xml")
path_to_expected_xform = os.path.join(directory,
root_filename + ".xml")
#Do the conversion:
json_survey = xls2json.parse_file_to_json(path_to_excel_file)
survey = pyxform.create_survey_element_from_dict(json_survey)
survey.print_xform_to_file(path_to_output_xform)
#Compare with the expected output:
with codecs.open(path_to_expected_xform, 'rb',
encoding="utf-8") as expected_file:
expected = etree.fromstring(expected_file.read())
result = etree.fromstring(survey.to_xml())
reporter = lambda x: sys.stdout.write(x + "\n")
self.assertTrue(
xml_compare(expected, result, reporter=reporter))
os.remove(path_to_output_xform)
def runTest(self):
files_to_test = ["instance_xmlns_test.xls"]
for file_to_test in files_to_test:
path_to_excel_file = utils.path_to_text_fixture(file_to_test)
# Get the xform output path:
directory, filename = os.path.split(path_to_excel_file)
root_filename, ext = os.path.splitext(filename)
path_to_output_xform = os.path.join(
directory, root_filename + "_output.xml")
path_to_expected_xform = os.path.join(
directory, root_filename + ".xml")
# Do the conversion:
json_survey = xls2json.parse_file_to_json(path_to_excel_file)
survey = pyxform.create_survey_element_from_dict(json_survey)
survey.print_xform_to_file(path_to_output_xform)
# Compare with the expected output:
with codecs.open(path_to_expected_xform, 'rb', encoding="utf-8"
) as expected_file:
expected = ETree.fromstring(expected_file.read())
result = ETree.fromstring(survey.to_xml())
def write_line(x): sys.stdout.write(x + "\n")
reporter = write_line
self.assertTrue(xml_compare(
expected, result, reporter=reporter))
os.remove(path_to_output_xform)
def test_to_xml_string(self):
"""Test exporting in XML string format."""
# read and parse sample file
self.build = BuildJob(constants.TEST_SAMPLE_TIMESTAMP_FILE)
# test xml string output
self.assertEqual(
b'<build>\n'
b' <stages>\n'
b' <stage duration="2.0" name="stage1"/>\n'
b' <stage duration="5.0" name="stage2"/>\n'
b' <stage duration="10.0" name="stage3"/>\n'
b' </stages>\n'
b'</build>\n', self.build.to_xml_string())
# add properties
self.build.add_property('property1', 2)
self.build.add_property('property2', 3)
# test xml string output
expected_xml = etree.fromstring(
b'<build property1="2" property2="3">\n'
b' <stages>\n'
b' <stage duration="2.0" name="stage1"/>\n'
b' <stage duration="5.0" name="stage2"/>\n'
b' <stage duration="10.0" name="stage3"/>\n'
b' </stages>\n'
b'</build>\n')
self.assertTrue(
xml_compare(expected_xml,
etree.fromstring(self.build.to_xml_string())))
def test_multiple_update(self):
pac = Cosm(1, 'ASDF')
pac.update(
[Data(1, 10),
Data(2, 22, unit=RH()),
Data(3, 44),
Data(5, 65)])
pac.update([Data(2, 476), Data(5, -1)])
assert_true(
xml_compare(etree.fromstring("""
<eeml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" xsi:schemaLocation="http://www.eeml.org/xsd/0.5.1 http://www.eeml.org/xsd/0.5.1/0.5.1.xsd" version="0.5.1">
<environment>
<data id="1">
<current_value>10</current_value>
</data>
<data id="2">
<current_value>476</current_value>
</data>
<data id="3">
<current_value>44</current_value>
</data>
<data id="5">
<current_value>-1</current_value>
</data>
</environment>
</eeml>"""),
etree.fromstring(pac.geteeml()),
reporter=self.fail))
def test_multiple_update(self):
pac = Cosm(1, 'ASDF')
pac.update([
Data(1, 10),
Data(2, 22, unit=RH()),
Data(3, 44),
Data(5, 65)])
pac.update([
Data(2, 476),
Data(5, -1)])
assert_true(xml_compare(etree.fromstring("""
<eeml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" xsi:schemaLocation="http://www.eeml.org/xsd/0.5.1 http://www.eeml.org/xsd/0.5.1/0.5.1.xsd" version="0.5.1">
<environment>
<data id="1">
<current_value>10</current_value>
</data>
<data id="2">
<current_value>476</current_value>
</data>
<data id="3">
<current_value>44</current_value>
</data>
<data id="5">
<current_value>-1</current_value>
</data>
</environment>
</eeml>"""),
etree.fromstring(pac.geteeml()), reporter=self.fail))
def test_good_environment(self):
env = Environment('A Room Somewhere',
'http://www.cosm.com/feeds/1.xml',
'frozen',
'This is a room somewhere',
'http://www.roomsomewhere/icon.png',
'http://www.roomsomewhere/',
'myemail@roomsomewhere',
updated='2007-05-04T18:13:51.0Z',
creator='http://www.somewhere',
id_=1)
assert_true(
xml_compare(etree.fromstring("""
<environment xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" creator="http://www.somewhere" id="1" updated="2007-05-04T18:13:51.0Z">
<title>A Room Somewhere</title>
<feed>http://www.cosm.com/feeds/1.xml</feed>
<status>frozen</status>
<description>This is a room somewhere</description>
<icon>http://www.roomsomewhere/icon.png</icon>
<website>http://www.roomsomewhere/</website>
<email>myemail@roomsomewhere</email>
</environment>"""),
env.toeeml(),
reporter=self.fail))
def test_to_xml_string(self):
"""Test exporting in XML string format."""
# read and parse sample file
self.build = BuildJob(constants.TEST_SAMPLE_TIMESTAMP_FILE)
# test xml string output
self.assertEqual(
b'<build>\n'
b' <stages>\n'
b' <stage duration="2.0" name="stage1"/>\n'
b' <stage duration="5.0" name="stage2"/>\n'
b' <stage duration="10.0" name="stage3"/>\n'
b' </stages>\n'
b'</build>\n',
self.build.to_xml_string())
# add properties
self.build.add_property('property1', 2)
self.build.add_property('property2', 3)
# test xml string output
expected_xml = etree.fromstring(
b'<build property1="2" property2="3">\n'
b' <stages>\n'
b' <stage duration="2.0" name="stage1"/>\n'
b' <stage duration="5.0" name="stage2"/>\n'
b' <stage duration="10.0" name="stage3"/>\n'
b' </stages>\n'
b'</build>\n'
)
self.assertTrue(
xml_compare(
expected_xml, etree.fromstring(self.build.to_xml_string())
)
)
def test_good_unit(self):
unit = Unit("Celzius", 'basicSI', "C")
assert_true(xml_compare(etree.fromstring(
"""
<unit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" type="basicSI" symbol="C">Celzius</unit>
""".strip()), unit.toeeml(), reporter=self.fail))
def _cmpXml(got, ref):
print "- " * 5 + "GOT:" + " -" * 20
print got
print "- " * 28
tree1 = etree.fromstring(str(got))
tree2 = etree.fromstring(str(ref))
assert xml_compare(tree1, tree2, lambda x: sys.stdout.write(x + "\n"))
def test_new_widgets(self):
survey = utils.build_survey('widgets.xls')
path = utils.path_to_text_fixture('widgets.xml')
survey.to_xml
with open(path) as f:
expected = etree.fromstring(survey.to_xml())
result = etree.fromstring(f.read())
self.assertTrue(xml_compare(expected, result))
def test_parse(self):
for xml0 in [GET]:
o = ofc.OFCapableSwitchType.from_xml(xml0)
xml1 = o.to_xml('capable-switch')
ok_(
xml_compare(ET.fromstring(xml0),
ET.fromstring(xml1),
reporter=sys.stderr.write))
def test_new_widgets(self):
survey = utils.build_survey('widgets.xls')
path = utils.path_to_text_fixture('widgets.xml')
survey.to_xml
with open(path) as f:
expected = etree.fromstring(survey.to_xml())
result = etree.fromstring(f.read())
self.assertTrue(xml_compare(expected, result))
def test_good_unit(self):
unit = Unit("Celzius", 'basicSI', "C")
assert_true(
xml_compare(etree.fromstring("""
<unit xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" type="basicSI" symbol="C">Celzius</unit>
"""),
unit.toeeml(),
reporter=self.fail))
def run_filename(filename):
f = open(filename)
content = f.read()
f.close()
parts = re.split(r"---*", content)
template = parts[0]
expected = parts[1]
if len(parts) == 3:
data_content = parts[2].strip()
elif len(parts) > 3:
print parts[3:]
assert 0, "Too many sections"
else:
data_content = ""
namespace = {}
if data_content:
exec data_content in namespace
data = namespace.copy()
data["defaults"] = data.get("defaults", {})
if data.has_key("check"):
checker = data["check"]
del data["check"]
else:
def checker(p, s):
pass
for name in data.keys():
if name.startswith("_") or hasattr(__builtin__, name):
del data[name]
listener = htmlfill_schemabuilder.SchemaBuilder()
p = htmlfill.FillingParser(listener=listener, **data)
p.feed(template)
p.close()
output = p.text()
def reporter(v):
print v
try:
output_xml = ET.XML(output)
expected_xml = ET.XML(expected)
except ExpatError:
comp = output.strip() == expected.strip()
else:
comp = xml_compare(output_xml, expected_xml, reporter)
if not comp:
print "---- Output: ----"
print output
print "---- Expected: ----"
print expected
assert 0
checker(p, listener.schema())
checker(p, htmlfill_schemabuilder.parse_schema(template))
def test_to_xml(self):
"""Test to_xml()"""
# read and parse sample file
self.stages.read_csv(constants.TEST_SAMPLE_TIMESTAMP_FILE)
# test xml output
expected_xml = etree.fromstring(
b'<stages><stage duration="2.0" name="stage1"/>'
b'<stage duration="5.0" name="stage2"/>'
b'<stage duration="10.0" name="stage3"/></stages>')
self.assertTrue(xml_compare(expected_xml, self.stages.to_xml()))
def test_env_private(self):
env = Environment(private=False)
assert_true(
xml_compare(etree.fromstring("""
<environment xmlns="http://www.eeml.org/xsd/0.5.1">
<private>false</private>
</environment>"""),
env.toeeml(),
reporter=self.fail))
env = Environment(private=True)
assert_true(
xml_compare(etree.fromstring("""
<environment xmlns="http://www.eeml.org/xsd/0.5.1">
<private>true</private>
</environment>"""),
env.toeeml(),
reporter=self.fail))
with self.assertRaises(ValueError):
Environment(private='foobar')
def assert_equal_xml(generated_xml, expected_xml):
"""
:type generated_xml: str
:type expected_xml: str
"""
__tracebackhide__ = True # noqa
differences = []
def append_to_messages(message):
"""
:type message: str
"""
differences.append(' * {}'.format(message))
generated_root_element = etree.fromstring(generated_xml.encode('utf-8'))
expected_root_element = etree.fromstring(expected_xml.encode('utf-8'))
xml_compare(expected_root_element, generated_root_element, reporter=append_to_messages)
if differences:
raise AssertionError('\n{}'.format('\n'.join(differences)))
def test_good_location(self):
loc = Location('My Room', 32.4, 22.7, 0.2, 'indoor', 'physical', 'fixed')
assert_true(xml_compare(etree.fromstring(
"""
<location xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" disposition="fixed" domain="physical" exposure="indoor">
<name>My Room</name>
<lat>32.4</lat>
<lon>22.7</lon>
<ele>0.2</ele>
</location>
""".strip()), loc.toeeml(), reporter=self.fail))
def test_to_xml(self):
"""Test to_xml()"""
# read and parse sample file
self.stages.read_csv(constants.TEST_SAMPLE_TIMESTAMP_FILE)
# test xml output
expected_xml = etree.fromstring(
b'<stages><stage duration="2.0" name="stage1"/>'
b'<stage duration="5.0" name="stage2"/>'
b'<stage duration="10.0" name="stage3"/></stages>'
)
self.assertTrue(xml_compare(expected_xml, self.stages.to_xml()))
def run_filename(filename):
f = open(filename)
content = f.read()
f.close()
parts = re.split(r"---*", content)
template = parts[0]
expected = parts[1]
if len(parts) == 3:
data_content = parts[2].strip()
elif len(parts) > 3:
assert False, "Too many sections: %s" % parts[3:]
else:
data_content = ""
namespace = {}
if data_content:
six.exec_(data_content, namespace)
data = namespace.copy()
data["defaults"] = data.get("defaults", {})
if "check" in data:
checker = data.pop("check")
else:
def checker(p, s):
pass
for name in list(data.keys()):
if name.startswith("_") or hasattr("__builtin__", name):
del data[name]
listener = htmlfill_schemabuilder.SchemaBuilder()
p = htmlfill.FillingParser(listener=listener, **data)
p.feed(template)
p.close()
output = p.text()
def reporter(v):
print(v)
try:
output_xml = ET.XML(output)
expected_xml = ET.XML(expected)
except XMLParseError:
comp = output.strip() == expected.strip()
else:
comp = xml_compare(output_xml, expected_xml, reporter)
if not comp:
print("---- Output: ----")
print(output)
print("---- Expected: ----")
print(expected)
assert False
checker(p, listener.schema())
checker(p, htmlfill_schemabuilder.parse_schema(template))
def run_filename(filename):
f = open(filename)
content = f.read()
f.close()
parts = re.split(r'---*', content)
template = parts[0]
expected = parts[1]
if len(parts) == 3:
data_content = parts[2].strip()
elif len(parts) > 3:
assert False, "Too many sections: %s" % parts[3:]
else:
data_content = ''
namespace = {}
if data_content:
exec data_content in namespace
data = namespace.copy()
data['defaults'] = data.get('defaults', {})
if 'check' in data:
checker = data.pop('check')
else:
def checker(p, s):
pass
for name in data.keys():
if name.startswith('_') or hasattr('__builtin__', name):
del data[name]
listener = htmlfill_schemabuilder.SchemaBuilder()
p = htmlfill.FillingParser(listener=listener, **data)
p.feed(template)
p.close()
output = p.text()
def reporter(v):
print v
try:
output_xml = ET.XML(output)
expected_xml = ET.XML(expected)
except XMLParseError:
comp = output.strip() == expected.strip()
else:
comp = xml_compare(output_xml, expected_xml, reporter)
if not comp:
print '---- Output: ----'
print output
print '---- Expected: ----'
print expected
assert False
checker(p, listener.schema())
checker(p, htmlfill_schemabuilder.parse_schema(template))
def test_novalue(self):
"""Test initial state the function and class instances."""
# number of stages should be zero
self.assertEqual(0, len(self.stages.stages))
# test total duration
self.assertEqual(0, self.stages.total_duration())
# test started_at and finished_at
self.assertEqual(None, self.stages.started_at)
self.assertEqual(None, self.stages.finished_at)
# xml shouldn't contain items
self.assertTrue(
xml_compare(etree.fromstring(b"<stages/>"), self.stages.to_xml()))
self.assertEqual(b"<stages/>\n", self.stages.to_xml_string())
def main():
# TODO: specify requirements and check inputs.
module=AnsibleModule(
argument_spec=dict(
host=dict(),
state=dict(),
name=dict(),
template=dict(),
)
)
host = module.params['host']
state = module.params['state']
name = module.params['name']
template = module.params['template']
# TODO: try catch here
J = Jenkins(host)
# TODO: try catch here
# TODO: how to handle paths?
if (template):
txt = open(template)
job_config = txt.read()
job_config_xml = etree.fromstring(job_config)
# There are 4 possible outcomes: created, updated, deleted, nochange.
if (state == 'present'):
# If the desired state is present we must check if the job exists and then check if the job has changed.
if (J.has_job(name)):
# The job exists so we must compare the XMLs for changes and update if they don't match.
current_conf = J[name].get_config()
current_conf = current_conf.encode('ascii','replace')
current_conf_xml = etree.fromstring(current_conf)
if (xml_compare(job_config_xml, current_conf_xml)):
module.exit_json(msg="job exists", changed=False)
else:
J[name].update_config(job_config)
module.exit_json(msg="job updated", changed=True)
else:
new_job = J.create_job(name, job_config)
module.exit_json(msg="job created", changed=True)
elif (state == 'absent'):
if (J.has_job(name)):
J.delete_job(name)
module.exit_json(msg="job deleted", changed=True)
else:
module.exit_json(msg="job does not exist", changed=False)
module.exit_json(msg=J.version, changed=False)
def test_extension(self):
xmlstring = """
<Extension url="http://example.com/ExtensionThingy">
<valueString value="Hurray for me"/>
</Extension>
"""
ext = fhir.model.Extension()
ext.url = 'http://example.com/ExtensionThingy'
ext.value = fhir.model.string('Hurray for me')
x1 = ET.fromstring(xmlstring)
x2 = ET.fromstring(ext.toXML())
self.assertTrue(xml_compare(x1, x2))
def test_multipleBoolean(self):
xmlstring = """
<Multiple xmlns="http://hl7.org/fhir">
<multiBoolean value="true"/>
</Multiple>
"""
m = Multiple()
m.multi = fhir.model.boolean(True)
x1 = ET.fromstring(xmlstring)
x2 = ET.fromstring(m.toXML())
msg = 'Serialized Resource does not match expected XML representation!'
self.assertTrue(xml_compare(x1, x2), msg)
def run_filename(filename):
f = open(filename)
content = f.read()
f.close()
parts = re.split(r'---*', content)
template = parts[0]
expected = parts[1]
if len(parts) == 3:
data_content = parts[2].strip()
elif len(parts) > 3:
assert False, "Too many sections: %s" % parts[3:]
else:
data_content = ''
namespace = {}
if data_content:
exec data_content in namespace
data = namespace.copy()
data['defaults'] = data.get('defaults', {})
if 'check' in data:
checker = data.pop('check')
else:
def checker(p, s):
pass
for name in data.keys():
if name.startswith('_') or hasattr('__builtin__', name):
del data[name]
listener = htmlfill_schemabuilder.SchemaBuilder()
p = htmlfill.FillingParser(listener=listener, **data)
p.feed(template)
p.close()
output = p.text()
def reporter(v):
print v
try:
output_xml = ET.XML(output)
expected_xml = ET.XML(expected)
except XMLParseError:
comp = output.strip() == expected.strip()
else:
comp = xml_compare(output_xml, expected_xml, reporter)
if not comp:
print '---- Output: ----'
print output
print '---- Expected: ----'
print expected
assert False
checker(p, listener.schema())
checker(p, htmlfill_schemabuilder.parse_schema(template))
def assert_equal_xml(generated_xml, expected_xml):
"""
:type generated_xml: str
:type expected_xml: str
"""
__tracebackhide__ = True # noqa
differences = []
def append_to_messages(message):
"""
:type message: str
"""
differences.append(' * {}'.format(message))
generated_root_element = etree.fromstring(generated_xml.encode('utf-8'))
expected_root_element = etree.fromstring(expected_xml.encode('utf-8'))
xml_compare(expected_root_element,
generated_root_element,
reporter=append_to_messages)
if differences:
raise AssertionError('\n{}'.format('\n'.join(differences)))
def test_novalue(self):
"""Test initial state the function and class instances."""
# number of stages should be zero
self.assertEqual(0, len(self.stages.stages))
# test total duration
self.assertEqual(0, self.stages.total_duration())
# test started_at and finished_at
self.assertEqual(None, self.stages.started_at)
self.assertEqual(None, self.stages.finished_at)
# xml shouldn't contain items
self.assertTrue(
xml_compare(etree.fromstring(b"<stages/>"), self.stages.to_xml())
)
self.assertEqual(b"<stages/>\n", self.stages.to_xml_string())
def _xml_semantic_compare(left_xml_str, right_xml_str):
"""
Compare two XML strings semantically to ensure the content is the same.
"""
# Reasons for using lxml.etree instead of Python's xml.etree.ElementTree:
# - The XML strings do not contain an XML directive specifying the
# encoding, and the encoding parameter of ElementTree.XMLParser() does
# not seem to work.
# - ET.fromstring() and ET.XML() do not handle byte strings in Python 2.x
# (see bugs.python.org/issue11033), so a manual conversion to unicode
# would be needed.
left_xml = etree.fromstring(left_xml_str)
right_xml = etree.fromstring(right_xml_str)
return doctest_xml_compare.xml_compare(left_xml, right_xml)
def main():
# TODO: specify requirements and check inputs.
module = AnsibleModule(argument_spec=dict(
host=dict(),
state=dict(),
name=dict(),
template=dict(),
))
host = module.params['host']
state = module.params['state']
name = module.params['name']
template = module.params['template']
# TODO: try catch here
J = Jenkins(host)
# TODO: try catch here
# TODO: how to handle paths?
if (template):
txt = open(template)
job_config = txt.read()
job_config_xml = etree.fromstring(job_config)
# There are 4 possible outcomes: created, updated, deleted, nochange.
if (state == 'present'):
# If the desired state is present we must check if the job exists and then check if the job has changed.
if (J.has_job(name)):
# The job exists so we must compare the XMLs for changes and update if they don't match.
current_conf = J[name].get_config()
current_conf = current_conf.encode('ascii', 'replace')
current_conf_xml = etree.fromstring(current_conf)
if (xml_compare(job_config_xml, current_conf_xml)):
module.exit_json(msg="job exists", changed=False)
else:
J[name].update_config(job_config)
module.exit_json(msg="job updated", changed=True)
else:
new_job = J.create_job(name, job_config)
module.exit_json(msg="job created", changed=True)
elif (state == 'absent'):
if (J.has_job(name)):
J.delete_job(name)
module.exit_json(msg="job deleted", changed=True)
else:
module.exit_json(msg="job does not exist", changed=False)
module.exit_json(msg=J.version, changed=False)
def assert_xml_compare(a, b):
report = []
def reporter(problem):
report.append(problem)
if not xml_compare(etree.XML(a), etree.XML(b), reporter=reporter):
print(a)
print()
print(b)
print()
print('XML compare report:')
for r_line in report:
print(r_line)
assert False
def assert_xml_equals(actual, expected):
'''
Assert xml files/strings are equivalent.
Differences in formatting or attribute order are ignored. Comments are
ignored as well. Differences in element order are significant though!
Parameters
----------
actual : ~typing.BinaryIO or ~pathlib.Path or str
Actual XML, as file object or Path to XML file, or XML contents as
string.
expected : ~typing.BinaryIO or ~pathlib.Path or str
Expected XML, as file object or Path to XML file, or XML contents as
string.
'''
# Note: if this ever breaks, there is a way to write out XML to file
# canonicalised. StringIO may help in not having to use any temp files
# http://lxml.de/api/lxml.etree._ElementTree-class.html#write_c14n
def tree(xml):
if isinstance(xml, str):
xml = etree.fromstring(str(xml))
else:
if isinstance(xml, Path):
xml = str(xml)
xml = etree.parse(xml)
return xml.getroot()
def raise_assert(msg):
assert False, (f'XMLs differ\n'
f'Actual XML: {actual}\n'
f'Expected XML: {expected}\n'
f'Difference: {msg}')
xml_compare(tree(actual), tree(expected), reporter=raise_assert)
def test_good_location(self):
loc = Location('physical', 'My Room', 32.4, 22.7, 0.2, 'indoor',
'fixed')
assert_true(
xml_compare(etree.fromstring("""
<location xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" disposition="fixed" domain="physical" exposure="indoor">
<name>My Room</name>
<lat>32.4</lat>
<lon>22.7</lon>
<ele>0.2</ele>
</location>
"""),
loc.toeeml(),
reporter=self.fail))
def test_multipleDateTime(self):
xmlstring = """
<Multiple xmlns="http://hl7.org/fhir">
<multiDateTime value="2080-01-01T00:00:00Z"/>
</Multiple>
"""
m = Multiple()
m.multi = fhir.model.dateTime("2080-01-01T00:00:00Z")
x1 = ET.fromstring(xmlstring)
x2 = ET.fromstring(m.toXML())
msg = 'Serialized Resource does not match expected XML representation!'
self.assertTrue(xml_compare(x1, x2), msg)
def assertXFormEqual(self, xform1, xform2):
xform1 = ETree.fromstring(xform1.encode('utf-8'))
xform2 = ETree.fromstring(xform2.encode('utf-8'))
# Sort tags under <model> section in each form
self.sort_model(xform1)
self.sort_model(xform2)
# Report any errors returned from xform_compare
errs = []
def reporter(msg):
errs.append(msg)
self.assertTrue(xml_compare(xform1, xform2, reporter),
"\n\n" + "\n".join(reversed(errs)))
def assertXFormEqual(self, xform1, xform2):
xform1 = etree.fromstring(xform1)
xform2 = etree.fromstring(xform2)
# Sort tags under <model> section in each form
self.sort_model(xform1)
self.sort_model(xform2)
# Report any errors returned from xform_compare
errs = []
def reporter(msg):
errs.append(msg)
self.assertTrue(
xml_compare(xform1, xform2, reporter),
"\n\n" + "\n".join(reversed(errs))
)
def test_good_data(self):
u = Unit('Celsius', 'derivedSI', 'C')
test_data = Data(
id=0,
value=10.0,
tags=['length'],
minValue=0,
maxValue=100,
unit=u)
assert_true(xml_compare(etree.fromstring(
"""
<data xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" id="0">
<tag>length</tag>
<current_value maxValue="100" minValue="0">10.0</current_value>
<unit symbol="C" type="derivedSI">Celsius</unit>
</data>
""".strip()), test_data.toeeml(), reporter=self.fail))
def _xml_semantic_compare(left_xml_str, right_xml_str):
"""
Compare two XML strings semantically to ensure the content is the same.
"""
# Reasons for using lxml.etree instead of Python's xml.etree.ElementTree
# (ET):
# - The XML strings do not contain an XML directive specifying the
# encoding, and the encoding parameter of ET.XMLParser() does not seem
# to work.
# - ET.fromstring() and ET.XML() do not handle byte strings in Python 2.x
# (see bugs.python.org/issue11033), so a manual conversion to unicode
# would be needed.
# Note: lxml.etree.fromstring() 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.
left_xml = etree.fromstring(_ensure_bytes(left_xml_str))
right_xml = etree.fromstring(_ensure_bytes(right_xml_str))
return doctest_xml_compare.xml_compare(left_xml, right_xml)
def test_good_datapoints(self):
env = Environment('A Room Somewhere',
'http://www.cosm.com/feeds/1.xml',
'frozen',
'This is a room somewhere',
'http://www.roomsomewhere/icon.png',
'http://www.roomsomewhere/',
'myemail@roomsomewhere',
updated=datetime(2007, 5, 4, 18, 13, 51, 0,
pytz.utc),
creator='http://www.somewhere',
id_=1)
datapoints = DataPoints(
1, [(0, ), (1, ),
(2, datetime(2007, 5, 4, 18, 13, 51, 0, pytz.utc))])
result = create_eeml(env, None, datapoints).toeeml()
assert_true(
xml_compare(etree.fromstring("""
<eeml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" xsi:schemaLocation="http://www.eeml.org/xsd/0.5.1 http://www.eeml.org/xsd/0.5.1/0.5.1.xsd" version="0.5.1">
<environment updated="2007-05-04T18:13:51+00:00" creator="http://www.somewhere" id="1">
<title>A Room Somewhere</title>
<feed>http://www.cosm.com/feeds/1.xml</feed>
<status>frozen</status>
<description>This is a room somewhere</description>
<icon>http://www.roomsomewhere/icon.png</icon>
<website>http://www.roomsomewhere/</website>
<email>myemail@roomsomewhere</email>
<data id="1">
<datapoints xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1">
<value>0</value>
<value>1</value>
<value at="2007-05-04T18:13:51+00:00">2</value>
</datapoints>
</data>
</environment>
</eeml>
"""),
result,
reporter=self.fail))
def test_good_data(self):
u = Unit('Celsius', 'derivedSI', 'C')
test_data = Data(id_=0,
value=10.0,
tags=['length', 'foo'],
minValue=0,
maxValue=100,
unit=u)
assert_true(
xml_compare(etree.fromstring("""
<data xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" id="0">
<tag>length</tag>
<tag>foo</tag>
<current_value maxValue="100" minValue="0">10.0</current_value>
<unit symbol="C" type="derivedSI">Celsius</unit>
</data>
"""),
test_data.toeeml(),
reporter=self.fail))
def test_multiple_datapoints(self):
env = Environment()
env.updateData(DataPoints(1, [(4,)]))
env.updateData(DataPoints(4, [(5,)]))
env.updateData(DataPoints(1, [(6,), (7,)]))
assert_true(xml_compare(etree.fromstring("""
<environment xmlns="http://www.eeml.org/xsd/0.5.1">
<data id="1">
<datapoints>
<value>6</value>
<value>7</value>
</datapoints>
</data>
<data id="4">
<datapoints>
<value>5</value>
</datapoints>
</data>
</environment>"""), env.toeeml(), reporter=self.fail))
def runTest(self):
path_to_excel_file = utils.path_to_text_fixture("xlsform_spec_test.xls")
#Get the xform output path:
directory, filename = os.path.split(path_to_excel_file)
root_filename, ext = os.path.splitext(filename)
path_to_xform = os.path.join(directory, root_filename + ".xml")
#Do the conversion:
json_survey = xls2json.parse_file_to_json(path_to_excel_file)
survey = pyxform.create_survey_element_from_dict(json_survey)
survey.print_xform_to_file(path_to_xform)
#Compare with the expected output:
expected_path = utils.path_to_text_fixture("spec_test_expected_output.xml")
with codecs.open(expected_path, 'rb', encoding="utf-8") as expected_file:
expected = etree.fromstring(expected_file.read())
result = etree.fromstring(survey.to_xml())
self.assertTrue(xml_compare(expected, result))
def test_multiple_datapoints(self):
env = Environment()
env.updateData(DataPoints(1, [(4, )]))
env.updateData(DataPoints(4, [(5, )]))
env.updateData(DataPoints(1, [(6, ), (7, )]))
assert_true(
xml_compare(etree.fromstring("""
<environment xmlns="http://www.eeml.org/xsd/0.5.1">
<data id="1">
<datapoints>
<value>6</value>
<value>7</value>
</datapoints>
</data>
<data id="4">
<datapoints>
<value>5</value>
</datapoints>
</data>
</environment>"""),
env.toeeml(),
reporter=self.fail))
def test_good_environment(self):
env = Environment('A Room Somewhere',
'http://www.cosm.com/feeds/1.xml',
'frozen',
'This is a room somewhere',
'http://www.roomsomewhere/icon.png',
'http://www.roomsomewhere/',
'myemail@roomsomewhere',
updated='2007-05-04T18:13:51.0Z',
creator='http://www.somewhere',
id=1)
assert_true(xml_compare(etree.fromstring(
"""
<environment xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" creator="http://www.somewhere" id="1" updated="2007-05-04T18:13:51.0Z">
<title>A Room Somewhere</title>
<feed />
<status>frozen</status>
<description>This is a room somewhere</description>
<icon>http://www.roomsomewhere/icon.png</icon>
<website>http://www.roomsomewhere/</website>
<email>myemail@roomsomewhere</email>
</environment>""".strip()), env.toeeml(), reporter=self.fail))
def test_good_datapoints(self):
env = Environment('A Room Somewhere',
'http://www.cosm.com/feeds/1.xml',
'frozen',
'This is a room somewhere',
'http://www.roomsomewhere/icon.png',
'http://www.roomsomewhere/',
'myemail@roomsomewhere',
updated='2007-05-04T18:13:51.0Z',
creator='http://www.somewhere',
id_=1)
datapoints = DataPoints([(0,), (1,), (2, datetime(2007, 5, 4, 18, 13, 51))])
result = create_eeml(env, None, datapoints).toeeml()
assert_true(xml_compare(etree.fromstring(
"""
<eeml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" xsi:schemaLocation="http://www.eeml.org/xsd/0.5.1 http://www.eeml.org/xsd/0.5.1/0.5.1.xsd" version="0.5.1">
<environment updated="2007-05-04T18:13:51.0Z" creator="http://www.somewhere" id="1">
<title>A Room Somewhere</title>
<feed>http://www.cosm.com/feeds/1.xml</feed>
<status>frozen</status>
<description>This is a room somewhere</description>
<icon>http://www.roomsomewhere/icon.png</icon>
<website>http://www.roomsomewhere/</website>
<email>myemail@roomsomewhere</email>
<data>
<datapoints xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1">
<value>0</value>
<value>1</value>
<value at="2007-05-04T18:13:51">2</value>
</datapoints>
</data>
</environment>
</eeml>
""".strip()), result, reporter=self.fail))
def testAll(self):
self.errors = BytesIO()
config = configparser.ConfigParser()
config.read([defaultsfn, os.path.join(self.testdir, "options.cfg")])
themefn = None
if config.get('diazotest', 'theme'):
themefn = os.path.join(self.testdir, config.get('diazotest',
'theme'))
contentfn = os.path.join(self.testdir, "content.html")
rulesfn = os.path.join(self.testdir, "rules.xml")
xpathsfn = os.path.join(self.testdir, "xpaths.txt")
xslfn = os.path.join(self.testdir, "compiled.xsl")
outputfn = os.path.join(self.testdir, "output.html")
xsl_params = {}
extra_params = config.get('diazotest', 'extra-params')
if extra_params:
for token in extra_params.split(' '):
token_split = token.split(':')
xsl_params[token_split[0]] = len(token_split) > 1 and \
token_split[1] or None
if not os.path.exists(rulesfn):
return
contentdoc = etree.parse(source=contentfn, base_url=contentfn,
parser=etree.HTMLParser())
# Make a compiled version
theme_parser = etree.HTMLParser()
ct = diazo.compiler.compile_theme(
rules=rulesfn,
theme=themefn,
parser=theme_parser,
absolute_prefix=config.get('diazotest', 'absolute-prefix'),
indent=config.getboolean('diazotest', 'pretty-print'),
xsl_params=xsl_params,
)
# Serialize / parse the theme - this can catch problems with escaping.
cts = etree.tostring(ct, encoding='unicode')
parser = etree.XMLParser()
etree.fromstring(cts, parser=parser)
# Compare to previous version
if os.path.exists(xslfn):
with open(xslfn) as f:
old = f.read()
new = cts
if old != new:
if self.writefiles:
with open(xslfn + '.old', 'w') as f:
f.write(old)
if self.warnings:
print("WARNING:", "compiled.xsl has CHANGED")
for line in difflib.unified_diff(old.split(u'\n'),
new.split(u'\n'),
xslfn, 'now'):
print(line)
# Write the compiled xsl out to catch unexpected changes
if self.writefiles:
with open(xslfn, 'w') as f:
f.write(cts)
# Apply the compiled version, then test against desired output
theme_parser.resolvers.add(diazo.run.RunResolver(self.testdir))
processor = etree.XSLT(ct)
params = {}
params['path'] = "'%s'" % config.get('diazotest', 'path')
for key in xsl_params:
try:
params[key] = quote_param(config.get('diazotest', key))
except configparser.NoOptionError:
pass
result = processor(contentdoc, **params)
# Read the whole thing to strip off xhtml namespace.
# If we had xslt 2.0 then we could use xpath-default-namespace.
self.themed_string = str(result)
self.themed_content = etree.ElementTree(
file=StringIO(self.themed_string), parser=etree.HTMLParser())
# remove the extra meta content type
metas = self.themed_content.xpath(
"/html/head/meta[@http-equiv='Content-Type']")
if metas:
meta = metas[0]
meta.getparent().remove(meta)
if os.path.exists(xpathsfn):
with open(xpathsfn) as f:
for xpath in f.readlines():
# Read the XPaths from the file, skipping blank lines and
# comments
this_xpath = xpath.strip()
if not this_xpath or this_xpath[0] == '#':
continue
assert self.themed_content.xpath(this_xpath), "%s: %s" % (
xpathsfn, this_xpath)
# Compare to previous version
if os.path.exists(outputfn):
with open(outputfn) as f:
old = f.read()
new = self.themed_string
if not xml_compare(
etree.fromstring(old.strip()),
etree.fromstring(new.strip())):
# if self.writefiles:
# open(outputfn + '.old', 'w').write(old)
for line in difflib.unified_diff(old.split(u'\n'),
new.split(u'\n'),
outputfn, 'now'):
print(line)
assert old == new, "output.html has CHANGED"
# Write out the result to catch unexpected changes
if self.writefiles:
with open(outputfn, 'w') as f:
f.write(self.themed_string)
def test_good_create_doc(self):
env = Environment('A Room Somewhere',
'http://www.cosm.com/feeds/1.xml',
'frozen',
'This is a room somewhere',
'http://www.roomsomewhere/icon.png',
'http://www.roomsomewhere/',
'myemail@roomsomewhere',
updated='2007-05-04T18:13:51.0Z',
creator='http://www.somewhere',
id_=1)
loc = Location('physical', 'My Room', 32.4, 22.7, 0.2, 'indoor',
'fixed')
u = Unit('Celsius', 'derivedSI', 'C')
dat = []
dat.append(
Data(0,
36.2,
minValue=23.8,
maxValue=48.0,
unit=u,
tags=['temperature']))
u = Unit('blushesPerHour', 'contextDependentUnits')
dat.append(
Data(1,
84.2,
minValue=0,
maxValue=100,
unit=u,
tags=['blush', 'redness', 'embarrasement']))
u = Unit('meter', 'basicSI', 'm')
dat.append(
Data(2,
12.3,
minValue=0,
unit=u,
tags=['length', 'distance', 'extension']))
intermed = etree.tostring(create_eeml(
env, loc, dat).toeeml()) # Broken down to help with error-checking
final = etree.fromstring(intermed)
assert_true(
xml_compare(etree.fromstring("""
<eeml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" xsi:schemaLocation="http://www.eeml.org/xsd/0.5.1 http://www.eeml.org/xsd/0.5.1/0.5.1.xsd" version="0.5.1">
<environment creator="http://www.somewhere" id="1" updated="2007-05-04T18:13:51.0Z">
<title>A Room Somewhere</title>
<feed>http://www.cosm.com/feeds/1.xml</feed>
<status>frozen</status>
<description>This is a room somewhere</description>
<icon>http://www.roomsomewhere/icon.png</icon>
<website>http://www.roomsomewhere/</website>
<email>myemail@roomsomewhere</email>
<location disposition="fixed" domain="physical" exposure="indoor">
<name>My Room</name>
<lat>32.4</lat>
<lon>22.7</lon>
<ele>0.2</ele>
</location>
<data id="0">
<tag>temperature</tag>
<current_value maxValue="48.0" minValue="23.8">36.2</current_value>
<unit symbol="C" type="derivedSI">Celsius</unit>
</data>
<data id="1">
<tag>blush</tag>
<tag>redness</tag>
<tag>embarrasement</tag>
<current_value maxValue="100" minValue="0">84.2</current_value>
<unit type="contextDependentUnits">blushesPerHour</unit>
</data>
<data id="2">
<tag>length</tag>
<tag>distance</tag>
<tag>extension</tag>
<current_value minValue="0">12.3</current_value>
<unit symbol="m" type="basicSI">meter</unit>
</data>
</environment>
</eeml>
"""),
final,
reporter=self.fail))
def testAll(self):
self.errors = BytesIO()
config = configparser.ConfigParser()
config.read([defaultsfn, os.path.join(self.testdir, "options.cfg")])
themefn = None
if config.get('diazotest', 'theme'):
themefn = os.path.join(self.testdir,
config.get('diazotest', 'theme'))
contentfn = os.path.join(self.testdir, "content.html")
rulesfn = os.path.join(self.testdir, "rules.xml")
xpathsfn = os.path.join(self.testdir, "xpaths.txt")
xslfn = os.path.join(self.testdir, "compiled.xsl")
outputfn = os.path.join(self.testdir, "output.html")
xsl_params = {}
extra_params = config.get('diazotest', 'extra-params')
if extra_params:
for token in extra_params.split(' '):
token_split = token.split(':')
xsl_params[token_split[0]] = len(token_split) > 1 and \
token_split[1] or None
if not os.path.exists(rulesfn):
return
contentdoc = etree.parse(source=contentfn,
base_url=contentfn,
parser=etree.HTMLParser())
# Make a compiled version
theme_parser = etree.HTMLParser()
ct = diazo.compiler.compile_theme(
rules=rulesfn,
theme=themefn,
parser=theme_parser,
absolute_prefix=config.get('diazotest', 'absolute-prefix'),
indent=config.getboolean('diazotest', 'pretty-print'),
xsl_params=xsl_params,
)
# Serialize / parse the theme - this can catch problems with escaping.
cts = etree.tostring(ct, encoding='unicode')
parser = etree.XMLParser()
etree.fromstring(cts, parser=parser)
# Compare to previous version
if os.path.exists(xslfn):
with open(xslfn) as f:
old = f.read()
new = cts
if old != new:
if self.writefiles:
with open(xslfn + '.old', 'w') as f:
f.write(old)
if self.warnings:
print("WARNING:", "compiled.xsl has CHANGED")
for line in difflib.unified_diff(old.split(u'\n'),
new.split(u'\n'), xslfn,
'now'):
print(line)
# Write the compiled xsl out to catch unexpected changes
if self.writefiles:
with open(xslfn, 'w') as f:
f.write(cts)
# Apply the compiled version, then test against desired output
theme_parser.resolvers.add(diazo.run.RunResolver(self.testdir))
processor = etree.XSLT(ct)
params = {}
params['path'] = "'%s'" % config.get('diazotest', 'path')
for key in xsl_params:
try:
params[key] = quote_param(config.get('diazotest', key))
except configparser.NoOptionError:
pass
result = processor(contentdoc, **params)
# Read the whole thing to strip off xhtml namespace.
# If we had xslt 2.0 then we could use xpath-default-namespace.
self.themed_string = str(result)
self.themed_content = etree.ElementTree(file=StringIO(
self.themed_string),
parser=etree.HTMLParser())
# remove the extra meta content type
metas = self.themed_content.xpath(
"/html/head/meta[@http-equiv='Content-Type']")
if metas:
meta = metas[0]
meta.getparent().remove(meta)
if os.path.exists(xpathsfn):
with open(xpathsfn) as f:
for xpath in f.readlines():
# Read the XPaths from the file, skipping blank lines and
# comments
this_xpath = xpath.strip()
if not this_xpath or this_xpath[0] == '#':
continue
assert self.themed_content.xpath(
this_xpath), "%s: %s" % (xpathsfn, this_xpath)
# Compare to previous version
if os.path.exists(outputfn):
with open(outputfn) as f:
old = f.read()
new = self.themed_string
if not xml_compare(etree.fromstring(old.strip()),
etree.fromstring(new.strip())):
# if self.writefiles:
# open(outputfn + '.old', 'w').write(old)
for line in difflib.unified_diff(old.split(u'\n'),
new.split(u'\n'), outputfn,
'now'):
print(line)
assert old == new, "output.html has CHANGED"
# Write out the result to catch unexpected changes
if self.writefiles:
with open(outputfn, 'w') as f:
f.write(self.themed_string)
def test_parse(self):
for xml0 in [GET]:
o = ofc.OFCapableSwitchType.from_xml(xml0)
xml1 = o.to_xml('capable-switch')
ok_(xml_compare(ET.fromstring(xml0), ET.fromstring(xml1),
reporter=sys.stderr.write))
def test_good_create_doc(self):
env = Environment('A Room Somewhere',
'http://www.cosm.com/feeds/1.xml',
'frozen',
'This is a room somewhere',
'http://www.roomsomewhere/icon.png',
'http://www.roomsomewhere/',
'myemail@roomsomewhere',
updated='2007-05-04T18:13:51.0Z',
creator='http://www.somewhere',
id=1)
loc = Location('My Room', 32.4, 22.7, 0.2, 'indoor', 'physical', 'fixed')
u = Unit('Celsius', 'derivedSI', 'C')
dat = []
dat.append(Data(0, 36.2, minValue=23.8, maxValue=48.0, unit = u, tags=['temperature']))
u = Unit('blushesPerHour', 'contextDependentUnits')
dat.append(Data(1, 84.2, minValue=0, maxValue=100, unit = u, tags=['blush', 'redness', 'embarrasement']))
u = Unit('meter', 'basicSI', 'm')
dat.append(Data(2, 12.3, minValue=0, unit = u, tags=['length', 'distance', 'extension']))
intermed = etree.tostring(
create_eeml(env, loc, dat).toeeml()) # Broken down to help with error-checking
final = etree.fromstring(intermed)
assert_true(xml_compare(etree.fromstring(
"""
<eeml xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.eeml.org/xsd/0.5.1" xsi:schemaLocation="http://www.eeml.org/xsd/0.5.1 http://www.eeml.org/xsd/0.5.1/0.5.1.xsd" version="0.5.1">
<environment creator="http://www.somewhere" id="1" updated="2007-05-04T18:13:51.0Z">
<title>A Room Somewhere</title>
<feed />
<status>frozen</status>
<description>This is a room somewhere</description>
<icon>http://www.roomsomewhere/icon.png</icon>
<website>http://www.roomsomewhere/</website>
<email>myemail@roomsomewhere</email>
<location disposition="fixed" domain="physical" exposure="indoor">
<name>My Room</name>
<lat>32.4</lat>
<lon>22.7</lon>
<ele>0.2</ele>
</location>
<data id="0">
<tag>temperature</tag>
<current_value maxValue="48.0" minValue="23.8">36.2</current_value>
<unit symbol="C" type="derivedSI">Celsius</unit>
</data>
<data id="1">
<tag>blush</tag>
<tag>redness</tag>
<tag>embarrasement</tag>
<current_value maxValue="100" minValue="0">84.2</current_value>
<unit type="contextDependentUnits">blushesPerHour</unit>
</data>
<data id="2">
<tag>length</tag>
<tag>distance</tag>
<tag>extension</tag>
<current_value minValue="0">12.3</current_value>
<unit symbol="m" type="basicSI">meter</unit>
</data>
</environment>
</eeml>
""".strip()), final, reporter=self.fail))
def test_xml_read_write(self):
xml_content = utils.get_config(self.test_file)
utils.update_config(self.test_file, xml_content)
new_xml_tree = self.get_xml_tree()
# pass element to xml_compare, not ElementTree
self.assertEqual(True, xml_compare(self.old_xml_tree, new_xml_tree))