1
# Copyright (C) 2006-2010, 2012, 2013, 2016 Canonical Ltd
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.
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.
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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17
"""Tests from HTTP response parsing.
19
The handle_response method read the response body of a GET request an returns
20
the corresponding RangeFile.
22
There are four different kinds of RangeFile:
23
- a whole file whose size is unknown, seen as a simple byte stream,
24
- a whole file whose size is known, we can't read past its end,
25
- a single range file, a part of a file with a start and a size,
26
- a multiple range file, several consecutive parts with known start offset
29
Some properties are common to all kinds:
30
- seek can only be forward (its really a socket underneath),
31
- read can't cross ranges,
32
- successive ranges are taken into account transparently,
34
- the expected pattern of use is either seek(offset)+read(size) or a single
35
read with no size specified. For multiple range files, multiple read() will
36
return the corresponding ranges, trying to read further will raise
41
import http.client as http_client
42
parse_headers = http_client.parse_headers
43
except ImportError: # python < 3
44
import httplib as http_client
45
parse_headers = http_client.HTTPMessage
51
from ..sixish import (
54
from ..transport.http import (
58
from .file_utils import (
63
class ReadSocket(object):
64
"""A socket-like object that can be given a predefined content."""
66
def __init__(self, data):
67
self.readfile = BytesIO(data)
69
def makefile(self, mode='r', bufsize=None):
73
class FakeHTTPConnection(_urllib2_wrappers.HTTPConnection):
75
def __init__(self, sock):
76
_urllib2_wrappers.HTTPConnection.__init__(self, 'localhost')
77
# Set the socket to bypass the connection
81
"""Ignores the writes on the socket."""
85
class TestResponseFileIter(tests.TestCase):
87
def test_iter_empty(self):
88
f = response.ResponseFile('empty', BytesIO())
89
self.assertEqual([], list(f))
91
def test_iter_many(self):
92
f = response.ResponseFile('many', BytesIO(b'0\n1\nboo!\n'))
93
self.assertEqual([b'0\n', b'1\n', b'boo!\n'], list(f))
96
class TestHTTPConnection(tests.TestCase):
98
def test_cleanup_pipe(self):
99
sock = ReadSocket(b"""HTTP/1.1 200 OK\r
100
Content-Type: text/plain; charset=UTF-8\r
105
conn = FakeHTTPConnection(sock)
106
# Simulate the request sending so that the connection will be able to
108
conn.putrequest('GET', 'http://localhost/fictious')
110
# Now, get the response
111
resp = conn.getresponse()
112
# Read part of the response
113
self.assertEqual(b'0123456789\n', resp.read(11))
114
# Override the thresold to force the warning emission
115
conn._range_warning_thresold = 6 # There are 7 bytes pending
117
self.assertContainsRe(self.get_log(), 'Got a 200 response when asking')
120
class TestRangeFileMixin(object):
121
"""Tests for accessing the first range in a RangeFile."""
123
# A simple string used to represent a file part (also called a range), in
124
# which offsets are easy to calculate for test writers. It's used as a
125
# building block with slight variations but basically 'a' is the first char
126
# of the range and 'z' is the last.
127
alpha = b'abcdefghijklmnopqrstuvwxyz'
129
def test_can_read_at_first_access(self):
130
"""Test that the just created file can be read."""
131
self.assertEqual(self.alpha, self._file.read())
133
def test_seek_read(self):
134
"""Test seek/read inside the range."""
136
start = self.first_range_start
137
# Before any use, tell() should be at the range start
138
self.assertEqual(start, f.tell())
139
cur = start # For an overall offset assertion
142
self.assertEqual(b'def', f.read(3))
146
self.assertEqual(b'klmn', f.read(4))
148
# read(0) in the middle of a range
149
self.assertEqual(b'', f.read(0))
153
self.assertEqual(here, f.tell())
154
self.assertEqual(cur, f.tell())
156
def test_read_zero(self):
158
self.assertEqual(b'', f.read(0))
160
self.assertEqual(b'', f.read(0))
162
def test_seek_at_range_end(self):
166
def test_read_at_range_end(self):
167
"""Test read behaviour at range end."""
169
self.assertEqual(self.alpha, f.read())
170
self.assertEqual(b'', f.read(0))
171
self.assertRaises(errors.InvalidRange, f.read, 1)
173
def test_unbounded_read_after_seek(self):
176
# Should not cross ranges
177
self.assertEqual(b'yz', f.read())
179
def test_seek_backwards(self):
181
start = self.first_range_start
184
self.assertRaises(errors.InvalidRange, f.seek, start + 5)
186
def test_seek_outside_single_range(self):
188
if f._size == -1 or f._boundary is not None:
189
raise tests.TestNotApplicable('Needs a fully defined range')
190
# Will seek past the range and then errors out
191
self.assertRaises(errors.InvalidRange,
192
f.seek, self.first_range_start + 27)
194
def test_read_past_end_of_range(self):
197
raise tests.TestNotApplicable("Can't check an unknown size")
198
start = self.first_range_start
200
self.assertRaises(errors.InvalidRange, f.read, 10)
202
def test_seek_from_end(self):
203
"""Test seeking from the end of the file.
205
The semantic is unclear in case of multiple ranges. Seeking from end
206
exists only for the http transports, cannot be used if the file size is
207
unknown and is not used in breezy itself. This test must be (and is)
208
overridden by daughter classes.
210
Reading from end makes sense only when a range has been requested from
211
the end of the file (see HttpTransportBase._get() when using the
212
'tail_amount' parameter). The HTTP response can only be a whole file or
217
self.assertEqual(b'yz', f.read())
220
class TestRangeFileSizeUnknown(tests.TestCase, TestRangeFileMixin):
221
"""Test a RangeFile for a whole file whose size is not known."""
224
super(TestRangeFileSizeUnknown, self).setUp()
225
self._file = response.RangeFile('Whole_file_size_known',
227
# We define no range, relying on RangeFile to provide default values
228
self.first_range_start = 0 # It's the whole file
230
def test_seek_from_end(self):
231
"""See TestRangeFileMixin.test_seek_from_end.
233
The end of the file can't be determined since the size is unknown.
235
self.assertRaises(errors.InvalidRange, self._file.seek, -1, 2)
237
def test_read_at_range_end(self):
238
"""Test read behaviour at range end."""
240
self.assertEqual(self.alpha, f.read())
241
self.assertEqual(b'', f.read(0))
242
self.assertEqual(b'', f.read(1))
245
class TestRangeFileSizeKnown(tests.TestCase, TestRangeFileMixin):
246
"""Test a RangeFile for a whole file whose size is known."""
249
super(TestRangeFileSizeKnown, self).setUp()
250
self._file = response.RangeFile('Whole_file_size_known',
252
self._file.set_range(0, len(self.alpha))
253
self.first_range_start = 0 # It's the whole file
256
class TestRangeFileSingleRange(tests.TestCase, TestRangeFileMixin):
257
"""Test a RangeFile for a single range."""
260
super(TestRangeFileSingleRange, self).setUp()
261
self._file = response.RangeFile('Single_range_file',
263
self.first_range_start = 15
264
self._file.set_range(self.first_range_start, len(self.alpha))
266
def test_read_before_range(self):
267
# This can't occur under normal circumstances, we have to force it
269
f._pos = 0 # Force an invalid pos
270
self.assertRaises(errors.InvalidRange, f.read, 2)
273
class TestRangeFileMultipleRanges(tests.TestCase, TestRangeFileMixin):
274
"""Test a RangeFile for multiple ranges.
276
The RangeFile used for the tests contains three ranges:
278
- at offset 25: alpha
279
- at offset 100: alpha
280
- at offset 126: alpha.upper()
282
The two last ranges are contiguous. This only rarely occurs (should not in
283
fact) in real uses but may lead to hard to track bugs.
286
# The following is used to represent the boundary paramter defined
287
# in HTTP response headers and the boundary lines that separate
290
boundary = b"separation"
293
super(TestRangeFileMultipleRanges, self).setUp()
295
boundary = self.boundary
298
self.first_range_start = 25
299
file_size = 200 # big enough to encompass all ranges
300
for (start, part) in [(self.first_range_start, self.alpha),
301
# Two contiguous ranges
303
(126, self.alpha.upper())]:
304
content += self._multipart_byterange(part, start, boundary,
307
content += self._boundary_line()
309
self._file = response.RangeFile('Multiple_ranges_file',
311
self.set_file_boundary()
313
def _boundary_line(self):
314
"""Helper to build the formatted boundary line."""
315
return b'--' + self.boundary + b'\r\n'
317
def set_file_boundary(self):
318
# Ranges are set by decoding the range headers, the RangeFile user is
319
# supposed to call the following before using seek or read since it
320
# requires knowing the *response* headers (in that case the boundary
321
# which is part of the Content-Type header).
322
self._file.set_boundary(self.boundary)
324
def _multipart_byterange(self, data, offset, boundary, file_size=b'*'):
325
"""Encode a part of a file as a multipart/byterange MIME type.
327
When a range request is issued, the HTTP response body can be
328
decomposed in parts, each one representing a range (start, size) in a
331
:param data: The payload.
332
:param offset: where data starts in the file
333
:param boundary: used to separate the parts
334
:param file_size: the size of the file containing the range (default to
337
:return: a string containing the data encoded as it will appear in the
340
bline = self._boundary_line()
341
# Each range begins with a boundary line
343
# A range is described by a set of headers, but only 'Content-Range' is
344
# required for our implementation (TestHandleResponse below will
345
# exercise ranges with multiple or missing headers')
346
if isinstance(file_size, int):
347
file_size = b'%d' % file_size
348
range += b'Content-Range: bytes %d-%d/%s\r\n' % (offset,
353
# Finally the raw bytes
357
def test_read_all_ranges(self):
359
self.assertEqual(self.alpha, f.read()) # Read first range
360
f.seek(100) # Trigger the second range recognition
361
self.assertEqual(self.alpha, f.read()) # Read second range
362
self.assertEqual(126, f.tell())
363
f.seek(126) # Start of third range which is also the current pos !
364
self.assertEqual(b'A', f.read(1))
366
self.assertEqual(b'LMN', f.read(3))
368
def test_seek_from_end(self):
369
"""See TestRangeFileMixin.test_seek_from_end."""
370
# The actual implementation will seek from end for the first range only
371
# and then fail. Since seeking from end is intended to be used for a
372
# single range only anyway, this test just document the actual
376
self.assertEqual(b'yz', f.read())
377
self.assertRaises(errors.InvalidRange, f.seek, -2, 2)
379
def test_seek_into_void(self):
381
start = self.first_range_start
383
# Seeking to a point between two ranges is possible (only once) but
384
# reading there is forbidden
386
# We crossed a range boundary, so now the file is positioned at the
387
# start of the new range (i.e. trying to seek below 100 will error out)
391
def test_seek_across_ranges(self):
393
f.seek(126) # skip the two first ranges
394
self.assertEqual(b'AB', f.read(2))
396
def test_checked_read_dont_overflow_buffers(self):
398
# We force a very low value to exercise all code paths in _checked_read
399
f._discarded_buf_size = 8
400
f.seek(126) # skip the two first ranges
401
self.assertEqual(b'AB', f.read(2))
403
def test_seek_twice_between_ranges(self):
405
start = self.first_range_start
406
f.seek(start + 40) # Past the first range but before the second
407
# Now the file is positioned at the second range start (100)
408
self.assertRaises(errors.InvalidRange, f.seek, start + 41)
410
def test_seek_at_range_end(self):
411
"""Test seek behavior at range end."""
417
def test_read_at_range_end(self):
419
self.assertEqual(self.alpha, f.read())
420
self.assertEqual(self.alpha, f.read())
421
self.assertEqual(self.alpha.upper(), f.read())
422
self.assertRaises(errors.InvalidHttpResponse, f.read, 1)
425
class TestRangeFileMultipleRangesQuotedBoundaries(TestRangeFileMultipleRanges):
426
"""Perform the same tests as TestRangeFileMultipleRanges, but uses
427
an angle-bracket quoted boundary string like IIS 6.0 and 7.0
428
(but not IIS 5, which breaks the RFC in a different way
429
by using square brackets, not angle brackets)
431
This reveals a bug caused by
433
- The bad implementation of RFC 822 unquoting in Python (angles are not
434
quotes), coupled with
436
- The bad implementation of RFC 2046 in IIS (angles are not permitted chars
440
# The boundary as it appears in boundary lines
441
# IIS 6 and 7 use this value
442
_boundary_trimmed = b"q1w2e3r4t5y6u7i8o9p0zaxscdvfbgnhmjklkl"
443
boundary = b'<' + _boundary_trimmed + b'>'
445
def set_file_boundary(self):
446
# Emulate broken rfc822.unquote() here by removing angles
447
self._file.set_boundary(self._boundary_trimmed)
450
class TestRangeFileVarious(tests.TestCase):
451
"""Tests RangeFile aspects not covered elsewhere."""
453
def test_seek_whence(self):
454
"""Test the seek whence parameter values."""
455
f = response.RangeFile('foo', BytesIO(b'abc'))
460
self.assertRaises(ValueError, f.seek, 0, 14)
462
def test_range_syntax(self):
463
"""Test the Content-Range scanning."""
465
f = response.RangeFile('foo', BytesIO())
467
def ok(expected, header_value):
468
f.set_range_from_header(header_value)
469
# Slightly peek under the covers to get the size
470
self.assertEqual(expected, (f.tell(), f._size))
472
ok((1, 10), 'bytes 1-10/11')
473
ok((1, 10), 'bytes 1-10/*')
474
ok((12, 2), '\tbytes 12-13/*')
475
ok((28, 1), ' bytes 28-28/*')
476
ok((2123, 2120), 'bytes 2123-4242/12310')
477
ok((1, 10), 'bytes 1-10/ttt') # We don't check total (ttt)
479
def nok(header_value):
480
self.assertRaises(errors.InvalidHttpRange,
481
f.set_range_from_header, header_value)
485
nok('bytes xx-yyy/zzz')
486
nok('bytes xx-12/zzz')
487
nok('bytes 11-yy/zzz')
491
# Taken from real request responses
492
_full_text_response = (200, b"""HTTP/1.1 200 OK\r
493
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
494
Server: Apache/2.0.54 (Fedora)\r
495
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
496
ETag: "56691-23-38e9ae00"\r
497
Accept-Ranges: bytes\r
500
Content-Type: text/plain; charset=UTF-8\r
502
""", b"""Bazaar-NG meta directory, format 1
506
_single_range_response = (206, b"""HTTP/1.1 206 Partial Content\r
507
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
508
Server: Apache/2.0.54 (Fedora)\r
509
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
510
ETag: "238a3c-16ec2-805c5540"\r
511
Accept-Ranges: bytes\r
512
Content-Length: 100\r
513
Content-Range: bytes 100-199/93890\r
515
Content-Type: text/plain; charset=UTF-8\r
517
""", b"""mbp@sourcefrog.net-20050309040815-13242001617e4a06
518
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e762""")
521
_single_range_no_content_type = (206, b"""HTTP/1.1 206 Partial Content\r
522
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
523
Server: Apache/2.0.54 (Fedora)\r
524
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
525
ETag: "238a3c-16ec2-805c5540"\r
526
Accept-Ranges: bytes\r
527
Content-Length: 100\r
528
Content-Range: bytes 100-199/93890\r
531
""", b"""mbp@sourcefrog.net-20050309040815-13242001617e4a06
532
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e762""")
535
_multipart_range_response = (206, b"""HTTP/1.1 206 Partial Content\r
536
Date: Tue, 11 Jul 2006 04:49:48 GMT\r
537
Server: Apache/2.0.54 (Fedora)\r
538
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
539
ETag: "238a3c-16ec2-805c5540"\r
540
Accept-Ranges: bytes\r
541
Content-Length: 1534\r
543
Content-Type: multipart/byteranges; boundary=418470f848b63279b\r
545
\r""", b"""--418470f848b63279b\r
546
Content-type: text/plain; charset=UTF-8\r
547
Content-range: bytes 0-254/93890\r
549
mbp@sourcefrog.net-20050309040815-13242001617e4a06
550
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e7627
551
mbp@sourcefrog.net-20050309040957-6cad07f466bb0bb8
552
mbp@sourcefrog.net-20050309041501-c840e09071de3b67
553
mbp@sourcefrog.net-20050309044615-c24a3250be83220a
555
--418470f848b63279b\r
556
Content-type: text/plain; charset=UTF-8\r
557
Content-range: bytes 1000-2049/93890\r
560
mbp@sourcefrog.net-20050311063625-07858525021f270b
561
mbp@sourcefrog.net-20050311231934-aa3776aff5200bb9
562
mbp@sourcefrog.net-20050311231953-73aeb3a131c3699a
563
mbp@sourcefrog.net-20050311232353-f5e33da490872c6a
564
mbp@sourcefrog.net-20050312071639-0a8f59a34a024ff0
565
mbp@sourcefrog.net-20050312073432-b2c16a55e0d6e9fb
566
mbp@sourcefrog.net-20050312073831-a47c3335ece1920f
567
mbp@sourcefrog.net-20050312085412-13373aa129ccbad3
568
mbp@sourcefrog.net-20050313052251-2bf004cb96b39933
569
mbp@sourcefrog.net-20050313052856-3edd84094687cb11
570
mbp@sourcefrog.net-20050313053233-e30a4f28aef48f9d
571
mbp@sourcefrog.net-20050313053853-7c64085594ff3072
572
mbp@sourcefrog.net-20050313054757-a86c3f5871069e22
573
mbp@sourcefrog.net-20050313061422-418f1f73b94879b9
574
mbp@sourcefrog.net-20050313120651-497bd231b19df600
575
mbp@sourcefrog.net-20050314024931-eae0170ef25a5d1a
576
mbp@sourcefrog.net-20050314025438-d52099f915fe65fc
577
mbp@sourcefrog.net-20050314025539-637a636692c055cf
578
mbp@sourcefrog.net-20050314025737-55eb441f430ab4ba
579
mbp@sourcefrog.net-20050314025901-d74aa93bb7ee8f62
581
--418470f848b63279b--\r
585
_multipart_squid_range_response = (206, b"""HTTP/1.0 206 Partial Content\r
586
Date: Thu, 31 Aug 2006 21:16:22 GMT\r
587
Server: Apache/2.2.2 (Unix) DAV/2\r
588
Last-Modified: Thu, 31 Aug 2006 17:57:06 GMT\r
589
Accept-Ranges: bytes\r
590
Content-Type: multipart/byteranges; boundary="squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196"\r
591
Content-Length: 598\r
592
X-Cache: MISS from localhost.localdomain\r
593
X-Cache-Lookup: HIT from localhost.localdomain:3128\r
594
Proxy-Connection: keep-alive\r
598
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196\r
599
Content-Type: text/plain\r
600
Content-Range: bytes 0-99/18672\r
604
scott@netsplit.com-20050708230047-47c7868f276b939f fulltext 0 863 :
606
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196\r
607
Content-Type: text/plain\r
608
Content-Range: bytes 300-499/18672\r
610
com-20050708231537-2b124b835395399a :
611
scott@netsplit.com-20050820234126-551311dbb7435b51 line-delta 1803 479 .scott@netsplit.com-20050820232911-dc4322a084eadf7e :
612
scott@netsplit.com-20050821213706-c86\r
613
--squid/2.5.STABLE12:C99323425AD4FE26F726261FA6C24196--\r
618
_full_text_response_no_content_type = (200, b"""HTTP/1.1 200 OK\r
619
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
620
Server: Apache/2.0.54 (Fedora)\r
621
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
622
ETag: "56691-23-38e9ae00"\r
623
Accept-Ranges: bytes\r
627
""", b"""Bazaar-NG meta directory, format 1
631
_full_text_response_no_content_length = (200, b"""HTTP/1.1 200 OK\r
632
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
633
Server: Apache/2.0.54 (Fedora)\r
634
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
635
ETag: "56691-23-38e9ae00"\r
636
Accept-Ranges: bytes\r
638
Content-Type: text/plain; charset=UTF-8\r
640
""", b"""Bazaar-NG meta directory, format 1
644
_single_range_no_content_range = (206, b"""HTTP/1.1 206 Partial Content\r
645
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
646
Server: Apache/2.0.54 (Fedora)\r
647
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
648
ETag: "238a3c-16ec2-805c5540"\r
649
Accept-Ranges: bytes\r
650
Content-Length: 100\r
653
""", b"""mbp@sourcefrog.net-20050309040815-13242001617e4a06
654
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e762""")
657
_single_range_response_truncated = (206, b"""HTTP/1.1 206 Partial Content\r
658
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
659
Server: Apache/2.0.54 (Fedora)\r
660
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
661
ETag: "238a3c-16ec2-805c5540"\r
662
Accept-Ranges: bytes\r
663
Content-Length: 100\r
664
Content-Range: bytes 100-199/93890\r
666
Content-Type: text/plain; charset=UTF-8\r
668
""", b"""mbp@sourcefrog.net-20050309040815-13242001617e4a06""")
671
_invalid_response = (444, b"""HTTP/1.1 444 Bad Response\r
672
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
674
Content-Type: text/html; charset=iso-8859-1\r
676
""", b"""<!DOCTYPE HTML PUBLIC "-//IETF//DTD HTML 2.0//EN">
678
<title>404 Not Found</title>
681
<p>I don't know what I'm doing</p>
687
_multipart_no_content_range = (206, b"""HTTP/1.0 206 Partial Content\r
688
Content-Type: multipart/byteranges; boundary=THIS_SEPARATES\r
689
Content-Length: 598\r
694
Content-Type: text/plain\r
701
_multipart_no_boundary = (206, b"""HTTP/1.0 206 Partial Content\r
702
Content-Type: multipart/byteranges; boundary=THIS_SEPARATES\r
703
Content-Length: 598\r
708
Content-Type: text/plain\r
709
Content-Range: bytes 0-18/18672\r
713
The range ended at the line above, this text is garbage instead of a boundary
718
class TestHandleResponse(tests.TestCase):
720
def _build_HTTPMessage(self, raw_headers):
721
status_and_headers = BytesIO(raw_headers)
722
# Get rid of the status line
723
status_and_headers.readline()
724
msg = parse_headers(status_and_headers)
727
def get_response(self, a_response):
728
"""Process a supplied response, and return the result."""
729
code, raw_headers, body = a_response
730
msg = self._build_HTTPMessage(raw_headers)
731
return response.handle_response('http://foo', code, msg,
732
BytesIO(a_response[2]))
734
def test_full_text(self):
735
out = self.get_response(_full_text_response)
736
# It is a BytesIO from the original data
737
self.assertEqual(_full_text_response[2], out.read())
739
def test_single_range(self):
740
out = self.get_response(_single_range_response)
743
self.assertEqual(_single_range_response[2], out.read(100))
745
def test_single_range_no_content(self):
746
out = self.get_response(_single_range_no_content_type)
749
self.assertEqual(_single_range_no_content_type[2], out.read(100))
751
def test_single_range_truncated(self):
752
out = self.get_response(_single_range_response_truncated)
753
# Content-Range declares 100 but only 51 present
754
self.assertRaises(errors.ShortReadvError, out.seek, out.tell() + 51)
756
def test_multi_range(self):
757
out = self.get_response(_multipart_range_response)
759
# Just make sure we can read the right contents
766
def test_multi_squid_range(self):
767
out = self.get_response(_multipart_squid_range_response)
769
# Just make sure we can read the right contents
776
def test_invalid_response(self):
777
self.assertRaises(errors.InvalidHttpResponse,
778
self.get_response, _invalid_response)
780
def test_full_text_no_content_type(self):
781
# We should not require Content-Type for a full response
782
code, raw_headers, body = _full_text_response_no_content_type
783
msg = self._build_HTTPMessage(raw_headers)
784
out = response.handle_response('http://foo', code, msg, BytesIO(body))
785
self.assertEqual(body, out.read())
787
def test_full_text_no_content_length(self):
788
code, raw_headers, body = _full_text_response_no_content_length
789
msg = self._build_HTTPMessage(raw_headers)
790
out = response.handle_response('http://foo', code, msg, BytesIO(body))
791
self.assertEqual(body, out.read())
793
def test_missing_content_range(self):
794
code, raw_headers, body = _single_range_no_content_range
795
msg = self._build_HTTPMessage(raw_headers)
796
self.assertRaises(errors.InvalidHttpResponse,
797
response.handle_response,
798
'http://bogus', code, msg, BytesIO(body))
800
def test_multipart_no_content_range(self):
801
code, raw_headers, body = _multipart_no_content_range
802
msg = self._build_HTTPMessage(raw_headers)
803
self.assertRaises(errors.InvalidHttpResponse,
804
response.handle_response,
805
'http://bogus', code, msg, BytesIO(body))
807
def test_multipart_no_boundary(self):
808
out = self.get_response(_multipart_no_boundary)
809
out.read() # Read the whole range
810
# Fail to find the boundary line
811
self.assertRaises(errors.InvalidHttpResponse, out.seek, 1, 1)
814
class TestRangeFileSizeReadLimited(tests.TestCase):
815
"""Test RangeFile _max_read_size functionality which limits the size of
816
read blocks to prevent MemoryError messages in socket.recv.
820
super(TestRangeFileSizeReadLimited, self).setUp()
821
# create a test datablock larger than _max_read_size.
822
chunk_size = response.RangeFile._max_read_size
823
test_pattern = b'0123456789ABCDEF'
824
self.test_data = test_pattern * (3 * chunk_size // len(test_pattern))
825
self.test_data_len = len(self.test_data)
827
def test_max_read_size(self):
828
"""Read data in blocks and verify that the reads are not larger than
829
the maximum read size.
831
# retrieve data in large blocks from response.RangeFile object
832
mock_read_file = FakeReadFile(self.test_data)
833
range_file = response.RangeFile('test_max_read_size', mock_read_file)
834
response_data = range_file.read(self.test_data_len)
836
# verify read size was equal to the maximum read size
837
self.assertTrue(mock_read_file.get_max_read_size() > 0)
838
self.assertEqual(mock_read_file.get_max_read_size(),
839
response.RangeFile._max_read_size)
840
self.assertEqual(mock_read_file.get_read_count(), 3)
842
# report error if the data wasn't equal (we only report the size due
843
# to the length of the data)
844
if response_data != self.test_data:
845
message = "Data not equal. Expected %d bytes, received %d."
846
self.fail(message % (len(response_data), self.test_data_len))
added
removed
breezy/tests/test_http_response.py
