Chris CoutinhoandClaude Opus 4.8
477fb02b0a
- purge route: 400 (not 500) on a valid-JSON non-object body
- scanner: backstop-purge admin-disabled note/news_item/deck_card points
(their deletion-tracking lives inside the skipped scan_* fns), mirroring the
files path; gated on a concrete allow-set so fail-open never deletes
- processor: record_ingest_dropped("admin_disabled") so consent-skipped index
tasks are observable/alertable
- app.py: list /api/v1/vector-sync/purge in the endpoints log line
- capabilities: drop empty-string doc types; return frozenset throughout
- purge: document the count-before-delete approximation
- tests: non-object body -> 400, ProvisioningRequiredError -> 428, cache TTL
expiry refetch, and the scanner consent backstop
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
159 lines
5.0 KiB
Python
159 lines
5.0 KiB
Python
"""Unit tests for the Astrolabe searchable-sources capability reader."""
|
|
|
|
from __future__ import annotations
|
|
|
|
from unittest.mock import AsyncMock
|
|
|
|
import nextcloud_mcp_server.capabilities as cap
|
|
from nextcloud_mcp_server.capabilities import (
|
|
_parse_enabled_doc_types,
|
|
allowed_doc_types,
|
|
clear_cache,
|
|
is_doc_type_allowed,
|
|
)
|
|
|
|
|
|
def _payload(enabled_doc_types) -> dict:
|
|
"""Build an OCS capabilities envelope carrying the astrolabe block.
|
|
|
|
``enabled_doc_types=...`` (Ellipsis) omits the key entirely.
|
|
"""
|
|
semantic: dict = {}
|
|
if enabled_doc_types is not ...:
|
|
semantic["enabled_doc_types"] = enabled_doc_types
|
|
return {
|
|
"ocs": {
|
|
"meta": {"status": "ok"},
|
|
"data": {"capabilities": {"astrolabe": {"semantic_search": semantic}}},
|
|
}
|
|
}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# _parse_enabled_doc_types
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_parse_present_list_returns_set():
|
|
assert _parse_enabled_doc_types(_payload(["note", "file"])) == {"note", "file"}
|
|
|
|
|
|
def test_parse_empty_list_returns_empty_set():
|
|
# Admin disabled every source — distinct from "no restriction".
|
|
assert _parse_enabled_doc_types(_payload([])) == set()
|
|
|
|
|
|
def test_parse_missing_astrolabe_block_returns_none():
|
|
payload = {"ocs": {"data": {"capabilities": {}}}}
|
|
assert _parse_enabled_doc_types(payload) is None
|
|
|
|
|
|
def test_parse_missing_enabled_key_returns_none():
|
|
assert _parse_enabled_doc_types(_payload(...)) is None
|
|
|
|
|
|
def test_parse_malformed_payload_returns_none():
|
|
assert _parse_enabled_doc_types(None) is None
|
|
assert _parse_enabled_doc_types({"ocs": "nope"}) is None
|
|
assert _parse_enabled_doc_types(_payload("not-a-list")) is None
|
|
|
|
|
|
def test_parse_drops_non_string_entries():
|
|
assert _parse_enabled_doc_types(_payload(["note", 5, None])) == {"note"}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# is_doc_type_allowed
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def test_is_doc_type_allowed_none_means_no_restriction():
|
|
assert is_doc_type_allowed("anything", None) is True
|
|
|
|
|
|
def test_is_doc_type_allowed_respects_set():
|
|
allowed = frozenset({"note"})
|
|
assert is_doc_type_allowed("note", allowed) is True
|
|
assert is_doc_type_allowed("file", allowed) is False
|
|
|
|
|
|
def test_is_doc_type_allowed_empty_set_blocks_all():
|
|
assert is_doc_type_allowed("note", frozenset()) is False
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# allowed_doc_types (cache + fail-open)
|
|
# ---------------------------------------------------------------------------
|
|
|
|
|
|
def _client(payload=None, raises: Exception | None = None) -> AsyncMock:
|
|
"""An object with an async ``capabilities()`` method (AsyncMock-backed)."""
|
|
m = AsyncMock()
|
|
if raises is not None:
|
|
m.capabilities.side_effect = raises
|
|
else:
|
|
m.capabilities.return_value = payload
|
|
return m
|
|
|
|
|
|
async def test_allowed_doc_types_parses_and_caches():
|
|
clear_cache()
|
|
client = _client(_payload(["note", "file"]))
|
|
|
|
first = await allowed_doc_types(client, "alice")
|
|
second = await allowed_doc_types(client, "alice")
|
|
|
|
assert first == frozenset({"note", "file"})
|
|
assert second == frozenset({"note", "file"})
|
|
# Second call served from the cache — only one OCS round-trip.
|
|
assert client.capabilities.await_count == 1
|
|
|
|
|
|
async def test_allowed_doc_types_missing_block_returns_none():
|
|
clear_cache()
|
|
client = _client({"ocs": {"data": {"capabilities": {}}}})
|
|
assert await allowed_doc_types(client, "bob") is None
|
|
|
|
|
|
async def test_allowed_doc_types_fail_open_not_cached():
|
|
clear_cache()
|
|
client = _client(raises=RuntimeError("ocs down"))
|
|
|
|
assert await allowed_doc_types(client, "carol") is None
|
|
# Failures are not cached — the next call retries the OCS lookup.
|
|
assert await allowed_doc_types(client, "carol") is None
|
|
assert client.capabilities.await_count == 2
|
|
|
|
|
|
async def test_allowed_doc_types_cache_is_per_user():
|
|
clear_cache()
|
|
alice = _client(_payload(["note"]))
|
|
bob = _client(_payload(["file"]))
|
|
|
|
assert await allowed_doc_types(alice, "alice") == frozenset({"note"})
|
|
assert await allowed_doc_types(bob, "bob") == frozenset({"file"})
|
|
|
|
|
|
async def test_allowed_doc_types_refetches_after_ttl(monkeypatch):
|
|
clear_cache()
|
|
client = _client(_payload(["note"]))
|
|
|
|
# Drive the module clock so the second call lands past the TTL window.
|
|
clock = {"now": 1000.0}
|
|
monkeypatch.setattr(cap.time, "monotonic", lambda: clock["now"])
|
|
|
|
await allowed_doc_types(client, "erin")
|
|
clock["now"] += cap._CACHE_TTL_SECONDS + 1
|
|
await allowed_doc_types(client, "erin")
|
|
|
|
assert client.capabilities.await_count == 2
|
|
|
|
|
|
async def test_clear_cache_forces_refetch():
|
|
clear_cache()
|
|
client = _client(_payload(["note"]))
|
|
await allowed_doc_types(client, "dave")
|
|
cap.clear_cache()
|
|
await allowed_doc_types(client, "dave")
|
|
assert client.capabilities.await_count == 2
|