Enterprise agent platform for building, deploying, and operating AI teammates.
"""Integration tests for ``DELETE /v1/chat/tasks/{task_id}``.
The endpoint deletes through the same shared orchestration as the Web UI
delete, so these tests pin the v1-specific parts (run-key ownership, the
running-task refusal, the 200/404 surface) and the shared cleanup outcome
(rows gone, workspace removed, pending obligations recorded).
"""
from __future__ import annotations
import uuid
from datetime import UTC, datetime, timedelta
from pathlib import Path
from typing import Iterator
from unittest.mock import AsyncMock, MagicMock, patch
import pytest
import xagent.web.services.task_delete as task_delete_module
from tests.shared.execution_scope import register_scope_resolver
from xagent.core.execution_scope import set_execution_scope_snapshot_loader
from xagent.web.models.chat_message import TaskChatMessage
from xagent.web.models.task import (
DAGExecution,
Task,
TaskConnectorRuntimeContext,
TaskStatus,
TraceCheckpointBlob,
TraceEvent,
TraceMessageBlob,
)
from xagent.web.models.task_command import TaskExecutionCommand
from xagent.web.models.task_runtime_secret import TaskRuntimeSecret
from xagent.web.models.uploaded_file import UploadedFile
from xagent.web.services.agent_service_manager import get_agent_manager
from xagent.web.services.execution_scope_snapshot import (
load_task_execution_scope_snapshot,
)
from xagent.web.services.task_cleanup_obligations import (
CleanupObligationStatus,
CleanupResourceKind,
list_cleanup_obligations,
)
from xagent.web.services.task_command_transport import (
COMMAND_COMPLETED,
COMMAND_PENDING,
COMMAND_PROCESSING,
)
from xagent.web.services.task_delete import (
capture_workspace_cleanup_target_best_effort,
)
from xagent.web.services.task_runtime import (
agent_config_with_task_extension_bindings,
register_task_extension,
unregister_task_extension,
)
from ..conftest import (
_admin_headers,
_direct_db_session,
_register_second_user,
client,
)
pytestmark = pytest.mark.usefixtures("_test_db")
@pytest.fixture(autouse=True)
def mock_start_task():
with patch(
"xagent.web.services.task_orchestrator._schedule_bg",
new=MagicMock(),
):
yield
@pytest.fixture(autouse=True)
def _workspace_root(tmp_path, monkeypatch) -> Iterator[Path]:
uploads = tmp_path / "uploads"
uploads.mkdir()
monkeypatch.setenv("XAGENT_UPLOADS_DIR", str(uploads))
monkeypatch.setenv("XAGENT_EXTERNAL_UPLOAD_DIRS", "")
register_scope_resolver(None)
set_execution_scope_snapshot_loader(load_task_execution_scope_snapshot)
manager = get_agent_manager()
manager._agents.clear()
manager._agent_owner_ids.clear()
manager._agent_run_ids.clear()
manager._agent_run_generations.clear()
manager._agent_cleanup_owner_ids.clear()
yield uploads
set_execution_scope_snapshot_loader(None)
def _bearer(full_key: str) -> dict[str, str]:
return {"Authorization": f"Bearer {full_key}"}
def _create_agent_with_key(
headers: dict[str, str] | None = None,
) -> tuple[int, str]:
headers = headers or _admin_headers()
agent_resp = client.post(
"/api/agents",
headers=headers,
json={
"name": f"v1 delete task agent {uuid.uuid4().hex[:8]}",
"description": "test",
"instructions": "you are a test agent",
"execution_mode": "balanced",
},
)
assert agent_resp.status_code == 200, agent_resp.text
agent_id = agent_resp.json()["id"]
key_resp = client.post(f"/api/agents/{agent_id}/api-key", headers=headers)
assert key_resp.status_code == 200, key_resp.text
return agent_id, key_resp.json()["full_key"]
def _create_task(full_key: str, agent_id: int) -> int:
response = client.post(
"/v1/chat/tasks",
headers=_bearer(full_key),
json={
"agent_id": agent_id,
"message": {"role": "user", "content": "delete me"},
},
)
assert response.status_code == 202, response.text
return response.json()["task_id"]
def _force_status(task_id: int, status: TaskStatus) -> None:
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.status = status
task.control_state = status.value
if status not in (TaskStatus.PENDING, TaskStatus.RUNNING):
# A finished turn has released its lease and settled its start
# command; creating the task claimed the first and may stage the other.
db.query(TaskExecutionCommand).filter(
TaskExecutionCommand.task_id == task_id
).update({"status": COMMAND_COMPLETED})
task.lease_expires_at = None
db.commit()
finally:
db.close()
def _seed_related_rows(
*,
task_id: int,
owner_id: int,
uploads: Path,
) -> None:
db = _direct_db_session()
try:
db.add(
TraceEvent(
task_id=task_id,
event_id=f"event-{task_id}",
event_type="ai_message",
timestamp=datetime.now(UTC),
data={"content": "trace"},
)
)
db.add(
TraceMessageBlob(
task_id=task_id,
execution_id=f"exec-{task_id}",
message_hash=f"hash-{task_id}",
message_data={"content": "blob"},
message_bytes=12,
)
)
db.add(
TraceCheckpointBlob(
task_id=task_id,
execution_id=f"exec-{task_id}",
blob_kind="messages",
blob_hash=f"blob-{task_id}",
blob_data={"content": "checkpoint"},
blob_bytes=16,
)
)
db.add(
TaskChatMessage(
task_id=task_id,
user_id=owner_id,
role="user",
content="delete me",
message_type="user_message",
)
)
db.add(DAGExecution(task_id=task_id))
db.add(
TaskConnectorRuntimeContext(
task_id=task_id,
connector_type="mcp",
connector_id=1,
context={"account_id": "acct"},
)
)
db.add(
TaskRuntimeSecret(
task_id=task_id,
turn_id=f"turn-{task_id}",
run_id=f"run-{task_id}",
owner_subject="owner",
ciphertext="ciphertext",
)
)
db.add(
UploadedFile(
user_id=owner_id,
task_id=task_id,
filename="attachment.txt",
storage_path=str(uploads / f"attachment-{task_id}.txt"),
file_size=4,
)
)
db.commit()
finally:
db.close()
def _bound_file_count(task_id: int) -> int:
db = _direct_db_session()
try:
return int(
db.query(UploadedFile).filter(UploadedFile.task_id == task_id).count()
)
finally:
db.close()
def _make_workspace(uploads: Path, task_id: int) -> Path:
workspace = uploads / f"web_task_{task_id}"
(workspace / "output").mkdir(parents=True)
(workspace / "output" / "result.txt").write_text("payload")
return workspace
def test_owner_delete_removes_rows_workspace_and_readability(
_workspace_root: Path,
) -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
db = _direct_db_session()
try:
owner_id = int(db.query(Task).filter(Task.id == task_id).one().user_id)
finally:
db.close()
_seed_related_rows(task_id=task_id, owner_id=owner_id, uploads=_workspace_root)
workspace = _make_workspace(_workspace_root, task_id)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 200, response.text
assert response.json() == {
"task_id": task_id,
"workspace_cleanup_pending": False,
"external_cleanup_pending": False,
}
assert not workspace.exists()
for path in (
f"/v1/chat/tasks/{task_id}",
f"/v1/chat/tasks/{task_id}/steps",
f"/v1/chat/tasks/{task_id}/events",
):
read = client.get(path, headers=_bearer(full_key))
assert read.status_code == 404, (path, read.text)
assert read.json()["error"]["code"] == "task_not_found"
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 0
assert db.query(TraceEvent).filter(TraceEvent.task_id == task_id).count() == 0
assert (
db.query(TraceMessageBlob)
.filter(TraceMessageBlob.task_id == task_id)
.count()
== 0
)
assert (
db.query(TraceCheckpointBlob)
.filter(TraceCheckpointBlob.task_id == task_id)
.count()
== 0
)
assert (
db.query(TaskChatMessage).filter(TaskChatMessage.task_id == task_id).count()
== 0
)
assert (
db.query(DAGExecution).filter(DAGExecution.task_id == task_id).count() == 0
)
assert (
db.query(TaskConnectorRuntimeContext)
.filter(TaskConnectorRuntimeContext.task_id == task_id)
.count()
== 0
)
assert (
db.query(TaskRuntimeSecret)
.filter(TaskRuntimeSecret.task_id == task_id)
.count()
== 0
)
assert _bound_file_count(task_id) == 0
files = db.query(UploadedFile).filter(UploadedFile.filename == "attachment.txt")
detached = [
row for row in files if row.storage_path.endswith(f"-{task_id}.txt")
]
assert len(detached) == 1
assert detached[0].task_id is None
assert detached[0].detached_reason == "task_deleted"
assert list_cleanup_obligations(db) == []
finally:
db.close()
def test_delete_refuses_another_agents_task_without_touching_it(
tmp_path: Path,
) -> None:
agent_a, key_a = _create_agent_with_key()
_ = agent_a
agent_b, key_b = _create_agent_with_key()
task_id = _create_task(key_b, agent_b)
_force_status(task_id, TaskStatus.COMPLETED)
db = _direct_db_session()
try:
owner_id = int(db.query(Task).filter(Task.id == task_id).one().user_id)
finally:
db.close()
_seed_related_rows(task_id=task_id, owner_id=owner_id, uploads=tmp_path)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(key_a))
assert response.status_code == 404, response.text
assert response.json()["error"]["code"] == "task_not_found"
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
assert db.query(TraceEvent).filter(TraceEvent.task_id == task_id).count() == 1
finally:
db.close()
def test_delete_of_another_users_task_is_404() -> None:
_admin_headers()
other_headers = _register_second_user("delete-other", "delete-other-pass1")
other_agent, other_key = _create_agent_with_key(other_headers)
task_id = _create_task(other_key, other_agent)
_force_status(task_id, TaskStatus.COMPLETED)
_agent, own_key = _create_agent_with_key()
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(own_key))
assert response.status_code == 404, response.text
assert response.json()["error"]["code"] == "task_not_found"
def test_delete_missing_task_and_second_delete_are_404() -> None:
agent_id, full_key = _create_agent_with_key()
missing = client.delete("/v1/chat/tasks/987654321", headers=_bearer(full_key))
assert missing.status_code == 404
assert missing.json()["error"]["code"] == "task_not_found"
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
first = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert first.status_code == 200, first.text
second = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert second.status_code == 404
assert second.json()["error"]["code"] == "task_not_found"
@pytest.mark.parametrize("status", [TaskStatus.PENDING, TaskStatus.RUNNING])
def test_delete_refuses_an_active_task(status: TaskStatus, tmp_path: Path) -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, status)
db = _direct_db_session()
try:
owner_id = int(db.query(Task).filter(Task.id == task_id).one().user_id)
finally:
db.close()
_seed_related_rows(task_id=task_id, owner_id=owner_id, uploads=tmp_path)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 409, response.text
assert response.json()["error"]["code"] == "task_busy"
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
assert db.query(TraceEvent).filter(TraceEvent.task_id == task_id).count() == 1
finally:
db.close()
@pytest.mark.parametrize(
"control_state",
["running", "pause_requested", "resume_requested"],
)
def test_delete_refuses_an_active_control_state(
control_state: str, tmp_path: Path
) -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.control_state = control_state
owner_id = int(task.user_id)
db.commit()
finally:
db.close()
_seed_related_rows(task_id=task_id, owner_id=owner_id, uploads=tmp_path)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 409, response.text
assert response.json()["error"]["code"] == "task_busy"
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
assert db.query(TraceEvent).filter(TraceEvent.task_id == task_id).count() == 1
finally:
db.close()
def _stage_command(task_id: int, status: str) -> None:
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
db.add(
TaskExecutionCommand(
task_id=task_id,
actor_user_id=int(task.user_id),
command_id=f"start:{task_id}:{status}",
kind="start",
payload={},
status=status,
)
)
db.commit()
finally:
db.close()
@pytest.mark.parametrize("command_status", [COMMAND_PENDING, COMMAND_PROCESSING])
def test_delete_refuses_a_task_with_a_live_command(
command_status: str, tmp_path: Path
) -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
_stage_command(task_id, command_status)
db = _direct_db_session()
try:
owner_id = int(db.query(Task).filter(Task.id == task_id).one().user_id)
finally:
db.close()
_seed_related_rows(task_id=task_id, owner_id=owner_id, uploads=tmp_path)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 409, response.text
assert response.json()["error"]["code"] == "task_busy"
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
assert (
db.query(TaskExecutionCommand)
.filter(TaskExecutionCommand.task_id == task_id)
.count()
== 1
)
assert db.query(TraceEvent).filter(TraceEvent.task_id == task_id).count() == 1
finally:
db.close()
def test_delete_ignores_a_finished_command(tmp_path: Path) -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
_stage_command(task_id, COMMAND_COMPLETED)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 200, response.text
def test_delete_refuses_a_task_with_an_unexpired_lease() -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.lease_expires_at = datetime.now(UTC) + timedelta(minutes=5)
db.commit()
finally:
db.close()
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 409, response.text
assert response.json()["error"]["code"] == "task_busy"
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.lease_expires_at = datetime.now(UTC) - timedelta(minutes=5)
db.commit()
finally:
db.close()
expired = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert expired.status_code == 200, expired.text
def test_delete_rechecks_activity_inside_the_deletion_transaction(
_workspace_root: Path,
) -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
db = _direct_db_session()
try:
owner_id = int(db.query(Task).filter(Task.id == task_id).one().user_id)
finally:
db.close()
_seed_related_rows(task_id=task_id, owner_id=owner_id, uploads=_workspace_root)
workspace = _make_workspace(_workspace_root, task_id)
flipped = {"done": False}
def _flip_status_then_capture(*args, **kwargs):
if not flipped["done"]:
flipped["done"] = True
_force_status(task_id, TaskStatus.RUNNING)
return capture_workspace_cleanup_target_best_effort(*args, **kwargs)
with patch(
"xagent.web.services.task_delete.capture_workspace_cleanup_target_best_effort",
side_effect=_flip_status_then_capture,
):
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert flipped["done"] is True
assert response.status_code == 409, response.text
assert response.json()["error"]["code"] == "task_busy"
assert workspace.exists()
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
assert db.query(TraceEvent).filter(TraceEvent.task_id == task_id).count() == 1
assert (
db.query(TaskChatMessage).filter(TaskChatMessage.task_id == task_id).count()
>= 1
)
finally:
db.close()
def test_delete_ignores_a_same_agent_task_not_created_by_sdk() -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.source = "web"
db.commit()
finally:
db.close()
read = client.get(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert read.status_code == 404, read.text
assert read.json()["error"]["code"] == "task_not_found"
assert response.status_code == 404, response.text
assert response.json()["error"]["code"] == "task_not_found"
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
finally:
db.close()
def test_failed_workspace_removal_leaves_a_pending_obligation(
_workspace_root: Path, monkeypatch
) -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
_make_workspace(_workspace_root, task_id)
def _explode(*args, **kwargs):
raise OSError("permission denied")
monkeypatch.setattr(
type(get_agent_manager()), "_cleanup_workspace_directory", _explode
)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 200, response.text
assert response.json()["workspace_cleanup_pending"] is True
assert response.json()["external_cleanup_pending"] is True
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 0
[owed] = list_cleanup_obligations(db)
assert owed.task_id == task_id
assert owed.kind is CleanupResourceKind.WORKSPACE
assert owed.status is CleanupObligationStatus.PENDING
assert owed.attempts == 1
assert "permission denied" in (owed.last_error or "")
finally:
db.close()
class _Provider:
def __init__(self, *, fail_delete: bool = False) -> None:
self.fail_delete = fail_delete
self.deleted: list[int] = []
async def on_task_created(self, context, configuration) -> None:
return None
async def build_runtime(self, context):
return None
async def public_metadata(self, context):
return None
async def on_task_deleted(self, context) -> None:
if self.fail_delete:
raise RuntimeError("provider is down")
self.deleted.append(int(context.task_id))
@pytest.fixture
def provider() -> Iterator[tuple[str, _Provider]]:
name = "delete_test_ext"
instance = _Provider()
register_task_extension(name, instance)
try:
yield name, instance
finally:
unregister_task_extension(name)
@pytest.fixture
def failing_provider() -> Iterator[str]:
name = "delete_failing_ext"
register_task_extension(name, _Provider(fail_delete=True))
try:
yield name
finally:
unregister_task_extension(name)
def _bind_extension(task_id: int, name: str) -> None:
db = _direct_db_session()
try:
task = db.query(Task).filter(Task.id == task_id).one()
task.agent_config = agent_config_with_task_extension_bindings(
task.agent_config, [name]
)
db.commit()
finally:
db.close()
def test_bound_extension_state_is_released(
provider: tuple[str, _Provider],
) -> None:
name, instance = provider
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
_bind_extension(task_id, name)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 200, response.text
assert instance.deleted == [task_id]
assert response.json()["external_cleanup_pending"] is False
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 0
assert list_cleanup_obligations(db) == []
finally:
db.close()
def test_failing_bound_extension_preserves_the_task(failing_provider: str) -> None:
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
_bind_extension(task_id, failing_provider)
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 503, response.text
assert response.json()["error"]["code"] == "internal_error"
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
assert list_cleanup_obligations(db) == []
finally:
db.close()
def test_active_task_is_refused_before_extension_state_is_released(
provider: tuple[str, _Provider],
) -> None:
name, instance = provider
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
_bind_extension(task_id, name)
flipped = {"done": False}
original = task_delete_module._refuse_if_task_active_sync
def _flip_status_then_check(task_id_arg: int) -> None:
if not flipped["done"]:
flipped["done"] = True
_force_status(task_id, TaskStatus.RUNNING)
original(task_id_arg)
with patch(
"xagent.web.services.task_delete._refuse_if_task_active_sync",
side_effect=_flip_status_then_check,
):
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert flipped["done"] is True
assert response.status_code == 409, response.text
assert response.json()["error"]["code"] == "task_busy"
assert instance.deleted == []
def test_activity_after_the_unlocked_check_refuses_but_the_release_has_happened(
provider: tuple[str, _Provider],
) -> None:
"""Pins the known window: the locked re-check still refuses the delete,
but provider state was released before it ran."""
name, instance = provider
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
_bind_extension(task_id, name)
flipped = {"done": False}
def _flip_status_then_capture(*args, **kwargs):
if not flipped["done"]:
flipped["done"] = True
_force_status(task_id, TaskStatus.RUNNING)
return capture_workspace_cleanup_target_best_effort(*args, **kwargs)
with patch(
"xagent.web.services.task_delete.capture_workspace_cleanup_target_best_effort",
side_effect=_flip_status_then_capture,
):
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert flipped["done"] is True
assert response.status_code == 409, response.text
assert response.json()["error"]["code"] == "task_busy"
assert instance.deleted == [task_id]
db = _direct_db_session()
try:
assert db.query(Task).filter(Task.id == task_id).count() == 1
finally:
db.close()
def test_delete_detaches_and_closes_the_tasks_websocket_connections() -> None:
from xagent.web.api.websocket import manager as websocket_manager
agent_id, full_key = _create_agent_with_key()
task_id = _create_task(full_key, agent_id)
_force_status(task_id, TaskStatus.COMPLETED)
connection = MagicMock()
connection.close = AsyncMock()
with patch.object(
websocket_manager, "detach_task_connections", return_value=[connection]
) as detach:
response = client.delete(f"/v1/chat/tasks/{task_id}", headers=_bearer(full_key))
assert response.status_code == 200, response.text
detach.assert_called_once_with(task_id)
connection.close.assert_awaited_once()