Skip to content

Enterprise agent platform for building, deploying, and operating AI teammates.

5.4 KB
Raw Blame
"""The admission predicate is built once per process and keyed on the DB clock."""

from __future__ import annotations

from datetime import datetime, timezone

import pytest
from sqlalchemy import bindparam, literal, update
from sqlalchemy.dialects import postgresql, sqlite
from sqlalchemy.orm import Session

from tests.web.services.test_task_execution_admission import engine as engine_fixture
from tests.web.services.test_task_execution_admission import enqueue
from tests.web.services.test_task_execution_admission import host as host_fixture
from xagent.web.models.task_admission_pacing import TaskAdmissionPacing
from xagent.web.services import task_admission_pacing as pacing
from xagent.web.services import task_command_transport as transport
from xagent.web.services import task_execution_admission as admission
from xagent.web.services.task_dispatch_cap import DispatchCapSnapshot, DispatchPolicy

host = host_fixture
engine = engine_fixture

DIALECTS = {"sqlite": sqlite.dialect, "postgresql": postgresql.dialect}
REAL_CLOCK_TEXT = {"sqlite": "julianday", "postgresql": "clock_timestamp()"}


@pytest.fixture(autouse=True)
def fresh_cache():
    admission.reset_admission_eligible_cache()
    yield
    admission.reset_admission_eligible_cache()


def clock_text(dialect_name: str) -> str:
    compiled = admission.admission_eligible().compile(
        dialect=DIALECTS[dialect_name](), compile_kwargs={"literal_binds": True}
    )
    return str(compiled)


def test_admission_predicate_is_built_once_and_shared():
    first = admission.admission_eligible()
    assert admission.admission_eligible() is first


def test_reset_makes_the_next_call_build_a_new_predicate():
    first = admission.admission_eligible()
    admission.reset_admission_eligible_cache()
    assert admission.admission_eligible() is not first


@pytest.mark.parametrize("dialect_name", sorted(DIALECTS))
def test_admission_predicate_rebuilds_when_clock_swapped(dialect_name, monkeypatch):
    real_clock = REAL_CLOCK_TEXT[dialect_name]
    assert real_clock in clock_text(dialect_name)

    monkeypatch.setattr(pacing, "database_time", lambda: literal(100.5))
    fixed_text = clock_text(dialect_name)
    assert "100.5" in fixed_text
    assert real_clock not in fixed_text

    now = [200.5]
    monkeypatch.setattr(
        pacing,
        "database_time",
        lambda: bindparam("fake_db_now", callable_=lambda: now[0]),
    )
    advancing_text = clock_text(dialect_name)
    assert "200.5" in advancing_text
    assert "100.5" not in advancing_text
    now[0] = 300.5
    assert "300.5" in clock_text(dialect_name)

    monkeypatch.undo()
    assert real_clock in clock_text(dialect_name)
    assert "200.5" not in clock_text(dialect_name)


POLICY = DispatchPolicy(limit=4, interactive_reserve=1)
CAPS = {
    "none": None,
    "open": DispatchCapSnapshot(policy=POLICY, active_ids=frozenset()),
    "batch_line": DispatchCapSnapshot(policy=POLICY, active_ids=frozenset({1, 2, 3})),
    "closed": DispatchCapSnapshot(policy=POLICY, active_ids=frozenset({1, 2, 3, 4})),
}
SCAN_TIME = datetime(2026, 1, 1, tzinfo=timezone.utc)


def compiled_scan(dialect_name: str, *, shared: bool, cap):
    query = transport._dispatcher_candidate_query(
        Session(),
        runner_id="runner",
        command_db_id=None,
        shared=shared,
        cap=cap,
        now=SCAN_TIME,
    )
    compiled = query.statement.compile(dialect=DIALECTS[dialect_name]())
    return str(compiled), dict(compiled.params)


@pytest.mark.parametrize("cap_name", sorted(CAPS))
@pytest.mark.parametrize("shared", [True, False], ids=["shared", "non_shared"])
@pytest.mark.parametrize("dialect_name", sorted(DIALECTS))
def test_cached_admission_predicate_compiles_identically(
    dialect_name, shared, cap_name, monkeypatch
):
    monkeypatch.setenv("XAGENT_SHARED_TASK_EXECUTION_ENABLED", str(shared).lower())
    cap = CAPS[cap_name]

    compiled_scan(dialect_name, shared=shared, cap=cap)
    cached = compiled_scan(dialect_name, shared=shared, cap=cap)

    monkeypatch.setattr(
        admission, "admission_eligible", admission._build_admission_eligible
    )
    rebuilt_first = compiled_scan(dialect_name, shared=shared, cap=cap)
    rebuilt_second = compiled_scan(dialect_name, shared=shared, cap=cap)

    assert cached == rebuilt_first == rebuilt_second


async def test_fake_database_clock_advances_through_cached_predicate(host, monkeypatch):
    now = [100.0]
    monkeypatch.setattr(
        pacing,
        "database_time",
        lambda: bindparam("fake_db_now", callable_=lambda: now[0]),
    )
    admission.set_task_admission_hook(
        lambda db, command: admission.AdmissionPolicy(
            "paced",
            10,
            20,
            pacing=pacing.StartupPacing(interval_seconds=1, burst=1),
        )
    )
    command = enqueue(host)
    with host.sessions() as db:
        db.execute(
            update(TaskAdmissionPacing)
            .where(TaskAdmissionPacing.bucket_key == "paced")
            .values(next_start_at=101.0)
        )
        db.commit()

    predicate = admission.admission_eligible()
    for instant, waits in [
        (100.0, True),
        (100.999, True),
        (101.0, False),
        (1000.0, False),
    ]:
        now[0] = instant
        with host.sessions() as db:
            assert admission.waiting_for_capacity(db, command.command_id) is waits
        # The clock advanced through the same shared expression, not a rebuild.
        assert admission.admission_eligible() is predicate