Source Code for Module lxml.tests.test_nsclasses

  1  # -*- coding: utf-8 -*- 
  2   
  3  """ 
  4  Test cases related to namespace implementation classes and the 
  5  namespace registry mechanism 
  6  """ 
  7   
  8  from __future__ import absolute_import 
  9   
 10  import unittest 
 11   
 12  from .common_imports import etree, HelperTestCase, _bytes, make_doctest 
 13   
 14 -class ETreeNamespaceClassesTestCase(HelperTestCase): 
 15       
 16 -    class default_class(etree.ElementBase): 
 17          pass 
 18 -    class maeh_class(etree.ElementBase): 
 19 -        def maeh(self): 
 20              return 'maeh' 
 21 -    class bluff_class(etree.ElementBase): 
 22 -        def bluff(self): 
 23              return 'bluff' 
 24   
 25 -    def setUp(self): 
 26          super(ETreeNamespaceClassesTestCase, self).setUp() 
 27          lookup = etree.ElementNamespaceClassLookup() 
 28          self.Namespace = lookup.get_namespace 
 29          parser = etree.XMLParser() 
 30          parser.set_element_class_lookup(lookup) 
 31          etree.set_default_parser(parser) 
 32   
 33 -    def tearDown(self): 
 34          etree.set_default_parser() 
 35          del self.Namespace 
 36          super(ETreeNamespaceClassesTestCase, self).tearDown() 
 37   
 38 -    def test_registry(self): 
 39          ns = self.Namespace('ns01') 
 40          ns['maeh'] = self.maeh_class 
 41   
 42          self.Namespace('ns01').clear() 
 43   
 44          self.Namespace('ns02').update({'maeh'  : self.maeh_class}) 
 45          self.Namespace('ns03').update({'bluff' : self.bluff_class}.items()) 
 46          self.Namespace('ns02').clear() 
 47          self.Namespace('ns03').clear() 
 48   
 49 -    def test_ns_classes(self): 
 50          bluff_dict = {'bluff' : self.bluff_class} 
 51          maeh_dict  = {'maeh'  : self.maeh_class} 
 52   
 53          self.Namespace('ns10').update(bluff_dict) 
 54   
 55          tree = self.parse(_bytes('<bluff xmlns="ns10"><ns11:maeh xmlns:ns11="ns11"/></bluff>')) 
 56   
 57          el = tree.getroot() 
 58          self.assertTrue(isinstance(el, etree.ElementBase)) 
 59          self.assertTrue(hasattr(el, 'bluff')) 
 60          self.assertFalse(hasattr(el[0], 'maeh')) 
 61          self.assertFalse(hasattr(el[0], 'bluff')) 
 62          self.assertEqual(el.bluff(), 'bluff') 
 63          del el 
 64   
 65          self.Namespace('ns11').update(maeh_dict) 
 66          el = tree.getroot() 
 67          self.assertTrue(hasattr(el, 'bluff')) 
 68          self.assertTrue(hasattr(el[0], 'maeh')) 
 69          self.assertEqual(el.bluff(), 'bluff') 
 70          self.assertEqual(el[0].maeh(), 'maeh') 
 71          del el 
 72   
 73          self.Namespace('ns10').clear() 
 74   
 75          tree = self.parse(_bytes('<bluff xmlns="ns10"><ns11:maeh xmlns:ns11="ns11"/></bluff>')) 
 76          el = tree.getroot() 
 77          self.assertFalse(hasattr(el, 'bluff')) 
 78          self.assertFalse(hasattr(el, 'maeh')) 
 79          self.assertFalse(hasattr(el[0], 'bluff')) 
 80          self.assertTrue(hasattr(el[0], 'maeh')) 
 81   
 82          self.Namespace('ns11').clear() 
 83   
 84 -    def test_default_tagname(self): 
 85          bluff_dict = { 
 86              None   : self.bluff_class, 
 87              'maeh' : self.maeh_class 
 88              } 
 89   
 90          ns = self.Namespace("uri:nsDefClass") 
 91          ns.update(bluff_dict) 
 92   
 93          tree = self.parse(_bytes(''' 
 94              <test xmlns="bla" xmlns:ns1="uri:nsDefClass" xmlns:ns2="uri:nsDefClass"> 
 95                <ns2:el1/><ns1:el2/><ns1:maeh/><ns2:maeh/><maeh/> 
 96              </test> 
 97              ''')) 
 98   
 99          el = tree.getroot() 
100          self.assertFalse(isinstance(el, etree.ElementBase)) 
101          for child in el[:-1]: 
102              self.assertTrue(isinstance(child, etree.ElementBase), child.tag) 
103          self.assertFalse(isinstance(el[-1], etree.ElementBase)) 
104   
105          self.assertTrue(hasattr(el[0], 'bluff')) 
106          self.assertTrue(hasattr(el[1], 'bluff')) 
107          self.assertTrue(hasattr(el[2], 'maeh')) 
108          self.assertTrue(hasattr(el[3], 'maeh')) 
109          self.assertFalse(hasattr(el[4], 'maeh')) 
110          del el 
111   
112          ns.clear() 
113   
114 -    def test_create_element(self): 
115          bluff_dict = {'bluff' : self.bluff_class} 
116          self.Namespace('ns20').update(bluff_dict) 
117   
118          maeh_dict  = {'maeh'  : self.maeh_class} 
119          self.Namespace('ns21').update(maeh_dict) 
120   
121          el = etree.Element("{ns20}bluff") 
122          self.assertTrue(hasattr(el, 'bluff')) 
123   
124          child = etree.SubElement(el, "{ns21}maeh") 
125          self.assertTrue(hasattr(child, 'maeh')) 
126          child = etree.SubElement(el, "{ns20}bluff") 
127          self.assertTrue(hasattr(child, 'bluff')) 
128          child = etree.SubElement(el, "{ns21}bluff") 
129          self.assertFalse(hasattr(child, 'bluff')) 
130          self.assertFalse(hasattr(child, 'maeh')) 
131   
132          self.assertTrue(hasattr(el[0], 'maeh')) 
133          self.assertTrue(hasattr(el[1], 'bluff')) 
134          self.assertFalse(hasattr(el[2], 'bluff')) 
135          self.assertFalse(hasattr(el[2], 'maeh')) 
136   
137          self.assertEqual(el.bluff(), 'bluff') 
138          self.assertEqual(el[0].maeh(), 'maeh') 
139          self.assertEqual(el[1].bluff(), 'bluff') 
140   
141          self.Namespace('ns20').clear() 
142          self.Namespace('ns21').clear() 
143   
144 -    def test_create_element_default(self): 
145          bluff_dict = {None : self.bluff_class} 
146          self.Namespace('ns30').update(bluff_dict) 
147   
148          maeh_dict  = {'maeh'  : self.maeh_class} 
149          self.Namespace(None).update(maeh_dict) 
150   
151          el = etree.Element("{ns30}bluff") 
152          etree.SubElement(el, "maeh") 
153          self.assertTrue(hasattr(el, 'bluff')) 
154          self.assertTrue(hasattr(el[0], 'maeh')) 
155          self.assertEqual(el.bluff(), 'bluff') 
156          self.assertEqual(el[0].maeh(), 'maeh') 
157   
158          self.Namespace(None).clear() 
159          self.Namespace('ns30').clear() 
160   
161 -    def test_element_creation(self): 
162          default, bluff, maeh = ( 
163              self.default_class, self.bluff_class, self.maeh_class) 
164   
165          class honk(etree.ElementBase): 
166              TAG = 'HONK' 
167              NAMESPACE = 'http://a.b/c' 
168   
169          el = default( 
170              "test", 
171              "text", 
172              bluff(honk, "TaIL", maeh), 
173              maeh("TeXT", bluff, honk(), "TAiL"), 
174              "Tail") 
175   
176          self.assertEqual('default_class', el.tag) 
177          self.assertEqual('testtext', el.text) 
178          self.assertEqual(None, el.tail) 
179          self.assertEqual(2, len(el)) 
180          self.assertEqual(7, len(list(el.iter()))) 
181   
182          self.assertEqual('bluff_class', el[0].tag) 
183          self.assertEqual('TaIL', el[0][0].tail) 
184          self.assertEqual('TaIL', ''.join(el[0].itertext())) 
185          self.assertEqual('{http://a.b/c}HONK', 
186                            el[0][0].tag) 
187          self.assertEqual('maeh_class', 
188                            el[0][1].tag) 
189   
190          self.assertEqual('maeh_class', el[1].tag) 
191          self.assertEqual('TeXT', el[1].text) 
192          self.assertEqual('bluff_class', el[1][0].tag) 
193          self.assertEqual('{http://a.b/c}HONK', el[1][1].tag) 
194          self.assertEqual('TAiL', el[1][1].tail) 
195   
196          self.assertEqual('TeXTTAiL', 
197                            ''.join(el[1].itertext())) 
198          self.assertEqual('Tail', el[1].tail) 
199          self.assertEqual('TAiL', el[1][1].tail) 
200          self.assertEqual('bluff_class', el[1][0].tag) 
201          self.assertEqual('{http://a.b/c}HONK', el[1][1].tag) 
202           
203   
204 -def test_suite(): 
205      suite = unittest.TestSuite() 
206      suite.addTests([unittest.makeSuite(ETreeNamespaceClassesTestCase)]) 
207      suite.addTests( 
208          [make_doctest('../../../doc/element_classes.txt')]) 
209      return suite 
210   
211  if __name__ == '__main__': 
212      print('to test use test.py %s' % __file__) 
213