Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
8 changes: 6 additions & 2 deletions tests/integration/test_scim_person_live_ch.py
Original file line number Diff line number Diff line change
Expand Up @@ -125,13 +125,17 @@ async def people(monkeypatch: pytest.MonkeyPatch) -> AsyncIterator[People]:
query_all, query_one = client.query_all, client.query_one

async def all_rows(sql: str, params: dict[str, Any] | None = None, **kwargs: Any) -> Any:
observing_person = ch.current_query_tag() == "auth.scim_people"
answer = await query_all(sql, params=params, **kwargs)
made.results.append((sql, ch.statement_settings(sql), answer))
if observing_person:
made.results.append((sql, ch.statement_settings(sql), answer))
return answer

async def one_row(sql: str, params: dict[str, Any] | None = None, **kwargs: Any) -> Any:
observing_person = ch.current_query_tag() == "auth.scim_people"
answer = await query_one(sql, params=params, **kwargs)
made.results.append((sql, ch.statement_settings(sql), answer))
if observing_person:
made.results.append((sql, ch.statement_settings(sql), answer))
return answer

monkeypatch.setattr(client, "query_all", all_rows)
Expand Down
116 changes: 116 additions & 0 deletions tests/unit/test_scim_person_query_observation.py
Original file line number Diff line number Diff line change
@@ -0,0 +1,116 @@
"""Person-query evidence excludes reads from independent background tasks."""

from __future__ import annotations

import asyncio
from contextvars import Context
from typing import Any

import pytest

from server.auth import scim_people
from server.core import ch, rmt_carry
from server.settings import settings
from tests.integration.test_scim_person_live_ch import people as person_fixture
from tests.unit.test_ch_client_hygiene import _client, _FakeAsync


class Queries:
def __init__(self) -> None:
self.started = asyncio.Event()
self.background_done = asyncio.Event()
self.block_person = False
self.transport: list[tuple[str, dict[str, Any]]] = []

async def connect(self) -> None:
pass

async def disconnect(self) -> None:
pass

async def _read(self, sql: str) -> dict[str, Any]:
self.transport.append((sql, ch.statement_settings(sql, cls="read")))
if sql == "SELECT 1 AS person" and self.block_person:
self.started.set()
await self.background_done.wait()
return {"n": 0, "at": None, "altered": None}

async def query_one(self, sql: str, params: Any = None) -> dict[str, Any]:
return await self._read(sql)

async def query_all(self, sql: str, params: Any = None) -> list[dict[str, Any]]:
return [await self._read(sql)]


@pytest.fixture
async def recording(monkeypatch):
client = Queries()
monkeypatch.setattr(ch, "get_client", lambda: client)
stream = person_fixture.__wrapped__(monkeypatch)
observed = await anext(stream)
try:
yield observed, client
finally:
await stream.aclose()


@pytest.mark.parametrize("read_timeout", [0, 2.5])
@pytest.mark.parametrize("many", [False, True])
async def test_background_schema_reads_do_not_enter_person_evidence(
recording, monkeypatch, read_timeout, many
):
observed, client = recording
monkeypatch.setattr(settings, "ch_timeout_read_s", read_timeout)
client.block_person = True

async def background():
await client.started.wait()
try:
with ch.query_tag("rmt_carry.columns"):
await rmt_carry._schema_stamp(client)
finally:
client.background_done.set()

watcher = asyncio.create_task(background(), context=Context())
try:
with ch.statement_timeout(1.75), ch.query_tag("auth.scim_people"):
query = client.query_all if many else client.query_one
await query("SELECT 1 AS person")
await watcher
finally:
if not watcher.done():
watcher.cancel()
await asyncio.gather(watcher, return_exceptions=True)

assert len(client.transport) == 2
assert any("system.tables" in sql for sql, _ in client.transport)
assert [sql for sql, _, _ in observed.results] == ["SELECT 1 AS person"]
assert 0 < observed.results[0][1]["max_execution_time"] <= 1.75


@pytest.mark.parametrize("many", [False, True])
async def test_unbounded_person_reads_remain_visible(recording, monkeypatch, many):
observed, client = recording
monkeypatch.setattr(settings, "ch_timeout_read_s", 0)
with ch.query_tag("auth.scim_people"):
query = client.query_all if many else client.query_one
await query("SELECT 1 AS person")
assert len(observed.results) == 1
with pytest.raises(KeyError, match="max_execution_time"):
assert 0 < observed.results[0][1]["max_execution_time"] <= 1.75


@pytest.mark.parametrize("read_timeout", [0, 2.5])
@pytest.mark.parametrize("many", [False, True])
async def test_actual_person_reader_applies_its_finite_budget_to_driver(
monkeypatch, read_timeout, many
):
driver = _FakeAsync()
client = _client(monkeypatch, driver, ch_timeout_read_s=read_timeout)
monkeypatch.setattr(ch, "get_client", lambda: client)
decision = scim_people._Decision("org", "owner", "owner@example.test", scim_people._now() + 10)
with ch.statement_timeout(1.75), ch.query_tag("auth.scim_people"):
await decision.query("SELECT 1 AS person", {}, many=many)
calls = [applied for kind, sql, applied in driver.calls if sql == "SELECT 1 AS person"]
assert len(calls) == 1
assert 0 < calls[0]["max_execution_time"] <= 1.75
31 changes: 27 additions & 4 deletions tests/unit/test_source_repo_search.py
Original file line number Diff line number Diff line change
Expand Up @@ -7,6 +7,7 @@
from types import SimpleNamespace

import pytest
import pytest_asyncio

from server.core.diagnostics import codes_only
from server.knowledge.api.models_knowledge import (
Expand Down Expand Up @@ -278,8 +279,23 @@ async def test_actual_checked_children_publish_only_their_cached_ordinary_rerend
renderer.render.assert_awaited_once_with([], 7)


@pytest.fixture
def renewal_clock(monkeypatch):
@pytest_asyncio.fixture(loop_scope="function")
async def renewal_clock(monkeypatch):
before = set(asyncio.all_tasks())
loop = asyncio.get_running_loop()
idle_clock = ManualClock(t=loop.time())
selector = loop._selector
real_select = selector.select

def select(timeout=None):
if timeout is not None:
idle_clock.advance(max(0.0, timeout))
timeout = 0
return real_select(timeout)

# The watchdog measures idle time; CPU scheduling cannot spend its budget.
monkeypatch.setattr(loop, "time", idle_clock.monotonic)
monkeypatch.setattr(selector, "select", select)
clock = ManualClock()
active = []

Expand All @@ -292,17 +308,23 @@ async def timeout_at(deadline):
finally:
active.pop()

# Only the repository budget uses manual time; the outer watchdog stays real.
# Repository expiry remains explicit and separate from the loop watchdog.
monkeypatch.setattr(
repo_docs,
"asyncio",
SimpleNamespace(
get_running_loop=lambda: SimpleNamespace(time=clock.monotonic), timeout_at=timeout_at
),
)
return clock, active
yield clock, active
leaked = asyncio.all_tasks() - before - {asyncio.current_task()}
for task in leaked:
task.cancel()
await asyncio.gather(*leaked, return_exceptions=True)
assert not leaked, "repository renewal leaves no task on its private loop"


@pytest.mark.asyncio(loop_scope="function")
async def test_additive_final_permission_renewal_is_bounded_without_failing_the_base(
monkeypatch, renewal_clock
):
Expand Down Expand Up @@ -346,6 +368,7 @@ async def wait_forever():
assert not children["home"].lost and "check:home" in events


@pytest.mark.asyncio(loop_scope="function")
async def test_expiry_before_renewal_does_not_start_the_extra_proof(monkeypatch, renewal_clock):
events, children = install(monkeypatch)
clock, _ = renewal_clock
Expand Down