← Back to branch summary

~justin-fathomdb/nova/justinsb-openstack-api-volumes

« back to all changes in this revision

Viewing changes to vendor/Twisted-10.0.0/twisted/web/test/test_domhelpers.py

  • Committer: Jesse Andrews
  • Date: 2010-05-28 06:05:26 UTC
  • Revision ID: git-v1:bf6e6e718cdc7488e2da87b21e258ccc065fe499
initial commit

Show diffs side-by-side

added added

removed removed

Lines of Context:
vendor/Twisted-10.0.0/twisted/web/test/test_domhelpers.py
 
1
# -*- test-case-name: twisted.web.test.test_domhelpers -*-
 
2
# Copyright (c) 2001-2009 Twisted Matrix Laboratories.
 
3
# See LICENSE for details.
 
4
 
 
5
"""
 
6
Specific tests for (some of) the methods in L{twisted.web.domhelpers}.
 
7
"""
 
8
 
 
9
from xml.dom import minidom
 
10
 
 
11
from twisted.trial.unittest import TestCase
 
12
 
 
13
from twisted.web import microdom
 
14
 
 
15
from twisted.web import domhelpers
 
16
 
 
17
 
 
18
class DOMHelpersTestsMixin:
 
19
    """
 
20
    A mixin for L{TestCase} subclasses which defines test methods for
 
21
    domhelpers functionality based on a DOM creation function provided by a
 
22
    subclass.
 
23
    """
 
24
    dom = None
 
25
 
 
26
    def test_getElementsByTagName(self):
 
27
        doc1 = self.dom.parseString('<foo/>')
 
28
        actual=domhelpers.getElementsByTagName(doc1, 'foo')[0].nodeName
 
29
        expected='foo'
 
30
        self.assertEquals(actual, expected)
 
31
        el1=doc1.documentElement
 
32
        actual=domhelpers.getElementsByTagName(el1, 'foo')[0].nodeName
 
33
        self.assertEqual(actual, expected)
 
34
 
 
35
        doc2_xml='<a><foo in="a"/><b><foo in="b"/></b><c><foo in="c"/></c><foo in="d"/><foo in="ef"/><g><foo in="g"/><h><foo in="h"/></h></g></a>'
 
36
        doc2 = self.dom.parseString(doc2_xml)
 
37
        tag_list=domhelpers.getElementsByTagName(doc2, 'foo')
 
38
        actual=''.join([node.getAttribute('in') for node in tag_list])
 
39
        expected='abcdefgh'
 
40
        self.assertEquals(actual, expected)
 
41
        el2=doc2.documentElement
 
42
        tag_list=domhelpers.getElementsByTagName(el2, 'foo')
 
43
        actual=''.join([node.getAttribute('in') for node in tag_list])
 
44
        self.assertEqual(actual, expected)
 
45
 
 
46
        doc3_xml='''
 
47
<a><foo in="a"/>
 
48
    <b><foo in="b"/>
 
49
        <d><foo in="d"/>
 
50
            <g><foo in="g"/></g>
 
51
            <h><foo in="h"/></h>
 
52
        </d>
 
53
        <e><foo in="e"/>
 
54
            <i><foo in="i"/></i>
 
55
        </e>
 
56
    </b>
 
57
    <c><foo in="c"/>
 
58
        <f><foo in="f"/>
 
59
            <j><foo in="j"/></j>
 
60
        </f>
 
61
    </c>
 
62
</a>'''
 
63
        doc3 = self.dom.parseString(doc3_xml)
 
64
        tag_list=domhelpers.getElementsByTagName(doc3, 'foo')
 
65
        actual=''.join([node.getAttribute('in') for node in tag_list])
 
66
        expected='abdgheicfj'
 
67
        self.assertEquals(actual, expected)
 
68
        el3=doc3.documentElement
 
69
        tag_list=domhelpers.getElementsByTagName(el3, 'foo')
 
70
        actual=''.join([node.getAttribute('in') for node in tag_list])
 
71
        self.assertEqual(actual, expected)
 
72
 
 
73
        doc4_xml='<foo><bar></bar><baz><foo/></baz></foo>'
 
74
        doc4 = self.dom.parseString(doc4_xml)
 
75
        actual=domhelpers.getElementsByTagName(doc4, 'foo')
 
76
        root=doc4.documentElement
 
77
        expected=[root, root.childNodes[-1].childNodes[0]]
 
78
        self.assertEquals(actual, expected)
 
79
        actual=domhelpers.getElementsByTagName(root, 'foo')
 
80
        self.assertEqual(actual, expected)
 
81
 
 
82
 
 
83
    def test_gatherTextNodes(self):
 
84
        doc1 = self.dom.parseString('<a>foo</a>')
 
85
        actual=domhelpers.gatherTextNodes(doc1)
 
86
        expected='foo'
 
87
        self.assertEqual(actual, expected)
 
88
        actual=domhelpers.gatherTextNodes(doc1.documentElement)
 
89
        self.assertEqual(actual, expected)
 
90
 
 
91
        doc2_xml='<a>a<b>b</b><c>c</c>def<g>g<h>h</h></g></a>'
 
92
        doc2 = self.dom.parseString(doc2_xml)
 
93
        actual=domhelpers.gatherTextNodes(doc2)
 
94
        expected='abcdefgh'
 
95
        self.assertEqual(actual, expected)
 
96
        actual=domhelpers.gatherTextNodes(doc2.documentElement)
 
97
        self.assertEqual(actual, expected)
 
98
 
 
99
        doc3_xml=('<a>a<b>b<d>d<g>g</g><h>h</h></d><e>e<i>i</i></e></b>' +
 
100
                  '<c>c<f>f<j>j</j></f></c></a>')
 
101
        doc3 = self.dom.parseString(doc3_xml)
 
102
        actual=domhelpers.gatherTextNodes(doc3)
 
103
        expected='abdgheicfj'
 
104
        self.assertEqual(actual, expected)
 
105
        actual=domhelpers.gatherTextNodes(doc3.documentElement)
 
106
        self.assertEqual(actual, expected)
 
107
 
 
108
    def test_clearNode(self):
 
109
        doc1 = self.dom.parseString('<a><b><c><d/></c></b></a>')
 
110
        a_node=doc1.documentElement
 
111
        domhelpers.clearNode(a_node)
 
112
        self.assertEqual(
 
113
            a_node.toxml(),
 
114
            self.dom.Element('a').toxml())
 
115
 
 
116
        doc2 = self.dom.parseString('<a><b><c><d/></c></b></a>')
 
117
        b_node=doc2.documentElement.childNodes[0]
 
118
        domhelpers.clearNode(b_node)
 
119
        actual=doc2.documentElement.toxml()
 
120
        expected = self.dom.Element('a')
 
121
        expected.appendChild(self.dom.Element('b'))
 
122
        self.assertEqual(actual, expected.toxml())
 
123
 
 
124
 
 
125
    def test_get(self):
 
126
        doc1 = self.dom.parseString('<a><b id="bar"/><c class="foo"/></a>')
 
127
        node=domhelpers.get(doc1, "foo")
 
128
        actual=node.toxml()
 
129
        expected = self.dom.Element('c')
 
130
        expected.setAttribute('class', 'foo')
 
131
        self.assertEqual(actual, expected.toxml())
 
132
 
 
133
        node=domhelpers.get(doc1, "bar")
 
134
        actual=node.toxml()
 
135
        expected = self.dom.Element('b')
 
136
        expected.setAttribute('id', 'bar')
 
137
        self.assertEqual(actual, expected.toxml())
 
138
 
 
139
        self.assertRaises(domhelpers.NodeLookupError, 
 
140
                          domhelpers.get, 
 
141
                          doc1, 
 
142
                          "pzork")
 
143
 
 
144
    def test_getIfExists(self):
 
145
        doc1 = self.dom.parseString('<a><b id="bar"/><c class="foo"/></a>')
 
146
        node=domhelpers.getIfExists(doc1, "foo")
 
147
        actual=node.toxml()
 
148
        expected = self.dom.Element('c')
 
149
        expected.setAttribute('class', 'foo')
 
150
        self.assertEqual(actual, expected.toxml())
 
151
 
 
152
        node=domhelpers.getIfExists(doc1, "pzork")
 
153
        self.assertIdentical(node, None)
 
154
 
 
155
 
 
156
    def test_getAndClear(self):
 
157
        doc1 = self.dom.parseString('<a><b id="foo"><c></c></b></a>')
 
158
        node=domhelpers.getAndClear(doc1, "foo")
 
159
        actual=node.toxml()
 
160
        expected = self.dom.Element('b')
 
161
        expected.setAttribute('id', 'foo')
 
162
        self.assertEqual(actual, expected.toxml())
 
163
 
 
164
 
 
165
    def test_locateNodes(self):
 
166
        doc1 = self.dom.parseString('<a><b foo="olive"><c foo="olive"/></b><d foo="poopy"/></a>')
 
167
        node_list=domhelpers.locateNodes(
 
168
            doc1.childNodes, 'foo', 'olive', noNesting=1)
 
169
        actual=''.join([node.toxml() for node in node_list])
 
170
        expected = self.dom.Element('b')
 
171
        expected.setAttribute('foo', 'olive')
 
172
        c = self.dom.Element('c')
 
173
        c.setAttribute('foo', 'olive')
 
174
        expected.appendChild(c)
 
175
 
 
176
        self.assertEqual(actual, expected.toxml())
 
177
 
 
178
        node_list=domhelpers.locateNodes(
 
179
            doc1.childNodes, 'foo', 'olive', noNesting=0)
 
180
        actual=''.join([node.toxml() for node in node_list])
 
181
        self.assertEqual(actual, expected.toxml() + c.toxml())
 
182
 
 
183
 
 
184
    def test_getParents(self):
 
185
        doc1 = self.dom.parseString('<a><b><c><d/></c><e/></b><f/></a>')
 
186
        node_list = domhelpers.getParents(
 
187
            doc1.childNodes[0].childNodes[0].childNodes[0])
 
188
        actual = ''.join([node.tagName for node in node_list
 
189
                          if hasattr(node, 'tagName')])
 
190
        self.assertEqual(actual, 'cba')
 
191
 
 
192
 
 
193
    def test_findElementsWithAttribute(self):
 
194
        doc1 = self.dom.parseString('<a foo="1"><b foo="2"/><c foo="1"/><d/></a>')
 
195
        node_list = domhelpers.findElementsWithAttribute(doc1, 'foo')
 
196
        actual = ''.join([node.tagName for node in node_list])
 
197
        self.assertEqual(actual, 'abc')
 
198
 
 
199
        node_list = domhelpers.findElementsWithAttribute(doc1, 'foo', '1')
 
200
        actual = ''.join([node.tagName for node in node_list])
 
201
        self.assertEqual(actual, 'ac')
 
202
 
 
203
 
 
204
    def test_findNodesNamed(self):
 
205
        doc1 = self.dom.parseString('<doc><foo/><bar/><foo>a</foo></doc>')
 
206
        node_list = domhelpers.findNodesNamed(doc1, 'foo')
 
207
        actual = len(node_list)
 
208
        self.assertEqual(actual, 2)
 
209
 
 
210
    # NOT SURE WHAT THESE ARE SUPPOSED TO DO..
 
211
    # def test_RawText  FIXME
 
212
    # def test_superSetAttribute FIXME
 
213
    # def test_superPrependAttribute FIXME
 
214
    # def test_superAppendAttribute FIXME
 
215
    # def test_substitute FIXME
 
216
 
 
217
    def test_escape(self):
 
218
        j='this string " contains many & characters> xml< won\'t like'
 
219
        expected='this string &quot; contains many &amp; characters&gt; xml&lt; won\'t like'
 
220
        self.assertEqual(domhelpers.escape(j), expected)
 
221
 
 
222
    def test_unescape(self):
 
223
        j='this string &quot; has &&amp; entities &gt; &lt; and some characters xml won\'t like<'
 
224
        expected='this string " has && entities > < and some characters xml won\'t like<'
 
225
        self.assertEqual(domhelpers.unescape(j), expected)
 
226
 
 
227
 
 
228
    def test_getNodeText(self):
 
229
        """
 
230
        L{getNodeText} returns the concatenation of all the text data at or
 
231
        beneath the node passed to it.
 
232
        """
 
233
        node = self.dom.parseString('<foo><bar>baz</bar><bar>quux</bar></foo>')
 
234
        self.assertEqual(domhelpers.getNodeText(node), "bazquux")
 
235
 
 
236
 
 
237
 
 
238
class MicroDOMHelpersTests(DOMHelpersTestsMixin, TestCase):
 
239
    dom = microdom
 
240
 
 
241
    def test_gatherTextNodesDropsWhitespace(self):
 
242
        """
 
243
        Microdom discards whitespace-only text nodes, so L{gatherTextNodes}
 
244
        returns only the text from nodes which had non-whitespace characters.
 
245
        """
 
246
        doc4_xml='''<html>
 
247
  <head>
 
248
  </head>
 
249
  <body>
 
250
    stuff
 
251
  </body>
 
252
</html>
 
253
'''
 
254
        doc4 = self.dom.parseString(doc4_xml)
 
255
        actual = domhelpers.gatherTextNodes(doc4)
 
256
        expected = '\n    stuff\n  '
 
257
        self.assertEqual(actual, expected)
 
258
        actual = domhelpers.gatherTextNodes(doc4.documentElement)
 
259
        self.assertEqual(actual, expected)
 
260
 
 
261
 
 
262
    def test_textEntitiesNotDecoded(self):
 
263
        """
 
264
        Microdom does not decode entities in text nodes.
 
265
        """
 
266
        doc5_xml='<x>Souffl&amp;</x>'
 
267
        doc5 = self.dom.parseString(doc5_xml)
 
268
        actual=domhelpers.gatherTextNodes(doc5)
 
269
        expected='Souffl&amp;'
 
270
        self.assertEqual(actual, expected)
 
271
        actual=domhelpers.gatherTextNodes(doc5.documentElement)
 
272
        self.assertEqual(actual, expected)
 
273
 
 
274
 
 
275
 
 
276
class MiniDOMHelpersTests(DOMHelpersTestsMixin, TestCase):
 
277
    dom = minidom
 
278
 
 
279
    def test_textEntitiesDecoded(self):
 
280
        """
 
281
        Minidom does decode entities in text nodes.
 
282
        """
 
283
        doc5_xml='<x>Souffl&amp;</x>'
 
284
        doc5 = self.dom.parseString(doc5_xml)
 
285
        actual=domhelpers.gatherTextNodes(doc5)
 
286
        expected='Souffl&'
 
287
        self.assertEqual(actual, expected)
 
288
        actual=domhelpers.gatherTextNodes(doc5.documentElement)
 
289
        self.assertEqual(actual, expected)
 
290
 
 
291
 
 
292
    def test_getNodeUnicodeText(self):
 
293
        """
 
294
        L{domhelpers.getNodeText} returns a C{unicode} string when text
 
295
        nodes are represented in the DOM with unicode, whether or not there
 
296
        are non-ASCII characters present.
 
297
        """
 
298
        node = self.dom.parseString("<foo>bar</foo>")
 
299
        text = domhelpers.getNodeText(node)
 
300
        self.assertEqual(text, u"bar")
 
301
        self.assertIsInstance(text, unicode)
 
302
 
 
303
        node = self.dom.parseString(u"<foo>\N{SNOWMAN}</foo>".encode('utf-8'))
 
304
        text = domhelpers.getNodeText(node)
 
305
        self.assertEqual(text, u"\N{SNOWMAN}")
 
306
        self.assertIsInstance(text, unicode)