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
72 changes: 71 additions & 1 deletion tests/unit/test_cell_attach_cleanup.py
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@
from unittest.mock import AsyncMock

import pytest
import pytest_asyncio

from server.cli import cell_attach, cell_control
from tests.unit.cell_control_owner import owner
Expand Down Expand Up @@ -96,7 +97,8 @@ async def work():
await asyncio.gather(*owned_tasks, return_exceptions=True)


@pytest.mark.asyncio
@pytest.mark.asyncio(loop_scope="function")
@pytest.mark.usefixtures("_cleanup_clock")
async def test_lock_owner_bounds_close_inside_the_same_cleanup_allowance():
closing = asyncio.Event()
conn = AsyncMock()
Expand Down Expand Up @@ -152,3 +154,71 @@ async def open(owned, what):
if failed:
assert caught.value is original
conn.close.assert_awaited_once()


@pytest.mark.parametrize("scheduler_s", [0.0, 0.16])
@pytest.mark.asyncio(loop_scope="function")
@pytest.mark.usefixtures("_cleanup_clock")
async def test_cleanup_allowance_ignores_independent_scheduler_time(monkeypatch, scheduler_s):
import time as wall_time

real_monotonic = wall_time.monotonic
elapsed = 0.0

def monotonic():
return real_monotonic() + elapsed

actual_close = cell_control.Owner.close

async def close(owned):
nonlocal elapsed
try:
return await actual_close(owned)
finally:
elapsed += scheduler_s

monkeypatch.setattr(wall_time, "monotonic", monotonic)
monkeypatch.setattr(cell_control.Owner, "close", close)
await test_lock_owner_bounds_close_inside_the_same_cleanup_allowance()


@pytest_asyncio.fixture(loop_scope="function")
async def _cleanup_clock(monkeypatch):
from server.core import pg
from tests.unit.clock_fake import ManualClock

before = set(asyncio.all_tasks())
loop = asyncio.get_running_loop()
clock = ManualClock(t=loop.time())
selector = loop._selector
real_select = selector.select

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

# The cleanup protocol spends idle time, independently of CPU scheduling.
monkeypatch.setattr(loop, "time", clock.monotonic)
monkeypatch.setattr(selector, "select", select)
monkeypatch.setattr(cell_control, "time", clock)
monkeypatch.setattr(pg, "time", clock)
monkeypatch.setattr(f"{__name__}.time", clock)
yield clock
leaked = asyncio.all_tasks() - before - {asyncio.current_task()}
for task in leaked:
task.cancel()
await asyncio.gather(*leaked, return_exceptions=True)
assert not leaked, "cell cleanup leaves no task on its private loop"


@pytest.mark.asyncio(loop_scope="function")
async def test_cleanup_clock_preserves_the_close_deadline(_cleanup_clock):
from server.core import pg

loop = asyncio.get_running_loop()
assert loop.time == time.monotonic == cell_control.time.monotonic == pg.time.monotonic
began = _cleanup_clock.monotonic()
await test_lock_owner_bounds_close_inside_the_same_cleanup_allowance()
assert _cleanup_clock.monotonic() - began == pytest.approx(0.03)
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
Loading