← 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_http_headers.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_http_headers.py
 
1
# Copyright (c) 2008-2009 Twisted Matrix Laboratories.
 
2
# See LICENSE for details.
 
3
 
 
4
"""
 
5
Tests for L{twisted.web.http_headers}.
 
6
"""
 
7
 
 
8
import sys
 
9
 
 
10
from twisted.python.compat import set
 
11
from twisted.trial.unittest import TestCase
 
12
from twisted.web.http_headers import _DictHeaders, Headers
 
13
 
 
14
 
 
15
class HeadersTests(TestCase):
 
16
    """
 
17
    Tests for L{Headers}.
 
18
    """
 
19
    def test_initializer(self):
 
20
        """
 
21
        The header values passed to L{Headers.__init__} can be retrieved via
 
22
        L{Headers.getRawHeaders}.
 
23
        """
 
24
        h = Headers({'Foo': ['bar']})
 
25
        self.assertEqual(h.getRawHeaders('foo'), ['bar'])
 
26
 
 
27
 
 
28
    def test_setRawHeaders(self):
 
29
        """
 
30
        L{Headers.setRawHeaders} sets the header values for the given
 
31
        header name to the sequence of string values.
 
32
        """
 
33
        rawValue = ["value1", "value2"]
 
34
        h = Headers()
 
35
        h.setRawHeaders("test", rawValue)
 
36
        self.assertTrue(h.hasHeader("test"))
 
37
        self.assertTrue(h.hasHeader("Test"))
 
38
        self.assertEqual(h.getRawHeaders("test"), rawValue)
 
39
 
 
40
 
 
41
    def test_addRawHeader(self):
 
42
        """
 
43
        L{Headers.addRawHeader} adds a new value for a given header.
 
44
        """
 
45
        h = Headers()
 
46
        h.addRawHeader("test", "lemur")
 
47
        self.assertEqual(h.getRawHeaders("test"), ["lemur"])
 
48
        h.addRawHeader("test", "panda")
 
49
        self.assertEqual(h.getRawHeaders("test"), ["lemur", "panda"])
 
50
 
 
51
 
 
52
    def test_getRawHeadersNoDefault(self):
 
53
        """
 
54
        L{Headers.getRawHeaders} returns C{None} if the header is not found and
 
55
        no default is specified.
 
56
        """
 
57
        self.assertIdentical(Headers().getRawHeaders("test"), None)
 
58
 
 
59
 
 
60
    def test_getRawHeadersDefaultValue(self):
 
61
        """
 
62
        L{Headers.getRawHeaders} returns the specified default value when no
 
63
        header is found.
 
64
        """
 
65
        h = Headers()
 
66
        default = object()
 
67
        self.assertIdentical(h.getRawHeaders("test", default), default)
 
68
 
 
69
 
 
70
    def test_getRawHeaders(self):
 
71
        """
 
72
        L{Headers.getRawHeaders} returns the values which have been set for a
 
73
        given header.
 
74
        """
 
75
        h = Headers()
 
76
        h.setRawHeaders("test", ["lemur"])
 
77
        self.assertEqual(h.getRawHeaders("test"), ["lemur"])
 
78
        self.assertEqual(h.getRawHeaders("Test"), ["lemur"])
 
79
 
 
80
 
 
81
    def test_hasHeaderTrue(self):
 
82
        """
 
83
        Check that L{Headers.hasHeader} returns C{True} when the given header
 
84
        is found.
 
85
        """
 
86
        h = Headers()
 
87
        h.setRawHeaders("test", ["lemur"])
 
88
        self.assertTrue(h.hasHeader("test"))
 
89
        self.assertTrue(h.hasHeader("Test"))
 
90
 
 
91
 
 
92
    def test_hasHeaderFalse(self):
 
93
        """
 
94
        L{Headers.hasHeader} returns C{False} when the given header is not
 
95
        found.
 
96
        """
 
97
        self.assertFalse(Headers().hasHeader("test"))
 
98
 
 
99
 
 
100
    def test_removeHeader(self):
 
101
        """
 
102
        Check that L{Headers.removeHeader} removes the given header.
 
103
        """
 
104
        h = Headers()
 
105
 
 
106
        h.setRawHeaders("foo", ["lemur"])
 
107
        self.assertTrue(h.hasHeader("foo"))
 
108
        h.removeHeader("foo")
 
109
        self.assertFalse(h.hasHeader("foo"))
 
110
 
 
111
        h.setRawHeaders("bar", ["panda"])
 
112
        self.assertTrue(h.hasHeader("bar"))
 
113
        h.removeHeader("Bar")
 
114
        self.assertFalse(h.hasHeader("bar"))
 
115
 
 
116
 
 
117
    def test_removeHeaderDoesntExist(self):
 
118
        """
 
119
        L{Headers.removeHeader} is a no-operation when the specified header is
 
120
        not found.
 
121
        """
 
122
        h = Headers()
 
123
        h.removeHeader("test")
 
124
        self.assertEqual(list(h.getAllRawHeaders()), [])
 
125
 
 
126
 
 
127
    def test_canonicalNameCaps(self):
 
128
        """
 
129
        L{Headers._canonicalNameCaps} returns the canonical capitalization for
 
130
        the given header.
 
131
        """
 
132
        h = Headers()
 
133
        self.assertEqual(h._canonicalNameCaps("test"), "Test")
 
134
        self.assertEqual(h._canonicalNameCaps("test-stuff"), "Test-Stuff")
 
135
        self.assertEqual(h._canonicalNameCaps("www-authenticate"),
 
136
                          "WWW-Authenticate")
 
137
 
 
138
 
 
139
    def test_getAllRawHeaders(self):
 
140
        """
 
141
        L{Headers.getAllRawHeaders} returns an iterable of (k, v) pairs, where
 
142
        C{k} is the canonicalized representation of the header name, and C{v}
 
143
        is a sequence of values.
 
144
        """
 
145
        h = Headers()
 
146
        h.setRawHeaders("test", ["lemurs"])
 
147
        h.setRawHeaders("www-authenticate", ["basic aksljdlk="])
 
148
 
 
149
        allHeaders = set([(k, tuple(v)) for k, v in h.getAllRawHeaders()])
 
150
 
 
151
        self.assertEqual(allHeaders,
 
152
                          set([("WWW-Authenticate", ("basic aksljdlk=",)),
 
153
                               ("Test", ("lemurs",))]))
 
154
 
 
155
 
 
156
    def test_headersComparison(self):
 
157
        """
 
158
        A L{Headers} instance compares equal to itself and to another
 
159
        L{Headers} instance with the same values.
 
160
        """
 
161
        first = Headers()
 
162
        first.setRawHeaders("foo", ["panda"])
 
163
        second = Headers()
 
164
        second.setRawHeaders("foo", ["panda"])
 
165
        third = Headers()
 
166
        third.setRawHeaders("foo", ["lemur", "panda"])
 
167
        self.assertEqual(first, first)
 
168
        self.assertEqual(first, second)
 
169
        self.assertNotEqual(first, third)
 
170
 
 
171
 
 
172
    def test_otherComparison(self):
 
173
        """
 
174
        An instance of L{Headers} does not compare equal to other unrelated
 
175
        objects.
 
176
        """
 
177
        h = Headers()
 
178
        self.assertNotEqual(h, ())
 
179
        self.assertNotEqual(h, object())
 
180
        self.assertNotEqual(h, "foo")
 
181
 
 
182
 
 
183
    def test_repr(self):
 
184
        """
 
185
        The L{repr} of a L{Headers} instance shows the names and values of all
 
186
        the headers it contains.
 
187
        """
 
188
        self.assertEqual(
 
189
            repr(Headers({"foo": ["bar", "baz"]})),
 
190
            "Headers({'foo': ['bar', 'baz']})")
 
191
 
 
192
 
 
193
    def test_subclassRepr(self):
 
194
        """
 
195
        The L{repr} of an instance of a subclass of L{Headers} uses the name
 
196
        of the subclass instead of the string C{"Headers"}.
 
197
        """
 
198
        class FunnyHeaders(Headers):
 
199
            pass
 
200
        self.assertEqual(
 
201
            repr(FunnyHeaders({"foo": ["bar", "baz"]})),
 
202
            "FunnyHeaders({'foo': ['bar', 'baz']})")
 
203
 
 
204
 
 
205
 
 
206
class HeaderDictTests(TestCase):
 
207
    """
 
208
    Tests for the backwards compatible C{dict} interface for L{Headers}
 
209
    provided by L{_DictHeaders}.
 
210
    """
 
211
    def headers(self, **kw):
 
212
        """
 
213
        Create a L{Headers} instance populated with the header name/values
 
214
        specified by C{kw} and a L{_DictHeaders} wrapped around it and return
 
215
        them both.
 
216
        """
 
217
        h = Headers()
 
218
        for k, v in kw.iteritems():
 
219
            h.setRawHeaders(k, v)
 
220
        return h, _DictHeaders(h)
 
221
 
 
222
 
 
223
    def test_getItem(self):
 
224
        """
 
225
        L{_DictHeaders.__getitem__} returns a single header for the given name.
 
226
        """
 
227
        headers, wrapper = self.headers(test=["lemur"])
 
228
        self.assertEqual(wrapper["test"], "lemur")
 
229
 
 
230
 
 
231
    def test_getItemMultiple(self):
 
232
        """
 
233
        L{_DictHeaders.__getitem__} returns only the last header value for a
 
234
        given name.
 
235
        """
 
236
        headers, wrapper = self.headers(test=["lemur", "panda"])
 
237
        self.assertEqual(wrapper["test"], "panda")
 
238
 
 
239
 
 
240
    def test_getItemMissing(self):
 
241
        """
 
242
        L{_DictHeaders.__getitem__} raises L{KeyError} if called with a header
 
243
        which is not present.
 
244
        """
 
245
        headers, wrapper = self.headers()
 
246
        exc = self.assertRaises(KeyError, wrapper.__getitem__, "test")
 
247
        self.assertEqual(exc.args, ("test",))
 
248
 
 
249
 
 
250
    def test_iteration(self):
 
251
        """
 
252
        L{_DictHeaders.__iter__} returns an iterator the elements of which
 
253
        are the lowercase name of each header present.
 
254
        """
 
255
        headers, wrapper = self.headers(foo=["lemur", "panda"], bar=["baz"])
 
256
        self.assertEqual(set(list(wrapper)), set(["foo", "bar"]))
 
257
 
 
258
 
 
259
    def test_length(self):
 
260
        """
 
261
        L{_DictHeaders.__len__} returns the number of headers present.
 
262
        """
 
263
        headers, wrapper = self.headers()
 
264
        self.assertEqual(len(wrapper), 0)
 
265
        headers.setRawHeaders("foo", ["bar"])
 
266
        self.assertEqual(len(wrapper), 1)
 
267
        headers.setRawHeaders("test", ["lemur", "panda"])
 
268
        self.assertEqual(len(wrapper), 2)
 
269
 
 
270
 
 
271
    def test_setItem(self):
 
272
        """
 
273
        L{_DictHeaders.__setitem__} sets a single header value for the given
 
274
        name.
 
275
        """
 
276
        headers, wrapper = self.headers()
 
277
        wrapper["test"] = "lemur"
 
278
        self.assertEqual(headers.getRawHeaders("test"), ["lemur"])
 
279
 
 
280
 
 
281
    def test_setItemOverwrites(self):
 
282
        """
 
283
        L{_DictHeaders.__setitem__} will replace any previous header values for
 
284
        the given name.
 
285
        """
 
286
        headers, wrapper = self.headers(test=["lemur", "panda"])
 
287
        wrapper["test"] = "lemur"
 
288
        self.assertEqual(headers.getRawHeaders("test"), ["lemur"])
 
289
 
 
290
 
 
291
    def test_delItem(self):
 
292
        """
 
293
        L{_DictHeaders.__delitem__} will remove the header values for the given
 
294
        name.
 
295
        """
 
296
        headers, wrapper = self.headers(test=["lemur"])
 
297
        del wrapper["test"]
 
298
        self.assertFalse(headers.hasHeader("test"))
 
299
 
 
300
 
 
301
    def test_delItemMissing(self):
 
302
        """
 
303
        L{_DictHeaders.__delitem__} will raise L{KeyError} if the given name is
 
304
        not present.
 
305
        """
 
306
        headers, wrapper = self.headers()
 
307
        exc = self.assertRaises(KeyError, wrapper.__delitem__, "test")
 
308
        self.assertEqual(exc.args, ("test",))
 
309
 
 
310
 
 
311
    def test_keys(self, _method='keys', _requireList=True):
 
312
        """
 
313
        L{_DictHeaders.keys} will return a list of all present header names.
 
314
        """
 
315
        headers, wrapper = self.headers(test=["lemur"], foo=["bar"])
 
316
        keys = getattr(wrapper, _method)()
 
317
        if _requireList:
 
318
            self.assertIsInstance(keys, list)
 
319
        self.assertEqual(set(keys), set(["foo", "test"]))
 
320
 
 
321
 
 
322
    def test_iterkeys(self):
 
323
        """
 
324
        L{_DictHeaders.iterkeys} will return all present header names.
 
325
        """
 
326
        self.test_keys('iterkeys', False)
 
327
 
 
328
 
 
329
    def test_values(self, _method='values', _requireList=True):
 
330
        """
 
331
        L{_DictHeaders.values} will return a list of all present header values,
 
332
        returning only the last value for headers with more than one.
 
333
        """
 
334
        headers, wrapper = self.headers(foo=["lemur"], bar=["marmot", "panda"])
 
335
        values = getattr(wrapper, _method)()
 
336
        if _requireList:
 
337
            self.assertIsInstance(values, list)
 
338
        self.assertEqual(set(values), set(["lemur", "panda"]))
 
339
 
 
340
 
 
341
    def test_itervalues(self):
 
342
        """
 
343
        L{_DictHeaders.itervalues} will return all present header values,
 
344
        returning only the last value for headers with more than one.
 
345
        """
 
346
        self.test_values('itervalues', False)
 
347
 
 
348
 
 
349
    def test_items(self, _method='items', _requireList=True):
 
350
        """
 
351
        L{_DictHeaders.items} will return a list of all present header names
 
352
        and values as tuples, returning only the last value for headers with
 
353
        more than one.
 
354
        """
 
355
        headers, wrapper = self.headers(foo=["lemur"], bar=["marmot", "panda"])
 
356
        items = getattr(wrapper, _method)()
 
357
        if _requireList:
 
358
            self.assertIsInstance(items, list)
 
359
        self.assertEqual(set(items), set([("foo", "lemur"), ("bar", "panda")]))
 
360
 
 
361
 
 
362
    def test_iteritems(self):
 
363
        """
 
364
        L{_DictHeaders.iteritems} will return all present header names and
 
365
        values as tuples, returning only the last value for headers with more
 
366
        than one.
 
367
        """
 
368
        self.test_items('iteritems', False)
 
369
 
 
370
 
 
371
    def test_clear(self):
 
372
        """
 
373
        L{_DictHeaders.clear} will remove all headers.
 
374
        """
 
375
        headers, wrapper = self.headers(foo=["lemur"], bar=["panda"])
 
376
        wrapper.clear()
 
377
        self.assertEqual(list(headers.getAllRawHeaders()), [])
 
378
 
 
379
 
 
380
    def test_copy(self):
 
381
        """
 
382
        L{_DictHeaders.copy} will return a C{dict} with all the same headers
 
383
        and the last value for each.
 
384
        """
 
385
        headers, wrapper = self.headers(foo=["lemur", "panda"], bar=["marmot"])
 
386
        duplicate = wrapper.copy()
 
387
        self.assertEqual(duplicate, {"foo": "panda", "bar": "marmot"})
 
388
 
 
389
 
 
390
    def test_get(self):
 
391
        """
 
392
        L{_DictHeaders.get} returns the last value for the given header name.
 
393
        """
 
394
        headers, wrapper = self.headers(foo=["lemur", "panda"])
 
395
        self.assertEqual(wrapper.get("foo"), "panda")
 
396
 
 
397
 
 
398
    def test_getMissing(self):
 
399
        """
 
400
        L{_DictHeaders.get} returns C{None} for a header which is not present.
 
401
        """
 
402
        headers, wrapper = self.headers()
 
403
        self.assertIdentical(wrapper.get("foo"), None)
 
404
 
 
405
 
 
406
    def test_getDefault(self):
 
407
        """
 
408
        L{_DictHeaders.get} returns the last value for the given header name
 
409
        even when it is invoked with a default value.
 
410
        """
 
411
        headers, wrapper = self.headers(foo=["lemur"])
 
412
        self.assertEqual(wrapper.get("foo", "bar"), "lemur")
 
413
 
 
414
 
 
415
    def test_getDefaultMissing(self):
 
416
        """
 
417
        L{_DictHeaders.get} returns the default value specified if asked for a
 
418
        header which is not present.
 
419
        """
 
420
        headers, wrapper = self.headers()
 
421
        self.assertEqual(wrapper.get("foo", "bar"), "bar")
 
422
 
 
423
 
 
424
    def test_has_key(self):
 
425
        """
 
426
        L{_DictHeaders.has_key} returns C{True} if the given header is present,
 
427
        C{False} otherwise.
 
428
        """
 
429
        headers, wrapper = self.headers(foo=["lemur"])
 
430
        self.assertTrue(wrapper.has_key("foo"))
 
431
        self.assertFalse(wrapper.has_key("bar"))
 
432
 
 
433
 
 
434
    def test_contains(self):
 
435
        """
 
436
        L{_DictHeaders.__contains__} returns C{True} if the given header is
 
437
        present, C{False} otherwise.
 
438
        """
 
439
        headers, wrapper = self.headers(foo=["lemur"])
 
440
        self.assertIn("foo", wrapper)
 
441
        self.assertNotIn("bar", wrapper)
 
442
 
 
443
 
 
444
    def test_pop(self):
 
445
        """
 
446
        L{_DictHeaders.pop} returns the last header value associated with the
 
447
        given header name and removes the header.
 
448
        """
 
449
        headers, wrapper = self.headers(foo=["lemur", "panda"])
 
450
        self.assertEqual(wrapper.pop("foo"), "panda")
 
451
        self.assertIdentical(headers.getRawHeaders("foo"), None)
 
452
 
 
453
 
 
454
    def test_popMissing(self):
 
455
        """
 
456
        L{_DictHeaders.pop} raises L{KeyError} if passed a header name which is
 
457
        not present.
 
458
        """
 
459
        headers, wrapper = self.headers()
 
460
        self.assertRaises(KeyError, wrapper.pop, "foo")
 
461
 
 
462
 
 
463
    def test_popDefault(self):
 
464
        """
 
465
        L{_DictHeaders.pop} returns the last header value associated with the
 
466
        given header name and removes the header, even if it is supplied with a
 
467
        default value.
 
468
        """
 
469
        headers, wrapper = self.headers(foo=["lemur"])
 
470
        self.assertEqual(wrapper.pop("foo", "bar"), "lemur")
 
471
        self.assertIdentical(headers.getRawHeaders("foo"), None)
 
472
 
 
473
 
 
474
    def test_popDefaultMissing(self):
 
475
        """
 
476
        L{_DictHeaders.pop} returns the default value is asked for a header
 
477
        name which is not present.
 
478
        """
 
479
        headers, wrapper = self.headers(foo=["lemur"])
 
480
        self.assertEqual(wrapper.pop("bar", "baz"), "baz")
 
481
        self.assertEqual(headers.getRawHeaders("foo"), ["lemur"])
 
482
 
 
483
 
 
484
    def test_popitem(self):
 
485
        """
 
486
        L{_DictHeaders.popitem} returns some header name/value pair.
 
487
        """
 
488
        headers, wrapper = self.headers(foo=["lemur", "panda"])
 
489
        self.assertEqual(wrapper.popitem(), ("foo", "panda"))
 
490
        self.assertIdentical(headers.getRawHeaders("foo"), None)
 
491
 
 
492
 
 
493
    def test_popitemEmpty(self):
 
494
        """
 
495
        L{_DictHeaders.popitem} raises L{KeyError} if there are no headers
 
496
        present.
 
497
        """
 
498
        headers, wrapper = self.headers()
 
499
        self.assertRaises(KeyError, wrapper.popitem)
 
500
 
 
501
 
 
502
    def test_update(self):
 
503
        """
 
504
        L{_DictHeaders.update} adds the header/value pairs in the C{dict} it is
 
505
        passed, overriding any existing values for those headers.
 
506
        """
 
507
        headers, wrapper = self.headers(foo=["lemur"])
 
508
        wrapper.update({"foo": "panda", "bar": "marmot"})
 
509
        self.assertEqual(headers.getRawHeaders("foo"), ["panda"])
 
510
        self.assertEqual(headers.getRawHeaders("bar"), ["marmot"])
 
511
 
 
512
 
 
513
    def test_updateWithKeywords(self):
 
514
        """
 
515
        L{_DictHeaders.update} adds header names given as keyword arguments
 
516
        with the keyword values as the header value.
 
517
        """
 
518
        headers, wrapper = self.headers(foo=["lemur"])
 
519
        wrapper.update(foo="panda", bar="marmot")
 
520
        self.assertEqual(headers.getRawHeaders("foo"), ["panda"])
 
521
        self.assertEqual(headers.getRawHeaders("bar"), ["marmot"])
 
522
 
 
523
    if sys.version_info < (2, 4):
 
524
        test_updateWithKeywords.skip = (
 
525
            "Python 2.3 does not support keyword arguments to dict.update.")
 
526
 
 
527
 
 
528
    def test_setdefaultMissing(self):
 
529
        """
 
530
        If passed the name of a header which is not present,
 
531
        L{_DictHeaders.setdefault} sets the value of the given header to the
 
532
        specified default value and returns it.
 
533
        """
 
534
        headers, wrapper = self.headers(foo=["bar"])
 
535
        self.assertEqual(wrapper.setdefault("baz", "quux"), "quux")
 
536
        self.assertEqual(headers.getRawHeaders("foo"), ["bar"])
 
537
        self.assertEqual(headers.getRawHeaders("baz"), ["quux"])
 
538
 
 
539
 
 
540
    def test_setdefaultPresent(self):
 
541
        """
 
542
        If passed the name of a header which is present,
 
543
        L{_DictHeaders.setdefault} makes no changes to the headers and
 
544
        returns the last value already associated with that header.
 
545
        """
 
546
        headers, wrapper = self.headers(foo=["bar", "baz"])
 
547
        self.assertEqual(wrapper.setdefault("foo", "quux"), "baz")
 
548
        self.assertEqual(headers.getRawHeaders("foo"), ["bar", "baz"])
 
549
 
 
550
 
 
551
    def test_setdefaultDefault(self):
 
552
        """
 
553
        If a value is not passed to L{_DictHeaders.setdefault}, C{None} is
 
554
        used.
 
555
        """
 
556
        # This results in an invalid state for the headers, but maybe some
 
557
        # application is doing this an intermediate step towards some other
 
558
        # state.  Anyway, it was broken with the old implementation so it's
 
559
        # broken with the new implementation.  Compatibility, for the win.
 
560
        # -exarkun
 
561
        headers, wrapper = self.headers()
 
562
        self.assertIdentical(wrapper.setdefault("foo"), None)
 
563
        self.assertEqual(headers.getRawHeaders("foo"), [None])
 
564
 
 
565
 
 
566
    def test_dictComparison(self):
 
567
        """
 
568
        An instance of L{_DictHeaders} compares equal to a C{dict} which
 
569
        contains the same header/value pairs.  For header names with multiple
 
570
        values, the last value only is considered.
 
571
        """
 
572
        headers, wrapper = self.headers(foo=["lemur"], bar=["panda", "marmot"])
 
573
        self.assertNotEqual(wrapper, {"foo": "lemur", "bar": "panda"})
 
574
        self.assertEqual(wrapper, {"foo": "lemur", "bar": "marmot"})
 
575
 
 
576
 
 
577
    def test_otherComparison(self):
 
578
        """
 
579
        An instance of L{_DictHeaders} does not compare equal to other
 
580
        unrelated objects.
 
581
        """
 
582
        headers, wrapper = self.headers()
 
583
        self.assertNotEqual(wrapper, ())
 
584
        self.assertNotEqual(wrapper, object())
 
585
        self.assertNotEqual(wrapper, "foo")