~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http_response.py

  • Committer: John Arbash Meinel
  • Date: 2013-05-19 14:29:37 UTC
  • mfrom: (6437.63.9 2.5)
  • mto: (6437.63.10 2.5)
  • mto: This revision was merged to the branch mainline in revision 6575.
  • Revision ID: john@arbash-meinel.com-20130519142937-21ykz2n2y2f22za9
Merge in the actual 2.5 branch. It seems I failed before

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2005, 2006 Canonical Ltd
 
1
# Copyright (C) 2006-2010 Canonical Ltd
2
2
#
3
3
# This program is free software; you can redistribute it and/or modify
4
4
# it under the terms of the GNU General Public License as published by
12
12
#
13
13
# You should have received a copy of the GNU General Public License
14
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."""
 
15
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
16
 
 
17
"""Tests from HTTP response parsing.
 
18
 
 
19
The handle_response method read the response body of a GET request an returns
 
20
the corresponding RangeFile.
 
21
 
 
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
 
27
  and size.
 
28
 
 
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,
 
33
 
 
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
 
37
  InvalidHttpResponse.
 
38
"""
18
39
 
19
40
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
 
 
 
41
import httplib
 
42
 
 
43
from bzrlib import (
 
44
    errors,
 
45
    tests,
 
46
    )
 
47
from bzrlib.transport.http import (
 
48
    response,
 
49
    _urllib2_wrappers,
 
50
    )
 
51
from bzrlib.tests.file_utils import (
 
52
    FakeReadFile,
 
53
    )
 
54
 
 
55
 
 
56
class ReadSocket(object):
 
57
    """A socket-like object that can be given a predefined content."""
 
58
 
 
59
    def __init__(self, data):
 
60
        self.readfile = StringIO(data)
 
61
 
 
62
    def makefile(self, mode='r', bufsize=None):
 
63
        return self.readfile
 
64
 
 
65
 
 
66
class FakeHTTPConnection(_urllib2_wrappers.HTTPConnection):
 
67
 
 
68
    def __init__(self, sock):
 
69
        _urllib2_wrappers.HTTPConnection.__init__(self, 'localhost')
 
70
        # Set the socket to bypass the connection
 
71
        self.sock = sock
 
72
 
 
73
    def send(self, str):
 
74
        """Ignores the writes on the socket."""
 
75
        pass
 
76
 
 
77
 
 
78
class TestHTTPConnection(tests.TestCase):
 
79
 
 
80
    def test_cleanup_pipe(self):
 
81
        sock = ReadSocket("""HTTP/1.1 200 OK\r
 
82
Content-Type: text/plain; charset=UTF-8\r
 
83
Content-Length: 18
 
84
\r
 
85
0123456789
 
86
garbage""")
 
87
        conn = FakeHTTPConnection(sock)
 
88
        # Simulate the request sending so that the connection will be able to
 
89
        # read the response.
 
90
        conn.putrequest('GET', 'http://localhost/fictious')
 
91
        conn.endheaders()
 
92
        # Now, get the response
 
93
        resp = conn.getresponse()
 
94
        # Read part of the response
 
95
        self.assertEquals('0123456789\n', resp.read(11))
 
96
        # Override the thresold to force the warning emission
 
97
        conn._range_warning_thresold = 6 # There are 7 bytes pending
 
98
        conn.cleanup_pipe()
 
99
        self.assertContainsRe(self.get_log(), 'Got a 200 response when asking')
 
100
 
 
101
 
 
102
class TestRangeFileMixin(object):
 
103
    """Tests for accessing the first range in a RangeFile."""
 
104
 
 
105
    # A simple string used to represent a file part (also called a range), in
 
106
    # which offsets are easy to calculate for test writers. It's used as a
 
107
    # building block with slight variations but basically 'a' is the first char
 
108
    # of the range and 'z' is the last.
 
109
    alpha = 'abcdefghijklmnopqrstuvwxyz'
 
110
 
 
111
    def test_can_read_at_first_access(self):
 
112
        """Test that the just created file can be read."""
 
113
        self.assertEquals(self.alpha, self._file.read())
 
114
 
 
115
    def test_seek_read(self):
 
116
        """Test seek/read inside the range."""
 
117
        f = self._file
 
118
        start = self.first_range_start
 
119
        # Before any use, tell() should be at the range start
 
120
        self.assertEquals(start, f.tell())
 
121
        cur = start # For an overall offset assertion
 
122
        f.seek(start + 3)
 
123
        cur += 3
 
124
        self.assertEquals('def', f.read(3))
 
125
        cur += len('def')
 
126
        f.seek(4, 1)
 
127
        cur += 4
 
128
        self.assertEquals('klmn', f.read(4))
 
129
        cur += len('klmn')
 
130
        # read(0) in the middle of a range
 
131
        self.assertEquals('', f.read(0))
 
132
        # seek in place
 
133
        here = f.tell()
 
134
        f.seek(0, 1)
 
135
        self.assertEquals(here, f.tell())
 
136
        self.assertEquals(cur, f.tell())
 
137
 
 
138
    def test_read_zero(self):
 
139
        f = self._file
 
140
        start = self.first_range_start
 
141
        self.assertEquals('', f.read(0))
 
142
        f.seek(10, 1)
 
143
        self.assertEquals('', f.read(0))
 
144
 
 
145
    def test_seek_at_range_end(self):
 
146
        f = self._file
 
147
        f.seek(26, 1)
 
148
 
 
149
    def test_read_at_range_end(self):
 
150
        """Test read behaviour at range end."""
 
151
        f = self._file
 
152
        self.assertEquals(self.alpha, f.read())
 
153
        self.assertEquals('', f.read(0))
 
154
        self.assertRaises(errors.InvalidRange, f.read, 1)
 
155
 
 
156
    def test_unbounded_read_after_seek(self):
 
157
        f = self._file
 
158
        f.seek(24, 1)
 
159
        # Should not cross ranges
 
160
        self.assertEquals('yz', f.read())
 
161
 
 
162
    def test_seek_backwards(self):
 
163
        f = self._file
 
164
        start = self.first_range_start
 
165
        f.seek(start)
 
166
        f.read(12)
 
167
        self.assertRaises(errors.InvalidRange, f.seek, start + 5)
 
168
 
 
169
    def test_seek_outside_single_range(self):
 
170
        f = self._file
 
171
        if f._size == -1 or f._boundary is not None:
 
172
            raise tests.TestNotApplicable('Needs a fully defined range')
 
173
        # Will seek past the range and then errors out
 
174
        self.assertRaises(errors.InvalidRange,
 
175
                          f.seek, self.first_range_start + 27)
 
176
 
 
177
    def test_read_past_end_of_range(self):
 
178
        f = self._file
 
179
        if f._size == -1:
 
180
            raise tests.TestNotApplicable("Can't check an unknown size")
 
181
        start = self.first_range_start
 
182
        f.seek(start + 20)
 
183
        self.assertRaises(errors.InvalidRange, f.read, 10)
 
184
 
 
185
    def test_seek_from_end(self):
 
186
       """Test seeking from the end of the file.
 
187
 
 
188
       The semantic is unclear in case of multiple ranges. Seeking from end
 
189
       exists only for the http transports, cannot be used if the file size is
 
190
       unknown and is not used in bzrlib itself. This test must be (and is)
 
191
       overridden by daughter classes.
 
192
 
 
193
       Reading from end makes sense only when a range has been requested from
 
194
       the end of the file (see HttpTransportBase._get() when using the
 
195
       'tail_amount' parameter). The HTTP response can only be a whole file or
 
196
       a single range.
 
197
       """
 
198
       f = self._file
 
199
       f.seek(-2, 2)
 
200
       self.assertEquals('yz', f.read())
 
201
 
 
202
 
 
203
class TestRangeFileSizeUnknown(tests.TestCase, TestRangeFileMixin):
 
204
    """Test a RangeFile for a whole file whose size is not known."""
 
205
 
 
206
    def setUp(self):
 
207
        super(TestRangeFileSizeUnknown, self).setUp()
 
208
        self._file = response.RangeFile('Whole_file_size_known',
 
209
                                        StringIO(self.alpha))
 
210
        # We define no range, relying on RangeFile to provide default values
 
211
        self.first_range_start = 0 # It's the whole file
 
212
 
 
213
    def test_seek_from_end(self):
 
214
        """See TestRangeFileMixin.test_seek_from_end.
 
215
 
 
216
        The end of the file can't be determined since the size is unknown.
 
217
        """
 
218
        self.assertRaises(errors.InvalidRange, self._file.seek, -1, 2)
 
219
 
 
220
    def test_read_at_range_end(self):
 
221
        """Test read behaviour at range end."""
 
222
        f = self._file
 
223
        self.assertEquals(self.alpha, f.read())
 
224
        self.assertEquals('', f.read(0))
 
225
        self.assertEquals('', f.read(1))
 
226
 
 
227
 
 
228
class TestRangeFileSizeKnown(tests.TestCase, TestRangeFileMixin):
 
229
    """Test a RangeFile for a whole file whose size is known."""
 
230
 
 
231
    def setUp(self):
 
232
        super(TestRangeFileSizeKnown, self).setUp()
 
233
        self._file = response.RangeFile('Whole_file_size_known',
 
234
                                        StringIO(self.alpha))
 
235
        self._file.set_range(0, len(self.alpha))
 
236
        self.first_range_start = 0 # It's the whole file
 
237
 
 
238
 
 
239
class TestRangeFileSingleRange(tests.TestCase, TestRangeFileMixin):
 
240
    """Test a RangeFile for a single range."""
 
241
 
 
242
    def setUp(self):
 
243
        super(TestRangeFileSingleRange, self).setUp()
 
244
        self._file = response.RangeFile('Single_range_file',
 
245
                                        StringIO(self.alpha))
 
246
        self.first_range_start = 15
 
247
        self._file.set_range(self.first_range_start, len(self.alpha))
 
248
 
 
249
 
 
250
    def test_read_before_range(self):
 
251
        # This can't occur under normal circumstances, we have to force it
 
252
        f = self._file
 
253
        f._pos = 0 # Force an invalid pos
 
254
        self.assertRaises(errors.InvalidRange, f.read, 2)
 
255
 
 
256
 
 
257
class TestRangeFileMultipleRanges(tests.TestCase, TestRangeFileMixin):
 
258
    """Test a RangeFile for multiple ranges.
 
259
 
 
260
    The RangeFile used for the tests contains three ranges:
 
261
 
 
262
    - at offset 25: alpha
 
263
    - at offset 100: alpha
 
264
    - at offset 126: alpha.upper()
 
265
 
 
266
    The two last ranges are contiguous. This only rarely occurs (should not in
 
267
    fact) in real uses but may lead to hard to track bugs.
 
268
    """
 
269
 
 
270
    # The following is used to represent the boundary paramter defined
 
271
    # in HTTP response headers and the boundary lines that separate
 
272
    # multipart content.
 
273
 
 
274
    boundary = "separation"
 
275
 
 
276
    def setUp(self):
 
277
        super(TestRangeFileMultipleRanges, self).setUp()
 
278
 
 
279
        boundary = self.boundary
 
280
 
 
281
        content = ''
 
282
        self.first_range_start = 25
 
283
        file_size = 200 # big enough to encompass all ranges
 
284
        for (start, part) in [(self.first_range_start, self.alpha),
 
285
                              # Two contiguous ranges
 
286
                              (100, self.alpha),
 
287
                              (126, self.alpha.upper())]:
 
288
            content += self._multipart_byterange(part, start, boundary,
 
289
                                                 file_size)
 
290
        # Final boundary
 
291
        content += self._boundary_line()
 
292
 
 
293
        self._file = response.RangeFile('Multiple_ranges_file',
 
294
                                        StringIO(content))
 
295
        self.set_file_boundary()
 
296
 
 
297
    def _boundary_line(self):
 
298
        """Helper to build the formatted boundary line."""
 
299
        return '--' + self.boundary + '\r\n'
 
300
 
 
301
    def set_file_boundary(self):
 
302
        # Ranges are set by decoding the range headers, the RangeFile user is
 
303
        # supposed to call the following before using seek or read since it
 
304
        # requires knowing the *response* headers (in that case the boundary
 
305
        # which is part of the Content-Type header).
 
306
        self._file.set_boundary(self.boundary)
 
307
 
 
308
    def _multipart_byterange(self, data, offset, boundary, file_size='*'):
 
309
        """Encode a part of a file as a multipart/byterange MIME type.
 
310
 
 
311
        When a range request is issued, the HTTP response body can be
 
312
        decomposed in parts, each one representing a range (start, size) in a
 
313
        file.
 
314
 
 
315
        :param data: The payload.
 
316
        :param offset: where data starts in the file
 
317
        :param boundary: used to separate the parts
 
318
        :param file_size: the size of the file containing the range (default to
 
319
            '*' meaning unknown)
 
320
 
 
321
        :return: a string containing the data encoded as it will appear in the
 
322
            HTTP response body.
 
323
        """
 
324
        bline = self._boundary_line()
 
325
        # Each range begins with a boundary line
 
326
        range = bline
 
327
        # A range is described by a set of headers, but only 'Content-Range' is
 
328
        # required for our implementation (TestHandleResponse below will
 
329
        # exercise ranges with multiple or missing headers')
 
330
        range += 'Content-Range: bytes %d-%d/%d\r\n' % (offset,
 
331
                                                        offset+len(data)-1,
 
332
                                                        file_size)
 
333
        range += '\r\n'
 
334
        # Finally the raw bytes
 
335
        range += data
 
336
        return range
 
337
 
 
338
    def test_read_all_ranges(self):
 
339
        f = self._file
 
340
        self.assertEquals(self.alpha, f.read()) # Read first range
 
341
        f.seek(100) # Trigger the second range recognition
 
342
        self.assertEquals(self.alpha, f.read()) # Read second range
 
343
        self.assertEquals(126, f.tell())
 
344
        f.seek(126) # Start of third range which is also the current pos !
 
345
        self.assertEquals('A', f.read(1))
 
346
        f.seek(10, 1)
 
347
        self.assertEquals('LMN', f.read(3))
 
348
 
 
349
    def test_seek_from_end(self):
 
350
        """See TestRangeFileMixin.test_seek_from_end."""
 
351
        # The actual implementation will seek from end for the first range only
 
352
        # and then fail. Since seeking from end is intended to be used for a
 
353
        # single range only anyway, this test just document the actual
 
354
        # behaviour.
 
355
        f = self._file
 
356
        f.seek(-2, 2)
 
357
        self.assertEquals('yz', f.read())
 
358
        self.assertRaises(errors.InvalidRange, f.seek, -2, 2)
 
359
 
 
360
    def test_seek_into_void(self):
 
361
        f = self._file
 
362
        start = self.first_range_start
 
363
        f.seek(start)
 
364
        # Seeking to a point between two ranges is possible (only once) but
 
365
        # reading there is forbidden
 
366
        f.seek(start + 40)
 
367
        # We crossed a range boundary, so now the file is positioned at the
 
368
        # start of the new range (i.e. trying to seek below 100 will error out)
 
369
        f.seek(100)
 
370
        f.seek(125)
 
371
 
 
372
    def test_seek_across_ranges(self):
 
373
        f = self._file
 
374
        start = self.first_range_start
 
375
        f.seek(126) # skip the two first ranges
 
376
        self.assertEquals('AB', f.read(2))
 
377
 
 
378
    def test_checked_read_dont_overflow_buffers(self):
 
379
        f = self._file
 
380
        start = self.first_range_start
 
381
        # We force a very low value to exercise all code paths in _checked_read
 
382
        f._discarded_buf_size = 8
 
383
        f.seek(126) # skip the two first ranges
 
384
        self.assertEquals('AB', f.read(2))
 
385
 
 
386
    def test_seek_twice_between_ranges(self):
 
387
        f = self._file
 
388
        start = self.first_range_start
 
389
        f.seek(start + 40) # Past the first range but before the second
 
390
        # Now the file is positioned at the second range start (100)
 
391
        self.assertRaises(errors.InvalidRange, f.seek, start + 41)
 
392
 
 
393
    def test_seek_at_range_end(self):
 
394
        """Test seek behavior at range end."""
 
395
        f = self._file
 
396
        f.seek(25 + 25)
 
397
        f.seek(100 + 25)
 
398
        f.seek(126 + 25)
 
399
 
 
400
    def test_read_at_range_end(self):
 
401
        f = self._file
 
402
        self.assertEquals(self.alpha, f.read())
 
403
        self.assertEquals(self.alpha, f.read())
 
404
        self.assertEquals(self.alpha.upper(), f.read())
 
405
        self.assertRaises(errors.InvalidHttpResponse, f.read, 1)
 
406
 
 
407
 
 
408
class TestRangeFileMultipleRangesQuotedBoundaries(TestRangeFileMultipleRanges):
 
409
    """Perform the same tests as TestRangeFileMultipleRanges, but uses
 
410
    an angle-bracket quoted boundary string like IIS 6.0 and 7.0
 
411
    (but not IIS 5, which breaks the RFC in a different way
 
412
    by using square brackets, not angle brackets)
 
413
 
 
414
    This reveals a bug caused by
 
415
 
 
416
    - The bad implementation of RFC 822 unquoting in Python (angles are not
 
417
      quotes), coupled with
 
418
 
 
419
    - The bad implementation of RFC 2046 in IIS (angles are not permitted chars
 
420
      in boundary lines).
 
421
 
 
422
    """
 
423
    # The boundary as it appears in boundary lines
 
424
    # IIS 6 and 7 use this value
 
425
    _boundary_trimmed = "q1w2e3r4t5y6u7i8o9p0zaxscdvfbgnhmjklkl"
 
426
    boundary = '<' + _boundary_trimmed + '>'
 
427
 
 
428
    def set_file_boundary(self):
 
429
        # Emulate broken rfc822.unquote() here by removing angles
 
430
        self._file.set_boundary(self._boundary_trimmed)
 
431
 
 
432
 
 
433
class TestRangeFileVarious(tests.TestCase):
 
434
    """Tests RangeFile aspects not covered elsewhere."""
 
435
 
 
436
    def test_seek_whence(self):
 
437
        """Test the seek whence parameter values."""
 
438
        f = response.RangeFile('foo', StringIO('abc'))
 
439
        f.set_range(0, 3)
250
440
        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;')
 
441
        f.seek(1, 1)
 
442
        f.seek(-1, 2)
 
443
        self.assertRaises(ValueError, f.seek, 0, 14)
 
444
 
 
445
    def test_range_syntax(self):
 
446
        """Test the Content-Range scanning."""
 
447
 
 
448
        f = response.RangeFile('foo', StringIO())
 
449
 
 
450
        def ok(expected, header_value):
 
451
            f.set_range_from_header(header_value)
 
452
            # Slightly peek under the covers to get the size
 
453
            self.assertEquals(expected, (f.tell(), f._size))
 
454
 
 
455
        ok((1, 10), 'bytes 1-10/11')
 
456
        ok((1, 10), 'bytes 1-10/*')
 
457
        ok((12, 2), '\tbytes 12-13/*')
 
458
        ok((28, 1), '  bytes 28-28/*')
 
459
        ok((2123, 2120), 'bytes  2123-4242/12310')
 
460
        ok((1, 10), 'bytes 1-10/ttt') # We don't check total (ttt)
 
461
 
 
462
        def nok(header_value):
 
463
            self.assertRaises(errors.InvalidHttpRange,
 
464
                              f.set_range_from_header, header_value)
 
465
 
 
466
        nok('bytes 10-2/3')
 
467
        nok('chars 1-2/3')
 
468
        nok('bytes xx-yyy/zzz')
 
469
        nok('bytes xx-12/zzz')
 
470
        nok('bytes 11-yy/zzz')
 
471
        nok('bytes10-2/3')
303
472
 
304
473
 
305
474
# Taken from real request responses
317
486
""")
318
487
 
319
488
 
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
489
_single_range_response = (206, """HTTP/1.1 206 Partial Content\r
340
490
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
341
491
Server: Apache/2.0.54 (Fedora)\r
414
564
--418470f848b63279b--\r
415
565
""")
416
566
 
 
567
 
417
568
_multipart_squid_range_response = (206, """HTTP/1.0 206 Partial Content\r
418
569
Date: Thu, 31 Aug 2006 21:16:22 GMT\r
419
570
Server: Apache/2.2.2 (Unix) DAV/2\r
446
597
""")
447
598
 
448
599
 
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
600
# This is made up
 
601
_full_text_response_no_content_type = (200, """HTTP/1.1 200 OK\r
 
602
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 
603
Server: Apache/2.0.54 (Fedora)\r
 
604
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
 
605
ETag: "56691-23-38e9ae00"\r
 
606
Accept-Ranges: bytes\r
 
607
Content-Length: 35\r
 
608
Connection: close\r
 
609
\r
 
610
""", """Bazaar-NG meta directory, format 1
 
611
""")
 
612
 
 
613
 
 
614
_full_text_response_no_content_length = (200, """HTTP/1.1 200 OK\r
 
615
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
 
616
Server: Apache/2.0.54 (Fedora)\r
 
617
Last-Modified: Sun, 23 Apr 2006 19:35:20 GMT\r
 
618
ETag: "56691-23-38e9ae00"\r
 
619
Accept-Ranges: bytes\r
 
620
Connection: close\r
 
621
Content-Type: text/plain; charset=UTF-8\r
 
622
\r
 
623
""", """Bazaar-NG meta directory, format 1
 
624
""")
 
625
 
 
626
 
 
627
_single_range_no_content_range = (206, """HTTP/1.1 206 Partial Content\r
 
628
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
 
629
Server: Apache/2.0.54 (Fedora)\r
 
630
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
 
631
ETag: "238a3c-16ec2-805c5540"\r
 
632
Accept-Ranges: bytes\r
 
633
Content-Length: 100\r
 
634
Connection: close\r
 
635
\r
 
636
""", """mbp@sourcefrog.net-20050309040815-13242001617e4a06
 
637
mbp@sourcefrog.net-20050309040929-eee0eb3e6d1e762""")
 
638
 
 
639
 
 
640
_single_range_response_truncated = (206, """HTTP/1.1 206 Partial Content\r
 
641
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
 
642
Server: Apache/2.0.54 (Fedora)\r
 
643
Last-Modified: Thu, 06 Jul 2006 20:22:05 GMT\r
 
644
ETag: "238a3c-16ec2-805c5540"\r
 
645
Accept-Ranges: bytes\r
 
646
Content-Length: 100\r
 
647
Content-Range: bytes 100-199/93890\r
 
648
Connection: close\r
 
649
Content-Type: text/plain; charset=UTF-8\r
 
650
\r
 
651
""", """mbp@sourcefrog.net-20050309040815-13242001617e4a06""")
 
652
 
 
653
 
477
654
_invalid_response = (444, """HTTP/1.1 444 Bad Response\r
478
655
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
479
656
Connection: close\r
490
667
""")
491
668
 
492
669
 
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
 
    
 
670
_multipart_no_content_range = (206, """HTTP/1.0 206 Partial Content\r
 
671
Content-Type: multipart/byteranges; boundary=THIS_SEPARATES\r
 
672
Content-Length: 598\r
 
673
\r
 
674
""",
 
675
"""\r
 
676
--THIS_SEPARATES\r
 
677
Content-Type: text/plain\r
 
678
\r
 
679
# bzr knit index 8
 
680
--THIS_SEPARATES\r
 
681
""")
 
682
 
 
683
 
 
684
_multipart_no_boundary = (206, """HTTP/1.0 206 Partial Content\r
 
685
Content-Type: multipart/byteranges; boundary=THIS_SEPARATES\r
 
686
Content-Length: 598\r
 
687
\r
 
688
""",
 
689
"""\r
 
690
--THIS_SEPARATES\r
 
691
Content-Type: text/plain\r
 
692
Content-Range: bytes 0-18/18672\r
 
693
\r
 
694
# bzr knit index 8
 
695
 
 
696
The range ended at the line above, this text is garbage instead of a boundary
 
697
line
 
698
""")
 
699
 
 
700
 
 
701
class TestHandleResponse(tests.TestCase):
 
702
 
 
703
    def _build_HTTPMessage(self, raw_headers):
 
704
        status_and_headers = StringIO(raw_headers)
 
705
        # Get rid of the status line
 
706
        status_and_headers.readline()
 
707
        msg = httplib.HTTPMessage(status_and_headers)
 
708
        return msg
 
709
 
596
710
    def get_response(self, a_response):
597
711
        """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,
 
712
        code, raw_headers, body = a_response
 
713
        msg = self._build_HTTPMessage(raw_headers)
 
714
        return response.handle_response('http://foo', code, msg,
600
715
                                        StringIO(a_response[2]))
601
716
 
602
717
    def test_full_text(self):
604
719
        # It is a StringIO from the original data
605
720
        self.assertEqual(_full_text_response[2], out.read())
606
721
 
607
 
    def test_missing_response(self):
608
 
        self.assertRaises(errors.NoSuchFile,
609
 
            self.get_response, _missing_response)
610
 
 
611
722
    def test_single_range(self):
612
723
        out = self.get_response(_single_range_response)
613
 
        self.assertIsInstance(out, response.HttpRangeResponse)
614
 
 
615
 
        self.assertRaises(errors.InvalidRange, out.read, 20)
616
724
 
617
725
        out.seek(100)
618
726
        self.assertEqual(_single_range_response[2], out.read(100))
619
727
 
620
728
    def test_single_range_no_content(self):
621
729
        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
730
 
626
731
        out.seek(100)
627
732
        self.assertEqual(_single_range_no_content_type[2], out.read(100))
628
733
 
 
734
    def test_single_range_truncated(self):
 
735
        out = self.get_response(_single_range_response_truncated)
 
736
        # Content-Range declares 100 but only 51 present
 
737
        self.assertRaises(errors.ShortReadvError, out.seek, out.tell() + 51)
 
738
 
629
739
    def test_multi_range(self):
630
740
        out = self.get_response(_multipart_range_response)
631
 
        self.assertIsInstance(out, response.HttpMultipartRangeResponse)
632
741
 
633
742
        # Just make sure we can read the right contents
634
743
        out.seek(0)
639
748
 
640
749
    def test_multi_squid_range(self):
641
750
        out = self.get_response(_multipart_squid_range_response)
642
 
        self.assertIsInstance(out, response.HttpMultipartRangeResponse)
643
751
 
644
752
        # Just make sure we can read the right contents
645
753
        out.seek(0)
650
758
 
651
759
    def test_invalid_response(self):
652
760
        self.assertRaises(errors.InvalidHttpResponse,
653
 
            self.get_response, _invalid_response)
 
761
                          self.get_response, _invalid_response)
654
762
 
655
763
    def test_full_text_no_content_type(self):
656
764
        # 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())
 
765
        code, raw_headers, body = _full_text_response_no_content_type
 
766
        msg = self._build_HTTPMessage(raw_headers)
 
767
        out = response.handle_response('http://foo', code, msg, StringIO(body))
 
768
        self.assertEqual(body, out.read())
663
769
 
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]))
 
770
    def test_full_text_no_content_length(self):
 
771
        code, raw_headers, body = _full_text_response_no_content_length
 
772
        msg = self._build_HTTPMessage(raw_headers)
 
773
        out = response.handle_response('http://foo', code, msg, StringIO(body))
 
774
        self.assertEqual(body, out.read())
672
775
 
673
776
    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]))
 
777
        code, raw_headers, body = _single_range_no_content_range
 
778
        msg = self._build_HTTPMessage(raw_headers)
 
779
        self.assertRaises(errors.InvalidHttpResponse,
 
780
                          response.handle_response,
 
781
                          'http://bogus', code, msg, StringIO(body))
 
782
 
 
783
    def test_multipart_no_content_range(self):
 
784
        code, raw_headers, body = _multipart_no_content_range
 
785
        msg = self._build_HTTPMessage(raw_headers)
 
786
        self.assertRaises(errors.InvalidHttpResponse,
 
787
                          response.handle_response,
 
788
                          'http://bogus', code, msg, StringIO(body))
 
789
 
 
790
    def test_multipart_no_boundary(self):
 
791
        out = self.get_response(_multipart_no_boundary)
 
792
        out.read()  # Read the whole range
 
793
        # Fail to find the boundary line
 
794
        self.assertRaises(errors.InvalidHttpResponse, out.seek, 1, 1)
 
795
 
 
796
 
 
797
class TestRangeFileSizeReadLimited(tests.TestCase):
 
798
    """Test RangeFile _max_read_size functionality which limits the size of
 
799
    read blocks to prevent MemoryError messages in socket.recv.
 
800
    """
 
801
 
 
802
    def setUp(self):
 
803
        tests.TestCase.setUp(self)
 
804
        # create a test datablock larger than _max_read_size.
 
805
        chunk_size = response.RangeFile._max_read_size
 
806
        test_pattern = '0123456789ABCDEF'
 
807
        self.test_data =  test_pattern * (3 * chunk_size / len(test_pattern))
 
808
        self.test_data_len = len(self.test_data)
 
809
 
 
810
    def test_max_read_size(self):
 
811
        """Read data in blocks and verify that the reads are not larger than
 
812
           the maximum read size.
 
813
        """
 
814
        # retrieve data in large blocks from response.RangeFile object
 
815
        mock_read_file = FakeReadFile(self.test_data)
 
816
        range_file = response.RangeFile('test_max_read_size', mock_read_file)
 
817
        response_data = range_file.read(self.test_data_len)
 
818
 
 
819
        # verify read size was equal to the maximum read size
 
820
        self.assertTrue(mock_read_file.get_max_read_size() > 0)
 
821
        self.assertEqual(mock_read_file.get_max_read_size(),
 
822
                         response.RangeFile._max_read_size)
 
823
        self.assertEqual(mock_read_file.get_read_count(), 3)
 
824
 
 
825
        # report error if the data wasn't equal (we only report the size due
 
826
        # to the length of the data)
 
827
        if response_data != self.test_data:
 
828
            message = "Data not equal.  Expected %d bytes, received %d."
 
829
            self.fail(message % (len(response_data), self.test_data_len))
 
830