Source Code for Module lxml.tests.test_xmlschema

  1  # -*- coding: utf-8 -*- 
  2   
  3  """ 
  4  Test cases related to XML Schema parsing and validation 
  5  """ 
  6   
  7  import unittest, sys, os.path 
  8   
  9  this_dir = os.path.dirname(__file__) 
 10  if this_dir not in sys.path: 
 11      sys.path.insert(0, this_dir) # needed for Py3 
 12   
 13  from common_imports import etree, BytesIO, HelperTestCase, fileInTestDir 
 14  from common_imports import doctest, make_doctest 
 15   
 16   
 17 -class ETreeXMLSchemaTestCase(HelperTestCase): 
 18 -    def test_xmlschema(self): 
 19          tree_valid = self.parse('<a><b></b></a>') 
 20          tree_invalid = self.parse('<a><c></c></a>') 
 21          schema = self.parse(''' 
 22  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
 23    <xsd:element name="a" type="AType"/> 
 24    <xsd:complexType name="AType"> 
 25      <xsd:sequence> 
 26        <xsd:element name="b" type="xsd:string" /> 
 27      </xsd:sequence> 
 28    </xsd:complexType> 
 29  </xsd:schema> 
 30  ''') 
 31          schema = etree.XMLSchema(schema) 
 32          self.assertTrue(schema.validate(tree_valid)) 
 33          self.assertFalse(schema.validate(tree_invalid)) 
 34          self.assertTrue(schema.validate(tree_valid))     # retry valid 
 35          self.assertFalse(schema.validate(tree_invalid))  # retry invalid 
 36   
 37 -    def test_xmlschema_error_log(self): 
 38          tree_valid = self.parse('<a><b></b></a>') 
 39          tree_invalid = self.parse('<a><c></c></a>') 
 40          schema = self.parse(''' 
 41  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
 42    <xsd:element name="a" type="AType"/> 
 43    <xsd:complexType name="AType"> 
 44      <xsd:sequence> 
 45        <xsd:element name="b" type="xsd:string" /> 
 46      </xsd:sequence> 
 47    </xsd:complexType> 
 48  </xsd:schema> 
 49  ''') 
 50          schema = etree.XMLSchema(schema) 
 51          self.assertTrue(schema.validate(tree_valid)) 
 52          self.assertFalse(schema.error_log.filter_from_errors()) 
 53   
 54          self.assertFalse(schema.validate(tree_invalid)) 
 55          self.assertTrue(schema.error_log.filter_from_errors()) 
 56          self.assertTrue(schema.error_log.filter_types( 
 57              etree.ErrorTypes.SCHEMAV_ELEMENT_CONTENT)) 
 58   
 59          self.assertTrue(schema.validate(tree_valid)) 
 60          self.assertFalse(schema.error_log.filter_from_errors()) 
 61   
 62          self.assertFalse(schema.validate(tree_invalid)) 
 63          self.assertTrue(schema.error_log.filter_from_errors()) 
 64          self.assertTrue(schema.error_log.filter_types( 
 65              etree.ErrorTypes.SCHEMAV_ELEMENT_CONTENT)) 
 66   
 67 -    def test_xmlschema_default_attributes(self): 
 68          schema = self.parse(''' 
 69  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
 70    <xsd:element name="a" type="AType"/> 
 71    <xsd:complexType name="AType"> 
 72      <xsd:sequence minOccurs="4" maxOccurs="4"> 
 73        <xsd:element name="b" type="BType" /> 
 74      </xsd:sequence> 
 75    </xsd:complexType> 
 76    <xsd:complexType name="BType"> 
 77      <xsd:attribute name="hardy" type="xsd:string" default="hey" /> 
 78    </xsd:complexType> 
 79  </xsd:schema> 
 80  ''') 
 81          schema = etree.XMLSchema(schema, attribute_defaults=True) 
 82   
 83          tree = self.parse('<a><b hardy="ho"/><b/><b hardy="ho"/><b/></a>') 
 84   
 85          root = tree.getroot() 
 86          self.assertEqual('ho', root[0].get('hardy')) 
 87          self.assertEqual(None, root[1].get('hardy')) 
 88          self.assertEqual('ho', root[2].get('hardy')) 
 89          self.assertEqual(None, root[3].get('hardy')) 
 90   
 91          self.assertTrue(schema(tree)) 
 92   
 93          root = tree.getroot() 
 94          self.assertEqual('ho', root[0].get('hardy')) 
 95          self.assertEqual('hey', root[1].get('hardy')) 
 96          self.assertEqual('ho', root[2].get('hardy')) 
 97          self.assertEqual('hey', root[3].get('hardy')) 
 98   
 99 -    def test_xmlschema_parse(self): 
100          schema = self.parse(''' 
101  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
102    <xsd:element name="a" type="AType"/> 
103    <xsd:complexType name="AType"> 
104      <xsd:sequence> 
105        <xsd:element name="b" type="xsd:string" /> 
106      </xsd:sequence> 
107    </xsd:complexType> 
108  </xsd:schema> 
109  ''') 
110          schema = etree.XMLSchema(schema) 
111          parser = etree.XMLParser(schema=schema) 
112   
113          tree_valid = self.parse('<a><b></b></a>', parser=parser) 
114          self.assertEqual('a', tree_valid.getroot().tag) 
115   
116          self.assertRaises(etree.XMLSyntaxError, 
117                            self.parse, '<a><c></c></a>', parser=parser) 
118   
119 -    def test_xmlschema_parse_default_attributes(self): 
120          # does not work as of libxml2 2.7.3 
121          schema = self.parse(''' 
122  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
123    <xsd:element name="a" type="AType"/> 
124    <xsd:complexType name="AType"> 
125      <xsd:sequence minOccurs="4" maxOccurs="4"> 
126        <xsd:element name="b" type="BType" /> 
127      </xsd:sequence> 
128    </xsd:complexType> 
129    <xsd:complexType name="BType"> 
130      <xsd:attribute name="hardy" type="xsd:string" default="hey" /> 
131    </xsd:complexType> 
132  </xsd:schema> 
133  ''') 
134          schema = etree.XMLSchema(schema) 
135          parser = etree.XMLParser(schema=schema, attribute_defaults=True) 
136   
137          tree_valid = self.parse('<a><b hardy="ho"/><b/><b hardy="ho"/><b/></a>', 
138                                  parser=parser) 
139          root = tree_valid.getroot() 
140          self.assertEqual('ho', root[0].get('hardy')) 
141          self.assertEqual('hey', root[1].get('hardy')) 
142          self.assertEqual('ho', root[2].get('hardy')) 
143          self.assertEqual('hey', root[3].get('hardy')) 
144   
145 -    def test_xmlschema_parse_default_attributes_schema_config(self): 
146          # does not work as of libxml2 2.7.3 
147          schema = self.parse(''' 
148  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
149    <xsd:element name="a" type="AType"/> 
150    <xsd:complexType name="AType"> 
151      <xsd:sequence minOccurs="4" maxOccurs="4"> 
152        <xsd:element name="b" type="BType" /> 
153      </xsd:sequence> 
154    </xsd:complexType> 
155    <xsd:complexType name="BType"> 
156      <xsd:attribute name="hardy" type="xsd:string" default="hey" /> 
157    </xsd:complexType> 
158  </xsd:schema> 
159  ''') 
160          schema = etree.XMLSchema(schema, attribute_defaults=True) 
161          parser = etree.XMLParser(schema=schema) 
162   
163          tree_valid = self.parse('<a><b hardy="ho"/><b/><b hardy="ho"/><b/></a>', 
164                                  parser=parser) 
165          root = tree_valid.getroot() 
166          self.assertEqual('ho', root[0].get('hardy')) 
167          self.assertEqual('hey', root[1].get('hardy')) 
168          self.assertEqual('ho', root[2].get('hardy')) 
169          self.assertEqual('hey', root[3].get('hardy')) 
170   
171 -    def test_xmlschema_parse_fixed_attributes(self): 
172          # does not work as of libxml2 2.7.3 
173          schema = self.parse(''' 
174  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
175    <xsd:element name="a" type="AType"/> 
176    <xsd:complexType name="AType"> 
177      <xsd:sequence minOccurs="3" maxOccurs="3"> 
178        <xsd:element name="b" type="BType" /> 
179      </xsd:sequence> 
180    </xsd:complexType> 
181    <xsd:complexType name="BType"> 
182      <xsd:attribute name="hardy" type="xsd:string" fixed="hey" /> 
183    </xsd:complexType> 
184  </xsd:schema> 
185  ''') 
186          schema = etree.XMLSchema(schema) 
187          parser = etree.XMLParser(schema=schema, attribute_defaults=True) 
188   
189          tree_valid = self.parse('<a><b/><b hardy="hey"/><b/></a>', 
190                                  parser=parser) 
191          root = tree_valid.getroot() 
192          self.assertEqual('hey', root[0].get('hardy')) 
193          self.assertEqual('hey', root[1].get('hardy')) 
194          self.assertEqual('hey', root[2].get('hardy')) 
195   
196 -    def test_xmlschema_stringio(self): 
197          schema_file = BytesIO(''' 
198  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
199    <xsd:element name="a" type="AType"/> 
200    <xsd:complexType name="AType"> 
201      <xsd:sequence> 
202        <xsd:element name="b" type="xsd:string" /> 
203      </xsd:sequence> 
204    </xsd:complexType> 
205  </xsd:schema> 
206  ''') 
207          schema = etree.XMLSchema(file=schema_file) 
208          parser = etree.XMLParser(schema=schema) 
209   
210          tree_valid = self.parse('<a><b></b></a>', parser=parser) 
211          self.assertEqual('a', tree_valid.getroot().tag) 
212   
213          self.assertRaises(etree.XMLSyntaxError, 
214                            self.parse, '<a><c></c></a>', parser=parser) 
215   
216 -    def test_xmlschema_iterparse(self): 
217          schema = self.parse(''' 
218  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
219    <xsd:element name="a" type="AType"/> 
220    <xsd:complexType name="AType"> 
221      <xsd:sequence> 
222        <xsd:element name="b" type="xsd:string" /> 
223      </xsd:sequence> 
224    </xsd:complexType> 
225  </xsd:schema> 
226  ''') 
227          schema = etree.XMLSchema(schema) 
228          xml = BytesIO('<a><b></b></a>') 
229          events = [ (event, el.tag) 
230                     for (event, el) in etree.iterparse(xml, schema=schema) ] 
231   
232          self.assertEqual([('end', 'b'), ('end', 'a')], 
233                            events) 
234   
235 -    def test_xmlschema_iterparse_fail(self): 
236          schema = self.parse(''' 
237  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
238    <xsd:element name="a" type="AType"/> 
239    <xsd:complexType name="AType"> 
240      <xsd:sequence> 
241        <xsd:element name="b" type="xsd:string" /> 
242      </xsd:sequence> 
243    </xsd:complexType> 
244  </xsd:schema> 
245  ''') 
246          schema = etree.XMLSchema(schema) 
247          self.assertRaises( 
248              etree.XMLSyntaxError, 
249              list, etree.iterparse(BytesIO('<a><c></c></a>'), schema=schema)) 
250   
251 -    def test_xmlschema_elementtree_error(self): 
252          self.assertRaises(ValueError, etree.XMLSchema, etree.ElementTree()) 
253   
254 -    def test_xmlschema_comment_error(self): 
255          self.assertRaises(ValueError, etree.XMLSchema, etree.Comment('TEST')) 
256   
257 -    def test_xmlschema_illegal_validation_error(self): 
258          schema = self.parse(''' 
259  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
260    <xsd:element name="a" type="xsd:string"/> 
261  </xsd:schema> 
262  ''') 
263          schema = etree.XMLSchema(schema) 
264   
265          root = etree.Element('a') 
266          root.text = 'TEST' 
267          self.assertTrue(schema(root)) 
268   
269          self.assertRaises(ValueError, schema, etree.Comment('TEST')) 
270          self.assertRaises(ValueError, schema, etree.PI('a', 'text')) 
271          self.assertRaises(ValueError, schema, etree.Entity('text')) 
272   
273 -    def test_xmlschema_invalid_schema1(self): 
274          schema = self.parse('''\ 
275  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
276    <element name="a" type="AType"/> 
277    <xsd:complexType name="AType"> 
278      <xsd:sequence> 
279        <xsd:element name="b" type="xsd:string" /> 
280      </xsd:sequence> 
281    </xsd:complexType> 
282  </xsd:schema> 
283  ''') 
284          self.assertRaises(etree.XMLSchemaParseError, 
285                            etree.XMLSchema, schema) 
286   
287 -    def test_xmlschema_invalid_schema2(self): 
288          schema = self.parse('<test/>') 
289          self.assertRaises(etree.XMLSchemaParseError, 
290                            etree.XMLSchema, schema) 
291   
292 -    def test_xmlschema_file(self): 
293          # this will only work if we access the file through path or 
294          # file object.. 
295          f = open(fileInTestDir('test.xsd'), 'rb') 
296          try: 
297              schema = etree.XMLSchema(file=f) 
298          finally: 
299              f.close() 
300          tree_valid = self.parse('<a><b></b></a>') 
301          self.assertTrue(schema.validate(tree_valid)) 
302   
303 -    def test_xmlschema_import_file(self): 
304          # this will only work if we access the file through path or 
305          # file object.. 
306          schema = etree.XMLSchema(file=fileInTestDir('test_import.xsd')) 
307          tree_valid = self.parse( 
308              '<a:x xmlns:a="http://codespeak.net/lxml/schema/ns1"><b></b></a:x>') 
309          self.assertTrue(schema.validate(tree_valid)) 
310   
311 -    def test_xmlschema_shortcut(self): 
312          tree_valid = self.parse('<a><b></b></a>') 
313          tree_invalid = self.parse('<a><c></c></a>') 
314          schema = self.parse('''\ 
315  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"> 
316    <xsd:element name="a" type="AType"/> 
317    <xsd:complexType name="AType"> 
318      <xsd:sequence> 
319        <xsd:element name="b" type="xsd:string" /> 
320      </xsd:sequence> 
321    </xsd:complexType> 
322  </xsd:schema> 
323  ''') 
324          self.assertTrue(tree_valid.xmlschema(schema)) 
325          self.assertFalse(tree_invalid.xmlschema(schema)) 
326   
327 -    def test_create_from_partial_doc(self): 
328          # this used to crash because the schema part was not properly copied out 
329          wsdl = self.parse('''\ 
330  <wsdl:definitions 
331     xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/" 
332     xmlns:xs="http://www.w3.org/2001/XMLSchema"> 
333   <wsdl:types> 
334    <xs:schema> 
335    </xs:schema> 
336   </wsdl:types> 
337  </wsdl:definitions> 
338          ''') 
339          schema_element = wsdl.find( 
340              "{http://schemas.xmlsoap.org/wsdl/}types/" 
341              "{http://www.w3.org/2001/XMLSchema}schema" 
342          ) 
343          etree.XMLSchema(schema_element) 
344          etree.XMLSchema(schema_element) 
345          etree.XMLSchema(schema_element) 
346   
347   
348 -class ETreeXMLSchemaResolversTestCase(HelperTestCase): 
349      resolver_schema_int = BytesIO("""\ 
350  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
351      xmlns:etype="http://codespeak.net/lxml/test/external" 
352      targetNamespace="http://codespeak.net/lxml/test/internal"> 
353          <xsd:import namespace="http://codespeak.net/lxml/test/external" schemaLocation="XXX.xsd" /> 
354          <xsd:element name="a" type="etype:AType"/> 
355  </xsd:schema>""") 
356   
357      resolver_schema_int2 = BytesIO("""\ 
358  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
359      xmlns:etype="http://codespeak.net/lxml/test/external" 
360      targetNamespace="http://codespeak.net/lxml/test/internal"> 
361          <xsd:import namespace="http://codespeak.net/lxml/test/external" schemaLocation="YYY.xsd" /> 
362          <xsd:element name="a" type="etype:AType"/> 
363  </xsd:schema>""") 
364   
365      resolver_schema_ext = """\ 
366  <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
367      targetNamespace="http://codespeak.net/lxml/test/external"> 
368      <xsd:complexType name="AType"> 
369        <xsd:sequence><xsd:element name="b" type="xsd:string" minOccurs="0" maxOccurs="unbounded" /></xsd:sequence> 
370      </xsd:complexType> 
371  </xsd:schema>"""  
372   
373 -    class simple_resolver(etree.Resolver): 
374 -        def __init__(self, schema): 
375              self.schema = schema 
376   
377 -        def resolve(self, url, id, context): 
378              assert url == 'XXX.xsd' 
379              return self.resolve_string(self.schema, context) 
380   
381      # tests: 
382   
383 -    def test_xmlschema_resolvers(self): 
384          # test that resolvers work with schema. 
385          parser = etree.XMLParser() 
386          parser.resolvers.add(self.simple_resolver(self.resolver_schema_ext)) 
387          schema_doc = etree.parse(self.resolver_schema_int, parser = parser) 
388          schema = etree.XMLSchema(schema_doc) 
389   
390 -    def test_xmlschema_resolvers_root(self): 
391          # test that the default resolver will get called if there's no 
392          # specific parser resolver. 
393          root_resolver = self.simple_resolver(self.resolver_schema_ext) 
394          etree.get_default_parser().resolvers.add(root_resolver) 
395          schema_doc = etree.parse(self.resolver_schema_int) 
396          schema = etree.XMLSchema(schema_doc) 
397          etree.get_default_parser().resolvers.remove(root_resolver) 
398   
399 -    def test_xmlschema_resolvers_noroot(self): 
400          # test that the default resolver will not get called when a 
401          # more specific resolver is registered. 
402   
403          class res_root(etree.Resolver): 
404              def resolve(self, url, id, context): 
405                  assert False 
406                  return None 
407   
408          root_resolver = res_root() 
409          etree.get_default_parser().resolvers.add(root_resolver) 
410   
411          parser = etree.XMLParser() 
412          parser.resolvers.add(self.simple_resolver(self.resolver_schema_ext)) 
413   
414          schema_doc = etree.parse(self.resolver_schema_int, parser = parser) 
415          schema = etree.XMLSchema(schema_doc) 
416          etree.get_default_parser().resolvers.remove(root_resolver) 
417   
418 -    def test_xmlschema_nested_resolvers(self): 
419          # test that resolvers work in a nested fashion. 
420   
421          resolver_schema = self.resolver_schema_ext 
422   
423          class res_nested(etree.Resolver): 
424              def __init__(self, ext_schema): 
425                  self.ext_schema = ext_schema 
426   
427              def resolve(self, url, id, context): 
428                  assert url == 'YYY.xsd' 
429                  return self.resolve_string(self.ext_schema, context) 
430   
431          class res(etree.Resolver): 
432              def __init__(self, ext_schema_1, ext_schema_2): 
433                  self.ext_schema_1 = ext_schema_1 
434                  self.ext_schema_2 = ext_schema_2 
435   
436              def resolve(self, url, id, context): 
437                  assert url == 'XXX.xsd' 
438   
439                  new_parser = etree.XMLParser() 
440                  new_parser.resolvers.add(res_nested(self.ext_schema_2)) 
441                  new_schema_doc = etree.parse(self.ext_schema_1, parser = new_parser) 
442                  new_schema = etree.XMLSchema(new_schema_doc) 
443   
444                  return self.resolve_string(resolver_schema, context) 
445   
446          parser = etree.XMLParser() 
447          parser.resolvers.add(res(self.resolver_schema_int2, self.resolver_schema_ext)) 
448          schema_doc = etree.parse(self.resolver_schema_int, parser = parser) 
449          schema = etree.XMLSchema(schema_doc) 
450   
451   
452 -def test_suite(): 
453      suite = unittest.TestSuite() 
454      suite.addTests([unittest.makeSuite(ETreeXMLSchemaTestCase)]) 
455      suite.addTests([unittest.makeSuite(ETreeXMLSchemaResolversTestCase)]) 
456      suite.addTests( 
457          [make_doctest('../../../doc/validation.txt')]) 
458      return suite 
459   
460   
461  if __name__ == '__main__': 
462      print('to test use test.py %s' % __file__) 
463