← Back to branch summary

~landscape/zope3/ztk-1.1.3

« back to all changes in this revision

Viewing changes to src/twisted/words/test/test_domish.py

  • Committer: Andreas Hasenack
  • Date: 2009-07-20 17:49:16 UTC
  • Revision ID: andreas@canonical.com-20090720174916-g2tn6qmietz2hn0u
Revert twisted removal, it breaks several dozen tests [trivial]

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/twisted/words/test/test_domish.py
 
1
# Copyright (c) 2001-2005 Twisted Matrix Laboratories.
 
2
# See LICENSE for details.
 
3
 
 
4
 
 
5
from twisted.trial import unittest
 
6
from twisted.words.xish import domish
 
7
 
 
8
class DomishTestCase(unittest.TestCase):
 
9
    def testEscaping(self):
 
10
        s = "&<>'\""
 
11
        self.assertEquals(domish.escapeToXml(s), "&amp;&lt;&gt;'\"")
 
12
        self.assertEquals(domish.escapeToXml(s, 1), "&amp;&lt;&gt;&apos;&quot;")
 
13
 
 
14
    def testNamespaceObject(self):
 
15
        ns = domish.Namespace("testns")
 
16
        self.assertEquals(ns.foo, ("testns", "foo"))
 
17
 
 
18
    def testElementInit(self):
 
19
        e = domish.Element((None, "foo"))
 
20
        self.assertEquals(e.name, "foo")
 
21
        self.assertEquals(e.uri, None)
 
22
        self.assertEquals(e.defaultUri, None)
 
23
        self.assertEquals(e.parent, None)
 
24
 
 
25
        e = domish.Element(("", "foo"))
 
26
        self.assertEquals(e.name, "foo")
 
27
        self.assertEquals(e.uri, "")
 
28
        self.assertEquals(e.defaultUri, "")
 
29
        self.assertEquals(e.parent, None)
 
30
 
 
31
        e = domish.Element(("testns", "foo"))
 
32
        self.assertEquals(e.name, "foo")
 
33
        self.assertEquals(e.uri, "testns")
 
34
        self.assertEquals(e.defaultUri, "testns")
 
35
        self.assertEquals(e.parent, None)
 
36
 
 
37
        e = domish.Element(("testns", "foo"), "test2ns")
 
38
        self.assertEquals(e.name, "foo")
 
39
        self.assertEquals(e.uri, "testns")
 
40
        self.assertEquals(e.defaultUri, "test2ns")
 
41
 
 
42
    def testChildOps(self):
 
43
        e = domish.Element(("testns", "foo"))
 
44
        e.addContent("somecontent")
 
45
        b2 = e.addElement(("testns2", "bar2"))
 
46
        e["attrib1"] = "value1"
 
47
        e[("testns2", "attrib2")] = "value2"
 
48
        e.addElement("bar")
 
49
        e.addElement("bar")
 
50
        e.addContent("abc")
 
51
        e.addContent("123")
 
52
 
 
53
        # Check content merging
 
54
        self.assertEquals(e.children[-1], "abc123")
 
55
 
 
56
        # Check str()/content extraction
 
57
        self.assertEquals(str(e), "somecontent")
 
58
 
 
59
        # Check direct child accessor
 
60
        self.assertEquals(e.bar2, b2)
 
61
        e.bar2.addContent("subcontent")
 
62
        e.bar2["bar2value"] = "somevalue"
 
63
 
 
64
        # Check child ops
 
65
        self.assertEquals(e.children[1], e.bar2)
 
66
        self.assertEquals(e.children[2], e.bar)
 
67
        
 
68
        # Check attribute ops
 
69
        self.assertEquals(e["attrib1"], "value1")
 
70
        del e["attrib1"]
 
71
        self.assertEquals(e.hasAttribute("attrib1"), 0)
 
72
        self.assertEquals(e.hasAttribute("attrib2"), 0)
 
73
        self.assertEquals(e[("testns2", "attrib2")], "value2")
 
74
 
 
75
class DomishStreamTests:
 
76
    def setUp(self):
 
77
        self.doc_started = False
 
78
        self.doc_ended = False
 
79
        self.root = None
 
80
        self.elements = []
 
81
        self.stream = self.streamClass()
 
82
        self.stream.DocumentStartEvent = self._docStarted
 
83
        self.stream.ElementEvent = self.elements.append
 
84
        self.stream.DocumentEndEvent = self._docEnded
 
85
 
 
86
    def _docStarted(self, root):
 
87
        self.root = root
 
88
        self.doc_started = True
 
89
 
 
90
    def _docEnded(self):
 
91
        self.doc_ended = True
 
92
 
 
93
    def doTest(self, xml):
 
94
        self.stream.parse(xml)
 
95
 
 
96
    def testHarness(self):
 
97
        xml = "<root><child/><child2/></root>"
 
98
        self.stream.parse(xml)
 
99
        self.assertEquals(self.doc_started, True)
 
100
        self.assertEquals(self.root.name, 'root')
 
101
        self.assertEquals(self.elements[0].name, 'child')
 
102
        self.assertEquals(self.elements[1].name, 'child2')
 
103
        self.assertEquals(self.doc_ended, True)
 
104
 
 
105
    def testBasic(self):
 
106
        xml = "<stream:stream xmlns:stream='etherx' xmlns='jabber'>\n" + \
 
107
              "  <message to='bar'>" + \
 
108
              "    <x xmlns='xdelay'>some&amp;data&gt;</x>" + \
 
109
              "  </message>" + \
 
110
              "</stream:stream>"
 
111
 
 
112
        self.stream.parse(xml)
 
113
        self.assertEquals(self.root.name, 'stream')
 
114
        self.assertEquals(self.root.uri, 'etherx')
 
115
        self.assertEquals(self.elements[0].name, 'message')
 
116
        self.assertEquals(self.elements[0].uri, 'jabber')
 
117
        self.assertEquals(self.elements[0]['to'], 'bar')
 
118
        self.assertEquals(self.elements[0].x.uri, 'xdelay')
 
119
        self.assertEquals(unicode(self.elements[0].x), 'some&data>')
 
120
 
 
121
    def testNoRootNS(self):
 
122
        xml = "<stream><error xmlns='etherx'/></stream>"
 
123
 
 
124
        self.stream.parse(xml)
 
125
        self.assertEquals(self.root.uri, '')
 
126
        self.assertEquals(self.elements[0].uri, 'etherx')
 
127
        
 
128
    def testNoDefaultNS(self):
 
129
        xml = "<stream:stream xmlns:stream='etherx'><error/></stream:stream>"""
 
130
 
 
131
        self.stream.parse(xml)
 
132
        self.assertEquals(self.root.uri, 'etherx')
 
133
        self.assertEquals(self.root.defaultUri, '')
 
134
        self.assertEquals(self.elements[0].uri, '')
 
135
        self.assertEquals(self.elements[0].defaultUri, '')
 
136
 
 
137
    def testChildDefaultNS(self):
 
138
        xml = "<root xmlns='testns'><child/></root>"
 
139
 
 
140
        self.stream.parse(xml)
 
141
        self.assertEquals(self.root.uri, 'testns')
 
142
        self.assertEquals(self.elements[0].uri, 'testns')
 
143
 
 
144
    def testEmptyChildNS(self):
 
145
        xml = "<root xmlns='testns'><child1><child2 xmlns=''/></child1></root>"
 
146
 
 
147
        self.stream.parse(xml)
 
148
        self.assertEquals(self.elements[0].child2.uri, '')
 
149
 
 
150
    def testChildPrefix(self):
 
151
        xml = "<root xmlns='testns' xmlns:foo='testns2'><foo:child/></root>"
 
152
 
 
153
        self.stream.parse(xml)
 
154
        self.assertEquals(self.root.localPrefixes['foo'], 'testns2')
 
155
        self.assertEquals(self.elements[0].uri, 'testns2')
 
156
 
 
157
    def testUnclosedElement(self):
 
158
        self.assertRaises(domish.ParserError, self.stream.parse, 
 
159
                                              "<root><error></root>")
 
160
 
 
161
class DomishExpatStreamTestCase(unittest.TestCase, DomishStreamTests):
 
162
    def setUp(self):
 
163
        DomishStreamTests.setUp(self)
 
164
 
 
165
    def setUpClass(self):
 
166
        try: 
 
167
            import pyexpat
 
168
        except ImportError:
 
169
            raise unittest.SkipTest, "Skipping ExpatElementStream test, since no expat wrapper is available."
 
170
 
 
171
        self.streamClass = domish.ExpatElementStream
 
172
 
 
173
class DomishSuxStreamTestCase(unittest.TestCase, DomishStreamTests):
 
174
    def setUp(self):
 
175
        DomishStreamTests.setUp(self)
 
176
 
 
177
    def setUpClass(self):
 
178
        if domish.SuxElementStream is None:
 
179
            raise unittest.SkipTest, "Skipping SuxElementStream test, since twisted.web is not available."
 
180
 
 
181
        self.streamClass = domish.SuxElementStream
 
182
 
 
183
class SerializerTests:
 
184
    def testNoNamespace(self):
 
185
        e = domish.Element((None, "foo"))
 
186
        self.assertEquals(e.toXml(), "<foo/>")
 
187
        self.assertEquals(e.toXml(closeElement = 0), "<foo>")
 
188
 
 
189
    def testDefaultNamespace(self):
 
190
        e = domish.Element(("testns", "foo"))
 
191
        self.assertEquals(e.toXml(), "<foo xmlns='testns'/>")
 
192
 
 
193
    def testOtherNamespace(self):
 
194
        e = domish.Element(("testns", "foo"), "testns2")
 
195
        self.assertEquals(e.toXml({'testns': 'bar'}),
 
196
                          "<bar:foo xmlns:bar='testns' xmlns='testns2'/>")
 
197
 
 
198
    def testChildDefaultNamespace(self):
 
199
        e = domish.Element(("testns", "foo"))
 
200
        e.addElement("bar")
 
201
        self.assertEquals(e.toXml(), "<foo xmlns='testns'><bar/></foo>")
 
202
 
 
203
    def testChildSameNamespace(self):
 
204
        e = domish.Element(("testns", "foo"))
 
205
        e.addElement(("testns", "bar"))
 
206
        self.assertEquals(e.toXml(), "<foo xmlns='testns'><bar/></foo>")
 
207
 
 
208
    def testChildSameDefaultNamespace(self):
 
209
        e = domish.Element(("testns", "foo"))
 
210
        e.addElement("bar", "testns")
 
211
        self.assertEquals(e.toXml(), "<foo xmlns='testns'><bar/></foo>")
 
212
 
 
213
    def testChildOtherDefaultNamespace(self):
 
214
        e = domish.Element(("testns", "foo"))
 
215
        e.addElement(("testns2", "bar"), 'testns2')
 
216
        self.assertEquals(e.toXml(), "<foo xmlns='testns'><bar xmlns='testns2'/></foo>")
 
217
 
 
218
    def testOnlyChildDefaultNamespace(self):
 
219
        e = domish.Element((None, "foo"))
 
220
        e.addElement(("ns2", "bar"), 'ns2')
 
221
        self.assertEquals(e.toXml(), "<foo><bar xmlns='ns2'/></foo>")
 
222
    
 
223
    def testOnlyChildDefaultNamespace2(self):
 
224
        e = domish.Element((None, "foo"))
 
225
        e.addElement("bar")
 
226
        self.assertEquals(e.toXml(), "<foo><bar/></foo>")
 
227
 
 
228
    def testChildInDefaultNamespace(self):
 
229
        e = domish.Element(("testns", "foo"), "testns2")
 
230
        e.addElement(("testns2", "bar"))
 
231
        self.assertEquals(e.toXml(), "<xn0:foo xmlns:xn0='testns' xmlns='testns2'><bar/></xn0:foo>")
 
232
 
 
233
    def testQualifiedAttribute(self):
 
234
        e = domish.Element((None, "foo"),
 
235
                           attribs = {("testns2", "bar"): "baz"})
 
236
        self.assertEquals(e.toXml(), "<foo xmlns:xn0='testns2' xn0:bar='baz'/>")
 
237
 
 
238
    def testQualifiedAttributeDefaultNS(self):
 
239
        e = domish.Element(("testns", "foo"),
 
240
                           attribs = {("testns", "bar"): "baz"})
 
241
        self.assertEquals(e.toXml(), "<foo xmlns='testns' xmlns:xn0='testns' xn0:bar='baz'/>")
 
242
 
 
243
    def testTwoChilds(self):
 
244
        e = domish.Element(('', "foo"))
 
245
        child1 = e.addElement(("testns", "bar"), "testns2")
 
246
        child1.addElement(('testns2', 'quux'))
 
247
        child2 = e.addElement(("testns3", "baz"), "testns4")
 
248
        child2.addElement(('testns', 'quux'))
 
249
        self.assertEquals(e.toXml(), "<foo><xn0:bar xmlns:xn0='testns' xmlns='testns2'><quux/></xn0:bar><xn1:baz xmlns:xn1='testns3' xmlns='testns4'><xn0:quux xmlns:xn0='testns'/></xn1:baz></foo>")
 
250
 
 
251
    def testXMLNamespace(self):
 
252
        e = domish.Element((None, "foo"),
 
253
                           attribs = {("http://www.w3.org/XML/1998/namespace",
 
254
                                       "lang"): "en_US"})
 
255
        self.assertEquals(e.toXml(), "<foo xml:lang='en_US'/>")
 
256
 
 
257
    def testQualifiedAttributeGivenListOfPrefixes(self):
 
258
        e = domish.Element((None, "foo"),
 
259
                           attribs = {("testns2", "bar"): "baz"})
 
260
        self.assertEquals(e.toXml({"testns2": "qux"}),
 
261
                          "<foo xmlns:qux='testns2' qux:bar='baz'/>")
 
262
 
 
263
    def testNSPrefix(self):
 
264
        e = domish.Element((None, "foo"),
 
265
                           attribs = {("testns2", "bar"): "baz"})
 
266
        c = e.addElement(("testns2", "qux"))
 
267
        c[("testns2", "bar")] = "quux"
 
268
 
 
269
        self.assertEquals(e.toXml(), "<foo xmlns:xn0='testns2' xn0:bar='baz'><xn0:qux xn0:bar='quux'/></foo>")
 
270
 
 
271
    def testDefaultNSPrefix(self):
 
272
        e = domish.Element((None, "foo"),
 
273
                           attribs = {("testns2", "bar"): "baz"})
 
274
        c = e.addElement(("testns2", "qux"))
 
275
        c[("testns2", "bar")] = "quux"
 
276
        c.addElement('foo')
 
277
 
 
278
        self.assertEquals(e.toXml(), "<foo xmlns:xn0='testns2' xn0:bar='baz'><xn0:qux xn0:bar='quux'><xn0:foo/></xn0:qux></foo>")
 
279
 
 
280
    def testPrefixScope(self):
 
281
        e = domish.Element(('testns', 'foo'))
 
282
 
 
283
        self.assertEquals(e.toXml(prefixes={'testns': 'bar'},
 
284
                                  prefixesInScope=['bar']),
 
285
                          "<bar:foo/>")
 
286
 
 
287
    def testLocalPrefixes(self):
 
288
        e = domish.Element(('testns', 'foo'), localPrefixes={'bar': 'testns'})
 
289
        self.assertEquals(e.toXml(), "<bar:foo xmlns:bar='testns'/>")
 
290
 
 
291
    def testLocalPrefixesWithChild(self):
 
292
        e = domish.Element(('testns', 'foo'), localPrefixes={'bar': 'testns'})
 
293
        e.addElement('baz')
 
294
        self.assertIdentical(e.baz.defaultUri, None)
 
295
        self.assertEquals(e.toXml(), "<bar:foo xmlns:bar='testns'><baz/></bar:foo>")
 
296
 
 
297
    def testRawXMLSerialization(self):
 
298
        e = domish.Element((None, "foo"))
 
299
        e.addRawXml("<abc123>")
 
300
        # The testcase below should NOT generate valid XML -- that's
 
301
        # the whole point of using the raw XML call -- it's the callers
 
302
        # responsiblity to ensure that the data inserted is valid
 
303
        self.assertEquals(e.toXml(), "<foo><abc123></foo>")
 
304
 
 
305
    def testRawXMLWithUnicodeSerialization(self):
 
306
        e = domish.Element((None, "foo"))
 
307
        e.addRawXml(u"<degree>\u00B0</degree>")
 
308
        self.assertEquals(e.toXml(), u"<foo><degree>\u00B0</degree></foo>")
 
309
 
 
310
    def testUnicodeSerialization(self):
 
311
        e = domish.Element((None, "foo"))
 
312
        e["test"] = u"my value\u0221e"
 
313
        e.addContent(u"A degree symbol...\u00B0")
 
314
        self.assertEquals(e.toXml(),
 
315
                          u"<foo test='my value\u0221e'>A degree symbol...\u00B0</foo>")
 
316
 
 
317
class DomishTestListSerializer(unittest.TestCase, SerializerTests):
 
318
    def setUpClass(self):
 
319
        self.__serializerClass = domish.SerializerClass
 
320
        domish.SerializerClass = domish._ListSerializer
 
321
 
 
322
    def tearDownClass(self):
 
323
        domish.SerializerClass = self.__serializerClass
 
324