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