Allow to read streams without flushing

Author: aklajnert

src/_pytest/capture.py

@@ -351,13 +351,17 @@ def close(self):
             self._capture.stop_capturing()
             self._capture = None
 
-    def readouterr(self, combined=False):
+    def readouterr(self, combined=False, flush=True):
         """Read and return the captured output so far, resetting the internal buffer.
 
         :return: captured content as a namedtuple with ``out`` and ``err`` string attributes
         """
         if combined:
             return CaptureResult(self._get_combined(), None)
+        if flush is False:
+            if self.captureclass is not OrderedCapture:
+                raise AttributeError("Only capsys can read streams without flushing.")
+            OrderedCapture.set_flush(False)
         captured_out, captured_err = self._captured_out, self._captured_err
         if self._capture is not None:
             out, err = self._capture.readouterr()
@@ -369,9 +373,9 @@ def readouterr(self, combined=False):
 
     def _get_combined(self):
         if self.captureclass is not OrderedCapture:
-            raise AttributeError("Only ordered capture is able to combine streams.")
+            raise AttributeError("Only capsys is able to combine streams.")
         result = "".join(line[0] for line in OrderedCapture.streams)
-        OrderedCapture.streams.clear()
+        OrderedCapture.flush()
         return result
 
     def _suspend(self):
@@ -713,8 +717,9 @@ def __init__(self, fd, tmpfile=None):
 
 
 class OrderedCapture(SysCapture):
-    """This class uses deque to keep streams in order."""
+    """Capture class that keeps streams in order."""
     streams = collections.deque()
+    _flush = True
 
     def _get_writer(self):
         return OrderedWriter(self.fd)
@@ -723,9 +728,26 @@ def snap(self):
         res = self.tmpfile.getvalue()
         if self.name == "stderr":
             # both streams are being read one after another, while stderr is last - it will clear the queue
-            self.streams.clear()
+            self.flush()
         return res
-
+    
+    @classmethod
+    def set_flush(cls, flush: bool) -> None:
+        cls._flush = flush
+        
+    @classmethod
+    def flush(cls) -> None:
+        """Clear streams. """
+        if cls._flush is False:
+            cls.set_flush(True)
+        else:
+            cls.streams.clear()
+            
+    @classmethod
+    def close(cls) -> None:
+        cls.set_flush(True)
+        cls.flush()
+        
 map_fixname_class = {
     "capfd": FDCapture,
     "capfdbinary": FDCaptureBinary,
@@ -749,25 +771,7 @@ def getvalue(self):
         return "".join((line[0] for line in OrderedCapture.streams if line[1] == self._fd))
 
     def close(self):
-        OrderedCapture.streams.clear()
-
-
-class OrderedWriter:
-    encoding = sys.getdefaultencoding()
-
-    def __init__(self, fd: int) -> None:
-        super().__init__()
-        self._fd = fd  # type: int
-
-    def write(self, text, **kwargs):
-        OrderedCapture.streams.append((text, self._fd))
-        return len(text)
-
-    def getvalue(self):
-        return "".join((line[0] for line in OrderedCapture.streams if line[1] == self._fd))
-
-    def close(self):
-        OrderedCapture.streams.clear()
+        OrderedCapture.close()
 
 
 class DontReadFromInput:

testing/test_capture.py

@@ -1575,6 +1575,13 @@ def test_combined_streams(capsys):
     print("stdout4")
     print("stdout5")
 
+    # this won't clear streams
+    out, err = capsys.readouterr(flush=False)
+    assert "stdout1" in out
+    assert "stdout1" not in err
+    assert "stderr1" in err
+    assert "stderr1" not in out
+
     out, err = capsys.readouterr(combined=True)
     assert (
         out == "stdout1\n"