use closed property, not _fp

tests/test_streaming.py

@@ -162,20 +162,15 @@ def on_read(chunk_size):
         # 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)
                 buf.read_line("\n")
         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)
 

tweepy/streaming.py

@@ -154,15 +154,15 @@ def __init__(self, stream, chunk_size):
         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))
             self._buffer += self._stream.read(read_len).decode("ascii")
 
     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))
@@ -292,9 +292,9 @@ def _data(self, data):
     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
@@ -334,7 +334,7 @@ def _read_loop(self, resp):
             #         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):