chore: import upstream snapshot with attribution

libs/checkpoint-sqlite/tests/test_async_store.py

@@ -0,0 +1,718 @@
+import asyncio
+import os
+import tempfile
+import uuid
+from collections.abc import AsyncIterator, Generator, Iterable
+from contextlib import asynccontextmanager
+from typing import cast
+
+import pytest
+from langgraph.store.base import (
+    GetOp,
+    Item,
+    ListNamespacesOp,
+    PutOp,
+    SearchOp,
+)
+
+from langgraph.store.sqlite import AsyncSqliteStore
+from langgraph.store.sqlite.base import SqliteIndexConfig
+from tests.test_store import CharacterEmbeddings
+
+
+@pytest.fixture(scope="function", params=["memory", "file"])
+async def store(request: pytest.FixtureRequest) -> AsyncIterator[AsyncSqliteStore]:
+    """Create an AsyncSqliteStore for testing."""
+    if request.param == "memory":
+        # In-memory store
+        async with AsyncSqliteStore.from_conn_string(":memory:") as store:
+            await store.setup()
+            yield store
+    else:
+        # Temporary file store
+        temp_file = tempfile.NamedTemporaryFile(delete=False)
+        temp_file.close()
+        try:
+            async with AsyncSqliteStore.from_conn_string(temp_file.name) as store:
+                await store.setup()
+                yield store
+        finally:
+            os.unlink(temp_file.name)
+
+
+@pytest.fixture(scope="function")
+def fake_embeddings() -> CharacterEmbeddings:
+    """Create fake embeddings for testing."""
+    return CharacterEmbeddings(dims=500)
+
+
+@asynccontextmanager
+async def create_vector_store(
+    fake_embeddings: CharacterEmbeddings,
+    conn_string: str = ":memory:",
+    text_fields: list[str] | None = None,
+) -> AsyncIterator[AsyncSqliteStore]:
+    """Create an AsyncSqliteStore with vector search capabilities."""
+    index_config: SqliteIndexConfig = {
+        "dims": fake_embeddings.dims,
+        "embed": fake_embeddings,
+        "text_fields": text_fields,
+    }
+
+    async with AsyncSqliteStore.from_conn_string(
+        conn_string, index=index_config
+    ) as store:
+        await store.setup()
+        yield store
+
+
+@pytest.fixture(scope="function", params=["memory", "file"])
+def conn_string(request: pytest.FixtureRequest) -> Generator[str, None, None]:
+    if request.param == "memory":
+        yield ":memory:"
+    else:
+        temp_file = tempfile.NamedTemporaryFile(delete=False)
+        temp_file.close()
+        try:
+            yield temp_file.name
+        finally:
+            os.unlink(temp_file.name)
+
+
+async def test_no_running_loop(store: AsyncSqliteStore) -> None:
+    """Test that sync methods raise proper errors in the main thread."""
+    with pytest.raises(asyncio.InvalidStateError):
+        store.put(("foo", "bar"), "baz", {"val": "baz"})
+    with pytest.raises(asyncio.InvalidStateError):
+        store.get(("foo", "bar"), "baz")
+    with pytest.raises(asyncio.InvalidStateError):
+        store.delete(("foo", "bar"), "baz")
+    with pytest.raises(asyncio.InvalidStateError):
+        store.search(("foo", "bar"))
+    with pytest.raises(asyncio.InvalidStateError):
+        store.list_namespaces(prefix=("foo",))
+    with pytest.raises(asyncio.InvalidStateError):
+        store.batch([PutOp(namespace=("foo", "bar"), key="baz", value={"val": "baz"})])
+
+
+async def test_large_batches_async(store: AsyncSqliteStore) -> None:
+    """Test processing large batch operations asynchronously."""
+    N = 100
+    M = 10
+    coros = []
+    for m in range(M):
+        for i in range(N):
+            coros.append(
+                store.aput(
+                    ("test", "foo", "bar", "baz", str(m % 2)),
+                    f"key{i}",
+                    value={"foo": "bar" + str(i)},
+                )
+            )
+            coros.append(
+                asyncio.create_task(
+                    store.aget(
+                        ("test", "foo", "bar", "baz", str(m % 2)),
+                        f"key{i}",
+                    )
+                )
+            )
+            coros.append(
+                asyncio.create_task(
+                    store.alist_namespaces(
+                        prefix=None,
+                        max_depth=m + 1,
+                    )
+                )
+            )
+            coros.append(
+                asyncio.create_task(
+                    store.asearch(
+                        ("test",),
+                    )
+                )
+            )
+            coros.append(
+                store.aput(
+                    ("test", "foo", "bar", "baz", str(m % 2)),
+                    f"key{i}",
+                    value={"foo": "bar" + str(i)},
+                )
+            )
+            coros.append(
+                store.adelete(
+                    ("test", "foo", "bar", "baz", str(m % 2)),
+                    f"key{i}",
+                )
+            )
+
+    results = await asyncio.gather(*coros)
+    assert len(results) == M * N * 6
+
+
+async def test_abatch_order(store: AsyncSqliteStore) -> None:
+    """Test ordering of batch operations in async context."""
+    # Setup test data
+    await store.aput(("test", "foo"), "key1", {"data": "value1"})
+    await store.aput(("test", "bar"), "key2", {"data": "value2"})
+
+    ops = [
+        GetOp(namespace=("test", "foo"), key="key1"),
+        PutOp(namespace=("test", "bar"), key="key2", value={"data": "value2"}),
+        SearchOp(
+            namespace_prefix=("test",), filter={"data": "value1"}, limit=10, offset=0
+        ),
+        ListNamespacesOp(match_conditions=None, max_depth=None, limit=10, offset=0),
+        GetOp(namespace=("test",), key="key3"),
+    ]
+
+    results = await store.abatch(
+        cast(Iterable[GetOp | PutOp | SearchOp | ListNamespacesOp], ops)
+    )
+    assert len(results) == 5
+    assert isinstance(results[0], Item)
+    assert isinstance(results[0].value, dict)
+    assert results[0].value == {"data": "value1"}
+    assert results[0].key == "key1"
+    assert results[1] is None  # Put operation returns None
+    assert isinstance(results[2], list)
+    # SQLite query implementation might return different results
+    # Just check that we get a list back and don't check the exact content
+    assert isinstance(results[3], list)
+    assert len(results[3]) > 0
+    assert results[4] is None  # Non-existent key returns None
+
+    # Test reordered operations
+    ops_reordered = [
+        SearchOp(namespace_prefix=("test",), filter=None, limit=5, offset=0),
+        GetOp(namespace=("test", "bar"), key="key2"),
+        ListNamespacesOp(match_conditions=None, max_depth=None, limit=5, offset=0),
+        PutOp(namespace=("test",), key="key3", value={"data": "value3"}),
+        GetOp(namespace=("test", "foo"), key="key1"),
+    ]
+
+    results_reordered = await store.abatch(
+        cast(Iterable[GetOp | PutOp | SearchOp | ListNamespacesOp], ops_reordered)
+    )
+    assert len(results_reordered) == 5
+    assert isinstance(results_reordered[0], list)
+    assert len(results_reordered[0]) >= 2  # Should find at least our two test items
+    assert isinstance(results_reordered[1], Item)
+    assert results_reordered[1].value == {"data": "value2"}
+    assert results_reordered[1].key == "key2"
+    assert isinstance(results_reordered[2], list)
+    assert len(results_reordered[2]) > 0
+    assert results_reordered[3] is None  # Put operation returns None
+    assert isinstance(results_reordered[4], Item)
+    assert results_reordered[4].value == {"data": "value1"}
+    assert results_reordered[4].key == "key1"
+
+
+async def test_batch_get_ops(store: AsyncSqliteStore) -> None:
+    """Test GET operations in batch context."""
+    # Setup test data
+    await store.aput(("test",), "key1", {"data": "value1"})
+    await store.aput(("test",), "key2", {"data": "value2"})
+
+    ops = [
+        GetOp(namespace=("test",), key="key1"),
+        GetOp(namespace=("test",), key="key2"),
+        GetOp(namespace=("test",), key="key3"),  # Non-existent key
+    ]
+
+    results = await store.abatch(ops)
+
+    assert len(results) == 3
+    assert results[0] is not None
+    assert results[1] is not None
+    assert results[2] is None
+    if results[0] is not None:
+        assert results[0].key == "key1"
+    if results[1] is not None:
+        assert results[1].key == "key2"
+
+
+async def test_batch_put_ops(store: AsyncSqliteStore) -> None:
+    """Test PUT operations in batch context."""
+    ops = [
+        PutOp(namespace=("test",), key="key1", value={"data": "value1"}),
+        PutOp(namespace=("test",), key="key2", value={"data": "value2"}),
+        PutOp(namespace=("test",), key="key3", value=None),  # Delete operation
+    ]
+
+    results = await store.abatch(ops)
+    assert len(results) == 3
+    assert all(result is None for result in results)
+
+    # Verify the puts worked
+    items = await store.asearch(("test",), limit=10)
+    assert len(items) == 2  # key3 had None value so wasn't stored
+
+
+async def test_batch_search_ops(store: AsyncSqliteStore) -> None:
+    """Test SEARCH operations in batch context."""
+    # Setup test data
+    await store.aput(("test", "foo"), "key1", {"data": "value1"})
+    await store.aput(("test", "bar"), "key2", {"data": "value2"})
+
+    ops = [
+        SearchOp(
+            namespace_prefix=("test",), filter={"data": "value1"}, limit=10, offset=0
+        ),
+        SearchOp(namespace_prefix=("test",), filter=None, limit=5, offset=0),
+    ]
+
+    results = await store.abatch(ops)
+
+    assert len(results) == 2
+    # SQLite query implementation might return different results
+    # Just check that we get lists back and don't check the exact content
+    assert isinstance(results[0], list)
+    assert isinstance(results[1], list)
+    assert len(results[1]) >= 1  # We should at least find some results
+
+
+async def test_batch_list_namespaces_ops(store: AsyncSqliteStore) -> None:
+    """Test LIST NAMESPACES operations in batch context."""
+    # Setup test data
+    await store.aput(("test", "namespace1"), "key1", {"data": "value1"})
+    await store.aput(("test", "namespace2"), "key2", {"data": "value2"})
+
+    ops = [ListNamespacesOp(match_conditions=None, max_depth=None, limit=10, offset=0)]
+
+    results = await store.abatch(ops)
+
+    assert len(results) == 1
+    if isinstance(results[0], list):
+        assert len(results[0]) == 2
+        assert ("test", "namespace1") in results[0]
+        assert ("test", "namespace2") in results[0]
+
+
+async def test_vector_store_initialization(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test store initialization with embedding config."""
+    async with create_vector_store(fake_embeddings) as store:
+        assert store.index_config is not None
+        assert store.index_config["dims"] == fake_embeddings.dims
+        if hasattr(store.index_config.get("embed"), "embed_documents"):
+            assert store.index_config["embed"] == fake_embeddings
+
+
+async def test_vector_insert_with_auto_embedding(
+    fake_embeddings: CharacterEmbeddings,
+    conn_string: str,
+) -> None:
+    """Test inserting items that get auto-embedded."""
+    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
+        docs = [
+            ("doc1", {"text": "short text"}),
+            ("doc2", {"text": "longer text document"}),
+            ("doc3", {"text": "longest text document here"}),
+            ("doc4", {"description": "text in description field"}),
+            ("doc5", {"content": "text in content field"}),
+            ("doc6", {"body": "text in body field"}),
+        ]
+
+        for key, value in docs:
+            await store.aput(("test",), key, value)
+
+        results = await store.asearch(("test",), query="long text")
+        assert len(results) > 0
+
+        doc_order = [r.key for r in results]
+        assert "doc2" in doc_order
+        assert "doc3" in doc_order
+
+
+async def test_vector_update_with_embedding(
+    fake_embeddings: CharacterEmbeddings,
+    conn_string: str,
+) -> None:
+    """Test that updating items properly updates their embeddings."""
+    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
+        await store.aput(("test",), "doc1", {"text": "zany zebra Xerxes"})
+        await store.aput(("test",), "doc2", {"text": "something about dogs"})
+        await store.aput(("test",), "doc3", {"text": "text about birds"})
+
+        results_initial = await store.asearch(("test",), query="Zany Xerxes")
+        assert len(results_initial) > 0
+        assert results_initial[0].score is not None
+        assert results_initial[0].key == "doc1"
+        initial_score = results_initial[0].score
+
+        await store.aput(("test",), "doc1", {"text": "new text about dogs"})
+
+        results_after = await store.asearch(("test",), query="Zany Xerxes")
+        after_score = next((r.score for r in results_after if r.key == "doc1"), 0.0)
+        assert (
+            after_score is not None
+            and initial_score is not None
+            and after_score < initial_score
+        )
+
+        results_new = await store.asearch(("test",), query="new text about dogs")
+        for r in results_new:
+            if r.key == "doc1":
+                assert (
+                    r.score is not None
+                    and after_score is not None
+                    and r.score > after_score
+                )
+
+        # Don't index this one
+        await store.aput(
+            ("test",), "doc4", {"text": "new text about dogs"}, index=False
+        )
+        results_new = await store.asearch(
+            ("test",), query="new text about dogs", limit=3
+        )
+        assert not any(r.key == "doc4" for r in results_new)
+
+
+async def test_vector_search_with_filters(
+    fake_embeddings: CharacterEmbeddings,
+    conn_string: str,
+) -> None:
+    """Test combining vector search with filters."""
+    async with create_vector_store(fake_embeddings, conn_string=conn_string) as store:
+        docs = [
+            ("doc1", {"text": "red apple", "color": "red", "score": 4.5}),
+            ("doc2", {"text": "red car", "color": "red", "score": 3.0}),
+            ("doc3", {"text": "green apple", "color": "green", "score": 4.0}),
+            ("doc4", {"text": "blue car", "color": "blue", "score": 3.5}),
+        ]
+
+        for key, value in docs:
+            await store.aput(("test",), key, value)
+
+        # Vector search with filters can be inconsistent in test environments
+        # Skip asserting exact results as we've already validated the functionality
+        # in the synchronous tests
+        _ = await store.asearch(("test",), query="apple", filter={"color": "red"})
+
+        # Skip asserting exact results as we've already validated the functionality
+        # in the synchronous tests
+        _ = await store.asearch(("test",), query="car", filter={"color": "red"})
+
+        # Skip asserting exact results as we've already validated the functionality
+        # in the synchronous tests
+        _ = await store.asearch(
+            ("test",), query="bbbbluuu", filter={"score": {"$gt": 3.2}}
+        )
+
+        # Skip asserting exact results as we've already validated the functionality
+        # in the synchronous tests
+        _ = await store.asearch(
+            ("test",), query="apple", filter={"score": {"$gte": 4.0}, "color": "green"}
+        )
+
+
+async def test_vector_search_pagination(fake_embeddings: CharacterEmbeddings) -> None:
+    """Test pagination with vector search."""
+    async with create_vector_store(fake_embeddings) as store:
+        for i in range(5):
+            await store.aput(
+                ("test",), f"doc{i}", {"text": f"test document number {i}"}
+            )
+
+        results_page1 = await store.asearch(("test",), query="test", limit=2)
+        results_page2 = await store.asearch(("test",), query="test", limit=2, offset=2)
+
+        assert len(results_page1) == 2
+        assert len(results_page2) == 2
+        assert results_page1[0].key != results_page2[0].key
+
+        all_results = await store.asearch(("test",), query="test", limit=10)
+        assert len(all_results) == 5
+
+
+async def test_vector_search_edge_cases(fake_embeddings: CharacterEmbeddings) -> None:
+    """Test edge cases in vector search."""
+    async with create_vector_store(fake_embeddings) as store:
+        await store.aput(("test",), "doc1", {"text": "test document"})
+
+        results = await store.asearch(("test",), query="")
+        assert len(results) == 1
+
+        results = await store.asearch(("test",), query=None)
+        assert len(results) == 1
+
+        long_query = "test " * 100
+        results = await store.asearch(("test",), query=long_query)
+        assert len(results) == 1
+
+        special_query = "test!@#$%^&*()"
+        results = await store.asearch(("test",), query=special_query)
+        assert len(results) == 1
+
+
+async def test_embed_with_path(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test vector search with specific text fields in SQLite store."""
+    async with create_vector_store(
+        fake_embeddings, text_fields=["key0", "key1", "key3"]
+    ) as store:
+        # This will have 2 vectors representing it
+        doc1 = {
+            # Omit key0 - check it doesn't raise an error
+            "key1": "xxx",
+            "key2": "yyy",
+            "key3": "zzz",
+        }
+        # This will have 3 vectors representing it
+        doc2 = {
+            "key0": "uuu",
+            "key1": "vvv",
+            "key2": "www",
+            "key3": "xxx",
+        }
+        await store.aput(("test",), "doc1", doc1)
+        await store.aput(("test",), "doc2", doc2)
+
+        # doc2.key3 and doc1.key1 both would have the highest score
+        results = await store.asearch(("test",), query="xxx")
+        assert len(results) == 2
+        assert results[0].key != results[1].key
+        assert results[0].score > 0.9
+        assert results[1].score > 0.9
+
+        # ~Only match doc2
+        results = await store.asearch(("test",), query="uuu")
+        assert len(results) == 2
+        assert results[0].key != results[1].key
+        assert results[0].key == "doc2"
+        assert results[0].score > results[1].score
+
+        # Un-indexed - will have low results for both. Not zero (because we're projecting)
+        # but less than the above.
+        results = await store.asearch(("test",), query="www")
+        assert len(results) == 2
+        assert results[0].score < 0.9
+        assert results[1].score < 0.9
+
+
+async def test_basic_store_ops(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test vector search with specific text fields in SQLite store."""
+    async with create_vector_store(
+        fake_embeddings, text_fields=["key0", "key1", "key3"]
+    ) as store:
+        uid = uuid.uuid4().hex
+        namespace = (uid, "test", "documents")
+        item_id = "doc1"
+        item_value = {"title": "Test Document", "content": "Hello, World!"}
+        results = await store.asearch((uid,))
+        assert len(results) == 0
+
+        await store.aput(namespace, item_id, item_value)
+        item = await store.aget(namespace, item_id)
+
+        assert item is not None
+        assert item.namespace == namespace
+        assert item.key == item_id
+        assert item.value == item_value
+        assert item.created_at is not None
+        assert item.updated_at is not None
+
+        updated_value = {
+            "title": "Updated Test Document",
+            "content": "Hello, LangGraph!",
+        }
+        await asyncio.sleep(1.01)
+        await store.aput(namespace, item_id, updated_value)
+        updated_item = await store.aget(namespace, item_id)
+        assert updated_item is not None
+
+        assert updated_item.value == updated_value
+        assert updated_item.updated_at > item.updated_at
+        different_namespace = (uid, "test", "other_documents")
+        item_in_different_namespace = await store.aget(different_namespace, item_id)
+        assert item_in_different_namespace is None
+
+        new_item_id = "doc2"
+        new_item_value = {"title": "Another Document", "content": "Greetings!"}
+        await store.aput(namespace, new_item_id, new_item_value)
+
+        items = await store.asearch((uid, "test"), limit=10)
+        assert len(items) == 2
+        assert any(item.key == item_id for item in items)
+        assert any(item.key == new_item_id for item in items)
+
+        namespaces = await store.alist_namespaces(prefix=(uid, "test"))
+        assert (uid, "test", "documents") in namespaces
+
+        await store.adelete(namespace, item_id)
+        await store.adelete(namespace, new_item_id)
+        deleted_item = await store.aget(namespace, item_id)
+        assert deleted_item is None
+
+        deleted_item = await store.aget(namespace, new_item_id)
+        assert deleted_item is None
+
+        empty_search_results = await store.asearch((uid, "test"), limit=10)
+        assert len(empty_search_results) == 0
+
+
+async def test_list_namespaces(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test list namespaces functionality with various filters."""
+    async with create_vector_store(
+        fake_embeddings, text_fields=["key0", "key1", "key3"]
+    ) as store:
+        test_pref = str(uuid.uuid4())
+        test_namespaces = [
+            (test_pref, "test", "documents", "public", test_pref),
+            (test_pref, "test", "documents", "private", test_pref),
+            (test_pref, "test", "images", "public", test_pref),
+            (test_pref, "test", "images", "private", test_pref),
+            (test_pref, "prod", "documents", "public", test_pref),
+            (test_pref, "prod", "documents", "some", "nesting", "public", test_pref),
+            (test_pref, "prod", "documents", "private", test_pref),
+        ]
+
+        # Add test data
+        for namespace in test_namespaces:
+            await store.aput(namespace, "dummy", {"content": "dummy"})
+
+        # Test prefix filtering
+        prefix_result = await store.alist_namespaces(prefix=(test_pref, "test"))
+        assert len(prefix_result) == 4
+        assert all(ns[1] == "test" for ns in prefix_result)
+
+        # Test specific prefix
+        specific_prefix_result = await store.alist_namespaces(
+            prefix=(test_pref, "test", "documents")
+        )
+        assert len(specific_prefix_result) == 2
+        assert all(ns[1:3] == ("test", "documents") for ns in specific_prefix_result)
+
+        # Test suffix filtering
+        suffix_result = await store.alist_namespaces(suffix=("public", test_pref))
+        assert len(suffix_result) == 4
+        assert all(ns[-2] == "public" for ns in suffix_result)
+
+        # Test combined prefix and suffix
+        prefix_suffix_result = await store.alist_namespaces(
+            prefix=(test_pref, "test"), suffix=("public", test_pref)
+        )
+        assert len(prefix_suffix_result) == 2
+        assert all(
+            ns[1] == "test" and ns[-2] == "public" for ns in prefix_suffix_result
+        )
+
+        # Test wildcard in prefix
+        wildcard_prefix_result = await store.alist_namespaces(
+            prefix=(test_pref, "*", "documents")
+        )
+        assert len(wildcard_prefix_result) == 5
+        assert all(ns[2] == "documents" for ns in wildcard_prefix_result)
+
+        # Test wildcard in suffix
+        wildcard_suffix_result = await store.alist_namespaces(
+            suffix=("*", "public", test_pref)
+        )
+        assert len(wildcard_suffix_result) == 4
+        assert all(ns[-2] == "public" for ns in wildcard_suffix_result)
+
+        wildcard_single = await store.alist_namespaces(
+            suffix=("some", "*", "public", test_pref)
+        )
+        assert len(wildcard_single) == 1
+        assert wildcard_single[0] == (
+            test_pref,
+            "prod",
+            "documents",
+            "some",
+            "nesting",
+            "public",
+            test_pref,
+        )
+
+        # Test max depth
+        max_depth_result = await store.alist_namespaces(max_depth=3)
+        assert all(len(ns) <= 3 for ns in max_depth_result)
+
+        max_depth_result = await store.alist_namespaces(
+            max_depth=4, prefix=(test_pref, "*", "documents")
+        )
+        assert len(set(res for res in max_depth_result)) == len(max_depth_result) == 5
+
+        # Test pagination
+        limit_result = await store.alist_namespaces(prefix=(test_pref,), limit=3)
+        assert len(limit_result) == 3
+
+        offset_result = await store.alist_namespaces(prefix=(test_pref,), offset=3)
+        assert len(offset_result) == len(test_namespaces) - 3
+
+        empty_prefix_result = await store.alist_namespaces(prefix=(test_pref,))
+        assert len(empty_prefix_result) == len(test_namespaces)
+        assert set(empty_prefix_result) == set(test_namespaces)
+
+        # Clean up
+        for namespace in test_namespaces:
+            await store.adelete(namespace, "dummy")
+
+
+async def test_search_items(
+    fake_embeddings: CharacterEmbeddings,
+) -> None:
+    """Test search_items functionality by calling store methods directly."""
+    base = "test_search_items"
+    test_namespaces = [
+        (base, "documents", "user1"),
+        (base, "documents", "user2"),
+        (base, "reports", "department1"),
+        (base, "reports", "department2"),
+    ]
+    test_items = [
+        {"title": "Doc 1", "author": "John Doe", "tags": ["important"]},
+        {"title": "Doc 2", "author": "Jane Smith", "tags": ["draft"]},
+        {"title": "Report A", "author": "John Doe", "tags": ["final"]},
+        {"title": "Report B", "author": "Alice Johnson", "tags": ["draft"]},
+    ]
+
+    async with create_vector_store(
+        fake_embeddings, text_fields=["key0", "key1", "key3"]
+    ) as store:
+        # Insert test data
+        for ns, item in zip(test_namespaces, test_items, strict=False):
+            key = f"item_{ns[-1]}"
+            await store.aput(ns, key, item)
+
+        # 1. Search documents
+        docs = await store.asearch((base, "documents"))
+        assert len(docs) == 2
+        assert all(item.namespace[1] == "documents" for item in docs)
+
+        # 2. Search reports
+        reports = await store.asearch((base, "reports"))
+        assert len(reports) == 2
+        assert all(item.namespace[1] == "reports" for item in reports)
+
+        # 3. Pagination
+        first_page = await store.asearch((base,), limit=2, offset=0)
+        second_page = await store.asearch((base,), limit=2, offset=2)
+        assert len(first_page) == 2
+        assert len(second_page) == 2
+        keys_page1 = {item.key for item in first_page}
+        keys_page2 = {item.key for item in second_page}
+        assert keys_page1.isdisjoint(keys_page2)
+        all_items = await store.asearch((base,))
+        assert len(all_items) == 4
+
+        john_items = await store.asearch((base,), filter={"author": "John Doe"})
+        assert len(john_items) == 2
+        assert all(item.value["author"] == "John Doe" for item in john_items)
+
+        draft_items = await store.asearch((base,), filter={"tags": ["draft"]})
+        assert len(draft_items) == 2
+        assert all("draft" in item.value["tags"] for item in draft_items)
+
+        for ns in test_namespaces:
+            key = f"item_{ns[-1]}"
+            await store.adelete(ns, key)