~bzr-pqm/bzr/bzr.dev

« back to all changes in this revision

Viewing changes to bzrlib/tests/test_http_response.py

Merge the 0.17 fixes back into bzr.dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
# Copyright (C) 2006-2010 Canonical Ltd
 
1
# Copyright (C) 2005, 2006 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., 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.
 
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
38
186
"""
39
187
 
40
 
from cStringIO import StringIO
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
 
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)
254
251
        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)
440
 
        f.seek(0)
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')
 
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;')
472
303
 
473
304
 
474
305
# Taken from real request responses
486
317
""")
487
318
 
488
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
 
489
339
_single_range_response = (206, """HTTP/1.1 206 Partial Content\r
490
340
Date: Tue, 11 Jul 2006 04:45:22 GMT\r
491
341
Server: Apache/2.0.54 (Fedora)\r
564
414
--418470f848b63279b--\r
565
415
""")
566
416
 
567
 
 
568
417
_multipart_squid_range_response = (206, """HTTP/1.0 206 Partial Content\r
569
418
Date: Thu, 31 Aug 2006 21:16:22 GMT\r
570
419
Server: Apache/2.2.2 (Unix) DAV/2\r
597
446
""")
598
447
 
599
448
 
 
449
_redirect_response = (206, """HTTP/1.1 301 Moved Permanently\r
 
450
Date: Tue, 18 Jul 2006 20:29:22 GMT\r
 
451
Server: Apache/2.0.54 (Ubuntu) PHP/4.4.0-3ubuntu1 mod_ssl/2.0.54 OpenSSL/0.9.7g\r
 
452
Location: http://bazaar-vcs.org/bzr/bzr.dev/.bzr/repository/inventory.knit\r
 
453
Content-Length: 272\r
 
454
Keep-Alive: timeout=15, max=100\r
 
455
Connection: Keep-Alive\r
 
456
Content-Type: text/html; charset=iso-8859-1\r
 
457
\r
 
458
HTTP/1.1 206 Partial Content\r
 
459
Date: Tue, 18 Jul 2006 20:29:23 GMT\r
 
460
Server: Apache/2.0.54 (Ubuntu) PHP/4.4.0-3ubuntu1 mod_ssl/2.0.54 OpenSSL/0.9.7g\r
 
461
Last-Modified: Tue, 18 Jul 2006 20:24:59 GMT\r
 
462
ETag: "be8213-83958c-f0d3dcc0"\r
 
463
Accept-Ranges: bytes\r
 
464
Content-Length: 425\r
 
465
Content-Range: bytes 8623075-8623499/8623500\r
 
466
Keep-Alive: timeout=15, max=100\r
 
467
Connection: Keep-Alive\r
 
468
Content-Type: text/plain; charset=UTF-8\r
 
469
\r
 
470
""", """this data intentionally removed, 
 
471
this is not meant to be tested by
 
472
handle_response, just _extract_headers
 
473
""")
 
474
 
 
475
 
600
476
# 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
 
 
654
477
_invalid_response = (444, """HTTP/1.1 444 Bad Response\r
655
478
Date: Tue, 11 Jul 2006 04:32:56 GMT\r
656
479
Connection: close\r
667
490
""")
668
491
 
669
492
 
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
 
 
 
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
    
710
596
    def get_response(self, a_response):
711
597
        """Process a supplied response, and return the result."""
712
 
        code, raw_headers, body = a_response
713
 
        msg = self._build_HTTPMessage(raw_headers)
714
 
        return response.handle_response('http://foo', code, msg,
 
598
        headers = http._extract_headers(a_response[1], 'http://foo')
 
599
        return response.handle_response('http://foo', a_response[0], headers,
715
600
                                        StringIO(a_response[2]))
716
601
 
717
602
    def test_full_text(self):
719
604
        # It is a StringIO from the original data
720
605
        self.assertEqual(_full_text_response[2], out.read())
721
606
 
 
607
    def test_missing_response(self):
 
608
        self.assertRaises(errors.NoSuchFile,
 
609
            self.get_response, _missing_response)
 
610
 
722
611
    def test_single_range(self):
723
612
        out = self.get_response(_single_range_response)
 
613
        self.assertIsInstance(out, response.HttpRangeResponse)
 
614
 
 
615
        self.assertRaises(errors.InvalidRange, out.read, 20)
724
616
 
725
617
        out.seek(100)
726
618
        self.assertEqual(_single_range_response[2], out.read(100))
727
619
 
728
620
    def test_single_range_no_content(self):
729
621
        out = self.get_response(_single_range_no_content_type)
 
622
        self.assertIsInstance(out, response.HttpRangeResponse)
 
623
 
 
624
        self.assertRaises(errors.InvalidRange, out.read, 20)
730
625
 
731
626
        out.seek(100)
732
627
        self.assertEqual(_single_range_no_content_type[2], out.read(100))
733
628
 
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
 
 
739
629
    def test_multi_range(self):
740
630
        out = self.get_response(_multipart_range_response)
 
631
        self.assertIsInstance(out, response.HttpMultipartRangeResponse)
741
632
 
742
633
        # Just make sure we can read the right contents
743
634
        out.seek(0)
748
639
 
749
640
    def test_multi_squid_range(self):
750
641
        out = self.get_response(_multipart_squid_range_response)
 
642
        self.assertIsInstance(out, response.HttpMultipartRangeResponse)
751
643
 
752
644
        # Just make sure we can read the right contents
753
645
        out.seek(0)
758
650
 
759
651
    def test_invalid_response(self):
760
652
        self.assertRaises(errors.InvalidHttpResponse,
761
 
                          self.get_response, _invalid_response)
 
653
            self.get_response, _invalid_response)
762
654
 
763
655
    def test_full_text_no_content_type(self):
764
656
        # We should not require Content-Type for a full response
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())
 
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())
769
663
 
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())
 
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]))
775
672
 
776
673
    def test_missing_content_range(self):
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
 
 
 
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]))