pytester: testdir: add makefiles helper

This is a sane method to create a set of files, allowing for absolute
paths.

Ref: pytest-dev#6578
Ref: pytest-dev#6579

Author: blueyed

changelog/6603.feature.rst

@@ -0,0 +1 @@
+Add :py:func:`~_pytest.pytester.Testdir.makefiles` helper to :ref:`testdir`, which allows to more easily create files with absolute paths.

src/_pytest/pytester.py

@@ -8,6 +8,7 @@
 import shlex
 import subprocess
 import sys
+import textwrap
 import time
 import traceback
 from fnmatch import fnmatch
@@ -741,6 +742,32 @@ def maketxtfile(self, *args, **kwargs):
         """Shortcut for .makefile() with a .txt extension."""
         return self._makefile(".txt", args, kwargs)
 
+    def makefiles(
+        self, files: Dict[str, str], allow_outside_tmpdir=False
+    ) -> List[Path]:
+        """Create the given set of files.
+
+        Unlike other helpers like :func:`makepyfile` this allows to specify
+        absolute paths, which need to be below :attr:`tmpdir` by default
+        (use `allow_outside_tmpdir` to write arbitrary files).
+        """
+        paths = []
+        if allow_outside_tmpdir:
+            validated_files = tuple((Path(k), v) for k, v in files.items())
+        else:
+            tmpdir_path = Path(self.tmpdir)
+            validated_files = tuple(
+                (Path(k).absolute().relative_to(tmpdir_path), v)
+                for k, v in files.items()
+            )
+
+        for fpath, content in validated_files:
+            path = Path(self.tmpdir).joinpath(fpath)
+            with open(str(path), "w") as fp:
+                fp.write(textwrap.dedent(content))
+            paths.append(path)
+        return paths
+
     def syspathinsert(self, path=None):
         """Prepend a directory to sys.path, defaults to :py:attr:`tmpdir`.
 

testing/test_pytester.py

@@ -1,7 +1,11 @@
+import builtins
 import os
+import re
 import subprocess
 import sys
 import time
+from collections import OrderedDict
+from contextlib import contextmanager
 from typing import List
 
 import py.path
@@ -10,6 +14,7 @@
 import pytest
 from _pytest.config import ExitCode
 from _pytest.config import PytestPluginManager
+from _pytest.pathlib import Path
 from _pytest.pytester import CwdSnapshot
 from _pytest.pytester import HookRecorder
 from _pytest.pytester import LineMatcher
@@ -1215,3 +1220,53 @@ def pytest_collect_file(path, parent):
             "=* 1 failed in *",
         ]
     )
+
+
+def test_testdir_makefiles(testdir: Testdir, monkeypatch: MonkeyPatch) -> None:
+    tmpdir = testdir.tmpdir
+
+    abspath = str(tmpdir / "bar")
+    created_paths = testdir.makefiles(OrderedDict({"foo": "", abspath: ""}))
+    p1 = created_paths[0]
+    assert isinstance(p1, Path)
+    relpath = tmpdir / "foo"
+    assert str(p1) == str(relpath)
+
+    p2 = created_paths[1]
+    assert p2.exists()
+    assert str(p2) == abspath
+
+    assert testdir.makefiles({}) == []
+
+    # Disallows creation outside of tmpdir by default.
+    with pytest.raises(
+        ValueError,
+        match="'/abspath' does not start with '{}'".format(re.escape(str(tmpdir))),
+    ):
+        testdir.makefiles({"shouldnotbecreated": "", "/abspath": ""})
+    # Validation before creating anything.
+    assert not Path("shouldnotbecreated").exists()
+
+    # Support writing arbitrary files on request.
+    open_calls = []
+    orig_open = builtins.open
+
+    @contextmanager
+    def mocked_open(*args):
+        open_calls.append(["__enter__", args])
+        with orig_open(os.devnull, *args[1:]) as fp:
+            yield fp
+
+    with monkeypatch.context() as mp:
+        mp.setattr(builtins, "open", mocked_open)
+        created_paths = testdir.makefiles({"/abspath": ""}, allow_outside_tmpdir=True)
+    assert created_paths == [Path("/abspath")]
+    assert open_calls == [["__enter__", ("/abspath", "w")]]
+
+    # Duplicated files (absolute and relative).
+    created_paths = testdir.makefiles(OrderedDict({"bar": "1", abspath: "2"}))
+    with open("bar", "r") as fp:
+        assert fp.read() == "2"
+    created_paths = testdir.makefiles(OrderedDict({abspath: "2", "bar": "1"}))
+    with open("bar", "r") as fp:
+        assert fp.read() == "1"