155 lines
7.0 KiB
Python
155 lines
7.0 KiB
Python
from contextlib import asynccontextmanager
|
|
from types import SimpleNamespace
|
|
from unittest.mock import AsyncMock
|
|
from uuid import uuid4
|
|
|
|
import pytest
|
|
|
|
from app.domain.domain_errors import DomainError
|
|
from app.domain.schemas.operational_task import AgentRunCommand
|
|
from app.infra.db.postgresql.operational_tasks import OperationalTaskRepository
|
|
from app.services.operational_tasks import OperationalTaskService
|
|
|
|
|
|
@pytest.fixture
|
|
def anyio_backend():
|
|
return "asyncio"
|
|
|
|
|
|
@pytest.mark.anyio
|
|
@pytest.mark.parametrize("available,agent_ownership_available,ready", [
|
|
(False, False, False), (True, False, False), (True, True, True),
|
|
])
|
|
async def test_execution_requires_message_and_agent_ownership_storage(
|
|
available, agent_ownership_available, ready,
|
|
):
|
|
cursor = SimpleNamespace(fetchone=AsyncMock(return_value={
|
|
"available": available,
|
|
"agent_ownership_available": agent_ownership_available,
|
|
}))
|
|
connection = SimpleNamespace(execute=AsyncMock(return_value=cursor))
|
|
repository = OperationalTaskRepository(connection, uuid4())
|
|
if ready:
|
|
await repository.require_execution_storage()
|
|
else:
|
|
with pytest.raises(DomainError) as failure:
|
|
await repository.require_execution_storage()
|
|
assert failure.value.status == 503
|
|
assert failure.value.code == "DEPENDENCY_UNAVAILABLE"
|
|
assert "024_agent_messages.sql" in failure.value.message
|
|
assert "030_operational_run_agent_ownership.sql" in failure.value.message
|
|
assert "to_regclass('workbench.agent_messages')" in connection.execute.call_args.args[0]
|
|
|
|
|
|
@pytest.mark.anyio
|
|
@pytest.mark.parametrize("available", [False, True])
|
|
async def test_run_update_uses_agent_owner_column_only_after_migration(available):
|
|
availability = SimpleNamespace(fetchone=AsyncMock(return_value={"available": available}))
|
|
updated = SimpleNamespace(rowcount=1)
|
|
connection = SimpleNamespace(execute=AsyncMock(side_effect=[availability, updated]))
|
|
repository = OperationalTaskRepository(connection, uuid4())
|
|
run_id = str(uuid4())
|
|
await repository.update_run({
|
|
"run_id": run_id, "status": "running", "revision": 2,
|
|
"agent_session_id": "session-1", "agent_instance_id": "agent-a",
|
|
"lease_expires_at": None, "heartbeat_at": None, "started_at": None,
|
|
"finished_at": None, "failure_code": None, "failure_detail": None,
|
|
"dispatch_attempts": 0, "next_dispatch_at": None, "updated_at": None,
|
|
}, 1)
|
|
|
|
query, params = connection.execute.call_args.args
|
|
assert ("agent_instance_id=%s" in query) is available
|
|
assert ("agent-a" in params) is available
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_missing_message_storage_rejects_claim_before_state_changes():
|
|
@asynccontextmanager
|
|
async def transaction():
|
|
yield
|
|
|
|
repository = SimpleNamespace(
|
|
transaction=transaction,
|
|
require_execution_storage=AsyncMock(side_effect=DomainError(
|
|
"DEPENDENCY_UNAVAILABLE", "Apply 024_agent_messages.sql", status=503,
|
|
)),
|
|
get_request=AsyncMock(return_value=None),
|
|
lock=AsyncMock(), update_run=AsyncMock(), update_task=AsyncMock(),
|
|
)
|
|
service = OperationalTaskService(repository, SimpleNamespace(), set())
|
|
with pytest.raises(DomainError, match="024_agent_messages.sql"):
|
|
await service.claim_run(uuid4(), uuid4(), AgentRunCommand(
|
|
request_id=uuid4(), expected_revision=1, source_session_id="test-session",
|
|
))
|
|
repository.get_request.assert_not_awaited()
|
|
repository.lock.assert_not_awaited()
|
|
repository.update_run.assert_not_awaited()
|
|
repository.update_task.assert_not_awaited()
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_presentation_history_storage_filters_project_task_and_committed_cursor():
|
|
project_id, task_id = uuid4(), uuid4()
|
|
connection = SimpleNamespace(execute=AsyncMock(return_value=SimpleNamespace(fetchall=AsyncMock(return_value=[]))))
|
|
repository = OperationalTaskRepository(connection, project_id)
|
|
assert await repository.list_presentation_events(str(task_id), 7, 30, 21) == []
|
|
query, params = connection.execute.call_args.args
|
|
assert params == (str(project_id), str(task_id), 7, 30, 21)
|
|
assert "project_id=%s" in query and "aggregate_id=%s" in query
|
|
assert "operational.presentation.requested" in query and "event_seq<=%s" in query
|
|
assert "ORDER BY event_seq LIMIT %s" in query
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_missing_scada_manifest_migration_fails_closed():
|
|
connection = SimpleNamespace(execute=AsyncMock(return_value=SimpleNamespace(
|
|
fetchone=AsyncMock(return_value={"available": False}),
|
|
)))
|
|
repository = OperationalTaskRepository(connection, uuid4())
|
|
with pytest.raises(DomainError) as failure:
|
|
await repository.get_scada_presentation(str(uuid4()), str(uuid4()))
|
|
assert failure.value.code == "DEPENDENCY_UNAVAILABLE"
|
|
assert failure.value.status == 503
|
|
assert "035_scada_presentation_coverage.sql" in failure.value.message
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_scada_manifest_is_scoped_to_project_task_and_run_and_preserves_other_run_facts():
|
|
from datetime import datetime, timezone
|
|
|
|
project, task, run = map(str, (uuid4(), uuid4(), uuid4()))
|
|
document = {"version": 1, "targets": ["524529"], "charts": {}}
|
|
connection = SimpleNamespace(execute=AsyncMock(side_effect=[
|
|
SimpleNamespace(fetchone=AsyncMock(return_value={"available": True})),
|
|
SimpleNamespace(fetchone=AsyncMock(return_value={"document": document})),
|
|
SimpleNamespace(rowcount=1),
|
|
]))
|
|
repository = OperationalTaskRepository(connection, project)
|
|
assert await repository.get_scada_presentation(task, run) == document
|
|
query, params = connection.execute.call_args.args
|
|
assert "artifact_manifest->'scada_presentation'" in query
|
|
assert params == (project, task, run)
|
|
await repository.save_scada_presentation(task, run, document, datetime.now(timezone.utc))
|
|
query, params = connection.execute.call_args.args
|
|
assert "jsonb_set(artifact_manifest,'{scada_presentation}'" in query
|
|
assert params[1:] == (project, task, run)
|
|
assert "revision=" not in query and "status=" not in query
|
|
|
|
|
|
@pytest.mark.anyio
|
|
async def test_internal_manifest_does_not_change_public_run_schemas_after_migration():
|
|
from datetime import datetime, timezone
|
|
from app.domain.schemas.operational_task import OperationalTaskRun
|
|
from tests.support.operational_task_repository import _active_run, _context, _task_document
|
|
|
|
context = _context()
|
|
task = _task_document(context, datetime.now(timezone.utc))
|
|
run = _active_run(task, datetime.now(timezone.utc))
|
|
connection = SimpleNamespace(execute=AsyncMock(return_value=SimpleNamespace(fetchall=AsyncMock(return_value=[{
|
|
**run, "project_id": context.project_id, "artifact_manifest": {"scada_presentation": {"targets": ["524529"]}},
|
|
}]))))
|
|
repository = OperationalTaskRepository(connection, context.project_id)
|
|
public = (await repository.list_task_runs(task["task_id"], 10, 0))[0]
|
|
assert "artifact_manifest" not in public
|
|
assert OperationalTaskRun.model_validate(public).run_id == OperationalTaskRun.model_validate(run).run_id
|