Source Code for Module lxml.tests.test_sax

  1  # -*- coding: utf-8 -*- 
  2   
  3  """ 
  4  Test cases related to SAX I/O 
  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 HelperTestCase, doctest, make_doctest, BytesIO, _bytes 
 14  from lxml import sax 
 15  from xml.dom import pulldom 
 16   
 17 -class ETreeSaxTestCase(HelperTestCase): 
 18   
 19 -    def test_etree_sax_simple(self): 
 20          tree = self.parse('<a>ab<b/>ba</a>') 
 21          xml_out = self._saxify_serialize(tree) 
 22          self.assertEqual(_bytes('<a>ab<b/>ba</a>'), 
 23                            xml_out) 
 24   
 25 -    def test_etree_sax_double(self): 
 26          tree = self.parse('<a>ab<b>bb</b>ba</a>') 
 27          xml_out = self._saxify_serialize(tree) 
 28          self.assertEqual(_bytes('<a>ab<b>bb</b>ba</a>'), 
 29                            xml_out) 
 30   
 31 -    def test_etree_sax_comment(self): 
 32          tree = self.parse('<a>ab<!-- TEST -->ba</a>') 
 33          xml_out = self._saxify_serialize(tree) 
 34          self.assertEqual(_bytes('<a>abba</a>'), 
 35                            xml_out) 
 36   
 37 -    def test_etree_sax_pi(self): 
 38          tree = self.parse('<a>ab<?this and that?>ba</a>') 
 39          xml_out = self._saxify_serialize(tree) 
 40          self.assertEqual(_bytes('<a>ab<?this and that?>ba</a>'), 
 41                            xml_out) 
 42   
 43 -    def test_etree_sax_comment_root(self): 
 44          tree = self.parse('<!-- TEST --><a>ab</a>') 
 45          xml_out = self._saxify_serialize(tree) 
 46          self.assertEqual(_bytes('<a>ab</a>'), 
 47                            xml_out) 
 48   
 49 -    def test_etree_sax_pi_root(self): 
 50          tree = self.parse('<?this and that?><a>ab</a>') 
 51          xml_out = self._saxify_serialize(tree) 
 52          self.assertEqual(_bytes('<?this and that?><a>ab</a>'), 
 53                            xml_out) 
 54   
 55 -    def test_etree_sax_attributes(self): 
 56          tree = self.parse('<a aa="5">ab<b b="5"/>ba</a>') 
 57          xml_out = self._saxify_serialize(tree) 
 58          self.assertEqual(_bytes('<a aa="5">ab<b b="5"/>ba</a>'), 
 59                            xml_out) 
 60   
 61 -    def test_etree_sax_ns1(self): 
 62          tree = self.parse('<a xmlns="bla">ab<b>bb</b>ba</a>') 
 63          new_tree = self._saxify_unsaxify(tree) 
 64          root = new_tree.getroot() 
 65          self.assertEqual('{bla}a', 
 66                           root.tag) 
 67          self.assertEqual('{bla}b', 
 68                           root[0].tag) 
 69   
 70 -    def test_etree_sax_ns2(self): 
 71          tree = self.parse('<a xmlns="blaA">ab<b:b xmlns:b="blaB">bb</b:b>ba</a>') 
 72          new_tree = self._saxify_unsaxify(tree) 
 73          root = new_tree.getroot() 
 74          self.assertEqual('{blaA}a', 
 75                           root.tag) 
 76          self.assertEqual('{blaB}b', 
 77                           root[0].tag) 
 78   
 79 -    def test_sax_to_pulldom(self): 
 80          tree = self.parse('<a xmlns="blaA">ab<b:b xmlns:b="blaB">bb</b:b>ba</a>') 
 81          handler = pulldom.SAX2DOM() 
 82          sax.saxify(tree, handler) 
 83          dom = handler.document 
 84   
 85          self.assertEqual('a', 
 86                           dom.firstChild.localName) 
 87          self.assertEqual('blaA', 
 88                           dom.firstChild.namespaceURI) 
 89   
 90          children = dom.firstChild.childNodes 
 91          self.assertEqual('ab', 
 92                           children[0].nodeValue) 
 93          self.assertEqual('blaB', 
 94                           children[1].namespaceURI) 
 95          self.assertEqual('ba', 
 96                           children[2].nodeValue) 
 97   
 98 -    def test_element_sax(self): 
 99          tree = self.parse('<a><b/></a>') 
100          a = tree.getroot() 
101          b = a[0] 
102   
103          xml_out = self._saxify_serialize(a) 
104          self.assertEqual(_bytes('<a><b/></a>'), 
105                            xml_out) 
106   
107          xml_out = self._saxify_serialize(b) 
108          self.assertEqual(_bytes('<b/>'), 
109                            xml_out) 
110   
111 -    def test_element_sax_ns(self): 
112          tree = self.parse('<a:a xmlns:a="blaA"><b/></a:a>') 
113          a = tree.getroot() 
114          b = a[0] 
115   
116          new_tree = self._saxify_unsaxify(a) 
117          root = new_tree.getroot() 
118          self.assertEqual('{blaA}a', 
119                           root.tag) 
120          self.assertEqual('b', 
121                           root[0].tag) 
122   
123          new_tree = self._saxify_unsaxify(b) 
124          root = new_tree.getroot() 
125          self.assertEqual('b', 
126                           root.tag) 
127          self.assertEqual(0, 
128                           len(root)) 
129   
130 -    def test_etree_sax_handler_default_ns(self): 
131          handler = sax.ElementTreeContentHandler() 
132          handler.startDocument() 
133          handler.startPrefixMapping(None, 'blaA') 
134          handler.startElementNS(('blaA', 'a'), 'a', {}) 
135          handler.startPrefixMapping(None, 'blaB') 
136          handler.startElementNS(('blaB', 'b'), 'b', {}) 
137          handler.endElementNS(  ('blaB', 'b'), 'b') 
138          handler.endPrefixMapping(None) 
139          handler.startElementNS(('blaA', 'c'), 'c', {}) 
140          handler.endElementNS(  ('blaA', 'c'), 'c') 
141          handler.endElementNS(  ('blaA', 'a'), 'a') 
142          handler.endPrefixMapping(None) 
143          handler.endDocument() 
144   
145          new_tree = handler.etree 
146          root = new_tree.getroot() 
147          self.assertEqual('{blaA}a', 
148                           root.tag) 
149          self.assertEqual('{blaB}b', 
150                           root[0].tag) 
151          self.assertEqual('{blaA}c', 
152                           root[1].tag) 
153   
154 -    def test_etree_sax_handler_default_ns_None(self): 
155          handler = sax.ElementTreeContentHandler() 
156          handler.startDocument() 
157          handler.startPrefixMapping(None, 'blaA') 
158          handler.startElementNS((None, 'a'), 'a', {}) 
159          handler.startPrefixMapping(None, 'blaB') 
160          handler.startElementNS((None, 'b'), 'b', {}) 
161          handler.endElementNS(  (None, 'b'), 'b') 
162          handler.endPrefixMapping(None) 
163          handler.startElementNS((None, 'c'), 'c', {}) 
164          handler.endElementNS(  (None, 'c'), 'c') 
165          handler.endElementNS(  (None, 'a'), 'a') 
166          handler.endPrefixMapping(None) 
167          handler.endDocument() 
168   
169          new_tree = handler.etree 
170          root = new_tree.getroot() 
171          self.assertEqual('{blaA}a', 
172                           root.tag) 
173          self.assertEqual('{blaB}b', 
174                           root[0].tag) 
175          self.assertEqual('{blaA}c', 
176                           root[1].tag) 
177   
178 -    def test_etree_sax_redefine_ns(self): 
179          handler = sax.ElementTreeContentHandler() 
180          handler.startDocument() 
181          handler.startPrefixMapping('ns', 'blaA') 
182          handler.startElementNS(('blaA', 'a'), 'ns:a', {}) 
183          handler.startPrefixMapping('ns', 'blaB') 
184          handler.startElementNS(('blaB', 'b'), 'ns:b', {}) 
185          handler.endElementNS(  ('blaB', 'b'), 'ns:b') 
186          handler.endPrefixMapping('ns') 
187          handler.startElementNS(('blaA', 'c'), 'ns:c', {}) 
188          handler.endElementNS(  ('blaA', 'c'), 'ns:c') 
189          handler.endElementNS(  ('blaA', 'a'), 'ns:a') 
190          handler.endPrefixMapping('ns') 
191          handler.endDocument() 
192   
193          new_tree = handler.etree 
194          root = new_tree.getroot() 
195          self.assertEqual('{blaA}a', 
196                           root.tag) 
197          self.assertEqual('{blaB}b', 
198                           root[0].tag) 
199          self.assertEqual('{blaA}c', 
200                           root[1].tag) 
201   
202 -    def test_etree_sax_no_ns(self): 
203          handler = sax.ElementTreeContentHandler() 
204          handler.startDocument() 
205          handler.startElement('a', {}) 
206          handler.startElement('b', {}) 
207          handler.endElement('b') 
208          handler.startElement('c') # with empty attributes 
209          handler.endElement('c') 
210          handler.endElement('a') 
211          handler.endDocument() 
212   
213          new_tree = handler.etree 
214          root = new_tree.getroot() 
215          self.assertEqual('a', root.tag) 
216          self.assertEqual('b', root[0].tag) 
217          self.assertEqual('c', root[1].tag) 
218   
219 -    def test_etree_sax_no_ns_attributes(self): 
220          handler = sax.ElementTreeContentHandler() 
221          handler.startDocument() 
222          handler.startElement('a', {"attr_a1": "a1"}) 
223          handler.startElement('b', {"attr_b1": "b1"}) 
224          handler.endElement('b') 
225          handler.endElement('a') 
226          handler.endDocument() 
227   
228          new_tree = handler.etree 
229          root = new_tree.getroot() 
230          self.assertEqual('a', root.tag) 
231          self.assertEqual('b', root[0].tag) 
232          self.assertEqual('a1', root.attrib["attr_a1"]) 
233          self.assertEqual('b1', root[0].attrib["attr_b1"]) 
234   
235 -    def test_etree_sax_ns_attributes(self): 
236          handler = sax.ElementTreeContentHandler() 
237          handler.startDocument() 
238   
239          self.assertRaises(ValueError, 
240              handler.startElement, 
241              'a', {"blaA:attr_a1": "a1"} 
242          ) 
243   
244 -    def test_etree_sax_error(self): 
245          handler = sax.ElementTreeContentHandler() 
246          handler.startDocument() 
247          handler.startElement('a') 
248          self.assertRaises(sax.SaxError, handler.endElement, 'b') 
249   
250 -    def test_etree_sax_error2(self): 
251          handler = sax.ElementTreeContentHandler() 
252          handler.startDocument() 
253          handler.startElement('a') 
254          handler.startElement('b') 
255          self.assertRaises(sax.SaxError, handler.endElement, 'a') 
256   
257 -    def _saxify_unsaxify(self, saxifiable): 
258          handler = sax.ElementTreeContentHandler() 
259          sax.ElementTreeProducer(saxifiable, handler).saxify() 
260          return handler.etree 
261   
262 -    def _saxify_serialize(self, tree): 
263          new_tree = self._saxify_unsaxify(tree) 
264          f = BytesIO() 
265          new_tree.write(f) 
266          return f.getvalue().replace(_bytes('\n'), _bytes('')) 
267   
268   
269 -def test_suite(): 
270      suite = unittest.TestSuite() 
271      suite.addTests([unittest.makeSuite(ETreeSaxTestCase)]) 
272      suite.addTests( 
273          [make_doctest('../../../doc/sax.txt')]) 
274      return suite 
275   
276  if __name__ == '__main__': 
277      print('to test use test.py %s' % __file__) 
278