chore: import upstream snapshot with attribution

python/tests/ops/dify/conftest.py

@@ -0,0 +1,29 @@
+from types import SimpleNamespace
+
+import pytest
+
+from mirage.cache.index import RAMIndexCacheStore
+from mirage.types import FileStat, FileType, PathSpec
+from mirage.utils.key_prefix import mount_key
+
+
+@pytest.fixture
+def dify_accessor() -> SimpleNamespace:
+    return SimpleNamespace(config=SimpleNamespace(dataset_id="dataset-1",
+                                                  slug_metadata_name="slug"))
+
+
+@pytest.fixture
+def dify_index() -> RAMIndexCacheStore:
+    return RAMIndexCacheStore()
+
+
+@pytest.fixture
+def guide_path() -> PathSpec:
+    return PathSpec.from_str_path(
+        "/knowledge/guides/quickstart",
+        mount_key("/knowledge/guides/quickstart", "/knowledge"))
+
+
+def sample_stat() -> FileStat:
+    return FileStat(name="quickstart", type=FileType.TEXT, size=12)

python/tests/ops/dify/test_grep.py

@@ -0,0 +1,23 @@
+import importlib
+
+import pytest
+
+from mirage.ops.dify.grep import grep
+
+op_grep = importlib.import_module("mirage.ops.dify.grep")
+
+
+async def grep_bytes(accessor, paths, pattern, index):
+    return b"match", {paths[0].virtual: b"content"}
+
+
+@pytest.mark.asyncio
+async def test_grep_op_delegates_to_core(monkeypatch, dify_accessor,
+                                         dify_index, guide_path):
+    monkeypatch.setattr(op_grep, "grep_bytes", grep_bytes)
+
+    result = await grep(dify_accessor, [guide_path],
+                        "pattern",
+                        index=dify_index)
+
+    assert result == b"match"

python/tests/ops/dify/test_read.py

@@ -0,0 +1,21 @@
+import importlib
+
+import pytest
+
+from mirage.ops.dify.read import read
+
+op_read = importlib.import_module("mirage.ops.dify.read")
+
+
+async def read_bytes(accessor, path, index):
+    return path.virtual.encode()
+
+
+@pytest.mark.asyncio
+async def test_read_op_delegates_to_core(monkeypatch, dify_accessor,
+                                         dify_index, guide_path):
+    monkeypatch.setattr(op_read, "read_bytes", read_bytes)
+
+    result = await read(dify_accessor, guide_path, index=dify_index)
+
+    assert result == guide_path.virtual.encode()

python/tests/ops/dify/test_readdir.py

@@ -0,0 +1,24 @@
+import importlib
+
+import pytest
+
+from mirage.ops.dify.readdir import readdir
+
+op_readdir = importlib.import_module("mirage.ops.dify.readdir")
+
+
+async def core_readdir_result(accessor, path, index):
+    return [path.child("a"), path.child("b")]
+
+
+@pytest.mark.asyncio
+async def test_readdir_op_delegates_to_core(monkeypatch, dify_accessor,
+                                            dify_index, guide_path):
+    monkeypatch.setattr(op_readdir, "core_readdir", core_readdir_result)
+
+    result = await readdir(dify_accessor, guide_path, index=dify_index)
+
+    assert result == [
+        "/knowledge/guides/quickstart/a",
+        "/knowledge/guides/quickstart/b",
+    ]

python/tests/ops/dify/test_search.py

@@ -0,0 +1,37 @@
+from types import SimpleNamespace
+
+import pytest
+
+from mirage.cache.index import RAMIndexCacheStore
+from mirage.types import PathSpec
+
+
+@pytest.mark.asyncio
+async def test_search_op_delegates_to_core(monkeypatch):
+    from mirage.core.dify import search
+    from mirage.ops.dify.search import search as search_op
+
+    calls: list[tuple[str, list[PathSpec], dict]] = []
+
+    async def search_segments(accessor, query, paths, index, **kwargs):
+        calls.append((query, paths, kwargs))
+        return b"result"
+
+    monkeypatch.setattr(search, "search_segments", search_segments)
+    paths = [
+        PathSpec(resource_path="knowledge/a",
+                 virtual="/knowledge/a",
+                 directory="/knowledge/a")
+    ]
+
+    result = await search_op(SimpleNamespace(),
+                             paths,
+                             "query",
+                             index=RAMIndexCacheStore(),
+                             method="keyword")
+
+    assert result == b"result"
+    assert calls == [("query", paths, {
+        "method": "keyword",
+        "mount_prefix": ""
+    })]

python/tests/ops/dify/test_stat.py

@@ -0,0 +1,23 @@
+import importlib
+
+import pytest
+
+from mirage.ops.dify.stat import stat
+
+from .conftest import sample_stat
+
+op_stat = importlib.import_module("mirage.ops.dify.stat")
+
+
+async def core_stat_result(accessor, path, index):
+    return sample_stat()
+
+
+@pytest.mark.asyncio
+async def test_stat_op_delegates_to_core(monkeypatch, dify_accessor,
+                                         dify_index, guide_path):
+    monkeypatch.setattr(op_stat, "core_stat", core_stat_result)
+
+    result = await stat(dify_accessor, guide_path, index=dify_index)
+
+    assert result == sample_stat()