← Back to branch summary

~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http_response.py

  • Committer: Canonical.com Patch Queue Manager
  • Date: 2006-09-25 01:24:45 UTC
  • mfrom: (2037.1.2 integration)
  • Revision ID: pqm@pqm.ubuntu.com-20060925012445-1cc0dd1824c4b731
(Robert Collins) Add 0.12 deprecation symbol.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_http_response.py
 
1
# Copyright (C) 2005, 2006 by Canonical Ltd
 
2
#
 
3
# This program is free software; you can redistribute it and/or modify
 
4
# it under the terms of the GNU General Public License as published by
 
5
# the Free Software Foundation; either version 2 of the License, or
 
6
# (at your option) any later version.
 
7
#
 
8
# This program is distributed in the hope that it will be useful,
 
9
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
10
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
11
# GNU General Public License for more details.
 
12
#
 
13
# You should have received a copy of the GNU General Public License
 
14
# along with this program; if not, write to the Free Software
 
15
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
16
 
 
17
"""Tests from HTTP response parsing."""
 
18
 
 
19
from cStringIO import StringIO
 
20
import mimetools
 
21
 
 
22
from bzrlib import errors
 
23
from bzrlib.transport import http
 
24
from bzrlib.transport.http import response
 
25
from bzrlib.tests import TestCase
 
26
 
 
27
 
 
28
class TestResponseRange(TestCase):
 
29
    """Test the ResponseRange class."""
 
30
 
 
31
    def test_cmp(self):
 
32
        RR = response.ResponseRange
 
33
        r1 = RR(0, 10, 0)
 
34
        r2 = RR(15, 20, 10)
 
35
        self.assertTrue(r1 < r2)
 
36
        self.assertFalse(r1 > r2)
 
37
        self.assertTrue(r1 < 5)
 
38
        self.assertFalse(r2 < 5)
 
39
 
 
40
        self.assertEqual(RR(0, 10, 5), RR(0, 10, 5))
 
41
        self.assertNotEqual(RR(0, 10, 5), RR(0, 8, 5))
 
42
        self.assertNotEqual(RR(0, 10, 5), RR(0, 10, 6))
 
43
 
 
44
    def test_sort_list(self):
 
45
        """Ensure longer ranges are sorted after shorter ones"""
 
46
        RR = response.ResponseRange
 
47
        lst = [RR(3, 8, 0), 5, RR(3, 7, 0), 6]
 
48
        lst.sort()
 
49
        self.assertEqual([RR(3,7,0), RR(3,8,0), 5, 6], lst)
 
50
 
 
51
 
 
52
class TestRangeFile(TestCase):
 
53
    """Test RangeFile."""
 
54
 
 
55
    def setUp(self):
 
56
        content = "abcdefghijklmnopqrstuvwxyz"
 
57
        self.fp = response.RangeFile('foo', StringIO(content))
 
58
        self.fp._add_range(0,  9,   0)
 
59
        self.fp._add_range(20, 29, 10)
 
60
        self.fp._add_range(30, 39, 15)
 
61
 
 
62
    def test_valid_accesses(self):
 
63
        """Test so that valid accesses work to the file."""
 
64
        self.fp.seek(0, 0)
 
65
        self.assertEquals(self.fp.read(3), 'abc')
 
66
        self.assertEquals(self.fp.read(3), 'def')
 
67
        self.assertEquals(self.fp.tell(), 6)
 
68
        self.fp.seek(20, 0)
 
69
        self.assertEquals(self.fp.read(3), 'klm')
 
70
        self.assertEquals(self.fp.read(2), 'no')
 
71
        self.assertEquals(self.fp.tell(), 25)
 
72
        # should wrap over to 30-39 entity
 
73
        self.assertEquals(self.fp.read(3), 'pqr')
 
74
        self.fp.seek(3)
 
75
        self.assertEquals(self.fp.read(3), 'def')
 
76
        self.assertEquals(self.fp.tell(), 6)
 
77
 
 
78
    def test_invalid_accesses(self):
 
79
        """Test so that invalid accesses trigger errors."""
 
80
        self.fp.seek(9)
 
81
        self.assertRaises(errors.InvalidRange, self.fp.read, 2)
 
82
        self.fp.seek(39)
 
83
        self.assertRaises(errors.InvalidRange, self.fp.read, 2)
 
84
        self.fp.seek(19)
 
85
        self.assertRaises(errors.InvalidRange, self.fp.read, 2)
 
86
 
 
87
    def test__finish_ranges(self):
 
88
        """Test that after RangeFile._finish_ranges the list is sorted."""
 
89
        self.fp._add_range(1, 2, 3)
 
90
        self.fp._add_range(8, 9, 10)
 
91
        self.fp._add_range(3, 4, 5)
 
92
 
 
93
        # TODO: jam 20060706 If we switch to inserting
 
94
        #       in sorted order, remove this test
 
95
        self.assertNotEqual(self.fp._ranges, sorted(self.fp._ranges))
 
96
 
 
97
        self.fp._finish_ranges()
 
98
        self.assertEqual(self.fp._ranges, sorted(self.fp._ranges))
 
99
 
 
100
    def test_seek_and_tell(self):
 
101
        # Check for seeking before start
 
102
        self.fp.seek(-2, 0)
 
103
        self.assertEqual(0, self.fp.tell())
 
104
 
 
105
        self.fp.seek(5, 0)
 
106
        self.assertEqual(5, self.fp.tell())
 
107
 
 
108
        self.fp.seek(-2, 1)
 
109
        self.assertEqual(3, self.fp.tell())
 
110
 
 
111
        # TODO: jam 20060706 following tests will fail if this 
 
112
        #       is not true, and would be difficult to debug
 
113
        #       but it is a layering violation
 
114
        self.assertEqual(39, self.fp._len)
 
115
 
 
116
        self.fp.seek(0, 2)
 
117
        self.assertEqual(39, self.fp.tell())
 
118
 
 
119
        self.fp.seek(-10, 2)
 
120
        self.assertEqual(29, self.fp.tell())
 
121
 
 
122
        self.assertRaises(ValueError, self.fp.seek, 0, 4)
 
123
        self.assertRaises(ValueError, self.fp.seek, 0, -1)
 
124
 
 
125
 
 
126
class TestRegexes(TestCase):
 
127
 
 
128
    def assertRegexMatches(self, groups, text):
 
129
        """Check that the regex matches and returns the right values"""
 
130
        m = self.regex.match(text)
 
131
        self.assertNotEqual(None, m, "text %s did not match regex" % (text,))
 
132
 
 
133
        self.assertEqual(groups, m.groups())
 
134
 
 
135
    def test_range_re(self):
 
136
        """Test that we match valid ranges."""
 
137
        self.regex = response.HttpRangeResponse._CONTENT_RANGE_RE
 
138
        self.assertRegexMatches(('bytes', '1', '10', '11'),
 
139
                           'bytes 1-10/11')
 
140
        self.assertRegexMatches(('bytes', '1', '10', '11'),
 
141
                           '\tbytes  1-10/11   ')
 
142
        self.assertRegexMatches(('bytes', '2123', '4242', '1231'),
 
143
                           '\tbytes  2123-4242/1231   ')
 
144
        self.assertRegexMatches(('chars', '1', '2', '3'),
 
145
                           ' chars 1-2/3')
 
146
 
 
147
    def test_content_type_re(self):
 
148
        self.regex = response.HttpMultipartRangeResponse._CONTENT_TYPE_RE
 
149
        self.assertRegexMatches(('', 'xxyyzz'),
 
150
                                'multipart/byteranges; boundary = xxyyzz')
 
151
        self.assertRegexMatches(('', 'xxyyzz'),
 
152
                                'multipart/byteranges;boundary=xxyyzz')
 
153
        self.assertRegexMatches(('', 'xx yy zz'),
 
154
                                ' multipart/byteranges ; boundary= xx yy zz ')
 
155
        self.assertRegexMatches(('"', 'xx yy zz'),
 
156
                                ' multipart/byteranges ; boundary= "xx yy zz" ')
 
157
        self.assertEqual(None,
 
158
                         self.regex.match(
 
159
                             ' multipart/byteranges ; boundary= "xx yy zz '))
 
160
        self.assertEqual(None,
 
161
                         self.regex.match(
 
162
                             ' multipart/byteranges ; boundary= xx yy zz" '))
 
163
        self.assertEqual(None,
 
164
                self.regex.match('multipart byteranges;boundary=xx'))
 
165
 
 
166
 
 
167
simple_data = """
 
168
--xxyyzz\r
 
169
foo\r
 
170
Content-range: bytes 1-10/20\r
 
171
\r
 
172
1234567890
 
173
--xxyyzz\r
 
174
Content-Range: bytes 21-30/20\r
 
175
bar\r
 
176
\r
 
177
abcdefghij
 
178
--xxyyzz\r
 
179
content-range: bytes 41-50/20\r
 
180
\r
 
181
zyxwvutsrq
 
182
--xxyyzz\r
 
183
content-range: bytes 51-60/20\r
 
184
\r
 
185
xxyyzz fbd
 
186
"""
 
187
 
 
188
 
 
189
class TestHelpers(TestCase):
 
190
    """Test the helper functions"""
 
191
 
 
192
    def test__parse_range(self):
 
193
        """Test that _parse_range acts reasonably."""
 
194
        content = StringIO('')
 
195
        parse_range = response.HttpRangeResponse._parse_range
 
196
        self.assertEqual((1,2), parse_range('bytes 1-2/3'))
 
197
        self.assertEqual((10,20), parse_range('bytes 10-20/2'))
 
198
 
 
199
        self.assertRaises(errors.InvalidHttpRange, parse_range, 'char 1-3/2')
 
200
        self.assertRaises(errors.InvalidHttpRange, parse_range, 'bytes a-3/2')
 
201
 
 
202
        try:
 
203
            parse_range('bytes x-10/3', path='http://foo/bar')
 
204
        except errors.InvalidHttpRange, e:
 
205
            self.assertContainsRe(str(e), 'http://foo/bar')
 
206
            self.assertContainsRe(str(e), 'bytes x-10/3')
 
207
        else:
 
208
            self.fail('Did not raise InvalidHttpRange')
 
209
 
 
210
    def test__parse_boundary_simple(self):
 
211
        """Test that _parse_boundary handles Content-type properly"""
 
212
        parse_boundary = response.HttpMultipartRangeResponse._parse_boundary
 
213
        m = parse_boundary(' multipart/byteranges; boundary=xxyyzz')
 
214
        self.assertNotEqual(None, m)
 
215
        # Check that the returned regex is capable of splitting simple_data
 
216
        matches = list(m.finditer(simple_data))
 
217
        self.assertEqual(4, len(matches))
 
218
 
 
219
        # match.group() should be the content-range entry
 
220
        # and match.end() should be the start of the content
 
221
        self.assertEqual(' bytes 1-10/20', matches[0].group(1))
 
222
        self.assertEqual(simple_data.find('1234567890'), matches[0].end())
 
223
        self.assertEqual(' bytes 21-30/20', matches[1].group(1))
 
224
        self.assertEqual(simple_data.find('abcdefghij'), matches[1].end())
 
225
        self.assertEqual(' bytes 41-50/20', matches[2].group(1))
 
226
        self.assertEqual(simple_data.find('zyxwvutsrq'), matches[2].end())
 
227
        self.assertEqual(' bytes 51-60/20', matches[3].group(1))
 
228
        self.assertEqual(simple_data.find('xxyyzz fbd'), matches[3].end())
 
229
 
 
230
    def test__parse_boundary_invalid(self):
 
231
        parse_boundary = response.HttpMultipartRangeResponse._parse_boundary
 
232
        try:
 
233
            parse_boundary(' multipart/bytes;boundary=xxyyzz',
 
234
                           path='http://foo/bar')
 
235
        except errors.InvalidHttpContentType, e:
 
236
            self.assertContainsRe(str(e), 'http://foo/bar')
 
237
            self.assertContainsRe(str(e), 'multipart/bytes;boundary=xxyyzz')
 
238
        else:
 
239
            self.fail('Did not raise InvalidHttpContentType')
 
240
 
 
241
 
 
242
class TestHttpRangeResponse(TestCase):
 
243
 
 
244
    def test_smoketest(self):
 
245
        """A basic test that HttpRangeResponse is reasonable."""
 
246
        content = StringIO('0123456789')
 
247
        f = response.HttpRangeResponse('http://foo', 'bytes 1-10/9', content)
 
248
        self.assertEqual([response.ResponseRange(1,10,0)], f._ranges)
 
249
 
 
250
        f.seek(0)
 
251
        self.assertRaises(errors.InvalidRange, f.read, 2)
 
252
        f.seek(1)
 
253
        self.assertEqual('012345', f.read(6))
 
254
 
 
255
    def test_invalid(self):
 
256
        try:
 
257
            f = response.HttpRangeResponse('http://foo', 'bytes x-10/9',
 
258
                                           StringIO('0123456789'))
 
259
        except errors.InvalidHttpRange, e:
 
260
            self.assertContainsRe(str(e), 'http://foo')
 
261
            self.assertContainsRe(str(e), 'bytes x-10/9')
 
262
        else:
 
263
            self.fail('Failed to raise InvalidHttpRange')
 
264
 
 
265
 
 
266
class TestHttpMultipartRangeResponse(TestCase):
 
267
    """Test the handling of multipart range responses"""
 
268
 
 
269
    def test_simple(self):
 
270
        content = StringIO(simple_data)
 
271
        multi = response.HttpMultipartRangeResponse('http://foo',
 
272
                    'multipart/byteranges; boundary = xxyyzz', content)
 
273
 
 
274
        self.assertEqual(4, len(multi._ranges))
 
275
 
 
276
        multi.seek(1)
 
277
        self.assertEqual('1234567890', multi.read(10))
 
278
        multi.seek(21)
 
279
        self.assertEqual('abcdefghij', multi.read(10))
 
280
        multi.seek(41)
 
281
        self.assertEqual('zyxwvutsrq', multi.read(10))
 
282
        multi.seek(51)
 
283
        self.assertEqual('xxyyzz fbd', multi.read(10))
 
284
        # TODO: jam 20060706 Currently RangeFile does not support
 
285
        #       reading across ranges. Consider adding it.
 
286
        multi.seek(41)
 
287
        # self.assertEqual('zyxwvutsrqxxyyzz fbd', multi.read(20))
 
288
        self.assertRaises(errors.InvalidRange, multi.read, 20)
 
289
 
 
290
        multi.seek(21)
 
291
        self.assertRaises(errors.InvalidRange, multi.read, 11)
 
292
        multi.seek(31)
 
293
        self.assertRaises(errors.InvalidRange, multi.read, 10)
 
294
 
 
295
    def test_invalid(self):
 
296
        content = StringIO('')
 
297
        try:
 
298
            response.HttpMultipartRangeResponse('http://foo',
 
299
                        'multipart/byte;boundary=invalid', content)
 
300
        except errors.InvalidHttpContentType, e:
 
301
            self.assertContainsRe(str(e), 'http://foo')
 
302
            self.assertContainsRe(str(e), 'multipart/byte;')
 
303
 
 
304
 
 
305
# Taken from real request responses
 
306
_full_text_response = (200, """HTTP/1.1 200 OK\r
 
307
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 
308
Server: Apache/2.0.54 (Fedora)\r
 
309
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
 
310
ETag: "56691-23-38e9ae00"\r
 
311
Accept-Ranges: bytes\r
 
312
Content-Length: 35\r
 
313
Connection: close\r
 
314
Content-Type: text/plain; charset=UTF-8\r
 
315
\r
 
316
""", """Bazaar-NG meta directory, format 1
 
317
""")
 
318
 
 
319
 
 
320
_missing_response = (404, """HTTP/1.1 404 Not Found\r
 
321
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 
322
Server: Apache/2.0.54 (Fedora)\r
 
323
Content-Length: 336\r
 
324
Connection: close\r
 
325
Content-Type: text/html; charset=iso-8859-1\r
 
326
\r
 
327
""", """<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
 
328
<html><head>
 
329
<title>404 Not Found</title>
 
330
</head><body>
 
331
<h1>Not Found</h1>
 
332
<p>The requested URL /branches/bzr/jam-integration/.bzr/repository/format was not found on this server.</p>
 
333
<hr>
 
334
<address>Apache/2.0.54 (Fedora) Server at bzr.arbash-meinel.com Port 80</address>
 
335
</body></html>
 
336
""")
 
337
 
 
338
 
 
339
_single_range_response = (206, """HTTP/1.1 206 Partial Content\r
 
340
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
 
341
Server: Apache/2.0.54 (Fedora)\r
 
342
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
 
343
ETag: "238a3c-16ec2-805c5540"\r
 
344
Accept-Ranges: bytes\r
 
345
Content-Length: 100\r
 
346
Content-Range: bytes 100-199/93890\r
 
347
Connection: close\r
 
348
Content-Type: text/plain; charset=UTF-8\r
 
349
\r
 
350
""", """mbp@sourcefrog.net-20050309040815-13242001617e4a06
 
351
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e762""")
 
352
 
 
353
 
 
354
_multipart_range_response = (206, """HTTP/1.1 206 Partial Content\r
 
355
Date: Tue, 11 Jul 2006 04:49:48 GMT\r
 
356
Server: Apache/2.0.54 (Fedora)\r
 
357
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
 
358
ETag: "238a3c-16ec2-805c5540"\r
 
359
Accept-Ranges: bytes\r
 
360
Content-Length: 1534\r
 
361
Connection: close\r
 
362
Content-Type: multipart/byteranges; boundary=418470f848b63279b\r
 
363
\r
 
364
\r""", """--418470f848b63279b\r
 
365
Content-type: text/plain; charset=UTF-8\r
 
366
Content-range: bytes 0-254/93890\r
 
367
\r
 
368
mbp@sourcefrog.net-20050309040815-13242001617e4a06
 
369
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e7627
 
370
mbp@sourcefrog.net-20050309040957-6cad07f466bb0bb8
 
371
mbp@sourcefrog.net-20050309041501-c840e09071de3b67
 
372
mbp@sourcefrog.net-20050309044615-c24a3250be83220a
 
373
\r
 
374
--418470f848b63279b\r
 
375
Content-type: text/plain; charset=UTF-8\r
 
376
Content-range: bytes 1000-2049/93890\r
 
377
\r
 
378
40-fd4ec249b6b139ab
 
379
mbp@sourcefrog.net-20050311063625-07858525021f270b
 
380
mbp@sourcefrog.net-20050311231934-aa3776aff5200bb9
 
381
mbp@sourcefrog.net-20050311231953-73aeb3a131c3699a
 
382
mbp@sourcefrog.net-20050311232353-f5e33da490872c6a
 
383
mbp@sourcefrog.net-20050312071639-0a8f59a34a024ff0
 
384
mbp@sourcefrog.net-20050312073432-b2c16a55e0d6e9fb
 
385
mbp@sourcefrog.net-20050312073831-a47c3335ece1920f
 
386
mbp@sourcefrog.net-20050312085412-13373aa129ccbad3
 
387
mbp@sourcefrog.net-20050313052251-2bf004cb96b39933
 
388
mbp@sourcefrog.net-20050313052856-3edd84094687cb11
 
389
mbp@sourcefrog.net-20050313053233-e30a4f28aef48f9d
 
390
mbp@sourcefrog.net-20050313053853-7c64085594ff3072
 
391
mbp@sourcefrog.net-20050313054757-a86c3f5871069e22
 
392
mbp@sourcefrog.net-20050313061422-418f1f73b94879b9
 
393
mbp@sourcefrog.net-20050313120651-497bd231b19df600
 
394
mbp@sourcefrog.net-20050314024931-eae0170ef25a5d1a
 
395
mbp@sourcefrog.net-20050314025438-d52099f915fe65fc
 
396
mbp@sourcefrog.net-20050314025539-637a636692c055cf
 
397
mbp@sourcefrog.net-20050314025737-55eb441f430ab4ba
 
398
mbp@sourcefrog.net-20050314025901-d74aa93bb7ee8f62
 
399
mbp@source\r
 
400
--418470f848b63279b--\r
 
401
""")
 
402
 
 
403
_multipart_squid_range_response = (206, """HTTP/1.0 206 Partial Content\r
 
404
Date: Thu, 31 Aug 2006 21:16:22 GMT\r
 
405
Server: Apache/2.2.2 (Unix) DAV/2\r
 
406
Last-Modified: Thu, 31 Aug 2006 17:57:06 GMT\r
 
407
Accept-Ranges: bytes\r
 
408
Content-Type: multipart/byteranges; boundary="squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196"\r
 
409
Content-Length: 598\r
 
410
X-Cache: MISS from localhost.localdomain\r
 
411
X-Cache-Lookup: HIT from localhost.localdomain:3128\r
 
412
Proxy-Connection: keep-alive\r
 
413
\r
 
414
""",
 
415
"""\r
 
416
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196\r
 
417
Content-Type: text/plain\r
 
418
Content-Range: bytes 0-99/18672\r
 
419
\r
 
420
# bzr knit index 8
 
421
 
 
422
scott@netsplit.com-20050708230047-47c7868f276b939f fulltext 0 863  :
 
423
scott@netsp\r
 
424
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196\r
 
425
Content-Type: text/plain\r
 
426
Content-Range: bytes 300-499/18672\r
 
427
\r
 
428
com-20050708231537-2b124b835395399a :
 
429
scott@netsplit.com-20050820234126-551311dbb7435b51 line-delta 1803 479 .scott@netsplit.com-20050820232911-dc4322a084eadf7e :
 
430
scott@netsplit.com-20050821213706-c86\r
 
431
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196--\r
 
432
""")
 
433
 
 
434
 
 
435
_redirect_response = (206, """HTTP/1.1 301 Moved Permanently\r
 
436
Date: Tue, 18 Jul 2006 20:29:22 GMT\r
 
437
Server: Apache/2.0.54 (Ubuntu) PHP/4.4.0-3ubuntu1 mod_ssl/2.0.54 OpenSSL/0.9.7g\r
 
438
Location: http://bazaar-vcs.org/bzr/bzr.dev/.bzr/repository/inventory.knit\r
 
439
Content-Length: 272\r
 
440
Keep-Alive: timeout=15, max=100\r
 
441
Connection: Keep-Alive\r
 
442
Content-Type: text/html; charset=iso-8859-1\r
 
443
\r
 
444
HTTP/1.1 206 Partial Content\r
 
445
Date: Tue, 18 Jul 2006 20:29:23 GMT\r
 
446
Server: Apache/2.0.54 (Ubuntu) PHP/4.4.0-3ubuntu1 mod_ssl/2.0.54 OpenSSL/0.9.7g\r
 
447
Last-Modified: Tue, 18 Jul 2006 20:24:59 GMT\r
 
448
ETag: "be8213-83958c-f0d3dcc0"\r
 
449
Accept-Ranges: bytes\r
 
450
Content-Length: 425\r
 
451
Content-Range: bytes 8623075-8623499/8623500\r
 
452
Keep-Alive: timeout=15, max=100\r
 
453
Connection: Keep-Alive\r
 
454
Content-Type: text/plain; charset=UTF-8\r
 
455
\r
 
456
""", """this data intentionally removed, 
 
457
this is not meant to be tested by
 
458
handle_response, just _extract_headers
 
459
""")
 
460
 
 
461
 
 
462
# This is made up
 
463
_invalid_response = (444, """HTTP/1.1 444 Bad Response\r
 
464
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 
465
Connection: close\r
 
466
Content-Type: text/html; charset=iso-8859-1\r
 
467
\r
 
468
""", """<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
 
469
<html><head>
 
470
<title>404 Not Found</title>
 
471
</head><body>
 
472
<h1>Not Found</h1>
 
473
<p>I don't know what I'm doing</p>
 
474
<hr>
 
475
</body></html>
 
476
""")
 
477
 
 
478
 
 
479
# This should be in test_http.py, but the headers we
 
480
# want to parse are here
 
481
class TestExtractHeader(TestCase):
 
482
    
 
483
    def use_response(self, response):
 
484
        self.headers = http._extract_headers(response[1], 'http://foo')
 
485
 
 
486
    def check_header(self, header, value):
 
487
        self.assertEqual(value, self.headers[header])
 
488
        
 
489
    def test_full_text(self):
 
490
        self.use_response(_full_text_response)
 
491
 
 
492
        self.check_header('Date', 'Tue, 11 Jul 2006 04:32:56 GMT')
 
493
        self.check_header('date', 'Tue, 11 Jul 2006 04:32:56 GMT')
 
494
        self.check_header('Content-Length', '35')
 
495
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
496
        self.check_header('content-type', 'text/plain; charset=UTF-8')
 
497
 
 
498
    def test_missing_response(self):
 
499
        self.use_response(_missing_response)
 
500
 
 
501
        self.check_header('Content-Length', '336')
 
502
        self.check_header('Content-Type', 'text/html; charset=iso-8859-1')
 
503
 
 
504
    def test_single_range(self):
 
505
        self.use_response(_single_range_response)
 
506
 
 
507
        self.check_header('Content-Length', '100')
 
508
        self.check_header('Content-Range', 'bytes 100-199/93890')
 
509
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
510
 
 
511
    def test_multi_range(self):
 
512
        self.use_response(_multipart_range_response)
 
513
 
 
514
        self.check_header('Content-Length', '1534')
 
515
        self.check_header('Content-Type',
 
516
                          'multipart/byteranges; boundary=418470f848b63279b')
 
517
 
 
518
    def test_multi_squid_range(self):
 
519
        self.use_response(_multipart_squid_range_response)
 
520
 
 
521
        self.check_header('Content-Length', '598')
 
522
        self.check_header('Content-Type',
 
523
                          'multipart/byteranges; '\
 
524
                          'boundary="squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196"')
 
525
 
 
526
    def test_redirect(self):
 
527
        """We default to returning the last group of headers in the file."""
 
528
        self.use_response(_redirect_response)
 
529
        self.check_header('Content-Range', 'bytes 8623075-8623499/8623500')
 
530
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
531
 
 
532
    def test_empty(self):
 
533
        self.assertRaises(errors.InvalidHttpResponse,
 
534
            http._extract_headers, '', 'bad url')
 
535
 
 
536
    def test_no_opening_http(self):
 
537
        # Remove the HTTP line from the header
 
538
        first, txt = _full_text_response[1].split('\r\n', 1)
 
539
        self.assertRaises(errors.InvalidHttpResponse,
 
540
            http._extract_headers, txt, 'missing HTTTP')
 
541
 
 
542
    def test_trailing_whitespace(self):
 
543
        # Test that we ignore bogus whitespace on the end
 
544
        code, txt, body = _full_text_response
 
545
        txt += '\r\n\n\n\n\n'
 
546
        self.use_response((code, txt, body))
 
547
 
 
548
        self.check_header('Date', 'Tue, 11 Jul 2006 04:32:56 GMT')
 
549
        self.check_header('Content-Length', '35')
 
550
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
551
 
 
552
    def test_trailing_non_http(self):
 
553
        # Test that we ignore bogus stuff on the end
 
554
        code, txt, body = _full_text_response
 
555
        txt = txt + 'Foo: Bar\r\nBaz: Bling\r\n\r\n'
 
556
        self.use_response((code, txt, body))
 
557
 
 
558
        self.check_header('Date', 'Tue, 11 Jul 2006 04:32:56 GMT')
 
559
        self.check_header('Content-Length', '35')
 
560
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
561
        self.assertRaises(KeyError, self.headers.__getitem__, 'Foo')
 
562
 
 
563
    def test_extra_whitespace(self):
 
564
        # Test that we read an HTTP response, even with extra whitespace
 
565
        code, txt, body = _redirect_response
 
566
        # Find the second HTTP location
 
567
        loc = txt.find('HTTP', 5)
 
568
        txt = txt[:loc] + '\r\n\n' + txt[loc:]
 
569
        self.use_response((code, txt, body))
 
570
        self.check_header('Content-Range', 'bytes 8623075-8623499/8623500')
 
571
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
572
 
 
573
 
 
574
class TestHandleResponse(TestCase):
 
575
    
 
576
    def get_response(self, a_response):
 
577
        """Process a supplied response, and return the result."""
 
578
        headers = http._extract_headers(a_response[1], 'http://foo')
 
579
        return response.handle_response('http://foo', a_response[0], headers,
 
580
                                        StringIO(a_response[2]))
 
581
 
 
582
    def test_full_text(self):
 
583
        out = self.get_response(_full_text_response)
 
584
        # It is a StringIO from the original data
 
585
        self.assertEqual(_full_text_response[2], out.read())
 
586
 
 
587
    def test_missing_response(self):
 
588
        self.assertRaises(errors.NoSuchFile,
 
589
            self.get_response, _missing_response)
 
590
 
 
591
    def test_single_range(self):
 
592
        out = self.get_response(_single_range_response)
 
593
        self.assertIsInstance(out, response.HttpRangeResponse)
 
594
 
 
595
        self.assertRaises(errors.InvalidRange, out.read, 20)
 
596
 
 
597
        out.seek(100)
 
598
        self.assertEqual(_single_range_response[2], out.read(100))
 
599
 
 
600
    def test_multi_range(self):
 
601
        out = self.get_response(_multipart_range_response)
 
602
        self.assertIsInstance(out, response.HttpMultipartRangeResponse)
 
603
 
 
604
        # Just make sure we can read the right contents
 
605
        out.seek(0)
 
606
        out.read(255)
 
607
 
 
608
        out.seek(1000)
 
609
        out.read(1050)
 
610
 
 
611
    def test_multi_squid_range(self):
 
612
        out = self.get_response(_multipart_squid_range_response)
 
613
        self.assertIsInstance(out, response.HttpMultipartRangeResponse)
 
614
 
 
615
        # Just make sure we can read the right contents
 
616
        out.seek(0)
 
617
        out.read(100)
 
618
 
 
619
        out.seek(300)
 
620
        out.read(200)
 
621
 
 
622
    def test_invalid_response(self):
 
623
        self.assertRaises(errors.InvalidHttpResponse,
 
624
            self.get_response, _invalid_response)
 
625
 
 
626
    def test_full_text_no_content_type(self):
 
627
        # We should not require Content-Type for a full response
 
628
        a_response = _full_text_response
 
629
        headers = http._extract_headers(a_response[1], 'http://foo')
 
630
        del headers['Content-Type']
 
631
        out = response.handle_response('http://foo', a_response[0], headers,
 
632
                                        StringIO(a_response[2]))
 
633
        self.assertEqual(_full_text_response[2], out.read())
 
634
 
 
635
    def test_missing_no_content_type(self):
 
636
        # Without Content-Type we should still raise NoSuchFile on a 404
 
637
        a_response = _missing_response
 
638
        headers = http._extract_headers(a_response[1], 'http://missing')
 
639
        del headers['Content-Type']
 
640
        self.assertRaises(errors.NoSuchFile,
 
641
            response.handle_response, 'http://missing', a_response[0], headers,
 
642
                                      StringIO(a_response[2]))
 
643
 
 
644
    def test_missing_content_type(self):
 
645
        a_response = _single_range_response
 
646
        headers = http._extract_headers(a_response[1], 'http://nocontent')
 
647
        del headers['Content-Type']
 
648
        self.assertRaises(errors.InvalidHttpContentType,
 
649
            response.handle_response, 'http://nocontent', a_response[0],
 
650
                                      headers, StringIO(a_response[2]))
 
651
 
 
652
    def test_missing_content_range(self):
 
653
        a_response = _single_range_response
 
654
        headers = http._extract_headers(a_response[1], 'http://nocontent')
 
655
        del headers['Content-Range']
 
656
        self.assertRaises(errors.InvalidHttpResponse,
 
657
            response.handle_response, 'http://nocontent', a_response[0],
 
658
                                      headers, StringIO(a_response[2]))