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)