def test_etree_element_method(self):
converter = XMLSchemaConverter()
elem = converter.etree_element('A')
self.assertIsNone(etree_elements_assert_equal(elem, etree_element('A')))
elem = converter.etree_element('A', attrib={})
self.assertIsNone(etree_elements_assert_equal(elem, etree_element('A')))
def check_etree_encode(self, root, converter=None, **kwargs):
data1 = self.schema.decode(root, converter=converter, **kwargs)
if isinstance(data1, tuple):
data1 = data1[0] # When validation='lax'
for _ in iter_nested_items(data1, dict_class=ordered_dict_class):
pass
elem1 = self.schema.encode(data1, path=root.tag, converter=converter, **kwargs)
if isinstance(elem1, tuple):
elem1 = elem1[0] # When validation='lax'
# Main check: compare original an re encoded tree
try:
etree_elements_assert_equal(root, elem1, strict=False)
except AssertionError as err:
# If the check fails retry only if the converter is lossy (eg. ParkerConverter)
# or it the XML case has defaults taken from the schema or some part of data
# decoding is skipped by schema wildcards (set the specific argument in testfiles).
if converter not in (ParkerConverter, AbderaConverter, JsonMLConverter) and not skip_strict:
if debug_mode:
pdb.set_trace()
raise AssertionError(str(err) + msg_template % "encoded tree differs from original")
else:
# Lossy or augmenting cases are checked after a re decoding-encoding pass
data2 = self.schema.decode(elem1, converter=converter, **kwargs)
if isinstance(data2, tuple):
data2 = data2[0]
if sys.version_info >= (3, 6):
# For Python < 3.6 cannot ensure attribute decoding order
try:
self.assertEqual(data1, data2, msg_template % "re decoded data changed")
except AssertionError:
if debug_mode:
pdb.set_trace()
raise
elem2 = self.schema.encode(data2, path=root.tag, converter=converter, **kwargs)
if isinstance(elem2, tuple):
elem2 = elem2[0]
try:
etree_elements_assert_equal(elem1, elem2, strict=False)
except AssertionError as err:
if debug_mode:
pdb.set_trace()
raise AssertionError(str(err) + msg_template % "encoded tree differs after second pass")
def check_json_serialization(self, root, converter=None, **kwargs):
data1 = xmlschema.to_json(root, schema=self.schema, converter=converter, **kwargs)
if isinstance(data1, tuple):
data1 = data1[0]
elem1 = xmlschema.from_json(data1, schema=self.schema, path=root.tag, converter=converter, **kwargs)
if isinstance(elem1, tuple):
elem1 = elem1[0]
data2 = xmlschema.to_json(elem1, schema=self.schema, converter=converter, **kwargs)
if isinstance(data2, tuple):
data2 = data2[0]
if converter is ParkerConverter and any(XSI_TYPE in e.attrib for e in root.iter()):
return # can't check encode equivalence if xsi:type is provided
elif sys.version_info >= (3, 6):
self.assertEqual(data2, data1, msg_tmpl % "serialized data changed at second pass")
else:
elem2 = xmlschema.from_json(data2, schema=self.schema, path=root.tag, converter=converter, **kwargs)
if isinstance(elem2, tuple):
elem2 = elem2[0]
try:
self.assertIsNone(etree_elements_assert_equal(elem1, elem2, strict=False, skip_comments=True))
except AssertionError as err:
self.assertIsNone(err, None)
def check_json_serialization(self, root, converter=None, **kwargs):
lossy = converter in (ParkerConverter, AbderaConverter,
ColumnarConverter)
unordered = converter not in (AbderaConverter, JsonMLConverter) or \
kwargs.get('unordered', False)
data1 = xmlschema.to_json(root,
schema=self.schema,
converter=converter,
**kwargs)
if isinstance(data1, tuple):
data1 = data1[0]
elem1 = xmlschema.from_json(data1,
schema=self.schema,
path=root.tag,
converter=converter,
**kwargs)
if isinstance(elem1, tuple):
elem1 = elem1[0]
data2 = xmlschema.to_json(elem1,
schema=self.schema,
converter=converter,
**kwargs)
if isinstance(data2, tuple):
data2 = data2[0]
if data2 != data1 and (lax_encode or lossy or unordered):
# Can't ensure decode equivalence if the test case use defaults,
# or the converter is lossy or the decoding is unordered.
return
if sys.version_info >= (3, 6):
if data1 != data2:
print(data1)
print(data2)
print(converter, unordered)
self.assertEqual(
data2, data1,
msg_tmpl % "serialized data changed at second pass")
else:
elem2 = xmlschema.from_json(data2,
schema=self.schema,
path=root.tag,
converter=converter,
**kwargs)
if isinstance(elem2, tuple):
elem2 = elem2[0]
try:
self.assertIsNone(
etree_elements_assert_equal(elem1,
elem2,
strict=False,
skip_comments=True,
unordered=unordered))
except AssertionError as err:
self.assertIsNone(err, None)
def check_etree_elements(self, elem, other):
try:
self.assertIsNone(
etree_elements_assert_equal(elem,
other,
strict=False,
skip_comments=True))
except AssertionError as err:
self.assertIsNone(err, None)
def check_json_serialization(self, root, converter=None, **kwargs):
lossy = converter in (ParkerConverter, AbderaConverter,
ColumnarConverter)
unordered = converter not in (AbderaConverter, JsonMLConverter) or \
kwargs.get('unordered', False)
json_data1 = xmlschema.to_json(root,
schema=self.schema,
converter=converter,
**kwargs)
if isinstance(json_data1, tuple):
json_data1 = json_data1[0]
elem1 = xmlschema.from_json(json_data1,
schema=self.schema,
path=root.tag,
converter=converter,
**kwargs)
if isinstance(elem1, tuple):
elem1 = elem1[0]
if lax_encode:
kwargs['validation'] = kwargs.get('validation', 'lax')
json_data2 = xmlschema.to_json(elem1,
schema=self.schema,
converter=converter,
**kwargs)
if isinstance(json_data2, tuple):
json_data2 = json_data2[0]
if json_data2 != json_data1 and (lax_encode or lossy or unordered):
# Can't ensure decode equivalence if the test case use defaults,
# or the converter is lossy or the decoding is unordered.
return
if sys.version_info >= (3, 6):
self.assertEqual(json_data2, json_data1, msg=xml_file)
else:
elem2 = xmlschema.from_json(json_data2,
schema=self.schema,
path=root.tag,
converter=converter,
**kwargs)
if isinstance(elem2, tuple):
elem2 = elem2[0]
try:
self.assertIsNone(etree_elements_assert_equal(
elem1,
elem2,
strict=False,
skip_comments=True,
unordered=unordered),
msg=xml_file)
except AssertionError as err:
self.assertIsNone(err, msg=xml_file)
def check_json_serialization(self, root, converter=None, **kwargs):
data1 = xmlschema.to_json(root, schema=self.schema, converter=converter, **kwargs)
if isinstance(data1, tuple):
data1 = data1[0]
elem1 = xmlschema.from_json(data1, schema=self.schema, path=root.tag, converter=converter, **kwargs)
if isinstance(elem1, tuple):
elem1 = elem1[0]
data2 = xmlschema.to_json(elem1, schema=self.schema, converter=converter, **kwargs)
if isinstance(data2, tuple):
data2 = data2[0]
if sys.version_info >= (3, 6):
self.assertEqual(data2, data1, msg_template % "serialized data changed at second pass")
else:
elem2 = xmlschema.from_json(data2, schema=self.schema, path=root.tag, converter=converter, **kwargs)
if isinstance(elem2, tuple):
elem2 = elem2[0]
try:
self.assertIsNone(etree_elements_assert_equal(elem1, elem2, strict=False, skip_comments=True))
except AssertionError as err:
self.assertIsNone(err, None)
def check_etree_encode(self, root, converter=None, **kwargs):
namespaces = kwargs.get('namespaces', {})
data1 = self.schema.decode(root, converter=converter, **kwargs)
if isinstance(data1, tuple):
data1 = data1[0] # When validation='lax'
for _ in iter_nested_items(data1, dict_class=ordered_dict_class):
pass
elem1 = self.schema.encode(data1,
path=root.tag,
converter=converter,
**kwargs)
if isinstance(elem1, tuple):
# When validation='lax'
if converter is not ParkerConverter:
for e in elem1[1]:
self.check_namespace_prefixes(unicode_type(e))
elem1 = elem1[0]
# Checks the encoded element to not contains reserved namespace prefixes
if namespaces and all('ns%d' % k not in namespaces
for k in range(10)):
self.check_namespace_prefixes(
etree_tostring(elem1, namespaces=namespaces))
# Main check: compare original a re-encoded tree
try:
etree_elements_assert_equal(root, elem1, strict=False)
except AssertionError as err:
# If the check fails retry only if the converter is lossy (eg. ParkerConverter)
# or if the XML case has defaults taken from the schema or some part of data
# decoding is skipped by schema wildcards (set the specific argument in testfiles).
if converter not in (ParkerConverter, AbderaConverter,
JsonMLConverter) and not skip_strict:
if debug_mode:
pdb.set_trace()
raise AssertionError(
str(err) +
msg_tmpl % "encoded tree differs from original")
elif converter is ParkerConverter and any(
XSI_TYPE in e.attrib for e in root.iter()):
return # can't check encode equivalence if xsi:type is provided
else:
# Lossy or augmenting cases are checked after another decoding/encoding pass
data2 = self.schema.decode(elem1,
converter=converter,
**kwargs)
if isinstance(data2, tuple):
data2 = data2[0]
if sys.version_info >= (3, 6):
# For Python < 3.6 cannot ensure attribute decoding order
try:
self.assertEqual(
data1, data2,
msg_tmpl % "re-decoded data changed")
except AssertionError:
if debug_mode:
pdb.set_trace()
raise
elem2 = self.schema.encode(data2,
path=root.tag,
converter=converter,
**kwargs)
if isinstance(elem2, tuple):
elem2 = elem2[0]
try:
etree_elements_assert_equal(elem1, elem2, strict=False)
except AssertionError as err:
if debug_mode:
pdb.set_trace()
raise AssertionError(
str(err) + msg_tmpl %
"encoded tree differs after second pass")
def test_etree_elements_assert_equal(self):
e1 = ElementTree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
e2 = ElementTree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
self.assertIsNone(etree_elements_assert_equal(e1, e1))
self.assertIsNone(etree_elements_assert_equal(e1, e2))
e2 = lxml.etree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
self.assertIsNone(etree_elements_assert_equal(e1, e2))
e2 = ElementTree.XML(
'<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/><b4/></a>\n')
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2)
self.assertIn("has lesser children than <Element 'a'",
str(ctx.exception))
e2 = ElementTree.XML('<a><b1>text <c1 a="1"/></b1>\n<b2/><b3/></a>\n')
self.assertIsNone(etree_elements_assert_equal(e1, e2, strict=False))
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2)
self.assertIn("texts differ: 'text' != 'text '", str(ctx.exception))
e2 = ElementTree.XML(
'<a><b1>text<c1 a="1"/></b1>\n<b2>text</b2><b3/></a>\n')
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2, strict=False)
self.assertIn("texts differ: None != 'text'", str(ctx.exception))
e2 = ElementTree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>')
self.assertIsNone(etree_elements_assert_equal(e1, e2))
e2 = ElementTree.XML('<a><b1>text<c1 a="1"/></b1><b2/><b3/></a>\n')
self.assertIsNone(etree_elements_assert_equal(e1, e2, strict=False))
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2)
self.assertIn(r"tails differ: '\n' != None", str(ctx.exception))
e2 = ElementTree.XML('<a><b1>text<c1 a="1 "/></b1>\n<b2/><b3/></a>\n')
self.assertIsNone(etree_elements_assert_equal(e1, e2, strict=False))
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2)
self.assertIn("attributes differ: {'a': '1'} != {'a': '1 '}",
str(ctx.exception))
e2 = ElementTree.XML('<a><b1>text<c1 a="2 "/></b1>\n<b2/><b3/></a>\n')
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2, strict=False)
self.assertIn("attribute 'a' values differ: '1' != '2'",
str(ctx.exception))
e2 = ElementTree.XML(
'<a><!--comment--><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
self.assertIsNone(etree_elements_assert_equal(e1, e2))
self.assertIsNone(
etree_elements_assert_equal(e1, e2, skip_comments=False))
e2 = lxml.etree.XML(
'<a><!--comment--><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
self.assertIsNone(etree_elements_assert_equal(e1, e2))
e1 = ElementTree.XML('<a><b1>+1</b1></a>')
e2 = ElementTree.XML('<a><b1>+ 1 </b1></a>')
self.assertIsNone(etree_elements_assert_equal(e1, e2, strict=False))
e1 = ElementTree.XML('<a><b1>+1</b1></a>')
e2 = ElementTree.XML('<a><b1>+1.1 </b1></a>')
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2, strict=False)
self.assertIn("texts differ: '+1' != '+1.1 '", str(ctx.exception))
e1 = ElementTree.XML('<a><b1>1</b1></a>')
e2 = ElementTree.XML('<a><b1>true </b1></a>')
self.assertIsNone(etree_elements_assert_equal(e1, e2, strict=False))
self.assertIsNone(etree_elements_assert_equal(e2, e1, strict=False))
e2 = ElementTree.XML('<a><b1>false </b1></a>')
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2, strict=False)
self.assertIn("texts differ: '1' != 'false '", str(ctx.exception))
e1 = ElementTree.XML('<a><b1> 0</b1></a>')
self.assertIsNone(etree_elements_assert_equal(e1, e2, strict=False))
self.assertIsNone(etree_elements_assert_equal(e2, e1, strict=False))
e2 = ElementTree.XML('<a><b1>true </b1></a>')
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2, strict=False)
self.assertIn("texts differ: ' 0' != 'true '", str(ctx.exception))
e1 = ElementTree.XML('<a><b1>text<c1 a="1"/></b1>\n<b2/><b3/></a>\n')
e2 = ElementTree.XML(
'<a><b1>text<c1 a="1"/>tail</b1>\n<b2/><b3/></a>\n')
with self.assertRaises(AssertionError) as ctx:
etree_elements_assert_equal(e1, e2, strict=False)
self.assertIn("tails differ: None != 'tail'", str(ctx.exception))
def check_decode_encode(self, root, converter=None, **kwargs):
namespaces = kwargs.get('namespaces', {})
lossy = converter in (ParkerConverter, AbderaConverter,
ColumnarConverter)
losslessly = converter is JsonMLConverter
unordered = converter not in (AbderaConverter, JsonMLConverter) or \
kwargs.get('unordered', False)
decoded_data1 = self.schema.decode(root,
converter=converter,
**kwargs)
if isinstance(decoded_data1, tuple):
decoded_data1 = decoded_data1[0] # When validation='lax'
for _ in iter_nested_items(decoded_data1,
dict_class=ordered_dict_class):
pass
try:
elem1 = self.schema.encode(decoded_data1,
path=root.tag,
converter=converter,
**kwargs)
except XMLSchemaValidationError as err:
raise AssertionError(
msg_tmpl.format("error during re-encoding", str(err)))
if isinstance(elem1, tuple):
# When validation='lax'
if converter is not ParkerConverter and converter is not ColumnarConverter:
for e in elem1[1]:
self.check_namespace_prefixes(str(e))
elem1 = elem1[0]
# Checks the encoded element to not contains reserved namespace prefixes
if namespaces and all('ns%d' % k not in namespaces
for k in range(10)):
self.check_namespace_prefixes(
etree_tostring(elem1, namespaces=namespaces))
# Main check: compare original a re-encoded tree
try:
etree_elements_assert_equal(root,
elem1,
strict=False,
unordered=unordered)
except AssertionError as err:
# If the check fails retry only if the converter is lossy (eg. ParkerConverter)
# or if the XML case has defaults taken from the schema or some part of data
# decoding is skipped by schema wildcards (set the specific argument in testfiles).
if lax_encode:
pass # can't ensure encode equivalence if the test case use defaults
elif lossy:
pass # can't check encode equivalence if the converter is lossy
elif losslessly:
if debug_mode:
pdb.set_trace()
raise AssertionError(
msg_tmpl.format("encoded tree differs from original",
str(err)))
else:
# Lossy or augmenting cases are checked with another decoding/encoding pass
decoded_data2 = self.schema.decode(elem1,
converter=converter,
**kwargs)
if isinstance(decoded_data2, tuple):
decoded_data2 = decoded_data2[0]
if sys.version_info >= (3, 6):
# For Python < 3.6 cannot ensure attribute decoding order
try:
self.assertEqual(decoded_data1,
decoded_data2,
msg=xml_file)
except AssertionError:
if debug_mode:
pdb.set_trace()
raise
elem2 = self.schema.encode(decoded_data2,
path=root.tag,
converter=converter,
**kwargs)
if isinstance(elem2, tuple):
elem2 = elem2[0]
try:
etree_elements_assert_equal(elem1,
elem2,
strict=False,
unordered=unordered)
except AssertionError as err:
if debug_mode:
pdb.set_trace()
raise AssertionError(
msg_tmpl.format(
"encoded tree differs after second pass",
str(err)))
def check_etree_elements(self, elem, other):
"""Checks if two ElementTree elements are equal."""
try:
self.assertIsNone(etree_elements_assert_equal(elem, other, strict=False, skip_comments=True))
except AssertionError as err:
self.assertIsNone(err, None)
