chore: import upstream snapshot with attribution

python/tests/core/nextcloud/conftest.py

@@ -0,0 +1,194 @@
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+
+import pytest
+from opendal.exceptions import NotFound
+from opendal.types import EntryMode
+
+from mirage.accessor.nextcloud import NextcloudAccessor
+from mirage.resource.nextcloud import NextcloudConfig
+
+
+@dataclass
+class _FakeMetadata:
+    content_length: int = 0
+    mode: EntryMode = EntryMode.File
+    etag: str | None = None
+    last_modified: datetime | None = None
+    content_type: str | None = None
+
+
+@dataclass
+class _FakeEntry:
+    path: str
+    metadata: _FakeMetadata
+
+    @property
+    def name(self) -> str:
+        return self.path.rstrip("/").rsplit("/", 1)[-1]
+
+
+@dataclass
+class _FakeFile:
+    data: bytes
+    pos: int = 0
+
+    async def __aenter__(self):
+        return self
+
+    async def __aexit__(self, *exc):
+        return None
+
+    async def seek(self, offset: int) -> None:
+        self.pos = offset
+
+    async def read(self, size: int | None = None) -> bytes:
+        if size is None:
+            out = self.data[self.pos:]
+            self.pos = len(self.data)
+        else:
+            out = self.data[self.pos:self.pos + size]
+            self.pos += len(out)
+        return out
+
+    async def tell(self) -> int:
+        return self.pos
+
+
+@dataclass
+class FakeAsyncOperator:
+    files: dict[str, bytes] = field(default_factory=dict)
+    metas: dict[str, _FakeMetadata] = field(default_factory=dict)
+    dirs: set[str] = field(default_factory=set)
+
+    def __post_init__(self):
+        for k, data in self.files.items():
+            self.metas.setdefault(
+                k,
+                _FakeMetadata(
+                    content_length=len(data),
+                    mode=EntryMode.File,
+                    etag=f"etag-{k}",
+                    last_modified=datetime(2026, 1, 1, tzinfo=timezone.utc),
+                ),
+            )
+
+    async def read(self, key: str) -> bytes:
+        if key not in self.files:
+            raise NotFound("path not found", key)
+        return self.files[key]
+
+    async def open(self, key: str, mode: str = "rb"):
+        if key not in self.files:
+            raise NotFound("path not found", key)
+        return _FakeFile(data=self.files[key])
+
+    async def stat(self, key: str) -> _FakeMetadata:
+        k = key.rstrip("/")
+        if key.endswith("/"):
+            if k + "/" in self.dirs or any(
+                    f.startswith(k + "/") for f in self.files):
+                return _FakeMetadata(content_length=0, mode=EntryMode.Dir)
+            raise NotFound("path not found", key)
+        if k in self.files:
+            return self.metas[k]
+        raise NotFound("path not found", key)
+
+    async def write(self, key: str, data: bytes) -> None:
+        self.files[key] = bytes(data)
+        self.metas[key] = _FakeMetadata(
+            content_length=len(data),
+            mode=EntryMode.File,
+            etag=f"etag-{key}",
+        )
+
+    async def delete(self, key: str) -> None:
+        if key.endswith("/"):
+            self.dirs.discard(key)
+            return
+        self.files.pop(key, None)
+        self.metas.pop(key, None)
+
+    async def create_dir(self, key: str) -> None:
+        self.dirs.add(key.rstrip("/") + "/")
+
+    async def copy(self, src: str, dst: str) -> None:
+        if src not in self.files:
+            raise NotFound("path not found", src)
+        await self.write(dst, self.files[src])
+
+    async def rename(self, src: str, dst: str) -> None:
+        if src not in self.files:
+            raise NotFound("path not found", src)
+        await self.write(dst, self.files[src])
+        await self.delete(src)
+
+    async def remove_all(self, prefix: str) -> None:
+        pfx = prefix.rstrip("/")
+        for f in [
+                f for f in self.files if f == pfx or f.startswith(pfx + "/")
+        ]:
+            self.files.pop(f, None)
+            self.metas.pop(f, None)
+
+    async def list(self, path: str):
+        pfx = path.lstrip("/")
+        seen_dirs: set[str] = set()
+        entries: list[_FakeEntry] = []
+        key = pfx.rstrip("/")
+        if key in self.files:
+            # WebDAV PROPFIND on a file returns the file itself.
+            entries.append(_FakeEntry(path=key, metadata=self.metas[key]))
+        for f in self.files:
+            if not f.startswith(pfx):
+                continue
+            rest = f[len(pfx):]
+            if "/" in rest:
+                subdir = rest.split("/", 1)[0]
+                dkey = pfx + subdir + "/"
+                if dkey not in seen_dirs:
+                    seen_dirs.add(dkey)
+                    entries.append(
+                        _FakeEntry(
+                            path=dkey,
+                            metadata=_FakeMetadata(mode=EntryMode.Dir),
+                        ))
+            else:
+                entries.append(_FakeEntry(path=f, metadata=self.metas[f]))
+
+        async def _iter():
+            for e in entries:
+                yield e
+
+        return _iter()
+
+    async def scan(self, path: str):
+        pfx = path.lstrip("/")
+        entries = [
+            _FakeEntry(path=f, metadata=self.metas[f]) for f in self.files
+            if f.startswith(pfx)
+        ]
+
+        async def _iter():
+            for e in entries:
+                yield e
+
+        return _iter()
+
+
+def make_accessor(files: dict[str, bytes] | None = None) -> NextcloudAccessor:
+    cfg = NextcloudConfig(
+        url="https://cloud.example.com/remote.php/dav/files/user/",
+        username="user",
+        password="pass",
+    )
+    acc = NextcloudAccessor(cfg)
+    fake = FakeAsyncOperator(files=dict(files or {}))
+    acc._fake = fake
+    acc.operator = lambda: fake
+    return acc
+
+
+@pytest.fixture
+def make_acc():
+    return make_accessor

python/tests/core/nextcloud/test_du.py

@@ -0,0 +1,45 @@
+import pytest
+
+from mirage.core.nextcloud.du import du, du_all
+from mirage.types import PathSpec
+
+
+@pytest.mark.asyncio
+async def test_du_sums_file_sizes_recursive(make_acc):
+    acc = make_acc({
+        "data/a.json": b"12345",
+        "data/sub/b.json": b"67",
+        "other.txt": b"x",
+    })
+    total = await du(acc, PathSpec.from_str_path("/data"))
+    assert total == 7
+
+
+@pytest.mark.asyncio
+async def test_du_all_returns_per_file_with_total(make_acc):
+    acc = make_acc({
+        "data/a.json": b"12345",
+        "data/b.json": b"67",
+    })
+    out = await du_all(acc, PathSpec.from_str_path("/data"))
+    assert out[-1] == ("/data", 7)
+    files = sorted(out[:-1])
+    assert files == [("/data/a.json", 5), ("/data/b.json", 2)]
+
+
+@pytest.mark.asyncio
+async def test_du_missing_returns_zero(make_acc):
+    acc = make_acc({})
+    assert await du(acc, PathSpec.from_str_path("/nope")) == 0
+
+
+@pytest.mark.asyncio
+async def test_du_of_file_returns_its_own_size(make_acc):
+    acc = make_acc({"data/a.json": b"12345"})
+    assert await du(acc, PathSpec.from_str_path("/data/a.json")) == 5
+
+
+@pytest.mark.asyncio
+async def test_du_all_of_file_is_empty(make_acc):
+    acc = make_acc({"data/a.json": b"12345"})
+    assert await du_all(acc, PathSpec.from_str_path("/data/a.json")) == []

python/tests/core/nextcloud/test_find.py

@@ -0,0 +1,67 @@
+import pytest
+
+from mirage.core.nextcloud.find import find
+from mirage.types import PathSpec
+
+
+@pytest.mark.asyncio
+async def test_find_root_returns_sorted_entries(make_acc):
+    acc = make_acc({
+        "a.json": b"a",
+        "b.json": b"b",
+        "data/c.json": b"c",
+    })
+    out = await find(acc, PathSpec.from_str_path("/"))
+    assert out == ["/", "/a.json", "/b.json", "/data", "/data/c.json"]
+
+
+@pytest.mark.asyncio
+async def test_find_subdir_scopes_results(make_acc):
+    acc = make_acc({
+        "data/a.json": b"a",
+        "data/sub/b.json": b"b",
+        "other.txt": b"o",
+    })
+    out = await find(acc, PathSpec.from_str_path("/data"))
+    assert out == ["/data", "/data/a.json", "/data/sub", "/data/sub/b.json"]
+
+
+@pytest.mark.asyncio
+async def test_find_missing_returns_empty(make_acc):
+    acc = make_acc({})
+    out = await find(acc, PathSpec.from_str_path("/nope"))
+    assert out == []
+
+
+@pytest.mark.asyncio
+async def test_find_name_filter(make_acc):
+    acc = make_acc({
+        "a.json": b"a",
+        "b.txt": b"b",
+        "data/c.json": b"c",
+    })
+    out = await find(acc, PathSpec.from_str_path("/"), name="*.json")
+    assert out == ["/a.json", "/data/c.json"]
+
+
+@pytest.mark.asyncio
+async def test_find_type_filter(make_acc):
+    acc = make_acc({
+        "a.json": b"a",
+        "data/c.json": b"c",
+    })
+    files = await find(acc, PathSpec.from_str_path("/"), type="f")
+    dirs = await find(acc, PathSpec.from_str_path("/"), type="d")
+    assert files == ["/a.json", "/data/c.json"]
+    assert dirs == ["/", "/data"]
+
+
+@pytest.mark.asyncio
+async def test_find_maxdepth(make_acc):
+    acc = make_acc({
+        "a.json": b"a",
+        "data/c.json": b"c",
+        "data/sub/d.json": b"d",
+    })
+    out = await find(acc, PathSpec.from_str_path("/"), maxdepth=1)
+    assert out == ["/", "/a.json", "/data"]

python/tests/core/nextcloud/test_read.py

@@ -0,0 +1,32 @@
+import pytest
+
+from mirage.core.nextcloud.read import read_bytes
+from mirage.types import PathSpec
+
+
+@pytest.mark.asyncio
+async def test_read_bytes_whole_file(make_acc):
+    acc = make_acc({"greet.txt": b"hello world"})
+    out = await read_bytes(acc, PathSpec.from_str_path("/greet.txt"))
+    assert out == b"hello world"
+
+
+@pytest.mark.asyncio
+async def test_read_bytes_offset_size_returns_slice(make_acc):
+    acc = make_acc({"x": b"abcdef"})
+    out = await read_bytes(acc, PathSpec.from_str_path("/x"), offset=2, size=4)
+    assert out == b"cdef"
+
+
+@pytest.mark.asyncio
+async def test_read_bytes_offset_only(make_acc):
+    acc = make_acc({"x": b"abcdef"})
+    out = await read_bytes(acc, PathSpec.from_str_path("/x"), offset=3)
+    assert out == b"def"
+
+
+@pytest.mark.asyncio
+async def test_read_bytes_missing_raises_filenotfound(make_acc):
+    acc = make_acc({})
+    with pytest.raises(FileNotFoundError):
+        await read_bytes(acc, PathSpec.from_str_path("/nope"))

python/tests/core/nextcloud/test_readdir.py

@@ -0,0 +1,55 @@
+import pytest
+
+from mirage.cache.index import RAMIndexCacheStore
+from mirage.core.nextcloud.readdir import readdir
+from mirage.types import PathSpec
+
+
+@pytest.mark.asyncio
+async def test_readdir_root_returns_children(make_acc):
+    acc = make_acc({"hello.txt": b"x", "data/file.txt": b"y"})
+    entries = await readdir(acc, PathSpec.from_str_path("/"),
+                            RAMIndexCacheStore(ttl=60))
+    assert "/data" in entries
+    assert "/hello.txt" in entries
+
+
+@pytest.mark.asyncio
+async def test_readdir_subdir(make_acc):
+    acc = make_acc({
+        "data/a.txt": b"a",
+        "data/sub/b.txt": b"b",
+        "other.txt": b"o"
+    })
+    entries = await readdir(acc, PathSpec.from_str_path("/data"),
+                            RAMIndexCacheStore(ttl=60))
+    assert sorted(entries) == ["/data/a.txt", "/data/sub"]
+
+
+@pytest.mark.asyncio
+async def test_readdir_file_raises_enotdir(make_acc):
+    acc = make_acc({"data/a.txt": b"a"})
+    with pytest.raises(NotADirectoryError):
+        await readdir(acc, PathSpec.from_str_path("/data/a.txt"),
+                      RAMIndexCacheStore(ttl=60))
+
+
+@pytest.mark.asyncio
+async def test_readdir_populates_index_cache(make_acc):
+    acc = make_acc({"f.txt": b"hello"})
+    cache = RAMIndexCacheStore(ttl=60)
+    await readdir(acc, PathSpec.from_str_path("/"), cache)
+    lookup = await cache.get("/f.txt")
+    assert lookup.entry is not None
+    assert lookup.entry.size == 5
+    assert lookup.entry.resource_type == "file"
+
+
+@pytest.mark.asyncio
+async def test_readdir_stores_remote_time_for_files(make_acc):
+    acc = make_acc({"f.txt": b"hello"})
+    cache = RAMIndexCacheStore(ttl=60)
+    await readdir(acc, PathSpec.from_str_path("/"), cache)
+    lookup = await cache.get("/f.txt")
+    assert lookup.entry is not None
+    assert lookup.entry.remote_time == "2026-01-01T00:00:00+00:00"

python/tests/core/nextcloud/test_stat.py

@@ -0,0 +1,49 @@
+import pytest
+
+from mirage.cache.index import RAMIndexCacheStore
+from mirage.core.nextcloud.readdir import readdir
+from mirage.core.nextcloud.stat import stat
+from mirage.types import FileType, PathSpec
+
+
+@pytest.mark.asyncio
+async def test_stat_file_returns_size_and_etag(make_acc):
+    acc = make_acc({"data/file.txt": b"abcde"})
+    s = await stat(acc, PathSpec.from_str_path("/data/file.txt"))
+    assert s.name == "file.txt"
+    assert s.size == 5
+    assert s.fingerprint == "etag-data/file.txt"
+    assert s.type != FileType.DIRECTORY
+
+
+@pytest.mark.asyncio
+async def test_stat_directory_via_dir_probe(make_acc):
+    acc = make_acc({"data/file.txt": b"x"})
+    s = await stat(acc, PathSpec.from_str_path("/data"))
+    assert s.type == FileType.DIRECTORY
+    assert s.name == "data"
+
+
+@pytest.mark.asyncio
+async def test_stat_missing_raises_filenotfound(make_acc):
+    acc = make_acc({})
+    with pytest.raises(FileNotFoundError):
+        await stat(acc, PathSpec.from_str_path("/missing.txt"))
+
+
+@pytest.mark.asyncio
+async def test_stat_root_is_directory(make_acc):
+    acc = make_acc({})
+    s = await stat(acc, PathSpec.from_str_path("/"))
+    assert s.type == FileType.DIRECTORY
+
+
+@pytest.mark.asyncio
+async def test_stat_returns_modified_from_index(make_acc):
+    acc = make_acc({"data/file.txt": b"abcde"})
+    cache = RAMIndexCacheStore(ttl=60)
+    await readdir(acc, PathSpec.from_str_path("/data"), cache)
+    s = await stat(acc, PathSpec.from_str_path("/data/file.txt"), index=cache)
+    assert s.modified == "2026-01-01T00:00:00+00:00"
+    assert s.size == 5
+    assert s.type != FileType.DIRECTORY

python/tests/core/nextcloud/test_write_ops.py

@@ -0,0 +1,79 @@
+import pytest
+
+from mirage.core.nextcloud.copy import copy
+from mirage.core.nextcloud.create import create
+from mirage.core.nextcloud.mkdir import mkdir
+from mirage.core.nextcloud.rename import rename
+from mirage.core.nextcloud.rm import rm_r
+from mirage.core.nextcloud.truncate import truncate
+from mirage.core.nextcloud.unlink import unlink
+from mirage.core.nextcloud.write import write_bytes
+from mirage.types import PathSpec
+
+
+@pytest.mark.asyncio
+async def test_write_bytes_uploads(make_acc):
+    acc = make_acc({})
+    await write_bytes(acc, PathSpec.from_str_path("/hello.txt"), b"hi there")
+    assert acc._fake.files == {"hello.txt": b"hi there"}
+
+
+@pytest.mark.asyncio
+async def test_unlink_deletes_file(make_acc):
+    acc = make_acc({"delete-me.txt": b"x"})
+    await unlink(acc, PathSpec.from_str_path("/delete-me.txt"))
+    assert "delete-me.txt" not in acc._fake.files
+
+
+@pytest.mark.asyncio
+async def test_create_writes_empty_file(make_acc):
+    acc = make_acc({})
+    await create(acc, PathSpec.from_str_path("/touched.txt"))
+    assert acc._fake.files.get("touched.txt") == b""
+
+
+@pytest.mark.asyncio
+async def test_mkdir_creates_collection(make_acc):
+    acc = make_acc({})
+    await mkdir(acc, PathSpec.from_str_path("/newdir"))
+    assert "newdir/" in acc._fake.dirs
+
+
+@pytest.mark.asyncio
+async def test_copy_duplicates_file(make_acc):
+    acc = make_acc({"src.txt": b"payload"})
+    await copy(acc, PathSpec.from_str_path("/src.txt"),
+               PathSpec.from_str_path("/dst.txt"))
+    assert acc._fake.files["dst.txt"] == b"payload"
+    assert acc._fake.files["src.txt"] == b"payload"
+
+
+@pytest.mark.asyncio
+async def test_rename_moves_file(make_acc):
+    acc = make_acc({"old.txt": b"data"})
+    await rename(acc, PathSpec.from_str_path("/old.txt"),
+                 PathSpec.from_str_path("/new.txt"))
+    assert acc._fake.files.get("new.txt") == b"data"
+    assert "old.txt" not in acc._fake.files
+
+
+@pytest.mark.asyncio
+async def test_rm_r_removes_subtree(make_acc):
+    acc = make_acc({
+        "dir/a.txt": b"a",
+        "dir/sub/b.txt": b"b",
+        "keep.txt": b"k"
+    })
+    await rm_r(acc, PathSpec.from_str_path("/dir"))
+    assert "dir/a.txt" not in acc._fake.files
+    assert "dir/sub/b.txt" not in acc._fake.files
+    assert "keep.txt" in acc._fake.files
+
+
+@pytest.mark.asyncio
+async def test_truncate_pads_and_shrinks(make_acc):
+    acc = make_acc({"f.txt": b"abcdef"})
+    await truncate(acc, PathSpec.from_str_path("/f.txt"), 3)
+    assert acc._fake.files["f.txt"] == b"abc"
+    await truncate(acc, PathSpec.from_str_path("/f.txt"), 5)
+    assert acc._fake.files["f.txt"] == b"abc\x00\x00"