monkeyfs 0.2.4__tar.gz → 0.2.6__tar.gz

{monkeyfs-0.2.4 → monkeyfs-0.2.6}/PKG-INFO

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

{monkeyfs-0.2.4 → monkeyfs-0.2.6}/monkeyfs/mount.py

@@ -9,7 +9,9 @@ from __future__ import annotations
 
 import errno
 import os
-from collections.abc import Iterable
+import posixpath
+from collections.abc import Iterable, Iterator
+from contextlib import contextmanager
 from datetime import datetime, timezone
 from typing import Any
 
@@ -128,6 +130,68 @@ class MountFS:
         base_path = abs_path.lstrip("/") or "/"
         return self._base, base_path
 
+    def _is_implied_dir(self, abs_path: str) -> bool:
+        """Whether abs_path is a directory on the way to a mount prefix.
+
+        The composition shows every such directory, whether the
+        filesystem that owns its path holds it or not -- ``isdir`` says
+        yes to ``/workspace`` with only ``/workspace/data`` mounted. A
+        mount prefix is not one (its filesystem's root answers for it),
+        and neither is ``/``.
+        """
+        return (
+            abs_path != "/"
+            and abs_path not in self._mounts
+            and self._is_mount_point(abs_path)
+        )
+
+    @contextmanager
+    def _implied_parents(self, *paths: str) -> Iterator[None]:
+        """Hold the implied directories that creates at ``paths`` land in.
+
+        A file, directory or link created in an implied directory lands
+        in the filesystem that owns the directory's path, which may not
+        hold it. That filesystem is given the directory first, as the
+        namespace already promised it. Only an implied directory is
+        made: a missing one that leads to no mount stays missing, and
+        the create fails there as it would without the composition.
+
+        If the create raises, the directories made for it are removed
+        again, deepest first, so a failed call leaves the filesystem
+        underneath as it found it -- on a versioned base, that is the
+        difference between a failed call and a staged change. One that
+        is no longer empty by then stays: something did land in it. Only
+        a failure the call itself raises is seen; a handle that defers
+        its write to ``close()`` has been handed back by then, over a
+        path that exists.
+        """
+        missing: list[str] = []
+        for path in paths:
+            abs_path = self._to_absolute(path)
+            if abs_path in self._mounts:
+                continue
+            probe = posixpath.dirname(abs_path)
+            while self._is_implied_dir(probe) and probe not in missing:
+                fs, inner = self._resolve(probe)
+                if fs.isdir(inner):
+                    break
+                missing.append(probe)
+                probe = posixpath.dirname(probe)
+        made_from_deepest = sorted(missing, key=lambda p: p.count("/"), reverse=True)
+        try:
+            for abs_dir in made_from_deepest:
+                fs, inner = self._resolve(abs_dir)
+                fs.makedirs(inner, exist_ok=True)
+            yield
+        except BaseException:
+            for abs_dir in made_from_deepest:
+                fs, inner = self._resolve(abs_dir)
+                try:
+                    fs.rmdir(inner)
+                except OSError:
+                    pass
+            raise
+
     def _is_mount_point(self, abs_path: str) -> bool:
         """Check if abs_path is a mount prefix or an implicit parent of one."""
         norm = abs_path.rstrip("/") if abs_path != "/" else ""
@@ -190,11 +254,13 @@ class MountFS:
         synthesized over its ``read()``/``write()``, so mounting a
         bytes-level filesystem does not make it unopenable.
         """
-        fs, inner = self._resolve(path)
-        backend_open = getattr(fs, "open", None)
-        if backend_open is not None:
-            return backend_open(inner, mode, **kwargs)
-        return open_file(fs, inner, mode, **kwargs)
+        creates = any(c in mode for c in "wax")
+        with self._implied_parents(*([path] if creates else [])):
+            fs, inner = self._resolve(path)
+            backend_open = getattr(fs, "open", None)
+            if backend_open is not None:
+                return backend_open(inner, mode, **kwargs)
+            return open_file(fs, inner, mode, **kwargs)
 
     def read(self, path: str, offset: int = 0, size: int = -1) -> bytes:
         """Read bytes from the filesystem that owns ``path``, range and all.
@@ -317,7 +383,22 @@ class MountFS:
         return result
 
     def access(self, path: str, mode: int) -> bool:
-        fs, inner = self._resolve(path)
+        """Answer ``os.access()`` for where a create at ``path`` would land.
+
+        An implied directory exists here whether or not the filesystem
+        owning its path holds it, and what is created in it is made
+        there (see ``_implied_parents``). Where that filesystem lacks
+        it, the nearest directory up the path that is real answers:
+        that is what a caller asking "may I write here" before creating
+        a file has to be told.
+        """
+        probe = self._to_absolute(path)
+        while self._is_implied_dir(probe):
+            fs, inner = self._resolve(probe)
+            if fs.isdir(inner):
+                break
+            probe = posixpath.dirname(probe)
+        fs, inner = self._resolve(probe)
         return fs.access(inner, mode)
 
     def getsize(self, path: str) -> int:
@@ -430,8 +511,9 @@ class MountFS:
     # -- Write operations --
 
     def write(self, path: str, content: bytes, mode: str = "w") -> None:
-        fs, inner = self._resolve(path)
-        fs.write(inner, content, mode=mode)
+        with self._implied_parents(path):
+            fs, inner = self._resolve(path)
+            fs.write(inner, content, mode=mode)
 
     def write_many(self, files: dict[str, bytes]) -> None:
         # Group by filesystem
@@ -442,8 +524,9 @@ class MountFS:
             if key not in groups:
                 groups[key] = (fs, {})
             groups[key][1][inner] = content
-        for fs, inner_files in groups.values():
-            fs.write_many(inner_files)
+        with self._implied_parents(*files):
+            for fs, inner_files in groups.values():
+                fs.write_many(inner_files)
 
     def remove(self, path: str) -> None:
         fs, inner = self._resolve(path)
@@ -462,8 +545,9 @@ class MountFS:
             fs.remove_many(inner_paths)
 
     def mkdir(self, path: str, **kwargs: Any) -> None:
-        fs, inner = self._resolve(path)
-        fs.mkdir(inner, **kwargs)
+        with self._implied_parents(path):
+            fs, inner = self._resolve(path)
+            fs.mkdir(inner, **kwargs)
 
     def makedirs(self, path: str, exist_ok: bool = True) -> None:
         fs, inner = self._resolve(path)
@@ -476,35 +560,41 @@ class MountFS:
     def rename(self, src: str, dst: str) -> None:
         src_fs, src_inner = self._resolve(src)
         dst_fs, dst_inner = self._resolve(dst)
-        if src_fs is dst_fs:
-            src_fs.rename(src_inner, dst_inner)
-        else:
-            if src_fs.isdir(src_inner):
-                raise OSError(errno.EXDEV, "Cross-mount directory rename not supported")
-            content = src_fs.read(src_inner)
-            dst_fs.write(dst_inner, content)
-            src_fs.remove(src_inner)
+        with self._implied_parents(dst):
+            if src_fs is dst_fs:
+                src_fs.rename(src_inner, dst_inner)
+            else:
+                if src_fs.isdir(src_inner):
+                    raise OSError(
+                        errno.EXDEV, "Cross-mount directory rename not supported"
+                    )
+                content = src_fs.read(src_inner)
+                dst_fs.write(dst_inner, content)
+                src_fs.remove(src_inner)
 
     def replace(self, src: str, dst: str) -> None:
         src_fs, src_inner = self._resolve(src)
         dst_fs, dst_inner = self._resolve(dst)
-        if src_fs is dst_fs:
-            src_fs.replace(src_inner, dst_inner)
-        else:
-            content = src_fs.read(src_inner)
-            dst_fs.write(dst_inner, content)
-            src_fs.remove(src_inner)
+        with self._implied_parents(dst):
+            if src_fs is dst_fs:
+                src_fs.replace(src_inner, dst_inner)
+            else:
+                content = src_fs.read(src_inner)
+                dst_fs.write(dst_inner, content)
+                src_fs.remove(src_inner)
 
     def symlink(self, src: str, dst: str) -> None:
-        fs, inner = self._resolve(dst)
-        fs.symlink(src, inner)
+        with self._implied_parents(dst):
+            fs, inner = self._resolve(dst)
+            fs.symlink(src, inner)
 
     def link(self, src: str, dst: str) -> None:
         src_fs, src_inner = self._resolve(src)
         dst_fs, dst_inner = self._resolve(dst)
         if src_fs is not dst_fs:
             raise OSError(errno.EXDEV, "Cross-mount link not supported")
-        src_fs.link(src_inner, dst_inner)
+        with self._implied_parents(dst):
+            src_fs.link(src_inner, dst_inner)
 
     def chmod(self, path: str, mode: int) -> None:
         fs, inner = self._resolve(path)

{monkeyfs-0.2.4 → monkeyfs-0.2.6}/monkeyfs/virtual.py

@@ -536,6 +536,18 @@ class VirtualFS:
         """
         return dict(self._meta_all())
 
+    @staticmethod
+    def _absolute(normalized: str) -> str:
+        """A normalized key as an absolute path, for handing back to a
+        method that resolves its argument.
+
+        ``resolve_path`` returns the key form, which has no leading
+        slash; passed on as it is, the next method reads it as relative
+        to the working directory and names a different path whenever
+        that is not ``/``.
+        """
+        return "/" + normalized.strip("/")
+
     def _normalize_path(self, path: str) -> str:
         """Normalize file path for consistent internal keys.
 
@@ -1094,11 +1106,12 @@ class VirtualFS:
         if parent and not self.isdir("/" + parent):
             raise FileNotFoundError(f"No such file or directory: '{path}'")
 
-        # Check if already exists
-        absolute = "/" + normalized
-        if self.isfile(path):
+        # Check if already exists (on the absolute path: ``path`` is the
+        # key form, and checked as it is it would resolve a second time)
+        absolute = self._absolute(normalized)
+        if self.isfile(absolute):
             raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
-        if self.isdir(path):
+        if self.isdir(absolute):
             if exist_ok:
                 return
             raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
@@ -1130,8 +1143,8 @@ class VirtualFS:
         """
         path = self.resolve_path(path)
 
-        if not exist_ok and self.isdir(path):
-            absolute = "/" + path.strip("/")
+        if not exist_ok and self.isdir(self._absolute(path)):
+            absolute = self._absolute(path)
             raise FileExistsError(errno.EEXIST, os.strerror(errno.EEXIST), absolute)
 
         parts = path.strip("/").split("/")
@@ -1157,16 +1170,19 @@ class VirtualFS:
         """
         path = self.resolve_path(path)
         normalized = self._normalize_path(path)
-
-        if not self.exists(path):
-            raise FileNotFoundError(f"No such directory: {path}")
-        if self.isfile(path):
-            raise NotADirectoryError(f"Not a directory: {path}")
-        if not self.isdir(path):
-            raise FileNotFoundError(f"No such directory: {path}")
+        # Checked on the absolute path: ``path`` is the key form, and the
+        # checks resolve their argument again.
+        absolute = self._absolute(normalized)
+
+        if not self.exists(absolute):
+            raise FileNotFoundError(f"No such directory: {absolute}")
+        if self.isfile(absolute):
+            raise NotADirectoryError(f"Not a directory: {absolute}")
+        if not self.isdir(absolute):
+            raise FileNotFoundError(f"No such directory: {absolute}")
 
         # Check if directory is empty
-        children = self.list(path)
+        children = self.list(absolute)
         if children:
             raise OSError(f"Directory not empty: {path}")
 

{monkeyfs-0.2.4 → monkeyfs-0.2.6}/monkeyfs.egg-info/PKG-INFO

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

{monkeyfs-0.2.4 → monkeyfs-0.2.6}/pyproject.toml

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

{monkeyfs-0.2.4 → monkeyfs-0.2.6}/tests/test_directory_ops.py

@@ -514,3 +514,63 @@ def test_isolatedfs_recursive_listing_names_are_basenames(tmp_path):
         ("sub", "/probe/sub"),
         ("two.txt", "/probe/sub/two.txt"),
     ]
+
+
+# -- a working directory other than / (issue #30) -------------------------
+#
+# rmdir, mkdir and makedirs resolved a path, then handed the result (the
+# key form, with no leading slash) to checks that resolved it again,
+# relative to the working directory. From / the two resolutions agreed;
+# from anywhere else they named different paths.
+
+
+@pytest.fixture(params=["/", "/workspace", "/workspace/src"])
+def cwd_fs(request):
+    fs = VirtualFS({})
+    fs.makedirs("/workspace/src/inner", exist_ok=True)
+    fs.write("/workspace/f.txt", b"data")
+    fs.chdir(request.param)
+    return fs
+
+
+def test_rmdir_removes_an_empty_directory_from_any_cwd(cwd_fs):
+    cwd_fs.rmdir("/workspace/src/inner")
+    assert not cwd_fs.exists("/workspace/src/inner")
+
+
+def test_rmdir_refuses_a_missing_directory_by_its_absolute_path(cwd_fs):
+    with pytest.raises(FileNotFoundError, match="/workspace/nope"):
+        cwd_fs.rmdir("/workspace/nope")
+
+
+def test_rmdir_refuses_a_file_from_any_cwd(cwd_fs):
+    with pytest.raises(NotADirectoryError):
+        cwd_fs.rmdir("/workspace/f.txt")
+
+
+def test_mkdir_refuses_an_existing_directory_from_any_cwd(cwd_fs):
+    with pytest.raises(FileExistsError):
+        cwd_fs.mkdir("/workspace/src")
+
+
+def test_mkdir_refuses_an_existing_file_and_leaves_it_a_file(cwd_fs):
+    with pytest.raises(FileExistsError):
+        cwd_fs.mkdir("/workspace/f.txt")
+    assert cwd_fs.isfile("/workspace/f.txt")
+    assert not cwd_fs.isdir("/workspace/f.txt")
+    assert cwd_fs.read("/workspace/f.txt") == b"data"
+
+
+def test_makedirs_without_exist_ok_refuses_an_existing_directory(cwd_fs):
+    with pytest.raises(FileExistsError):
+        cwd_fs.makedirs("/workspace/src", exist_ok=False)
+
+
+def test_a_relative_rmdir_and_mkdir_resolve_against_the_cwd():
+    fs = VirtualFS({})
+    fs.makedirs("/workspace/src", exist_ok=True)
+    fs.chdir("/workspace")
+    fs.mkdir("new")
+    assert fs.isdir("/workspace/new")
+    fs.rmdir("src")
+    assert not fs.exists("/workspace/src")

{monkeyfs-0.2.4 → monkeyfs-0.2.6}/tests/test_mount.py

@@ -600,3 +600,149 @@ class TestNestedMountListing:
             "missing/deep",
             "missing/deep/leaf.txt",
         ]
+
+
+class TestImpliedDirectories:
+    """A directory the composition shows on the way to a mount takes
+    creates, whether or not the filesystem owning its path holds it."""
+
+    @staticmethod
+    def _composed(mounts=("/workspace/docs",), base=None):
+        base = VirtualFS() if base is None else base
+        docs = VirtualFS()
+        docs.write("README.md", b"reference")
+        return base, MountFS(base, {m: ReadOnlyFS(docs) for m in mounts})
+
+    def test_open_for_write_in_an_implied_directory(self):
+        base, fs = self._composed()
+        assert fs.isdir("/workspace") and not base.isdir("workspace")
+        with fs.open("/workspace/a.txt", "w") as f:
+            f.write("x")
+        assert base.isdir("workspace")
+        assert base.read("workspace/a.txt") == b"x"
+
+    def test_patched_open_in_an_implied_directory(self):
+        base, fs = self._composed()
+        with patch(fs):
+            with open("/workspace/a.txt", "w") as f:
+                f.write("x")
+            with open("/workspace/b.bin", "xb") as f:
+                f.write(b"y")
+            with open("/workspace/c.txt", "a") as f:
+                f.write("z")
+        assert base.read("workspace/a.txt") == b"x"
+        assert base.read("workspace/b.bin") == b"y"
+        assert base.read("workspace/c.txt") == b"z"
+
+    def test_write_mkdir_and_rename_into_an_implied_directory(self):
+        base, fs = self._composed()
+        fs.mkdir("/workspace/sub")
+        assert base.isdir("workspace/sub")
+
+        base2, fs2 = self._composed()
+        fs2.write("/workspace/w.txt", b"w")
+        assert base2.read("workspace/w.txt") == b"w"
+
+        base3, fs3 = self._composed()
+        fs3.write("/top.txt", b"t")
+        fs3.rename("/top.txt", "/workspace/moved.txt")
+        assert base3.read("workspace/moved.txt") == b"t"
+
+    def test_every_implied_level_takes_a_create(self):
+        base, fs = self._composed(mounts=("/workspace/inputs/docs",))
+        fs.write("/workspace/a.txt", b"a")
+        with fs.open("/workspace/inputs/b.txt", "w") as f:
+            f.write("b")
+        assert base.read("workspace/a.txt") == b"a"
+        assert base.read("workspace/inputs/b.txt") == b"b"
+
+    def test_an_implied_directory_inside_a_mount(self):
+        outer = VirtualFS()
+        deep = VirtualFS()
+        deep.write("leaf.txt", b"x")
+        fs = MountFS(VirtualFS(), {"/a": outer, "/a/missing/deep": deep})
+        with fs.open("/a/missing/new.txt", "w") as f:
+            f.write("n")
+        assert outer.read("missing/new.txt") == b"n"
+
+    def test_a_missing_directory_leading_to_no_mount_stays_missing(self):
+        base, fs = self._composed()
+        with pytest.raises(FileNotFoundError):
+            fs.open("/workspace/new/b.txt", "w")
+        assert not base.exists("workspace/new")
+
+    def test_a_read_leaves_the_base_alone(self):
+        base, fs = self._composed()
+        with pytest.raises(FileNotFoundError):
+            fs.open("/workspace/a.txt", "r")
+        assert fs.access("/workspace", os.W_OK)
+        assert not base.exists("workspace")
+
+    def test_access_answers_for_where_a_create_lands(self):
+        _, fs = self._composed(mounts=("/workspace/inputs/docs",))
+        for path in ("/workspace", "/workspace/inputs"):
+            assert fs.access(path, os.F_OK)
+            assert fs.access(path, os.W_OK)
+        assert not fs.access("/workspace/inputs/docs", os.W_OK)
+
+    def test_a_read_only_base_refuses_the_create(self):
+        _, fs = self._composed(base=ReadOnlyFS(VirtualFS()))
+        assert not fs.access("/workspace", os.W_OK)
+        with pytest.raises(PermissionError):
+            fs.open("/workspace/a.txt", "w")
+
+    def test_an_isolated_base_gets_a_real_directory(self, tmp_path):
+        base, fs = self._composed(base=IsolatedFS(str(tmp_path)))
+        with fs.open("/workspace/a.txt", "w") as f:
+            f.write("x")
+        assert (tmp_path / "workspace" / "a.txt").read_text() == "x"
+
+    def test_a_failed_rename_leaves_the_base_as_it_was(self):
+        base, fs = self._composed()
+        with pytest.raises(FileNotFoundError):
+            fs.rename("/missing", "/workspace/new")
+        assert not base.exists("workspace")
+
+    def test_a_refused_cross_mount_rename_leaves_the_base_as_it_was(self):
+        base = VirtualFS()
+        outer = VirtualFS()
+        outer.makedirs("tree")
+        fs = MountFS(
+            base, {"/outer": outer, "/workspace/docs": ReadOnlyFS(VirtualFS())}
+        )
+        with pytest.raises(OSError) as raised:
+            fs.rename("/outer/tree", "/workspace/tree")
+        assert raised.value.errno == errno.EXDEV
+        assert not base.exists("workspace")
+
+    def test_an_invalid_open_mode_leaves_the_base_as_it_was(self, tmp_path):
+        _, fs = self._composed(base=IsolatedFS(str(tmp_path)))
+        with pytest.raises(ValueError):
+            fs.open("/workspace/a.txt", "wq")
+        assert not (tmp_path / "workspace").exists()
+
+    def test_every_level_made_for_a_failed_create_is_removed(self):
+        base, fs = self._composed(mounts=("/workspace/inputs/docs",))
+        with pytest.raises(FileNotFoundError):
+            fs.rename("/missing", "/workspace/inputs/new")
+        assert not base.exists("workspace")
+
+    def test_a_directory_something_landed_in_stays(self):
+        class Partial(VirtualFS):
+            def write_many(self, files):
+                first, *_ = files
+                self.write(first, files[first])
+                raise OSError(errno.ENOSPC, "full")
+
+        base = Partial()
+        fs = MountFS(base, {"/workspace/docs": ReadOnlyFS(VirtualFS())})
+        with pytest.raises(OSError):
+            fs.write_many({"/workspace/a.txt": b"a", "/workspace/b.txt": b"b"})
+        assert base.read("workspace/a.txt") == b"a"
+
+    def test_a_directory_the_base_already_held_is_never_removed(self):
+        base, fs = self._composed()
+        base.makedirs("workspace")
+        with pytest.raises(FileNotFoundError):
+            fs.rename("/missing", "/workspace/new")
+        assert base.isdir("workspace")