Rebase with master

Author: aklajnert

src/_pytest/capture.py

@@ -93,7 +93,7 @@ def _getcapture(self, method):
         if method == "fd":
             return MultiCapture(out=True, err=True, Capture=FDCapture)
         elif method == "sys":
-            return MultiCapture(out=True, err=True, Capture=SysCapture)
+            return MultiCapture(out=True, err=True, Capture=OrderedCapture)
         elif method == "no":
             return MultiCapture(out=False, err=False, in_=False)
         elif method == "tee-sys":
@@ -351,11 +351,13 @@ def close(self):
             self._capture.stop_capturing()
             self._capture = None
 
-    def readouterr(self):
+    def readouterr(self, combined=False):
         """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)
         captured_out, captured_err = self._captured_out, self._captured_err
         if self._capture is not None:
             out, err = self._capture.readouterr()
@@ -365,6 +367,13 @@ def readouterr(self):
         self._captured_err = self.captureclass.EMPTY_BUFFER
         return CaptureResult(captured_out, captured_err)
 
+    def _get_combined(self):
+        if self.captureclass is not OrderedCapture:
+            raise AttributeError("Only ordered capture is able to combine streams.")
+        result = "".join(line[0] for line in OrderedCapture.streams)
+        OrderedCapture.streams.clear()
+        return result
+
     def _suspend(self):
         """Suspends this fixture's own capturing temporarily."""
         if self._capture is not None:
@@ -630,12 +639,16 @@ def __init__(self, fd, tmpfile=None):
         name = patchsysdict[fd]
         self._old = getattr(sys, name)
         self.name = name
+        self.fd = fd
         if tmpfile is None:
             if name == "stdin":
                 tmpfile = DontReadFromInput()
             else:
-                tmpfile = CaptureIO()
+                tmpfile = self._get_writer()
         self.tmpfile = tmpfile
+        
+    def _get_writer(self):
+        return CaptureIO()
 
     def __repr__(self):
         return "<{} {} _old={} _state={!r} tmpfile={!r}>".format(
@@ -698,14 +711,80 @@ def __init__(self, fd, tmpfile=None):
         self.tmpfile = tmpfile
 
 
+
+class OrderedCapture(SysCapture):
+    """This class uses deque to keep streams in order."""
+    streams = collections.deque()
+
+    def _get_writer(self):
+        return OrderedWriter(self.fd)
+
+    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()
+        return res
+
 map_fixname_class = {
     "capfd": FDCapture,
     "capfdbinary": FDCaptureBinary,
-    "capsys": SysCapture,
+    "capsys": OrderedCapture,
     "capsysbinary": SysCaptureBinary,
 }
 
 
+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()
+
+
+class OrderedCapture(SysCapture):
+    """This class uses deque to keep streams in order."""
+    streams = collections.deque()
+
+    def _get_writer(self):
+        return OrderedWriter(self.fd)
+
+    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()
+        return res
+
+
+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()
+
+
 class DontReadFromInput:
     encoding = None
 

testing/test_capture.py

@@ -1563,3 +1563,27 @@ def test_encodedfile_writelines(tmpfile: BinaryIO) -> None:
     tmpfile.close()
     with pytest.raises(ValueError):
         ef.read()
+
+def test_combined_streams(capsys):
+    """Show that capsys is capable of preserving chronological order of streams."""
+    print("stdout1")
+    print("stdout2")
+    print("stderr1", file=sys.stderr)
+    print("stdout3")
+    print("stderr2", file=sys.stderr)
+    print("stderr3", file=sys.stderr)
+    print("stdout4")
+    print("stdout5")
+
+    out, err = capsys.readouterr(combined=True)
+    assert (
+        out == "stdout1\n"
+        "stdout2\n"
+        "stderr1\n"
+        "stdout3\n"
+        "stderr2\n"
+        "stderr3\n"
+        "stdout4\n"
+        "stdout5\n"
+    )
+    assert err is None