Skip to content

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

10.8 KB
Raw Blame
"""First A2A inputs retain their identity across durable acceptance retries."""

from concurrent.futures import ThreadPoolExecutor
from threading import Barrier
from unittest.mock import Mock

import pytest
from sqlalchemy.orm import sessionmaker

from tests.web.services.task_database_shared import engine as engine_fixture
from xagent.web.models import database
from xagent.web.models.agent import Agent
from xagent.web.models.database import Base
from xagent.web.models.task import Task, TaskStatus
from xagent.web.models.task_command import TaskExecutionCommand
from xagent.web.models.user import User
from xagent.web.services import (
    a2a_task_read,
    task_event_bridge,
    task_orchestrator,
    task_start,
)

engine = engine_fixture


@pytest.fixture
def ingress(engine, monkeypatch):
    monkeypatch.setenv("XAGENT_SHARED_TASK_EXECUTION_ENABLED", "true")
    monkeypatch.setattr(task_event_bridge, "_bridge", Mock())
    monkeypatch.setattr(
        task_orchestrator,
        "_schedule_bg",
        Mock(side_effect=AssertionError("local execution")),
    )
    Base.metadata.create_all(engine)
    sessions = sessionmaker(bind=engine)
    for module in (database, task_start, a2a_task_read):
        monkeypatch.setattr(module, "get_session_local", lambda: sessions)
    with sessions() as db:
        user = User(username="owner", password_hash="unused")
        db.add(user)
        db.flush()
        agent = Agent(user_id=user.id, name="A2A")
        db.add(agent)
        db.commit()
        args = dict(
            agent_id=agent.id,
            task_owner_user_id=user.id,
            agent_execution_mode="balanced",
            text="hello",
            message_id="message-1",
            key_prefix="key-one",
            context_id=None,
            task_id=None,
        )
    yield sessions, args
    Base.metadata.drop_all(engine)


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "status", [TaskStatus.PENDING, TaskStatus.COMPLETED, TaskStatus.FAILED]
)
async def test_first_message_replay_returns_original_task_without_scheduling(
    ingress, status
):
    sessions, args = ingress
    first = await task_start.start_a2a_turn(**args)
    with sessions() as db:
        db.get(Task, first.id).status = status
        db.commit()
    replay = await task_start.start_a2a_turn(**args)
    assert replay.id == first.id
    assert replay.status == status
    with sessions() as db:
        assert db.query(Task).count() == 1
        assert db.query(TaskExecutionCommand).count() == 1


@pytest.mark.asyncio
@pytest.mark.parametrize(
    "change", [{"text": "different"}, {"context_id": "different-context"}]
)
async def test_same_message_with_changed_input_is_conflict(ingress, change):
    sessions, args = ingress
    await task_start.start_a2a_turn(**args)
    with pytest.raises(task_start.TaskStartRejected, match="a2a_input_conflict"):
        await task_start.start_a2a_turn(**(args | change))
    with sessions() as db:
        assert db.query(Task).count() == 1


@pytest.mark.asyncio
async def test_different_message_identity_is_a_new_task(ingress):
    _, args = ingress
    first = await task_start.start_a2a_turn(**args)
    second = await task_start.start_a2a_turn(**(args | {"message_id": "message-2"}))
    assert first.id != second.id


@pytest.mark.asyncio
async def test_same_message_is_isolated_by_agent_and_owner(ingress):
    sessions, args = ingress
    first = await task_start.start_a2a_turn(**args)
    with sessions() as db:
        another = Agent(user_id=args["task_owner_user_id"], name="another")
        db.add(another)
        db.commit()
        agent_id = another.id
    second = await task_start.start_a2a_turn(**(args | {"agent_id": agent_id}))
    with sessions() as db:
        owner = User(username="new-owner", password_hash="unused")
        db.add(owner)
        db.flush()
        db.get(Agent, args["agent_id"]).user_id = owner.id
        db.commit()
        owner_id = owner.id
    third = await task_start.start_a2a_turn(**(args | {"task_owner_user_id": owner_id}))
    assert len({first.id, second.id, third.id}) == 3


@pytest.mark.asyncio
@pytest.mark.parametrize("delete_command", [False, True])
async def test_deleted_input_target_remains_a_tombstone(ingress, delete_command):
    from xagent.web.models.task_input_receipt import TaskInputReceipt

    sessions, args = ingress
    first = await task_start.start_a2a_turn(**args)
    with sessions() as db:
        if delete_command:
            db.query(TaskExecutionCommand).delete(synchronize_session=False)
        else:
            db.query(Task).filter_by(id=first.id).delete(synchronize_session=False)
        db.commit()
        assert db.query(TaskInputReceipt).count() == 1
    with pytest.raises(task_start.TaskStartRejected, match="a2a_input_unavailable"):
        await task_start.start_a2a_turn(**args)
    with sessions() as db:
        assert db.query(TaskExecutionCommand).count() == 0
        assert db.query(Task).count() == int(delete_command)


@pytest.mark.asyncio
async def test_owner_transfer_does_not_expose_original_input(ingress):
    sessions, args = ingress
    first = await task_start.start_a2a_turn(**args)
    with sessions() as db:
        owner = User(username="replacement", password_hash="unused")
        db.add(owner)
        db.flush()
        db.get(Task, first.id).user_id = owner.id
        db.commit()
    with pytest.raises(task_start.TaskStartRejected, match="a2a_input_unavailable"):
        await task_start.start_a2a_turn(**args)


def test_concurrent_first_requests_commit_only_one_graph(ingress, engine):
    from sqlalchemy import event

    from xagent.web.models.chat_message import TaskChatMessage
    from xagent.web.models.task_input_receipt import TaskInputReceipt

    sessions, args = ingress
    barrier = Barrier(2)

    def before_insert(_conn, _cursor, statement, _parameters, _context, _many):
        if statement.startswith("INSERT INTO task_input_receipts"):
            barrier.wait(timeout=10)

    event.listen(engine, "before_cursor_execute", before_insert)
    try:
        with ThreadPoolExecutor(max_workers=2) as executor:
            futures = [
                executor.submit(task_start._prepare_a2a_turn_sync, **args)
                for _ in range(2)
            ]
            results = [future.result(timeout=20) for future in futures]
    finally:
        event.remove(engine, "before_cursor_execute", before_insert)
    ids = [
        result.task.id
        if isinstance(result, task_start._A2ATurnPreparation)
        else result.id
        for result in results
    ]
    assert ids[0] == ids[1]
    with sessions() as db:
        assert db.query(TaskInputReceipt).count() == 1
        assert db.query(Task).count() == 1
        assert db.query(TaskExecutionCommand).count() == 1
        assert db.query(TaskChatMessage).count() == 1


@pytest.mark.asyncio
async def test_acceptance_failure_rolls_back_receipt_and_task(ingress, monkeypatch):
    from xagent.web.models.task_input_receipt import TaskInputReceipt

    sessions, args = ingress
    original = task_orchestrator.TaskTurnOrchestrator.claim_created_turn_no_commit
    monkeypatch.setattr(
        task_orchestrator.TaskTurnOrchestrator,
        "claim_created_turn_no_commit",
        Mock(side_effect=RuntimeError("reject admission")),
    )
    with pytest.raises(RuntimeError, match="reject admission"):
        await task_start.start_a2a_turn(**args)
    with sessions() as db:
        assert db.query(TaskInputReceipt).count() == 0
        assert db.query(Task).count() == 0
        assert db.query(TaskExecutionCommand).count() == 0
    monkeypatch.setattr(
        task_orchestrator.TaskTurnOrchestrator, "claim_created_turn_no_commit", original
    )
    await task_start.start_a2a_turn(**args)


@pytest.mark.asyncio
@pytest.mark.parametrize("committed", [False, True])
async def test_uncertain_commit_reconciles_only_durable_receipt(
    ingress, engine, monkeypatch, committed
):
    from sqlalchemy.orm import Session

    from xagent.web.models.task_input_receipt import TaskInputReceipt

    sessions, args = ingress
    failed = False

    class UncertainSession(Session):
        def commit(self):
            nonlocal failed
            if not failed:
                failed = True
                if committed:
                    super().commit()
                raise RuntimeError("commit acknowledgement lost")
            return super().commit()

    uncertain = sessionmaker(bind=engine, class_=UncertainSession)
    monkeypatch.setattr(task_start, "get_session_local", lambda: uncertain)
    if committed:
        first = await task_start.start_a2a_turn(**args)
    else:
        with pytest.raises(RuntimeError, match="commit acknowledgement lost"):
            await task_start.start_a2a_turn(**args)
    with sessions() as db:
        assert db.query(TaskInputReceipt).count() == int(committed)
        assert db.query(Task).count() == int(committed)
    retry = await task_start.start_a2a_turn(**args)
    if committed:
        assert retry.id == first.id
    with sessions() as db:
        assert db.query(TaskInputReceipt).count() == 1
        assert db.query(TaskExecutionCommand).count() == 1


@pytest.mark.asyncio
@pytest.mark.parametrize("text", ["hello", "different input"])
async def test_different_key_has_independent_message_identity(ingress, text):
    sessions, args = ingress
    first = await task_start.start_a2a_turn(**args)
    other = args | {"key_prefix": "key-two", "text": text}
    second = await task_start.start_a2a_turn(**other)
    replay = await task_start.start_a2a_turn(**other)
    assert second.id != first.id
    assert replay.id == second.id
    with sessions() as db:
        assert db.query(Task).count() == 2
        assert db.query(TaskExecutionCommand).count() == 2


@pytest.mark.asyncio
@pytest.mark.parametrize("initial_context", [None, "caller-context"])
async def test_retry_with_returned_context_preserves_original_input(
    ingress, initial_context
):
    sessions, args = ingress
    args = args | {"context_id": initial_context}
    first = await task_start.start_a2a_turn(**args)
    returned = task_start.task_context_id(first)
    retry = args | {"context_id": returned}
    replay = await task_start.start_a2a_turn(**retry)
    assert replay.id == first.id
    for change in ({"text": "changed"}, {"context_id": "wrong-context"}):
        with pytest.raises(task_start.TaskStartRejected, match="a2a_input_conflict"):
            await task_start.start_a2a_turn(**(retry | change))
    if initial_context is not None:
        with pytest.raises(task_start.TaskStartRejected, match="a2a_input_conflict"):
            await task_start.start_a2a_turn(**(args | {"context_id": None}))
    with sessions() as db:
        assert db.query(Task).count() == 1
        db.query(Task).delete(synchronize_session=False)
        db.commit()
    with pytest.raises(task_start.TaskStartRejected, match="a2a_input_unavailable"):
        await task_start.start_a2a_turn(**retry)