def _make_request(self, *args, **kwargs):
httplib_response = httplib.HTTPResponse(MockSock)
httplib_response.fp = MockChunkedEncodingResponse(
[b"f", b"o", b"o"])
httplib_response.headers = httplib_response.msg = HTTPHeaderDict(
)
return httplib_response
def test_io(self):
fp = BytesIO(b'foo')
resp = HTTPResponse(fp, preload_content=False)
self.assertEqual(resp.closed, False)
self.assertEqual(resp.readable(), True)
self.assertEqual(resp.writable(), False)
self.assertRaises(IOError, resp.fileno)
resp.close()
self.assertEqual(resp.closed, True)
# Try closing with an `httplib.HTTPResponse`, because it has an
# `isclosed` method.
sock = socket.socket()
self.addCleanup(sock.close)
hlr = httplib.HTTPResponse(sock)
self.addCleanup(hlr.close)
resp2 = HTTPResponse(hlr, preload_content=False)
self.assertEqual(resp2.closed, False)
resp2.close()
self.assertEqual(resp2.closed, True)
# also try when only data is present.
resp3 = HTTPResponse('foodata')
self.assertRaises(IOError, resp3.fileno)
resp3._fp = 2
# A corner case where _fp is present but doesn't have `closed`,
# `isclosed`, or `fileno`. Unlikely, but possible.
self.assertEqual(resp3.closed, True)
self.assertRaises(IOError, resp3.fileno)
def test_io(self, sock):
fp = BytesIO(b"foo")
resp = HTTPResponse(fp, preload_content=False)
assert not resp.closed
assert resp.readable()
assert not resp.writable()
with pytest.raises(IOError):
resp.fileno()
resp.close()
assert resp.closed
# Try closing with an `httplib.HTTPResponse`, because it has an
# `isclosed` method.
try:
hlr = httplib.HTTPResponse(sock)
resp2 = HTTPResponse(hlr, preload_content=False)
assert not resp2.closed
resp2.close()
assert resp2.closed
finally:
hlr.close()
# also try when only data is present.
resp3 = HTTPResponse("foodata")
with pytest.raises(IOError):
resp3.fileno()
resp3._fp = 2
# A corner case where _fp is present but doesn't have `closed`,
# `isclosed`, or `fileno`. Unlikely, but possible.
assert resp3.closed
with pytest.raises(IOError):
resp3.fileno()
def __call__(self, *args, **kwargs):
if self._ex:
ex, self._ex = self._ex, None
raise ex()
response = httplib.HTTPResponse(MockSock)
response.fp = MockChunkedEncodingResponse([b"f", b"o", b"o"])
response.headers = response.msg = HTTPHeaderDict()
return response
def test_invalid_chunks(self):
stream = [b"foooo", b"bbbbaaaaar"]
fp = MockChunkedInvalidEncoding(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(r, preload_content=False, headers={'transfer-encoding': 'chunked'})
self.assertRaises(ProtocolError, next, resp.read_chunked())
def test_chunked_response_with_extensions(self):
stream = [b"foo", b"bar"]
fp = MockChunkedEncodingWithExtensions(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(r, preload_content=False, headers={'transfer-encoding': 'chunked'})
assert stream == list(resp.stream())
def test_mock_transfer_encoding_chunked_unlmtd_read(self):
stream = [b"foooo", b"bbbbaaaaar"]
fp = MockChunkedEncodingResponse(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(r, preload_content=False, headers={'transfer-encoding': 'chunked'})
assert stream == list(resp.read_chunked())
def test_mock_transfer_encoding_chunked(self):
stream = [b"fo", b"o", b"bar"]
fp = MockChunkedEncodingResponse(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
resp = HTTPResponse(r, preload_content=False, headers={'transfer-encoding': 'chunked'})
for i, c in enumerate(resp.stream()):
assert c == stream[i]
def test_mock_transfer_encoding_chunked_custom_read(self):
stream = [b"foooo", b"bbbbaaaaar"]
fp = MockChunkedEncodingResponse(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(r, preload_content=False, headers={'transfer-encoding': 'chunked'})
expected_response = [b'fo', b'oo', b'o', b'bb', b'bb', b'aa', b'aa', b'ar']
response = list(resp.read_chunked(2))
assert expected_response == response
def test_chunked_response_without_crlf_on_end(self):
stream = [b"foo", b"bar", b"baz"]
fp = MockChunkedEncodingWithoutCRLFOnEnd(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(
r, preload_content=False, headers={"transfer-encoding": "chunked"}
)
assert stream == list(resp.stream())
def test_mock_transfer_encoding_chunked(self):
stream = [b"fo", b"o", b"bar"]
fp = MockChunkedEncodingResponse(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
resp = HTTPResponse(r, preload_content=False, headers={'transfer-encoding': 'chunked'})
i = 0
for c in resp.stream():
self.assertEqual(c, stream[i])
i += 1
def test_invalid_chunks(self):
stream = [b"foooo", b"bbbbaaaaar"]
fp = MockChunkedInvalidEncoding(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(
r, preload_content=False, headers={"transfer-encoding": "chunked"}
)
with pytest.raises(ProtocolError):
next(resp.read_chunked())
def test_chunked_response_with_extensions(self):
stream = [b"foo", b"bar"]
fp = MockChunkedEncodingWithExtensions(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(r, preload_content=False, headers={'transfer-encoding': 'chunked'})
if getattr(self, "assertListEqual", False):
self.assertListEqual(stream, list(resp.stream()))
else:
for index, item in enumerate(resp.stream()):
v = stream[index]
self.assertEqual(item, v)
def test_io_closed_consistently(self):
hlr = httplib.HTTPResponse(socket.socket())
hlr.fp = BytesIO(b'foo')
hlr.chunked = 0
hlr.length = 3
resp = HTTPResponse(hlr, preload_content=False)
self.assertEqual(resp.closed, False)
self.assertEqual(resp._fp.isclosed(), False)
self.assertEqual(is_fp_closed(resp._fp), False)
resp.read()
self.assertEqual(resp.closed, True)
self.assertEqual(resp._fp.isclosed(), True)
self.assertEqual(is_fp_closed(resp._fp), True)
def test_chunked_head_response(self):
r = httplib.HTTPResponse(MockSock, method='HEAD')
r.chunked = True
r.chunk_left = None
resp = HTTPResponse('',
preload_content=False,
headers={'transfer-encoding': 'chunked'},
original_response=r)
assert resp.chunked is True
resp.supports_chunked_reads = lambda: True
resp.release_conn = mock.Mock()
for _ in resp.stream():
continue
resp.release_conn.assert_called_once_with()
def test_incomplete_chunk(self):
stream = [b"foooo", b"bbbbaaaaar"]
fp = MockChunkedIncompleteRead(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(r,
preload_content=False,
headers={"transfer-encoding": "chunked"})
with pytest.raises(ProtocolError) as ctx:
next(resp.read_chunked())
orig_ex = ctx.value.args[1]
assert isinstance(orig_ex, httplib_IncompleteRead)
def test_io_closed_consistently(self, sock):
try:
hlr = httplib.HTTPResponse(sock)
hlr.fp = BytesIO(b'foo')
hlr.chunked = 0
hlr.length = 3
with HTTPResponse(hlr, preload_content=False) as resp:
assert not resp.closed
assert not resp._fp.isclosed()
assert not is_fp_closed(resp._fp)
resp.read()
assert resp.closed
assert resp._fp.isclosed()
assert is_fp_closed(resp._fp)
finally:
hlr.close()
def test_invalid_chunk_length(self):
stream = [b"foooo", b"bbbbaaaaar"]
fp = MockChunkedInvalidChunkLength(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(r,
preload_content=False,
headers={"transfer-encoding": "chunked"})
with pytest.raises(ProtocolError) as ctx:
next(resp.read_chunked())
orig_ex = ctx.value.args[1]
assert isinstance(orig_ex, InvalidChunkLength)
assert orig_ex.length == six.b(fp.BAD_LENGTH_LINE)
def test_mock_transfer_encoding_chunked_custom_read(self):
stream = [b"foooo", b"bbbbaaaaar"]
fp = MockChunkedEncodingResponse(stream)
r = httplib.HTTPResponse(MockSock)
r.fp = fp
r.chunked = True
r.chunk_left = None
resp = HTTPResponse(r, preload_content=False, headers={'transfer-encoding': 'chunked'})
expected_response = [b'fo', b'oo', b'o', b'bb', b'bb', b'aa', b'aa', b'ar']
response = list(resp.read_chunked(2))
if getattr(self, "assertListEqual", False):
self.assertListEqual(expected_response, response)
else:
for index, item in enumerate(response):
v = expected_response[index]
self.assertEqual(item, v)
def test__iter__decode_content(self):
def stream():
# Set up a generator to chunk the gzipped body
compress = zlib.compressobj(6, zlib.DEFLATED, 16 + zlib.MAX_WBITS)
data = compress.compress(b"foo\nbar")
data += compress.flush()
for i in range(0, len(data), 2):
yield data[i : i + 2]
fp = MockChunkedEncodingResponse(list(stream()))
r = httplib.HTTPResponse(MockSock)
r.fp = fp
headers = {"transfer-encoding": "chunked", "content-encoding": "gzip"}
resp = HTTPResponse(r, preload_content=False, headers=headers)
data = b""
for c in resp:
data += c
assert b"foo\nbar" == data
def test_mock_gzipped_transfer_encoding_chunked_decoded(self):
"""Show that we can decode the gizpped and chunked body."""
def stream():
# Set up a generator to chunk the gzipped body
compress = zlib.compressobj(6, zlib.DEFLATED, 16 + zlib.MAX_WBITS)
data = compress.compress(b'foobar')
data += compress.flush()
for i in range(0, len(data), 2):
yield data[i:i + 2]
fp = MockChunkedEncodingResponse(list(stream()))
r = httplib.HTTPResponse(MockSock)
r.fp = fp
headers = {'transfer-encoding': 'chunked', 'content-encoding': 'gzip'}
resp = HTTPResponse(r, preload_content=False, headers=headers)
data = b''
for c in resp.stream(decode_content=True):
data += c
assert b'foobar' == data
