Download sibyl-memory-langgraph/tests/test_namespaces.py from SibylLabsLLC/Sibyl-Memory: direct link, hf CLI and curl.
- Browser
- Download file 12.7 kB
-
https://huggingface.co/SibylLabsLLC/Sibyl-Memory/resolve/main/sibyl-memory-langgraph/tests/test_namespaces.py
- Command line
-
hf download hf://SibylLabsLLC/Sibyl-Memory/sibyl-memory-langgraph/tests/test_namespaces.py
-
curl -L -o test_namespaces.py https://huggingface.co/SibylLabsLLC/Sibyl-Memory/resolve/main/sibyl-memory-langgraph/tests/test_namespaces.py
12.7 kB
| """Rigorous coverage of SibylStore NAMESPACES + list_namespaces + VALIDATION. | |
| Dimension: namespace listing, max_depth, prefix/suffix/wildcard matching, | |
| limit/offset pagination, namespace validation, deep-namespace round-trip, | |
| namespace isolation, and a SET-based differential against the reference | |
| ``InMemoryStore``. | |
| Contract under test (per task brief, treated as intentional / NOT bugs): | |
| * namespace tuple -> category "/".join(namespace). | |
| * namespace elements MUST be non-empty strings with no "/" and no ".."; | |
| invalid -> ValueError. Empty namespace tuple -> ValueError. | |
| * list_namespaces(*, prefix, suffix, max_depth, limit=100, offset=0) | |
| returns a list of namespace tuples (dispatches to ListNamespacesOp). | |
| Note on the reference impl: langgraph's ``InMemoryStore`` validates via | |
| ``_validate_namespace`` which bans "." (and thereby ".."), empty strings, | |
| non-strings, and a "langgraph" root, but ALLOWS "/". SibylStore instead bans | |
| "/" and "..". These validation *rules* differ by design, so the differential | |
| below only ever uses namespaces that are valid under BOTH stores, and the | |
| validation tests assert SibylStore's own documented rules directly. | |
| """ | |
| from __future__ import annotations | |
| import os | |
| import tempfile | |
| import pytest | |
| from sibyl_memory_langgraph import SibylStore | |
| from langgraph.store.memory import InMemoryStore | |
| from langgraph.store.base import ListNamespacesOp, MatchCondition | |
| # -------------------------------------------------------------------------- | |
| # fixtures / helpers | |
| # -------------------------------------------------------------------------- | |
| def _new_sibyl() -> SibylStore: | |
| d = tempfile.mkdtemp() | |
| return SibylStore(path=os.path.join(d, "t.db"), tier="free") | |
| def store(): | |
| s = _new_sibyl() | |
| try: | |
| yield s | |
| finally: | |
| s.close() | |
| # A namespace set valid under BOTH SibylStore and InMemoryStore (no ".", no "/", | |
| # no "..", no "langgraph" root). Used for listing + differential tests. | |
| DIFF_NS = [ | |
| ("a", "b", "c"), | |
| ("a", "b", "d", "e"), | |
| ("a", "b", "f"), | |
| ("a", "c", "f"), | |
| ("docs", "reports", "2024"), | |
| ("docs", "reports", "2025"), | |
| ] | |
| def _populate(s, namespaces, value=None): | |
| for ns in namespaces: | |
| s.put(ns, "k", value or {"v": 1}) | |
| def pair(): | |
| """A SibylStore and an InMemoryStore populated identically with DIFF_NS.""" | |
| s = _new_sibyl() | |
| m = InMemoryStore() | |
| _populate(s, DIFF_NS) | |
| _populate(m, DIFF_NS) | |
| try: | |
| yield s, m | |
| finally: | |
| s.close() | |
| # -------------------------------------------------------------------------- | |
| # basic listing + round-trip | |
| # -------------------------------------------------------------------------- | |
| def test_list_namespaces_returns_every_distinct_namespace(store): | |
| _populate(store, DIFF_NS) | |
| got = store.list_namespaces() | |
| assert set(got) == set(DIFF_NS) | |
| def test_list_namespaces_returns_tuples(store): | |
| _populate(store, DIFF_NS) | |
| got = store.list_namespaces() | |
| assert all(isinstance(ns, tuple) for ns in got) | |
| assert all(all(isinstance(el, str) for el in ns) for ns in got) | |
| def test_list_namespaces_is_sorted_ascending(store): | |
| _populate(store, DIFF_NS) | |
| got = store.list_namespaces() | |
| assert got == sorted(got) | |
| def test_list_namespaces_dedups_overwrites(store): | |
| store.put(("a", "b"), "k1", {"v": 1}) | |
| store.put(("a", "b"), "k1", {"v": 2}) # overwrite same key | |
| store.put(("a", "b"), "k2", {"v": 3}) # second key, same namespace | |
| got = store.list_namespaces() | |
| assert got.count(("a", "b")) == 1 | |
| def test_list_namespaces_reflects_delete(store): | |
| store.put(("solo",), "k", {"v": 1}) | |
| assert ("solo",) in store.list_namespaces() | |
| store.delete(("solo",), "k") | |
| assert ("solo",) not in store.list_namespaces() | |
| def test_parent_and_child_namespaces_are_distinct(store): | |
| store.put(("a",), "k", {"v": 1}) | |
| store.put(("a", "b"), "k", {"v": 2}) | |
| got = set(store.list_namespaces()) | |
| assert ("a",) in got | |
| assert ("a", "b") in got | |
| # -------------------------------------------------------------------------- | |
| # deep namespaces round-trip | |
| # -------------------------------------------------------------------------- | |
| def test_deep_namespace_roundtrip(store, ns): | |
| store.put(ns, "k", {"depth": len(ns)}) | |
| item = store.get(ns, "k") | |
| assert item is not None | |
| assert item.namespace == ns | |
| assert item.value["depth"] == len(ns) | |
| assert ns in store.list_namespaces() | |
| # -------------------------------------------------------------------------- | |
| # namespace isolation | |
| # -------------------------------------------------------------------------- | |
| def test_namespace_isolation_same_key_independent(store): | |
| store.put(("a", "b"), "key", {"who": "b"}) | |
| store.put(("a", "c"), "key", {"who": "c"}) | |
| assert store.get(("a", "b"), "key").value == {"who": "b"} | |
| assert store.get(("a", "c"), "key").value == {"who": "c"} | |
| # deleting one leaves the other intact | |
| store.delete(("a", "b"), "key") | |
| assert store.get(("a", "b"), "key") is None | |
| assert store.get(("a", "c"), "key").value == {"who": "c"} | |
| # -------------------------------------------------------------------------- | |
| # max_depth (alone) — truncate + dedup | |
| # -------------------------------------------------------------------------- | |
| def test_max_depth_truncates_and_dedups(store): | |
| store.put(("a", "b", "c"), "k", {"v": 1}) | |
| got = store.list_namespaces(max_depth=1) | |
| assert ("a",) in got | |
| # nothing longer than depth 1 should survive | |
| assert all(len(ns) <= 1 for ns in got) | |
| def test_max_depth_dedup_collapses_siblings(store): | |
| _populate(store, DIFF_NS) | |
| got = set(store.list_namespaces(max_depth=2)) | |
| assert got == {("a", "b"), ("a", "c"), ("docs", "reports")} | |
| def test_parent_and_child_collapse_under_max_depth(store): | |
| store.put(("a",), "k", {"v": 1}) | |
| store.put(("a", "b"), "k", {"v": 2}) | |
| got = store.list_namespaces(max_depth=1) | |
| assert got.count(("a",)) == 1 | |
| # -------------------------------------------------------------------------- | |
| # prefix / suffix / wildcard matching | |
| # -------------------------------------------------------------------------- | |
| def test_prefix_match(store): | |
| _populate(store, DIFF_NS) | |
| got = set(store.list_namespaces(prefix=("a", "b"))) | |
| assert got == {("a", "b", "c"), ("a", "b", "d", "e"), ("a", "b", "f")} | |
| def test_prefix_no_match_returns_empty(store): | |
| _populate(store, DIFF_NS) | |
| assert store.list_namespaces(prefix=("nope",)) == [] | |
| def test_suffix_match(store): | |
| _populate(store, DIFF_NS) | |
| got = set(store.list_namespaces(suffix=("f",))) | |
| assert got == {("a", "b", "f"), ("a", "c", "f")} | |
| def test_prefix_wildcard(store): | |
| _populate(store, DIFF_NS) | |
| got = set(store.list_namespaces(prefix=("a", "*"))) | |
| assert got == { | |
| ("a", "b", "c"), | |
| ("a", "b", "d", "e"), | |
| ("a", "b", "f"), | |
| ("a", "c", "f"), | |
| } | |
| def test_suffix_wildcard(store): | |
| _populate(store, DIFF_NS) | |
| got = set(store.list_namespaces(suffix=("*", "f"))) | |
| assert got == {("a", "b", "f"), ("a", "c", "f")} | |
| def test_prefix_and_suffix_combined(store): | |
| _populate(store, DIFF_NS) | |
| got = set(store.list_namespaces(prefix=("a", "b"), suffix=("c",))) | |
| assert got == {("a", "b", "c")} | |
| # -------------------------------------------------------------------------- | |
| # pagination | |
| # -------------------------------------------------------------------------- | |
| def test_limit(store): | |
| _populate(store, DIFF_NS) | |
| full = store.list_namespaces() | |
| got = store.list_namespaces(limit=2) | |
| assert got == full[:2] | |
| def test_offset(store): | |
| _populate(store, DIFF_NS) | |
| full = store.list_namespaces() | |
| got = store.list_namespaces(offset=2) | |
| assert got == full[2:] | |
| def test_offset_limit_combo(store): | |
| _populate(store, DIFF_NS) | |
| full = store.list_namespaces() | |
| got = store.list_namespaces(offset=2, limit=2) | |
| assert got == full[2:4] | |
| def test_offset_past_end_returns_empty(store): | |
| _populate(store, DIFF_NS) | |
| assert store.list_namespaces(offset=999) == [] | |
| # -------------------------------------------------------------------------- | |
| # DIFFERENTIAL vs InMemoryStore (compare as SETS) | |
| # -------------------------------------------------------------------------- | |
| # Each entry is kwargs for list_namespaces. SibylStore and InMemoryStore must | |
| # return the same SET of namespaces. Cases tagged below with comments that | |
| # include "BUG" are expected to fail and expose adapter defects. | |
| DIFF_QUERIES = [ | |
| {}, | |
| {"max_depth": 1}, | |
| {"max_depth": 2}, | |
| {"max_depth": 3}, | |
| {"prefix": ("a",)}, | |
| {"prefix": ("a", "b")}, | |
| {"suffix": ("f",)}, | |
| {"suffix": ("2024",)}, | |
| {"prefix": ("a", "*")}, | |
| {"suffix": ("*", "f")}, | |
| {"prefix": ("a", "b"), "suffix": ("c",)}, | |
| {"prefix": ("a", "b"), "max_depth": 3}, # control: max_depth >= prefix len | |
| {"suffix": ("c",), "max_depth": 3}, # control: max_depth keeps suffix elem | |
| {"limit": 2}, | |
| {"offset": 2, "limit": 2}, | |
| {"prefix": ("a", "b"), "max_depth": 1}, # BUG A: max_depth < prefix len | |
| {"suffix": ("f",), "max_depth": 2}, # BUG A: max_depth truncates suffix elem | |
| ] | |
| def test_differential_list_namespaces(pair, kwargs): | |
| s, m = pair | |
| sib = set(s.list_namespaces(**kwargs)) | |
| ref = set(m.list_namespaces(**kwargs)) | |
| assert sib == ref, f"divergence for {kwargs}: sibyl={sib} inmemory={ref}" | |
| def test_differential_via_low_level_op(pair): | |
| """Same divergence reproduced through the raw ListNamespacesOp API.""" | |
| s, m = pair | |
| op = ListNamespacesOp( | |
| match_conditions=(MatchCondition(match_type="prefix", path=("a", "b")),), | |
| max_depth=1, | |
| ) | |
| sib = set(s.batch([op])[0]) | |
| ref = set(m.batch([op])[0]) | |
| assert sib == ref, f"sibyl={sib} inmemory={ref}" | |
| # -------------------------------------------------------------------------- | |
| # VALIDATION | |
| # -------------------------------------------------------------------------- | |
| # Non-empty namespaces that are invalid under SibylStore's documented rules. | |
| INVALID_NS = [ | |
| pytest.param(("bad/elem",), id="slash"), | |
| pytest.param(("ok", "bad/elem"), id="slash-nested"), | |
| pytest.param(("..",), id="dotdot"), | |
| pytest.param(("a", "x..y"), id="dotdot-nested"), | |
| pytest.param(("",), id="empty-string"), | |
| pytest.param(("a", ""), id="empty-string-nested"), | |
| pytest.param((123,), id="non-string"), | |
| pytest.param(("a", 123), id="non-string-nested"), | |
| ] | |
| def test_get_rejects_invalid_namespace(store, ns): | |
| with pytest.raises(ValueError): | |
| store.get(ns, "k") | |
| def test_put_rejects_invalid_namespace(store, ns): | |
| with pytest.raises(ValueError): | |
| store.put(ns, "k", {"v": 1}) | |
| def test_delete_rejects_invalid_namespace(store, ns): | |
| with pytest.raises(ValueError): | |
| store.delete(ns, "k") | |
| # Per the contract, search must ALSO enforce namespace validation. These are | |
| # expected to FAIL (Bug B): search silently returns [] for invalid prefixes. | |
| def test_search_rejects_invalid_namespace(store, ns): | |
| with pytest.raises(ValueError): | |
| store.search(ns, query="x") | |
| # Empty tuple is invalid for get/put/delete (single-entity addressing) ... | |
| def test_empty_tuple_rejected_for_addressed_ops(store, fn): | |
| with pytest.raises(ValueError): | |
| fn(store) | |
| # ... but empty tuple IS a valid search prefix (search-all) and must not raise. | |
| def test_search_empty_prefix_is_valid(store): | |
| store.put(("x", "y"), "k", {"text": "hello world"}) | |
| hits = store.search((), query="hello") | |
| assert any(h.namespace == ("x", "y") for h in hits) | |
| def test_valid_namespace_roundtrips_through_all_ops(store): | |
| ns = ("users", "u1", "profile") | |
| store.put(ns, "k", {"text": "fine"}) | |
| assert store.get(ns, "k") is not None | |
| assert store.search(ns, query="fine") # exact-namespace search ok | |
| assert ns in store.list_namespaces() | |
| store.delete(ns, "k") | |
| assert store.get(ns, "k") is None | |