← 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: Andrew Bennetts
  • Date: 2007-06-14 11:23:38 UTC
  • mto: (2506.2.7 container-format)
  • mto: This revision was merged to the branch mainline in revision 2572.
  • Revision ID: andrew.bennetts@canonical.com-20070614112338-6u3900u6nkag66u8
Return a callable instead of a str from read, and add more validation.

Show diffs side-by-side

added added

removed removed

Lines of Context:
bzrlib/tests/test_http_response.py
 
1
# Copyright (C) 2005, 2006 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
_single_range_no_content_type = (206, """HTTP/1.1 206 Partial Content\r
 
355
Date: Tue, 11 Jul 2006 04:45:22 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: 100\r
 
361
Content-Range: bytes 100-199/93890\r
 
362
Connection: close\r
 
363
\r
 
364
""", """mbp@sourcefrog.net-20050309040815-13242001617e4a06
 
365
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e762""")
 
366
 
 
367
 
 
368
_multipart_range_response = (206, """HTTP/1.1 206 Partial Content\r
 
369
Date: Tue, 11 Jul 2006 04:49:48 GMT\r
 
370
Server: Apache/2.0.54 (Fedora)\r
 
371
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
 
372
ETag: "238a3c-16ec2-805c5540"\r
 
373
Accept-Ranges: bytes\r
 
374
Content-Length: 1534\r
 
375
Connection: close\r
 
376
Content-Type: multipart/byteranges; boundary=418470f848b63279b\r
 
377
\r
 
378
\r""", """--418470f848b63279b\r
 
379
Content-type: text/plain; charset=UTF-8\r
 
380
Content-range: bytes 0-254/93890\r
 
381
\r
 
382
mbp@sourcefrog.net-20050309040815-13242001617e4a06
 
383
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e7627
 
384
mbp@sourcefrog.net-20050309040957-6cad07f466bb0bb8
 
385
mbp@sourcefrog.net-20050309041501-c840e09071de3b67
 
386
mbp@sourcefrog.net-20050309044615-c24a3250be83220a
 
387
\r
 
388
--418470f848b63279b\r
 
389
Content-type: text/plain; charset=UTF-8\r
 
390
Content-range: bytes 1000-2049/93890\r
 
391
\r
 
392
40-fd4ec249b6b139ab
 
393
mbp@sourcefrog.net-20050311063625-07858525021f270b
 
394
mbp@sourcefrog.net-20050311231934-aa3776aff5200bb9
 
395
mbp@sourcefrog.net-20050311231953-73aeb3a131c3699a
 
396
mbp@sourcefrog.net-20050311232353-f5e33da490872c6a
 
397
mbp@sourcefrog.net-20050312071639-0a8f59a34a024ff0
 
398
mbp@sourcefrog.net-20050312073432-b2c16a55e0d6e9fb
 
399
mbp@sourcefrog.net-20050312073831-a47c3335ece1920f
 
400
mbp@sourcefrog.net-20050312085412-13373aa129ccbad3
 
401
mbp@sourcefrog.net-20050313052251-2bf004cb96b39933
 
402
mbp@sourcefrog.net-20050313052856-3edd84094687cb11
 
403
mbp@sourcefrog.net-20050313053233-e30a4f28aef48f9d
 
404
mbp@sourcefrog.net-20050313053853-7c64085594ff3072
 
405
mbp@sourcefrog.net-20050313054757-a86c3f5871069e22
 
406
mbp@sourcefrog.net-20050313061422-418f1f73b94879b9
 
407
mbp@sourcefrog.net-20050313120651-497bd231b19df600
 
408
mbp@sourcefrog.net-20050314024931-eae0170ef25a5d1a
 
409
mbp@sourcefrog.net-20050314025438-d52099f915fe65fc
 
410
mbp@sourcefrog.net-20050314025539-637a636692c055cf
 
411
mbp@sourcefrog.net-20050314025737-55eb441f430ab4ba
 
412
mbp@sourcefrog.net-20050314025901-d74aa93bb7ee8f62
 
413
mbp@source\r
 
414
--418470f848b63279b--\r
 
415
""")
 
416
 
 
417
_multipart_squid_range_response = (206, """HTTP/1.0 206 Partial Content\r
 
418
Date: Thu, 31 Aug 2006 21:16:22 GMT\r
 
419
Server: Apache/2.2.2 (Unix) DAV/2\r
 
420
Last-Modified: Thu, 31 Aug 2006 17:57:06 GMT\r
 
421
Accept-Ranges: bytes\r
 
422
Content-Type: multipart/byteranges; boundary="squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196"\r
 
423
Content-Length: 598\r
 
424
X-Cache: MISS from localhost.localdomain\r
 
425
X-Cache-Lookup: HIT from localhost.localdomain:3128\r
 
426
Proxy-Connection: keep-alive\r
 
427
\r
 
428
""",
 
429
"""\r
 
430
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196\r
 
431
Content-Type: text/plain\r
 
432
Content-Range: bytes 0-99/18672\r
 
433
\r
 
434
# bzr knit index 8
 
435
 
 
436
scott@netsplit.com-20050708230047-47c7868f276b939f fulltext 0 863  :
 
437
scott@netsp\r
 
438
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196\r
 
439
Content-Type: text/plain\r
 
440
Content-Range: bytes 300-499/18672\r
 
441
\r
 
442
com-20050708231537-2b124b835395399a :
 
443
scott@netsplit.com-20050820234126-551311dbb7435b51 line-delta 1803 479 .scott@netsplit.com-20050820232911-dc4322a084eadf7e :
 
444
scott@netsplit.com-20050821213706-c86\r
 
445
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196--\r
 
446
""")
 
447
 
 
448
 
 
449
_redirect_response = (206, """HTTP/1.1 301 Moved Permanently\r
 
450
Date: Tue, 18 Jul 2006 20:29:22 GMT\r
 
451
Server: Apache/2.0.54 (Ubuntu) PHP/4.4.0-3ubuntu1 mod_ssl/2.0.54 OpenSSL/0.9.7g\r
 
452
Location: http://bazaar-vcs.org/bzr/bzr.dev/.bzr/repository/inventory.knit\r
 
453
Content-Length: 272\r
 
454
Keep-Alive: timeout=15, max=100\r
 
455
Connection: Keep-Alive\r
 
456
Content-Type: text/html; charset=iso-8859-1\r
 
457
\r
 
458
HTTP/1.1 206 Partial Content\r
 
459
Date: Tue, 18 Jul 2006 20:29:23 GMT\r
 
460
Server: Apache/2.0.54 (Ubuntu) PHP/4.4.0-3ubuntu1 mod_ssl/2.0.54 OpenSSL/0.9.7g\r
 
461
Last-Modified: Tue, 18 Jul 2006 20:24:59 GMT\r
 
462
ETag: "be8213-83958c-f0d3dcc0"\r
 
463
Accept-Ranges: bytes\r
 
464
Content-Length: 425\r
 
465
Content-Range: bytes 8623075-8623499/8623500\r
 
466
Keep-Alive: timeout=15, max=100\r
 
467
Connection: Keep-Alive\r
 
468
Content-Type: text/plain; charset=UTF-8\r
 
469
\r
 
470
""", """this data intentionally removed, 
 
471
this is not meant to be tested by
 
472
handle_response, just _extract_headers
 
473
""")
 
474
 
 
475
 
 
476
# This is made up
 
477
_invalid_response = (444, """HTTP/1.1 444 Bad Response\r
 
478
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 
479
Connection: close\r
 
480
Content-Type: text/html; charset=iso-8859-1\r
 
481
\r
 
482
""", """<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
 
483
<html><head>
 
484
<title>404 Not Found</title>
 
485
</head><body>
 
486
<h1>Not Found</h1>
 
487
<p>I don't know what I'm doing</p>
 
488
<hr>
 
489
</body></html>
 
490
""")
 
491
 
 
492
 
 
493
# This should be in test_http.py, but the headers we
 
494
# want to parse are here
 
495
class TestExtractHeader(TestCase):
 
496
    
 
497
    def use_response(self, response):
 
498
        self.headers = http._extract_headers(response[1], 'http://foo')
 
499
 
 
500
    def check_header(self, header, value):
 
501
        self.assertEqual(value, self.headers[header])
 
502
        
 
503
    def test_full_text(self):
 
504
        self.use_response(_full_text_response)
 
505
 
 
506
        self.check_header('Date', 'Tue, 11 Jul 2006 04:32:56 GMT')
 
507
        self.check_header('date', 'Tue, 11 Jul 2006 04:32:56 GMT')
 
508
        self.check_header('Content-Length', '35')
 
509
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
510
        self.check_header('content-type', 'text/plain; charset=UTF-8')
 
511
 
 
512
    def test_missing_response(self):
 
513
        self.use_response(_missing_response)
 
514
 
 
515
        self.check_header('Content-Length', '336')
 
516
        self.check_header('Content-Type', 'text/html; charset=iso-8859-1')
 
517
 
 
518
    def test_single_range(self):
 
519
        self.use_response(_single_range_response)
 
520
 
 
521
        self.check_header('Content-Length', '100')
 
522
        self.check_header('Content-Range', 'bytes 100-199/93890')
 
523
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
524
 
 
525
    def test_single_range_no_content(self):
 
526
        self.use_response(_single_range_no_content_type)
 
527
 
 
528
        self.check_header('Content-Length', '100')
 
529
        self.check_header('Content-Range', 'bytes 100-199/93890')
 
530
 
 
531
    def test_multi_range(self):
 
532
        self.use_response(_multipart_range_response)
 
533
 
 
534
        self.check_header('Content-Length', '1534')
 
535
        self.check_header('Content-Type',
 
536
                          'multipart/byteranges; boundary=418470f848b63279b')
 
537
 
 
538
    def test_multi_squid_range(self):
 
539
        self.use_response(_multipart_squid_range_response)
 
540
 
 
541
        self.check_header('Content-Length', '598')
 
542
        self.check_header('Content-Type',
 
543
                          'multipart/byteranges; '\
 
544
                          'boundary="squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196"')
 
545
 
 
546
    def test_redirect(self):
 
547
        """We default to returning the last group of headers in the file."""
 
548
        self.use_response(_redirect_response)
 
549
        self.check_header('Content-Range', 'bytes 8623075-8623499/8623500')
 
550
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
551
 
 
552
    def test_empty(self):
 
553
        self.assertRaises(errors.InvalidHttpResponse,
 
554
            http._extract_headers, '', 'bad url')
 
555
 
 
556
    def test_no_opening_http(self):
 
557
        # Remove the HTTP line from the header
 
558
        first, txt = _full_text_response[1].split('\r\n', 1)
 
559
        self.assertRaises(errors.InvalidHttpResponse,
 
560
            http._extract_headers, txt, 'missing HTTTP')
 
561
 
 
562
    def test_trailing_whitespace(self):
 
563
        # Test that we ignore bogus whitespace on the end
 
564
        code, txt, body = _full_text_response
 
565
        txt += '\r\n\n\n\n\n'
 
566
        self.use_response((code, txt, body))
 
567
 
 
568
        self.check_header('Date', 'Tue, 11 Jul 2006 04:32:56 GMT')
 
569
        self.check_header('Content-Length', '35')
 
570
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
571
 
 
572
    def test_trailing_non_http(self):
 
573
        # Test that we ignore bogus stuff on the end
 
574
        code, txt, body = _full_text_response
 
575
        txt = txt + 'Foo: Bar\r\nBaz: Bling\r\n\r\n'
 
576
        self.use_response((code, txt, body))
 
577
 
 
578
        self.check_header('Date', 'Tue, 11 Jul 2006 04:32:56 GMT')
 
579
        self.check_header('Content-Length', '35')
 
580
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
581
        self.assertRaises(KeyError, self.headers.__getitem__, 'Foo')
 
582
 
 
583
    def test_extra_whitespace(self):
 
584
        # Test that we read an HTTP response, even with extra whitespace
 
585
        code, txt, body = _redirect_response
 
586
        # Find the second HTTP location
 
587
        loc = txt.find('HTTP', 5)
 
588
        txt = txt[:loc] + '\r\n\n' + txt[loc:]
 
589
        self.use_response((code, txt, body))
 
590
        self.check_header('Content-Range', 'bytes 8623075-8623499/8623500')
 
591
        self.check_header('Content-Type', 'text/plain; charset=UTF-8')
 
592
 
 
593
 
 
594
class TestHandleResponse(TestCase):
 
595
    
 
596
    def get_response(self, a_response):
 
597
        """Process a supplied response, and return the result."""
 
598
        headers = http._extract_headers(a_response[1], 'http://foo')
 
599
        return response.handle_response('http://foo', a_response[0], headers,
 
600
                                        StringIO(a_response[2]))
 
601
 
 
602
    def test_full_text(self):
 
603
        out = self.get_response(_full_text_response)
 
604
        # It is a StringIO from the original data
 
605
        self.assertEqual(_full_text_response[2], out.read())
 
606
 
 
607
    def test_missing_response(self):
 
608
        self.assertRaises(errors.NoSuchFile,
 
609
            self.get_response, _missing_response)
 
610
 
 
611
    def test_single_range(self):
 
612
        out = self.get_response(_single_range_response)
 
613
        self.assertIsInstance(out, response.HttpRangeResponse)
 
614
 
 
615
        self.assertRaises(errors.InvalidRange, out.read, 20)
 
616
 
 
617
        out.seek(100)
 
618
        self.assertEqual(_single_range_response[2], out.read(100))
 
619
 
 
620
    def test_single_range_no_content(self):
 
621
        out = self.get_response(_single_range_no_content_type)
 
622
        self.assertIsInstance(out, response.HttpRangeResponse)
 
623
 
 
624
        self.assertRaises(errors.InvalidRange, out.read, 20)
 
625
 
 
626
        out.seek(100)
 
627
        self.assertEqual(_single_range_no_content_type[2], out.read(100))
 
628
 
 
629
    def test_multi_range(self):
 
630
        out = self.get_response(_multipart_range_response)
 
631
        self.assertIsInstance(out, response.HttpMultipartRangeResponse)
 
632
 
 
633
        # Just make sure we can read the right contents
 
634
        out.seek(0)
 
635
        out.read(255)
 
636
 
 
637
        out.seek(1000)
 
638
        out.read(1050)
 
639
 
 
640
    def test_multi_squid_range(self):
 
641
        out = self.get_response(_multipart_squid_range_response)
 
642
        self.assertIsInstance(out, response.HttpMultipartRangeResponse)
 
643
 
 
644
        # Just make sure we can read the right contents
 
645
        out.seek(0)
 
646
        out.read(100)
 
647
 
 
648
        out.seek(300)
 
649
        out.read(200)
 
650
 
 
651
    def test_invalid_response(self):
 
652
        self.assertRaises(errors.InvalidHttpResponse,
 
653
            self.get_response, _invalid_response)
 
654
 
 
655
    def test_full_text_no_content_type(self):
 
656
        # We should not require Content-Type for a full response
 
657
        a_response = _full_text_response
 
658
        headers = http._extract_headers(a_response[1], 'http://foo')
 
659
        del headers['Content-Type']
 
660
        out = response.handle_response('http://foo', a_response[0], headers,
 
661
                                        StringIO(a_response[2]))
 
662
        self.assertEqual(_full_text_response[2], out.read())
 
663
 
 
664
    def test_missing_no_content_type(self):
 
665
        # Without Content-Type we should still raise NoSuchFile on a 404
 
666
        a_response = _missing_response
 
667
        headers = http._extract_headers(a_response[1], 'http://missing')
 
668
        del headers['Content-Type']
 
669
        self.assertRaises(errors.NoSuchFile,
 
670
            response.handle_response, 'http://missing', a_response[0], headers,
 
671
                                      StringIO(a_response[2]))
 
672
 
 
673
    def test_missing_content_range(self):
 
674
        a_response = _single_range_response
 
675
        headers = http._extract_headers(a_response[1], 'http://nocontent')
 
676
        del headers['Content-Range']
 
677
        self.assertRaises(errors.InvalidHttpResponse,
 
678
            response.handle_response, 'http://nocontent', a_response[0],
 
679
                                      headers, StringIO(a_response[2]))