← 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: Martin Pool
  • Date: 2005-09-13 02:11:41 UTC
  • Revision ID: mbp@sourcefrog.net-20050913021141-263bfc2655ac3ed2
- store inventories in weave

- put more intelligence into WeaveStore

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]))