1
# Copyright (c) 2001-2005 Twisted Matrix Laboratories.
2
# See LICENSE for details.
5
from twisted.trial import unittest
6
from twisted.words.xish import domish
8
class DomishTestCase(unittest.TestCase):
9
def testEscaping(self):
11
self.assertEquals(domish.escapeToXml(s), "&<>'\"")
12
self.assertEquals(domish.escapeToXml(s, 1), "&<>'"")
14
def testNamespaceObject(self):
15
ns = domish.Namespace("testns")
16
self.assertEquals(ns.foo, ("testns", "foo"))
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)
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)
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)
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")
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"
53
# Check content merging
54
self.assertEquals(e.children[-1], "abc123")
56
# Check str()/content extraction
57
self.assertEquals(str(e), "somecontent")
59
# Check direct child accessor
60
self.assertEquals(e.bar2, b2)
61
e.bar2.addContent("subcontent")
62
e.bar2["bar2value"] = "somevalue"
65
self.assertEquals(e.children[1], e.bar2)
66
self.assertEquals(e.children[2], e.bar)
69
self.assertEquals(e["attrib1"], "value1")
71
self.assertEquals(e.hasAttribute("attrib1"), 0)
72
self.assertEquals(e.hasAttribute("attrib2"), 0)
73
self.assertEquals(e[("testns2", "attrib2")], "value2")
75
class DomishStreamTests:
77
self.doc_started = False
78
self.doc_ended = False
81
self.stream = self.streamClass()
82
self.stream.DocumentStartEvent = self._docStarted
83
self.stream.ElementEvent = self.elements.append
84
self.stream.DocumentEndEvent = self._docEnded
86
def _docStarted(self, root):
88
self.doc_started = True
93
def doTest(self, xml):
94
self.stream.parse(xml)
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)
106
xml = "<stream:stream xmlns:stream='etherx' xmlns='jabber'>\n" + \
107
" <message to='bar'>" + \
108
" <x xmlns='xdelay'>some&data></x>" + \
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>')
121
def testNoRootNS(self):
122
xml = "<stream><error xmlns='etherx'/></stream>"
124
self.stream.parse(xml)
125
self.assertEquals(self.root.uri, '')
126
self.assertEquals(self.elements[0].uri, 'etherx')
128
def testNoDefaultNS(self):
129
xml = "<stream:stream xmlns:stream='etherx'><error/></stream:stream>"""
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, '')
137
def testChildDefaultNS(self):
138
xml = "<root xmlns='testns'><child/></root>"
140
self.stream.parse(xml)
141
self.assertEquals(self.root.uri, 'testns')
142
self.assertEquals(self.elements[0].uri, 'testns')
144
def testEmptyChildNS(self):
145
xml = "<root xmlns='testns'><child1><child2 xmlns=''/></child1></root>"
147
self.stream.parse(xml)
148
self.assertEquals(self.elements[0].child2.uri, '')
150
def testChildPrefix(self):
151
xml = "<root xmlns='testns' xmlns:foo='testns2'><foo:child/></root>"
153
self.stream.parse(xml)
154
self.assertEquals(self.root.localPrefixes['foo'], 'testns2')
155
self.assertEquals(self.elements[0].uri, 'testns2')
157
def testUnclosedElement(self):
158
self.assertRaises(domish.ParserError, self.stream.parse,
159
"<root><error></root>")
161
class DomishExpatStreamTestCase(unittest.TestCase, DomishStreamTests):
163
DomishStreamTests.setUp(self)
165
def setUpClass(self):
169
raise unittest.SkipTest, "Skipping ExpatElementStream test, since no expat wrapper is available."
171
self.streamClass = domish.ExpatElementStream
173
class DomishSuxStreamTestCase(unittest.TestCase, DomishStreamTests):
175
DomishStreamTests.setUp(self)
177
def setUpClass(self):
178
if domish.SuxElementStream is None:
179
raise unittest.SkipTest, "Skipping SuxElementStream test, since twisted.web is not available."
181
self.streamClass = domish.SuxElementStream
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>")
189
def testDefaultNamespace(self):
190
e = domish.Element(("testns", "foo"))
191
self.assertEquals(e.toXml(), "<foo xmlns='testns'/>")
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'/>")
198
def testChildDefaultNamespace(self):
199
e = domish.Element(("testns", "foo"))
201
self.assertEquals(e.toXml(), "<foo xmlns='testns'><bar/></foo>")
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>")
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>")
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>")
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>")
223
def testOnlyChildDefaultNamespace2(self):
224
e = domish.Element((None, "foo"))
226
self.assertEquals(e.toXml(), "<foo><bar/></foo>")
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>")
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'/>")
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'/>")
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>")
251
def testXMLNamespace(self):
252
e = domish.Element((None, "foo"),
253
attribs = {("http://www.w3.org/XML/1998/namespace",
255
self.assertEquals(e.toXml(), "<foo xml:lang='en_US'/>")
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'/>")
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"
269
self.assertEquals(e.toXml(), "<foo xmlns:xn0='testns2' xn0:bar='baz'><xn0:qux xn0:bar='quux'/></foo>")
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"
278
self.assertEquals(e.toXml(), "<foo xmlns:xn0='testns2' xn0:bar='baz'><xn0:qux xn0:bar='quux'><xn0:foo/></xn0:qux></foo>")
280
def testPrefixScope(self):
281
e = domish.Element(('testns', 'foo'))
283
self.assertEquals(e.toXml(prefixes={'testns': 'bar'},
284
prefixesInScope=['bar']),
287
def testLocalPrefixes(self):
288
e = domish.Element(('testns', 'foo'), localPrefixes={'bar': 'testns'})
289
self.assertEquals(e.toXml(), "<bar:foo xmlns:bar='testns'/>")
291
def testLocalPrefixesWithChild(self):
292
e = domish.Element(('testns', 'foo'), localPrefixes={'bar': 'testns'})
294
self.assertIdentical(e.baz.defaultUri, None)
295
self.assertEquals(e.toXml(), "<bar:foo xmlns:bar='testns'><baz/></bar:foo>")
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>")
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>")
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>")
317
class DomishTestListSerializer(unittest.TestCase, SerializerTests):
318
def setUpClass(self):
319
self.__serializerClass = domish.SerializerClass
320
domish.SerializerClass = domish._ListSerializer
322
def tearDownClass(self):
323
domish.SerializerClass = self.__serializerClass
added
removed
src/twisted/words/test/test_domish.py
