# Mock it's read function so it can't be called too many times
mock_read = MagicMock(side_effect=on_read)
- # Add an _fp member to it, like a real requests.raw stream
- mock_fp = MagicMock()
- mock_fp.isclosed.return_value = True
-
try:
- with patch.multiple(stream, read=mock_read, _fp=mock_fp, create=True):
+ with patch.multiple(stream, create=True, read=mock_read, closed=True):
# Now the stream can't call 'read' more than call_limit times
# and it looks like a requests stream that is closed
buf = ReadBuffer(stream, 50)
except InfiniteLoopException:
self.fail("ReadBuffer.read_line tried to loop infinitely.")
- self.assertEqual(mock_fp.isclosed.call_count, 1)
# The mocked function not have been called at all since the stream looks closed
self.assertEqual(mock_read.call_count, 0)
self._chunk_size = chunk_size
def read_len(self, length):
- while not self._stream._fp.isclosed():
+ while not self._stream.closed:
if len(self._buffer) >= length:
return self._pop(length)
read_len = max(self._chunk_size, length - len(self._buffer))
def read_line(self, sep='\n'):
start = 0
- while not self._stream._fp.isclosed():
+ while not self._stream.closed:
loc = self._buffer.find(sep, start)
if loc >= 0:
return self._pop(loc + len(sep))
def _read_loop(self, resp):
buf = ReadBuffer(resp.raw, self.chunk_size)
- while self.running and not resp.raw._fp.isclosed():
+ while self.running and not resp.raw.closed:
length = 0
- while not resp.raw._fp.isclosed():
+ while not resp.raw.closed:
line = buf.read_line().strip()
if not line:
self.listener.keep_alive() # keep-alive new lines are expected
# self._data(next_status_obj.decode('utf-8'))
- if resp.raw._fp.isclosed():
+ if resp.raw.closed:
self.on_closed(resp)
def _start(self, async):