Source Code for Module lxml.tests.test_pyclasslookup

  1  # -*- coding: utf-8 -*- 
  2   
  3  """ 
  4  Tests specific to the Python based class lookup. 
  5  """ 
  6   
  7  from __future__ import absolute_import 
  8   
  9  import unittest 
 10   
 11  from .common_imports import etree, HelperTestCase, _bytes 
 12   
 13  from lxml.etree import PythonElementClassLookup 
 14   
 15   
 16  xml_str = _bytes('''\ 
 17  <obj:root xmlns:obj="objectified" xmlns:other="otherNS"> 
 18    <obj:c1 a1="A1" a2="A2" other:a3="A3"> 
 19      <obj:c2>0</obj:c2> 
 20      <obj:c2>1</obj:c2> 
 21      <obj:c2>2</obj:c2> 
 22      <other:c2>3</other:c2> 
 23      <c2>3</c2> 
 24    </obj:c1> 
 25  </obj:root>''') 
 26   
 27   
 28 -class PyClassLookupTestCase(HelperTestCase): 
 29      """Test cases for the lxml.pyclasslookup class lookup mechanism. 
 30      """ 
 31      etree = etree 
 32      parser = etree.XMLParser() 
 33      Element = parser.makeelement 
 34   
 35 -    def tearDown(self): 
 36          self.parser.set_element_class_lookup(None) 
 37          super(PyClassLookupTestCase, self).tearDown() 
 38   
 39 -    def _setClassLookup(self, lookup_function): 
 40          class Lookup(PythonElementClassLookup): 
 41              def lookup(self, *args): 
 42                  return lookup_function(*args) 
 43          self.parser.set_element_class_lookup( Lookup() ) 
 44   
 45 -    def _buildElementClass(self): 
 46          class LocalElement(etree.ElementBase): 
 47              pass 
 48          return LocalElement 
 49   
 50 -    def XML(self, xml): 
 51          return self.etree.XML(xml, self.parser) 
 52   
 53      # --- Test cases 
 54   
 55 -    def test_lookup(self): 
 56          el_class = self._buildElementClass() 
 57          el_class.i = 1 
 58          def lookup(*args): 
 59              if el_class.i == 1: 
 60                  el_class.i = 2 
 61              return el_class 
 62          self._setClassLookup(lookup) 
 63          root = self.XML(xml_str) 
 64          self.assertEqual(2, el_class.i) 
 65   
 66 -    def test_lookup_keep_ref_assertion(self): 
 67          el_class = self._buildElementClass() 
 68          el_class.EL = None 
 69          def lookup(doc, el): 
 70              if el_class.EL is None: 
 71                  el_class.EL = el 
 72              return el_class 
 73          self._setClassLookup(lookup) 
 74          root = self.XML(xml_str) 
 75          self.assertNotEqual(None, el_class.EL) 
 76          self.assertRaises(ReferenceError, el_class.EL.getchildren) 
 77   
 78 -    def test_lookup_tag(self): 
 79          el_class = self._buildElementClass() 
 80          el_class.TAG = None 
 81          def lookup(doc, el): 
 82              if el_class.TAG is None: 
 83                  el_class.TAG = el.tag 
 84              return el_class 
 85          self._setClassLookup(lookup) 
 86          root = self.XML(xml_str) 
 87          self.assertNotEqual(None, root.TAG) 
 88          self.assertEqual(root.tag, root.TAG) 
 89   
 90 -    def test_lookup_text(self): 
 91          el_class = self._buildElementClass() 
 92          el_class.TEXT = None 
 93          def lookup(doc, el): 
 94              if el_class.TEXT is None: 
 95                  el_class.TEXT = el.text 
 96              return el_class 
 97          self._setClassLookup(lookup) 
 98          root = self.XML(xml_str) 
 99          self.assertNotEqual(None, root.TEXT) 
100          self.assertEqual(root.text, root.TEXT) 
101   
102 -    def test_lookup_tail(self): 
103          el_class = self._buildElementClass() 
104          el_class.TAIL = None 
105          def lookup(doc, el): 
106              if el_class.TAIL is None: 
107                  el_class.TAIL = el.tail 
108              return el_class 
109          self._setClassLookup(lookup) 
110          root = self.XML(xml_str) 
111          self.assertEqual(root.tail, root.TAIL) 
112   
113 -    def test_lookup_attrib(self): 
114          el_class = self._buildElementClass() 
115          el_class.ATTRIB = None 
116          def lookup(doc, el): 
117              if el_class.ATTRIB is None: 
118                  el_class.ATTRIB = el[0].attrib 
119              return el_class 
120          self._setClassLookup(lookup) 
121          root = self.XML(xml_str) 
122          items1 = list(root[0].attrib.items()) 
123          items1.sort() 
124          items2 = list(root.ATTRIB.items()) 
125          items2.sort() 
126          self.assertEqual(items1, items2) 
127   
128 -    def test_lookup_prefix(self): 
129          el_class = self._buildElementClass() 
130          el_class.PREFIX = None 
131          def lookup(doc, el): 
132              if el_class.PREFIX is None: 
133                  el_class.PREFIX = el.prefix 
134              return el_class 
135          self._setClassLookup(lookup) 
136          root = self.XML(xml_str) 
137          self.assertEqual(root.prefix, root.PREFIX) 
138   
139 -    def test_lookup_sourceline(self): 
140          el_class = self._buildElementClass() 
141          el_class.LINE = None 
142          def lookup(doc, el): 
143              if el_class.LINE is None: 
144                  el_class.LINE = el.sourceline 
145              return el_class 
146          self._setClassLookup(lookup) 
147          root = self.XML(xml_str) 
148          self.assertEqual(root.sourceline, root.LINE) 
149   
150 -    def test_lookup_getitem(self): 
151          el_class = self._buildElementClass() 
152          el_class.CHILD_TAG = None 
153          def lookup(doc, el): 
154              el_class.CHILD_TAG = el[0].tag 
155              return el_class 
156          self._setClassLookup(lookup) 
157          root = self.XML(xml_str) 
158          child_tag = root.CHILD_TAG 
159          self.assertNotEqual(None, child_tag) 
160          self.assertEqual(root[0].tag, child_tag) 
161   
162 -    def test_lookup_getitem_neg(self): 
163          el_class = self._buildElementClass() 
164          el_class.CHILD_TAG = None 
165          def lookup(doc, el): 
166              if el_class.CHILD_TAG is None: 
167                  el_class.CHILD_TAG = el[-1].tag 
168              return el_class 
169          self._setClassLookup(lookup) 
170          root = self.XML(xml_str) 
171          child_tag = root.CHILD_TAG 
172          self.assertNotEqual(None, child_tag) 
173          self.assertEqual(root[-1].tag, child_tag) 
174   
175 -    def test_lookup_getslice(self): 
176          el_class = self._buildElementClass() 
177          el_class.CHILD_TAGS = None 
178          def lookup(doc, el): 
179              if el_class.CHILD_TAGS is None: 
180                  el_class.CHILD_TAGS = [ c.tag for c in el[1:-1] ] 
181              return el_class 
182          self._setClassLookup(lookup) 
183          root = self.XML(xml_str) 
184          child_tags = root.CHILD_TAGS 
185          self.assertNotEqual(None, child_tags) 
186          self.assertEqual([ c.tag for c in root[1:-1] ], 
187                            child_tags) 
188   
189 -    def test_lookup_len(self): 
190          el_class = self._buildElementClass() 
191          el_class.LEN = None 
192          def lookup(doc, el): 
193              if el_class.LEN is None: 
194                  el_class.LEN = len(el) 
195              return el_class 
196          self._setClassLookup(lookup) 
197          root = self.XML(xml_str) 
198          self.assertEqual(1, el_class.LEN) 
199   
200 -    def test_lookup_bool(self): 
201          el_class = self._buildElementClass() 
202          el_class.TRUE = None 
203          def lookup(doc, el): 
204              if el_class.TRUE is None: 
205                  el_class.TRUE = bool(el) 
206              return el_class 
207          self._setClassLookup(lookup) 
208          root = self.XML(xml_str) 
209          self.assertTrue(el_class.TRUE) 
210   
211 -    def test_lookup_get(self): 
212          el_class = self._buildElementClass() 
213          el_class.VAL = None 
214          def lookup(doc, el): 
215              if el_class.VAL is None: 
216                  el_class.VAL = el[0].get('a1') 
217              return el_class 
218          self._setClassLookup(lookup) 
219          root = self.XML(xml_str) 
220          self.assertNotEqual(None, el_class.VAL) 
221          self.assertEqual(root[0].get('a1'), el_class.VAL) 
222   
223 -    def test_lookup_get_default(self): 
224          el_class = self._buildElementClass() 
225          default = str(id(el_class)) 
226          el_class.VAL = None 
227          def lookup(doc, el): 
228              if el_class.VAL is None: 
229                  el_class.VAL = el[0].get('unknownattribute', default) 
230              return el_class 
231          self._setClassLookup(lookup) 
232          root = self.XML(xml_str) 
233          self.assertEqual(default, el_class.VAL) 
234   
235 -    def test_lookup_getchildren(self): 
236          el_class = self._buildElementClass() 
237          el_class.CHILD_TAGS = None 
238          def lookup(doc, el): 
239              if el_class.CHILD_TAGS is None: 
240                  el_class.CHILD_TAGS = [ c.tag for c in el.getchildren() ] 
241              return el_class 
242          self._setClassLookup(lookup) 
243          root = self.XML(xml_str) 
244          child_tags = root.CHILD_TAGS 
245          self.assertNotEqual(None, child_tags) 
246          self.assertEqual([ c.tag for c in root.getchildren() ], 
247                            child_tags) 
248   
249 -    def test_lookup_iter_children(self): 
250          el_class = self._buildElementClass() 
251          el_class.CHILD_TAGS = None 
252          def lookup(doc, el): 
253              if el_class.CHILD_TAGS is None: 
254                  el_class.CHILD_TAGS = [ c.tag for c in el ] 
255              return el_class 
256          self._setClassLookup(lookup) 
257          root = self.XML(xml_str) 
258          child_tags = root.CHILD_TAGS 
259          self.assertNotEqual(None, child_tags) 
260          self.assertEqual([ c.tag for c in root.getchildren() ], 
261                            child_tags) 
262   
263 -    def test_lookup_iterchildren(self): 
264          el_class = self._buildElementClass() 
265          el_class.CHILD_TAGS = None 
266          def lookup(doc, el): 
267              if el_class.CHILD_TAGS is None: 
268                  el_class.CHILD_TAGS = [ c.tag for c in el.iterchildren() ] 
269              return el_class 
270          self._setClassLookup(lookup) 
271          root = self.XML(xml_str) 
272          child_tags = root.CHILD_TAGS 
273          self.assertNotEqual(None, child_tags) 
274          self.assertEqual([ c.tag for c in root.getchildren() ], 
275                            child_tags) 
276   
277 -    def test_lookup_iterchildren_tag(self): 
278          el_class = self._buildElementClass() 
279          el_class.CHILD_TAGS = None 
280          def lookup(doc, el): 
281              if not el_class.CHILD_TAGS: 
282                  el_class.CHILD_TAGS = [ 
283                      c.tag for c in el.iterchildren(tag='{objectified}c2') ] 
284              return el_class 
285          self._setClassLookup(lookup) 
286   
287          root = self.XML(xml_str) 
288          child_tags = root.CHILD_TAGS 
289          self.assertNotEqual(None, child_tags) 
290          self.assertEqual([], child_tags) 
291   
292          c1 = root[0] 
293          child_tags = root.CHILD_TAGS 
294          self.assertNotEqual(None, child_tags) 
295          self.assertNotEqual([], child_tags) 
296          self.assertEqual( 
297              [ c.tag for c in root[0].iterchildren(tag='{objectified}c2') ], 
298              child_tags) 
299   
300 -    def test_lookup_getparent(self): 
301          el_class = self._buildElementClass() 
302          el_class.PARENT = None 
303          def lookup(doc, el): 
304              if el_class.PARENT is None: 
305                  el_class.PARENT = el[0].getparent().tag 
306              return el_class 
307          self._setClassLookup(lookup) 
308          root = self.XML(xml_str) 
309          self.assertEqual(root.tag, root.PARENT) 
310   
311 -    def test_lookup_getnext(self): 
312          el_class = self._buildElementClass() 
313          el_class.NEXT = None 
314          def lookup(doc, el): 
315              if el_class.NEXT is None: 
316                  el_class.NEXT = el[0][1].getnext().tag 
317              return el_class 
318          self._setClassLookup(lookup) 
319          root = self.XML(xml_str) 
320          self.assertNotEqual(None, el_class.NEXT) 
321          self.assertEqual(root[0][1].getnext().tag, el_class.NEXT) 
322   
323 -    def test_lookup_getprevious(self): 
324          el_class = self._buildElementClass() 
325          el_class.PREV = None 
326          def lookup(doc, el): 
327              if el_class.PREV is None: 
328                  el_class.PREV = el[0][1].getprevious().tag 
329              return el_class 
330          self._setClassLookup(lookup) 
331          root = self.XML(xml_str) 
332          self.assertNotEqual(None, el_class.PREV) 
333          self.assertEqual(root[0][1].getprevious().tag, el_class.PREV) 
334   
335 -    def test_comments_fallback(self): 
336          def return_none(*args): 
337              return None 
338   
339          self._setClassLookup(return_none) 
340          el = self.XML('<a><!-- hello world --></a>') 
341          self.assertEqual(el[0].tag, self.etree.Comment) 
342          self.assertEqual(el[0].text, " hello world ") 
343   
344   
345 -def test_suite(): 
346      suite = unittest.TestSuite() 
347      suite.addTests([unittest.makeSuite(PyClassLookupTestCase)]) 
348      return suite 
349   
350  if __name__ == '__main__': 
351      print('to test use test.py %s' % __file__) 
352