monkeyfs 0.2.0__tar.gz → 0.2.2__tar.gz

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monkeyfs
-Version: 0.2.0
+Version: 0.2.2
 Summary: Transparent filesystem interception via monkey-patching.
 Author: ashenfad
 License-Expression: MIT

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/monkeyfs/base.py

@@ -83,7 +83,11 @@ class FileInfo:
 
     Attributes:
         name: File or directory name (basename).
-        path: Full path to file or directory.
+        path: The queried directory joined with the entry's path relative to
+            it, so list_detailed("/src", recursive=True) names
+            "/src/lib/util.py" and list_detailed("src", recursive=True) names
+            "src/lib/util.py". An absolute query therefore answers in this
+            filesystem's own absolute paths, never in a host's.
         size: File size in bytes (0 for directories).
         created_at: ISO 8601 timestamp when created (UTC).
         modified_at: ISO 8601 timestamp when last modified (UTC).
@@ -266,11 +270,11 @@ class FileSystem(Protocol):
         ...
 
     def mkdir(self, path: str, parents: bool = False, exist_ok: bool = False) -> None:
-        """Create a directory."""
+        """Create a directory; raise FileExistsError unless exist_ok."""
         ...
 
     def makedirs(self, path: str, exist_ok: bool = True) -> None:
-        """Create directory tree."""
+        """Create directory tree; raise FileExistsError unless exist_ok."""
         ...
 
     def rename(self, src: str, dst: str) -> None:

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/monkeyfs/conformance.py

@@ -8,13 +8,14 @@ nothing else -- not a test harness, not the library on the other side of the
 protocol.
 
 What it checks, in order: the required methods exist; directories,
-``getcwd``/``chdir`` and relative resolution behave; a file written comes
-back through ``stat()``, ``list()`` and ``read()``; the ranged read means
-what it says, including the cases a backend that quietly ignores ``offset``
-and ``size`` would fail; ``open()`` round-trips bytes and text, through the
-backend's own if it has one and through the synthesized one under ``patch()``
-if it does not; and ``rename``/``remove`` leave the filesystem as they found
-it.
+``getcwd``/``chdir`` and relative resolution behave, ``exist_ok`` included;
+a file written comes back through ``stat()``, ``list()`` and ``read()``;
+``list_detailed()`` names each entry in the namespace it was asked in; the
+ranged read means what it says, including the cases a backend that quietly
+ignores ``offset`` and ``size`` would fail; ``open()`` round-trips bytes and
+text, through the backend's own if it has one and through the synthesized one
+under ``patch()`` if it does not; and ``rename``/``remove`` leave the
+filesystem as they found it.
 
 Usage::
 
@@ -76,6 +77,7 @@ def check_filesystem(fs: Any, scratch: str = SCRATCH) -> None:
         path = f"{scratch}/probe.bin"
         _write(fs, path, CONTENT)
         _check_file_metadata(fs, scratch, path)
+        _check_listing_paths(fs, scratch)
         _check_ranged_read(fs, path)
         _check_open(fs, scratch, path)
         _check_rename_and_remove(fs, scratch, path)
@@ -127,6 +129,8 @@ def _check_directories(fs: Any, scratch: str) -> None:
         f"{fs.list(scratch)!r} -- names, not paths",
     )
 
+    _check_exist_ok(fs, scratch, nested)
+
     missing = f"{scratch}/not-there"
     _require(
         not fs.exists(missing) and not fs.isfile(missing) and not fs.isdir(missing),
@@ -134,6 +138,112 @@ def _check_directories(fs: Any, scratch: str) -> None:
     )
 
 
+def _check_exist_ok(fs: Any, scratch: str, nested: str) -> None:
+    """A directory that is already there is an error unless asked to be fine.
+
+    ``exist_ok`` is the only thing that makes creating an existing directory
+    succeed, and a caller reaches for False precisely to be told. A backend
+    that returns silently instead hands that caller the answer it asked to
+    be spared.
+    """
+    fs.makedirs(scratch)
+    _require(
+        fs.isdir(scratch),
+        f"makedirs({scratch!r}) on a directory that already exists must be "
+        f"silent -- exist_ok defaults to True -- and must leave it a directory",
+    )
+
+    cases = [
+        (
+            lambda: fs.makedirs(scratch, exist_ok=False),
+            f"makedirs({scratch!r}, exist_ok=False) on an existing directory "
+            f"must raise FileExistsError",
+        ),
+        (
+            lambda: fs.mkdir(nested),
+            f"mkdir({nested!r}) on an existing directory must raise "
+            f"FileExistsError -- exist_ok defaults to False",
+        ),
+        (
+            lambda: fs.mkdir(nested, parents=True, exist_ok=False),
+            f"mkdir({nested!r}, parents=True, exist_ok=False) on an existing "
+            f"directory must raise FileExistsError: parents says how to build "
+            f"the tree, not whether the end of it may already be there",
+        ),
+    ]
+    for call, message in cases:
+        try:
+            call()
+        except FileExistsError:
+            continue
+        except Exception as error:  # noqa: BLE001 - reported as the failure
+            raise AssertionError(
+                f"{message}, not {type(error).__name__} ({error})"
+            ) from error
+        raise AssertionError(f"{message}, rather than returning silently")
+
+    fs.mkdir(nested, exist_ok=True)
+    _require(
+        fs.isdir(nested),
+        f"mkdir({nested!r}, exist_ok=True) on an existing directory must be "
+        f"silent and must leave it a directory",
+    )
+
+
+def _check_listing_paths(fs: Any, scratch: str) -> None:
+    """``FileInfo.path``: the directory as queried, joined with the entry.
+
+    Listing ``"/src"`` names ``"/src/lib/util.py"`` and listing ``"src"``
+    names ``"src/lib/util.py"``, so a path that comes out of a listing goes
+    back in, and an absolute query never answers in anything but this
+    filesystem's own absolute paths.
+    """
+    if not _has(fs, "list_detailed"):
+        return
+
+    leaf = f"{scratch}/nested/leaf.bin"
+    _write(fs, leaf, b"leaf")
+    try:
+        absolute = {info.name: info.path for info in fs.list_detailed(scratch)}
+        _require(
+            absolute.get("probe.bin") == f"{scratch}/probe.bin",
+            f"list_detailed({scratch!r})[...].path must be the queried "
+            f"directory joined with the entry, {scratch + '/probe.bin'!r}, got "
+            f"{absolute.get('probe.bin')!r}",
+        )
+
+        entries = fs.list_detailed(scratch, True)
+        deep = [info.path for info in entries]
+        _require(
+            f"{scratch}/nested/leaf.bin" in deep,
+            f"a recursive list_detailed({scratch!r}) must name a nested entry "
+            f"{scratch + '/nested/leaf.bin'!r}, got {deep!r}",
+        )
+        for info in entries:
+            _require(
+                info.name == info.path.rsplit("/", 1)[-1],
+                f"list_detailed(...).name is the entry's own name, the last "
+                f"component of its path, at every depth: for path "
+                f"{info.path!r} expected {info.path.rsplit('/', 1)[-1]!r}, "
+                f"got {info.name!r}",
+            )
+
+        start = fs.getcwd()
+        fs.chdir(scratch)
+        try:
+            relative = [info.path for info in fs.list_detailed("nested")]
+            _require(
+                relative == ["nested/leaf.bin"],
+                f"list_detailed('nested') must answer in the namespace it was "
+                f"asked in: a relative query gives paths relative to the same "
+                f"place, ['nested/leaf.bin'], got {relative!r}",
+            )
+        finally:
+            fs.chdir(start)
+    finally:
+        fs.remove(leaf)
+
+
 def _check_working_directory(fs: Any, scratch: str) -> None:
     start = fs.getcwd()
     _require(

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/monkeyfs/isolated.py

@@ -570,6 +570,14 @@ class IsolatedFS:
     def list_detailed(self, path: str = ".", recursive: bool = False) -> list[FileInfo]:
         """List directory with detailed file information.
 
+        Each ``FileInfo.path`` is the directory as it was asked for, joined
+        with the entry's path relative to it: listing ``"/src"`` names
+        ``"/src/lib/util.py"`` and listing ``"src"`` names ``"src/lib/util.py"``.
+        So an absolute query answers in absolute paths and a relative one
+        answers relative to the same place the caller named, and neither ever
+        carries the host location of the root -- what comes back is a path
+        this filesystem accepts back.
+
         Args:
             path: Directory path to list.
             recursive: If True, list all nested items.
@@ -582,15 +590,17 @@ class IsolatedFS:
 
             result = []
             items = resolved.rglob("*") if recursive else resolved.iterdir()
+            prefix = path.rstrip("/")
 
             for item in items:
-                rel_path = str(item.relative_to(self.root))
+                relative = item.relative_to(resolved).as_posix()
+                display = f"{prefix}/{relative}" if prefix != "." else relative
                 stat_info = item.stat()
 
                 result.append(
                     FileInfo(
                         name=item.name,
-                        path=rel_path,
+                        path=display,
                         is_dir=item.is_dir(),
                         size=stat_info.st_size if item.is_file() else 0,
                         created_at=datetime.fromtimestamp(

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/monkeyfs/mount.py

@@ -285,10 +285,11 @@ class MountFS:
         for name in names:
             full_abs = f"{norm}/{name}" if norm else f"/{name}"
             display = f"{user_prefix}/{name}" if user_prefix != "." else name
+            basename = name.rsplit("/", 1)[-1]
             meta = self.stat(full_abs)
             result.append(
                 FileInfo(
-                    name=name,
+                    name=basename,
                     path=display,
                     size=meta.size,
                     created_at=meta.created_at,

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/monkeyfs/virtual.py

@@ -1027,7 +1027,10 @@ class VirtualFS:
             parents: If True, create parent directories as needed.
 
         Raises:
-            FileExistsError: If path exists (as file or dir when exist_ok=False).
+            FileExistsError: If path exists, as a file or -- unless exist_ok
+                is True -- as a directory. Any path isdir() reports True for
+                exists, including a directory that is there only because a
+                file path passes through it.
             FileNotFoundError: If parent doesn't exist and parents=False.
         """
         if parents:
@@ -1043,12 +1046,13 @@ class VirtualFS:
             raise FileNotFoundError(f"No such file or directory: '{path}'")
 
         # Check if already exists
+        absolute = "/" + normalized
         if self.isfile(path):
-            raise FileExistsError(f"File exists: {path}")
+            raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
         if self.isdir(path):
             if exist_ok:
                 return
-            raise FileExistsError(f"Directory exists: {path}")
+            raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
 
         # Create the directory's own row (implicit directories have none)
         now = datetime.now(timezone.utc).isoformat()
@@ -1061,23 +1065,33 @@ class VirtualFS:
     def makedirs(self, path: str, exist_ok: bool = True) -> None:
         """Create directory tree.
 
-        Creates all parent directories as needed.
+        Creates all parent directories as needed. With ``exist_ok`` False the
+        directory must not already be there: anything ``isdir()`` reports True
+        for counts as there, whether it was created by ``mkdir()`` or exists
+        only because a file path passes through it. A caller cannot tell the
+        two apart through this interface, so neither does the check.
 
         Args:
             path: Directory path.
             exist_ok: If True, don't raise if directory exists.
 
         Raises:
-            FileExistsError: If path exists as a file.
+            FileExistsError: If path exists as a file, or if it exists as a
+                directory and exist_ok is False.
         """
         path = self.resolve_path(path)
+
+        if not exist_ok and self.isdir(path):
+            absolute = "/" + path.strip("/")
+            raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
+
         parts = path.strip("/").split("/")
 
         # Create each parent directory
         for i in range(len(parts)):
             dir_path = "/" + "/".join(parts[: i + 1])
             if self.isfile(dir_path):
-                raise FileExistsError(f"File exists: {dir_path}")
+                raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), dir_path)
             if not self.isdir(dir_path):
                 self.mkdir(dir_path, exist_ok=True)
 
@@ -1311,7 +1325,10 @@ class VirtualFS:
             recursive: If True, list all nested files and directories.
 
         Returns:
-            List of FileInfo objects sorted by name.
+            List of FileInfo objects sorted by path relative to the queried
+            directory, so a directory precedes its contents. ``name`` is the
+            entry's own name, the last component of ``path``, at every depth;
+            it is not what the list is ordered by.
 
         Example:
             >>> files = vfs.list_detailed("/shared")
@@ -1336,7 +1353,9 @@ class VirtualFS:
             internal_path = f"{base}/{name}" if base else name
             absolute = "/" + internal_path
 
-            # Display path preserves the user's queried prefix
+            # Display path preserves the user's queried prefix; the name
+            # is the last component alone, whatever depth the entry sits at.
+            basename = name.rsplit("/", 1)[-1]
             display = f"{user_prefix}/{name}" if user_prefix != "." else name
 
             meta = self._meta_at(internal_path)
@@ -1346,7 +1365,7 @@ class VirtualFS:
                 now = self._now_iso()
                 result.append(
                     FileInfo(
-                        name=name,
+                        name=basename,
                         path=display,
                         size=0,
                         created_at=meta.created_at if meta is not None else now,
@@ -1357,7 +1376,7 @@ class VirtualFS:
             elif meta is not None:
                 result.append(
                     FileInfo(
-                        name=name,
+                        name=basename,
                         path=display,
                         size=meta.size,
                         created_at=meta.created_at,
@@ -1371,7 +1390,7 @@ class VirtualFS:
                 now = self._now_iso()
                 result.append(
                     FileInfo(
-                        name=name,
+                        name=basename,
                         path=display,
                         size=len(content),
                         created_at=now,

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/monkeyfs.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: monkeyfs
-Version: 0.2.0
+Version: 0.2.2
 Summary: Transparent filesystem interception via monkey-patching.
 Author: ashenfad
 License-Expression: MIT

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "monkeyfs"
-version = "0.2.0"
+version = "0.2.2"
 description = "Transparent filesystem interception via monkey-patching."
 readme = "README.md"
 license = "MIT"

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/tests/test_conformance.py

@@ -105,6 +105,53 @@ class TestBackendsThatShouldFail:
         with pytest.raises(AssertionError, match="FileNotFoundError"):
             check_filesystem(ForgivingRemove({}))
 
+    def test_a_makedirs_that_forgives_an_existing_directory(self):
+        class ForgivingMakedirs(VirtualFS):
+            def makedirs(self, path, exist_ok=True):
+                super().makedirs(path, exist_ok=True)
+
+        with pytest.raises(AssertionError, match="exist_ok=False"):
+            check_filesystem(ForgivingMakedirs({}))
+
+    def test_a_mkdir_that_forgives_an_existing_directory(self):
+        class ForgivingMkdir(VirtualFS):
+            def mkdir(self, path, parents=False, exist_ok=False):
+                super().mkdir(path, parents=parents, exist_ok=True)
+
+        with pytest.raises(AssertionError, match="FileExistsError"):
+            check_filesystem(ForgivingMkdir({}))
+
+    def test_a_mkdir_that_forgives_when_building_parents(self):
+        class ForgivingParents(VirtualFS):
+            def mkdir(self, path, parents=False, exist_ok=False):
+                super().mkdir(path, parents=parents, exist_ok=exist_ok or parents)
+
+        with pytest.raises(AssertionError, match="parents"):
+            check_filesystem(ForgivingParents({}))
+
+    def test_a_listing_that_answers_in_another_namespace(self):
+        class RootRelative(VirtualFS):
+            def list_detailed(self, path=".", recursive=False):
+                entries = super().list_detailed(path, recursive)
+                for info in entries:
+                    info.path = info.path.lstrip("/")
+                return entries
+
+        with pytest.raises(AssertionError, match="list_detailed"):
+            check_filesystem(RootRelative({}))
+
+    def test_a_listing_that_answers_absolutely_whatever_it_was_asked(self):
+        class AlwaysAbsolute(VirtualFS):
+            def list_detailed(self, path=".", recursive=False):
+                entries = super().list_detailed(path, recursive)
+                for info in entries:
+                    if not info.path.startswith("/"):
+                        info.path = "/" + self.resolve_path(info.path).lstrip("/")
+                return entries
+
+        with pytest.raises(AssertionError, match="relative query"):
+            check_filesystem(AlwaysAbsolute({}))
+
     def test_a_filesystem_that_is_not_empty(self):
         fs = VirtualFS({})
         fs.makedirs(SCRATCH)

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/tests/test_directory_ops.py

@@ -4,6 +4,7 @@ These tests verify the explicit directory support and current working directory
 functionality added to VirtualFS.
 """
 
+import errno
 import os
 
 import pytest
@@ -103,6 +104,65 @@ class TestVFSMakedirs:
         with pytest.raises(FileExistsError):
             vfs.makedirs("a/b/c")
 
+    def test_makedirs_exist_ok_false_raises_on_an_existing_directory(self):
+        """An existing directory is an error unless exist_ok says otherwise."""
+        vfs = VirtualFS({})
+        vfs.mkdir("d")
+
+        with pytest.raises(FileExistsError) as caught:
+            vfs.makedirs("d", exist_ok=False)
+
+        assert caught.value.errno == errno.EEXIST
+
+    def test_makedirs_exist_ok_false_raises_on_an_implicit_directory(self):
+        """A directory a file path passes through exists like any other."""
+        vfs = VirtualFS({})
+        vfs.write("d/file.txt", b"content")
+
+        assert vfs.isdir("d") is True
+        with pytest.raises(FileExistsError) as caught:
+            vfs.makedirs("d", exist_ok=False)
+
+        assert caught.value.errno == errno.EEXIST
+
+    def test_makedirs_exist_ok_true_is_silent(self):
+        """The default keeps working on a tree that is already there."""
+        vfs = VirtualFS({})
+        vfs.makedirs("a/b/c")
+
+        vfs.makedirs("a/b/c")
+        vfs.makedirs("a/b/c", exist_ok=True)
+
+        assert vfs.isdir("a/b/c") is True
+
+    def test_makedirs_exist_ok_false_still_creates_a_missing_tree(self):
+        """Raising on what exists must not stop it creating what does not."""
+        vfs = VirtualFS({})
+        vfs.mkdir("a")
+
+        vfs.makedirs("a/b/c", exist_ok=False)
+
+        assert vfs.isdir("a/b") is True
+        assert vfs.isdir("a/b/c") is True
+
+    def test_mkdir_parents_exist_ok_false_raises_on_an_existing_directory(self):
+        """parents=True must not soften the check exist_ok=False asks for."""
+        vfs = VirtualFS({})
+        vfs.makedirs("a/b")
+
+        with pytest.raises(FileExistsError) as caught:
+            vfs.mkdir("a/b", parents=True, exist_ok=False)
+
+        assert caught.value.errno == errno.EEXIST
+
+    def test_mkdir_parents_exist_ok_true_is_silent(self):
+        vfs = VirtualFS({})
+        vfs.makedirs("a/b")
+
+        vfs.mkdir("a/b", parents=True, exist_ok=True)
+
+        assert vfs.isdir("a/b") is True
+
 
 class TestVFSRmdir:
     """Test VirtualFS.rmdir() functionality."""
@@ -311,6 +371,17 @@ class TestVFSOsPatches:
             assert os.path.isdir("a/b") is True
             assert os.path.isdir("a/b/c") is True
 
+    def test_os_makedirs_defaults_to_refusing_an_existing_directory(self):
+        """os.makedirs() raises on a directory that is already there."""
+        vfs = VirtualFS({})
+        vfs.mkdir("a")
+
+        with patch(vfs):
+            with pytest.raises(FileExistsError):
+                os.makedirs("a")
+
+            os.makedirs("a", exist_ok=True)
+
     def test_os_path_abspath_respects_cwd(self):
         """os.path.abspath resolves against virtual CWD."""
         vfs = VirtualFS({})
@@ -395,3 +466,51 @@ class TestImplicitDirectories:
         assert vfs.list("/") == ["pkg", "top.py"]
         assert vfs.list("pkg") == ["__init__.py", "sub", "utils.py"]
         assert vfs.list("pkg/sub") == ["mod.py"]
+
+
+# -- list_detailed().name is the entry's own name at every depth ---------------
+
+
+def _nested_tree(fs):
+    fs.makedirs("/probe/sub")
+    fs.write("/probe/one.txt", b"1")
+    fs.write("/probe/sub/two.txt", b"2")
+    return fs
+
+
+def _names_and_paths(fs):
+    # The sequence as returned, not a sorted copy: every backend orders a
+    # recursive listing by path relative to the queried directory, so a
+    # directory precedes its contents, and a backend that drifts from
+    # that order fails here rather than being tidied into agreement.
+    return [(i.name, i.path) for i in fs.list_detailed("/probe", recursive=True)]
+
+
+def test_virtualfs_recursive_listing_names_are_basenames():
+    from monkeyfs import VirtualFS
+
+    assert _names_and_paths(_nested_tree(VirtualFS({}))) == [
+        ("one.txt", "/probe/one.txt"),
+        ("sub", "/probe/sub"),
+        ("two.txt", "/probe/sub/two.txt"),
+    ]
+
+
+def test_mountfs_recursive_listing_names_are_basenames():
+    from monkeyfs import MountFS, VirtualFS
+
+    assert _names_and_paths(_nested_tree(MountFS(VirtualFS({})))) == [
+        ("one.txt", "/probe/one.txt"),
+        ("sub", "/probe/sub"),
+        ("two.txt", "/probe/sub/two.txt"),
+    ]
+
+
+def test_isolatedfs_recursive_listing_names_are_basenames(tmp_path):
+    from monkeyfs import IsolatedFS
+
+    assert _names_and_paths(_nested_tree(IsolatedFS(str(tmp_path)))) == [
+        ("one.txt", "/probe/one.txt"),
+        ("sub", "/probe/sub"),
+        ("two.txt", "/probe/sub/two.txt"),
+    ]

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/tests/test_mount.py

@@ -564,6 +564,29 @@ class TestNestedMountListing:
         paths = [e.path for e in fs.list_detailed("/", recursive=True)]
         assert "/workspace/data/out/o.txt" in paths
 
+    def test_list_detailed_over_an_isolated_mount_stays_in_the_namespace(
+        self, tmp_path
+    ):
+        """The mount prefix goes on once, and the sandbox root never appears."""
+        inner = IsolatedFS(str(tmp_path))
+        inner.write("sub/one.txt", b"x")
+        fs = MountFS(VirtualFS({}), {"/data": inner})
+        fs.write("/top.txt", b"t")
+
+        assert [e.path for e in fs.list_detailed("/")] == ["/data", "/top.txt"]
+        assert [e.path for e in fs.list_detailed("/data", recursive=True)] == [
+            "/data/sub",
+            "/data/sub/one.txt",
+        ]
+        for entry in fs.list_detailed("/", recursive=True):
+            assert not entry.path.startswith("//")
+            assert str(tmp_path) not in entry.path
+            if not entry.is_dir:
+                assert fs.read(entry.path)
+
+        fs.chdir("/data")
+        assert [e.path for e in fs.list_detailed("sub")] == ["sub/one.txt"]
+
     def test_an_implicit_parent_inside_a_mount_lists_like_one_in_the_base(self):
         outer = VirtualFS()
         deep = VirtualFS()

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/tests/test_open_optional.py

@@ -180,13 +180,18 @@ class TermishFS:
     def list_detailed(self, path: str = ".", recursive: bool = False) -> list[FileInfo]:
         entries = []
         base = self._abs(path)
+        prefix = path.rstrip("/")
         for name in self.list(path, recursive):
             full = posixpath.join(base, name)
+            # The queried directory joined with the entry: an absolute query
+            # answers absolute, a relative one answers relative to the same
+            # place the caller named.
+            display = f"{prefix}/{name}" if prefix != "." else name
             meta = self.stat(full)
             entries.append(
                 FileInfo(
-                    name=name,
-                    path=full,
+                    name=posixpath.basename(name),
+                    path=display,
                     size=meta.size,
                     created_at=meta.created_at,
                     modified_at=meta.modified_at,

{monkeyfs-0.2.0 → monkeyfs-0.2.2}/tests/test_protocol.py

@@ -261,6 +261,76 @@ class TestMountFSForwarding:
         mount.invalidate()  # must not raise
 
 
+class TestListingPathsAgreeAcrossBackends:
+    """``FileInfo.path`` is the queried directory joined with the entry.
+
+    A listing answers in the namespace it was asked in: an absolute query in
+    absolute paths, a relative one relative to the place the caller named.
+    Every backend answers the same, because the path is the caller's to use
+    -- to read, to pass back in, to show -- and a backend that answers in its
+    own storage layout instead hands back something that names the file to
+    nobody but itself.
+    """
+
+    BACKENDS = {
+        "virtual": lambda tmp: VirtualFS({}),
+        "isolated": lambda tmp: IsolatedFS(str(tmp)),
+        "mounted": lambda tmp: MountFS(VirtualFS({})),
+    }
+
+    @pytest.fixture(params=sorted(BACKENDS))
+    def fs(self, request, tmp_path):
+        filesystem = self.BACKENDS[request.param](tmp_path)
+        filesystem.makedirs("/probe/sub/deep")
+        filesystem.write("/probe/sub/deep/three.txt", b"three")
+        filesystem.write("/probe/sub/one.txt", b"one")
+        filesystem.write("/probe/two.txt", b"two")
+        return filesystem
+
+    @staticmethod
+    def paths(fs, path, recursive=False):
+        return sorted(info.path for info in fs.list_detailed(path, recursive))
+
+    def test_absolute_query(self, fs):
+        assert self.paths(fs, "/probe") == ["/probe/sub", "/probe/two.txt"]
+
+    def test_absolute_query_recursive(self, fs):
+        assert self.paths(fs, "/probe", True) == [
+            "/probe/sub",
+            "/probe/sub/deep",
+            "/probe/sub/deep/three.txt",
+            "/probe/sub/one.txt",
+            "/probe/two.txt",
+        ]
+
+    def test_root_query(self, fs):
+        assert self.paths(fs, "/") == ["/probe"]
+
+    def test_a_trailing_slash_does_not_double(self, fs):
+        assert self.paths(fs, "/probe/") == ["/probe/sub", "/probe/two.txt"]
+
+    def test_relative_query(self, fs):
+        fs.chdir("/probe")
+        assert self.paths(fs, "sub") == ["sub/deep", "sub/one.txt"]
+
+    def test_relative_query_recursive(self, fs):
+        fs.chdir("/probe")
+        assert self.paths(fs, "sub", True) == [
+            "sub/deep",
+            "sub/deep/three.txt",
+            "sub/one.txt",
+        ]
+
+    def test_the_cwd_itself_is_named_by_its_children(self, fs):
+        fs.chdir("/probe")
+        assert self.paths(fs, ".") == ["sub", "two.txt"]
+
+    def test_a_listed_path_reads_back(self, fs):
+        for info in fs.list_detailed("/probe", True):
+            if not info.is_dir:
+                assert fs.exists(info.path), info.path
+
+
 class TestReadOnlyFSForwarding:
     """The wrapper's allowlist comes from the protocol, so it cannot drift."""