simple-module-background-tasks 0.0.38__tar.gz → 0.0.40__tar.gz

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: simple_module_background_tasks
-Version: 0.0.38
+Version: 0.0.40
 Summary: Celery + Redis task queue with admin UI for monitoring and retrying failed/stuck tasks
 Project-URL: Homepage, https://github.com/antosubash/simple_module_python
 Project-URL: Repository, https://github.com/antosubash/simple_module_python
@@ -21,12 +21,12 @@ Classifier: Topic :: Internet :: WWW/HTTP
 Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Typing :: Typed
 Requires-Python: >=3.12
-Requires-Dist: celery[redis]>=5.4
-Requires-Dist: redis>=5
-Requires-Dist: simple-module-core==0.0.38
-Requires-Dist: simple-module-db==0.0.38
-Requires-Dist: simple-module-hosting==0.0.38
-Requires-Dist: simple-module-settings==0.0.38
+Requires-Dist: celery[redis]<6,>=5.4
+Requires-Dist: redis<7,>=5
+Requires-Dist: simple-module-core==0.0.40
+Requires-Dist: simple-module-db==0.0.40
+Requires-Dist: simple-module-hosting==0.0.40
+Requires-Dist: simple-module-settings==0.0.40
 Description-Content-Type: text/markdown
 
 # simple_module_background_tasks

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/_signal_support.py

@@ -15,6 +15,7 @@ from typing import Any
 
 from sqlalchemy import select
 from sqlalchemy.orm import Session
+from sqlmodel import col
 
 from background_tasks.constants import INTERNAL_TASK_SWEEP_OUTBOX, TaskStatus
 from background_tasks.models import TaskExecution
@@ -53,7 +54,7 @@ def upsert_by_celery_id(
     """
     row: TaskExecution | None = None
     if celery_task_id:
-        stmt = select(TaskExecution).where(TaskExecution.celery_task_id == celery_task_id)  # ty: ignore[invalid-argument-type]
+        stmt = select(TaskExecution).where(col(TaskExecution.celery_task_id) == celery_task_id)
         row = session.execute(stmt).scalar_one_or_none()
     if row is None:
         row = TaskExecution(celery_task_id=celery_task_id, **defaults)

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/after_commit.py

@@ -59,6 +59,11 @@ _HOOKED_KEY = "background_tasks_after_commit_hooked"
 def enqueue_after_commit(db: AsyncSession | Session, task: Any, *args: Any, **kwargs: Any) -> str:
     """Send *task* once *db*'s transaction commits; never if it rolls back.
 
+    Delivery is at-most-once: publish intent exists only in memory. Broker
+    failure after commit is logged without retry; a process exit between commit
+    and publish also loses the job. For must-run work use the event bus's
+    ``publish_durable(event, db)`` transactional outbox with a durable handler.
+
     *task* is a Celery task (``send_receipt``), a signature
     (``send_receipt.s().set(queue="mail")``, for routing options), or a
     registered task name. ``*args`` / ``**kwargs`` are the task's own
@@ -89,7 +94,7 @@ def after_commit(
     request. Left off for a single publish so Celery's eager mode — which runs
     the task body inside the publish — stays on the loop's thread. One failed
     publish is logged and does not stop the rest: the rows are already
-    committed, and an unsent ``pending`` row is visible and retryable.
+    committed. Only callers with persisted pending work can reconcile failures.
     """
     batch = list(publishes)
     if isinstance(db, RequestSession) and SESSION_START_KEY in db.info:

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/endpoints/api_status.py

@@ -18,6 +18,7 @@ from simple_module_db.deps import get_db
 from simple_module_hosting.permissions import ensure_resolved_permissions
 from simple_module_hosting.token_guard import Authenticated
 from sqlalchemy import select
+from sqlmodel import col
 
 from background_tasks.constants import MODULE_NAME, PERM_VIEW, STATUS_ROUTER_PREFIX
 from background_tasks.contracts.schemas import TaskStatusDTO
@@ -56,7 +57,7 @@ async def get_task_status(
     row = (
         await db.execute(
             select(TaskExecution)
-            .where(TaskExecution.celery_task_id == celery_task_id)  # ty: ignore[invalid-argument-type]
+            .where(col(TaskExecution.celery_task_id) == celery_task_id)
             .order_by(TaskExecution.queued_at.desc())
             .limit(1)
         )

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/filters.py

@@ -10,6 +10,7 @@ from __future__ import annotations
 
 from simple_module_db import LIKE_ESCAPE_CHAR, like_contains_pattern
 from sqlalchemy import ColumnElement, select
+from sqlmodel import col
 
 from background_tasks.constants import PLATFORM_TENANT_FILTER, RETRYABLE_STATUSES, TaskStatus
 from background_tasks.models import TaskExecution
@@ -34,15 +35,15 @@ def execution_filters(
     if tenant_id == PLATFORM_TENANT_FILTER:
         conditions.append(TaskExecution.tenant_id.is_(None))
     elif tenant_id:
-        conditions.append(TaskExecution.tenant_id == tenant_id)  # ty: ignore[invalid-argument-type]
+        conditions.append(col(TaskExecution.tenant_id) == tenant_id)
     if status is not None:
-        conditions.append(TaskExecution.status == status)  # ty: ignore[invalid-argument-type]
+        conditions.append(col(TaskExecution.status) == status)
     if task_name:
         conditions.append(
             TaskExecution.task_name.ilike(like_contains_pattern(task_name), escape=LIKE_ESCAPE_CHAR)
         )
     if queue:
-        conditions.append(TaskExecution.queue == queue)  # ty: ignore[invalid-argument-type]
+        conditions.append(col(TaskExecution.queue) == queue)
     return conditions
 
 

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/log_purge.py

@@ -6,11 +6,12 @@ from datetime import datetime
 
 from sqlalchemy import delete
 from sqlalchemy.orm import Session
+from sqlmodel import col
 
 from background_tasks.models import RetainedLog
 
 
 def purge_log_records(session: Session, cutoff: datetime) -> int:
     """Delete log lines older than ``cutoff``; returns the count."""
-    result = session.execute(delete(RetainedLog).where(RetainedLog.ts < cutoff))  # ty: ignore[invalid-argument-type]
+    result = session.execute(delete(RetainedLog).where(col(RetainedLog.ts) < cutoff))
     return result.rowcount or 0

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/log_service.py

@@ -9,6 +9,7 @@ from typing import Any
 from simple_module_db import RequestSession
 from simple_module_db.pagination import PageParams, paginate
 from sqlalchemy import false, select
+from sqlmodel import col
 
 from background_tasks.constants import LOG_LEVEL_NAMES
 from background_tasks.contracts.logs import LogItem, LogListResponse
@@ -60,16 +61,18 @@ class LogService:
     ) -> LogListResponse:
         where = [*self.scope.conditions()]
         if task_id is not None:
-            where.append(RetainedLog.task_id == task_id)
+            where.append(col(RetainedLog.task_id) == task_id)
         if (level := level_number(min_level)) is not None:
-            where.append(RetainedLog.level >= level)
+            where.append(col(RetainedLog.level) >= level)
         if q:
-            where.append(RetainedLog.message.ilike(_like(q), escape="\\"))
+            where.append(col(RetainedLog.message).ilike(_like(q), escape="\\"))
         if logger_name:
-            where.append(RetainedLog.logger.startswith(logger_name))
+            where.append(col(RetainedLog.logger).startswith(logger_name))
         found = await paginate(
             self.db,
-            select(RetainedLog).where(*where).order_by(RetainedLog.ts.desc(), RetainedLog.id),  # ty: ignore[invalid-argument-type]
+            select(RetainedLog)
+            .where(*where)
+            .order_by(col(RetainedLog.ts).desc(), col(RetainedLog.id)),
             PageParams(page=page, per_page=per_page),
         )
         return LogListResponse(

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/outbox_claim.py

@@ -20,6 +20,7 @@ from typing import Any
 
 from sqlalchemy import or_, select, update
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
+from sqlmodel import col
 
 from background_tasks.constants import (
     OUTBOX_BACKOFF_BASE_SECONDS,
@@ -103,12 +104,12 @@ async def reclaim_expired(
     async with factory() as session:
         now = now or await db_now(session)
         expired = (
-            OutboxMessage.status == OutboxStatus.RUNNING,
-            or_(OutboxMessage.locked_until < now, OutboxMessage.locked_until.is_(None)),
+            col(OutboxMessage.status) == OutboxStatus.RUNNING,
+            or_(col(OutboxMessage.locked_until) < now, col(OutboxMessage.locked_until).is_(None)),
         )
         dead = await session.execute(
             update(OutboxMessage)
-            .where(*expired, OutboxMessage.attempts >= max_attempts)  # ty: ignore[invalid-argument-type]
+            .where(*expired, col(OutboxMessage.attempts) >= max_attempts)
             .values(
                 status=OutboxStatus.DEAD,
                 locked_until=None,
@@ -118,7 +119,7 @@ async def reclaim_expired(
         )
         back = await session.execute(
             update(OutboxMessage)
-            .where(*expired)  # ty: ignore[invalid-argument-type]
+            .where(*expired)
             .values(status=OutboxStatus.PENDING, locked_until=None, next_attempt_at=now)
             .execution_options(synchronize_session=False)
         )
@@ -174,7 +175,7 @@ async def claim(
             update(OutboxMessage)
             .where(
                 OutboxMessage.id.in_(select(claimable.c.id)),
-                OutboxMessage.status == OutboxStatus.PENDING,  # ty: ignore[invalid-argument-type]
+                col(OutboxMessage.status) == OutboxStatus.PENDING,
             )
             .values(
                 status=OutboxStatus.RUNNING,

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/outbox_clock.py

@@ -22,6 +22,8 @@ from __future__ import annotations
 from datetime import UTC, datetime
 from typing import Any
 
+from simple_module_core.datetimes import aware as _aware
+from simple_module_core.datetimes import utcnow
 from sqlalchemy import func, select
 from sqlalchemy.orm import Session
 
@@ -30,10 +32,6 @@ def _is_postgres(session: Any) -> bool:
     return session.get_bind().dialect.name == "postgresql"
 
 
-def _aware(value: datetime) -> datetime:
-    return value if value.tzinfo is not None else value.replace(tzinfo=UTC)
-
-
 async def db_now(session: Any) -> datetime:
     """The database's current time, as an aware UTC ``datetime``.
 
@@ -41,7 +39,7 @@ async def db_now(session: Any) -> datetime:
     hold either).
     """
     if not _is_postgres(session):
-        return datetime.now(UTC)
+        return utcnow()
     stmt = select(func.clock_timestamp())
     if isinstance(session, Session):
         value = session.execute(stmt).scalar_one()

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/outbox_service.py

@@ -9,6 +9,7 @@ from typing import TYPE_CHECKING, Any
 from fastapi import HTTPException, status
 from simple_module_db.pagination import PageParams, paginate
 from sqlalchemy import delete, false, func, select, update
+from sqlmodel import col
 
 from background_tasks.constants import OutboxStatus
 from background_tasks.contracts.outbox import OutboxItem, OutboxListResponse
@@ -66,7 +67,7 @@ class OutboxService:
             self.db,
             select(OutboxMessage)
             .where(*where)
-            .order_by(OutboxMessage.created_at.desc(), OutboxMessage.id),  # ty: ignore[invalid-argument-type]
+            .order_by(col(OutboxMessage.created_at).desc(), col(OutboxMessage.id)),
             PageParams(page=page, per_page=per_page),
         )
         return OutboxListResponse(
@@ -93,7 +94,7 @@ class OutboxService:
         row = (
             await self.db.execute(
                 select(OutboxMessage)
-                .where(OutboxMessage.id == message_id, *self.scope.conditions())  # ty: ignore[invalid-argument-type]
+                .where(col(OutboxMessage.id) == message_id, *self.scope.conditions())
                 .execution_options(populate_existing=True)
             )
         ).scalar_one_or_none()
@@ -114,8 +115,8 @@ class OutboxService:
         result = await self.db.execute(
             update(OutboxMessage)
             .where(
-                OutboxMessage.id == message_id,  # ty: ignore[invalid-argument-type]
-                OutboxMessage.status == OutboxStatus.DEAD,  # ty: ignore[invalid-argument-type]
+                col(OutboxMessage.id) == message_id,
+                col(OutboxMessage.status) == OutboxStatus.DEAD,
                 *self.scope.conditions(),
             )
             .values(
@@ -141,7 +142,7 @@ class OutboxService:
         result = await self.db.execute(
             delete(OutboxMessage)
             .where(
-                OutboxMessage.id == message_id,  # ty: ignore[invalid-argument-type]
+                col(OutboxMessage.id) == message_id,
                 OutboxMessage.status.in_(DISCARDABLE),
                 *self.scope.conditions(),
             )

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/outbox_worker.py

@@ -30,6 +30,7 @@ from simple_module_core.events import EventBus
 from simple_module_db import init_db
 from simple_module_db.listeners import attach_session_listeners
 from simple_module_db.query_filter import bind_engine_policy
+from simple_module_db.tenant_cleanup import register_tenant_cleanup
 from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker
 
 from background_tasks import sync_db
@@ -118,6 +119,7 @@ def build_worker_bus() -> EventBus:
     from simple_module_core.discovery import discover_modules, topological_sort
 
     bus = EventBus()
+    register_tenant_cleanup(bus)
     bus.durable_transport = WorkerOutboxTransport()
     # Lenient on purpose: the worker delivers whatever is installed, and a
     # module set the web process refuses is reported there, not here.

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/pages/Outbox.tsx

@@ -1,11 +1,12 @@
 import { Head, Link, router } from '@inertiajs/react';
 import { keys, useT } from '@simple-module-py/i18n';
+import { ConfirmActionDialog } from '@simple-module-py/ui/components/ConfirmActionDialog';
 import { PageShell } from '@simple-module-py/ui/components/PageShell';
 import { Button } from '@simple-module-py/ui/components/ui/button';
 import { usePermissions } from '@simple-module-py/ui/hooks/use-permissions';
 import { AdminLayout } from '@simple-module-py/ui/layouts/AdminLayout';
 import { cn } from '@simple-module-py/ui/lib/utils';
-import { ArrowLeft } from 'lucide-react';
+import { ArrowLeft, Trash2 } from 'lucide-react';
 import { useState } from 'react';
 import { OutboxTable } from './components/OutboxTable';
 import { VIEW_BASE } from './constants';
@@ -31,6 +32,7 @@ function Outbox({ messages, counts, pagination, filters }: Props) {
   const { t } = useT();
   const { can } = usePermissions();
   const canManage = can('background_tasks.manage');
+  const [pendingDiscard, setPendingDiscard] = useState<OutboxMessage | null>(null);
   const [busyId, setBusyId] = useState<string | null>(null);
 
   function visit(status: string, page: number) {
@@ -51,13 +53,6 @@ function Outbox({ messages, counts, pagination, filters }: Props) {
     }
   }
 
-  function discard(message: OutboxMessage) {
-    const prompt = t(keys.background_tasks.outbox.discard_confirm, {
-      handler: message.handler_name,
-    });
-    if (window.confirm(prompt)) void act(message, discardOutboxMessage);
-  }
-
   const segments = [
     { value: '', label: t(keys.background_tasks.outbox.filter_all), count: null },
     ...OPEN_OUTBOX_STATUSES.map((s) => ({
@@ -105,13 +100,30 @@ function Outbox({ messages, counts, pagination, filters }: Props) {
           canManage={canManage}
           busyId={busyId}
           onRetry={(m) => void act(m, retryOutboxMessage)}
-          onDiscard={discard}
+          onDiscard={setPendingDiscard}
           page={pagination.page}
           perPage={pagination.per_page}
           total={pagination.total}
           onPageChange={(page) => visit(filters.status, page)}
         />
       </PageShell>
+      <ConfirmActionDialog
+        open={pendingDiscard !== null}
+        onOpenChange={(open) => !open && setPendingDiscard(null)}
+        icon={Trash2}
+        title={t(keys.background_tasks.outbox.discard)}
+        description={t(keys.background_tasks.outbox.discard_confirm, {
+          handler: pendingDiscard?.handler_name ?? '',
+        })}
+        confirmLabel={t(keys.background_tasks.outbox.discard)}
+        cancelLabel={t(keys.background_tasks.retry_dialog.cancel)}
+        busy={busyId !== null}
+        onConfirm={() => {
+          if (pendingDiscard) {
+            void act(pendingDiscard, discardOutboxMessage).finally(() => setPendingDiscard(null));
+          }
+        }}
+      />
     </>
   );
 }

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/retry_service.py

@@ -16,6 +16,7 @@ from typing import TYPE_CHECKING, Any
 from simple_module_core.events import EventBus
 from simple_module_db import RequestSession, all_tenants, tenant_context
 from sqlalchemy import Select, func, select, update
+from sqlmodel import col
 
 from background_tasks._signal_support import now_utc
 from background_tasks.after_commit import after_commit
@@ -271,8 +272,8 @@ def _fail_unsent(task_id: str, exc: Exception) -> None:
             session.execute(
                 update(TaskExecution)
                 .where(
-                    TaskExecution.celery_task_id == task_id,  # ty: ignore[invalid-argument-type]
-                    TaskExecution.status == TaskStatus.PENDING,  # ty: ignore[invalid-argument-type]
+                    col(TaskExecution.celery_task_id) == task_id,
+                    col(TaskExecution.status) == TaskStatus.PENDING,
                 )
                 .values(
                     status=TaskStatus.FAILED,

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/task_heartbeat.py

@@ -24,6 +24,7 @@ import time
 
 from celery import current_task
 from sqlalchemy import update
+from sqlmodel import col
 
 from background_tasks._signal_support import now_utc
 from background_tasks.constants import (
@@ -122,11 +123,11 @@ def heartbeat(
             session.execute(
                 update(TaskExecution)
                 .where(
-                    TaskExecution.celery_task_id == task_id,  # ty: ignore[invalid-argument-type]
+                    col(TaskExecution.celery_task_id) == task_id,
                     # Only a row still ``running``: a heartbeat must not revive
                     # a row the sweep already declared stuck (it may have been
                     # retried since) or rewrite a terminal one.
-                    TaskExecution.status == TaskStatus.RUNNING,  # ty: ignore[invalid-argument-type]
+                    col(TaskExecution.status) == TaskStatus.RUNNING,
                 )
                 .values(heartbeat_at=now_utc(), **pending)
             )

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/background_tasks/tasks.py

@@ -21,6 +21,7 @@ from typing import Any
 
 from celery import Task, shared_task
 from sqlalchemy import ColumnElement, and_, delete, or_, update
+from sqlmodel import col
 
 from background_tasks.constants import (
     DEMO_ECHO_TASK,
@@ -119,7 +120,7 @@ def sweep_stuck_tasks(self: Task) -> int:
         stmt = (
             update(TaskExecution)
             .where(
-                TaskExecution.status == TaskStatus.RUNNING,  # ty: ignore[invalid-argument-type]
+                col(TaskExecution.status) == TaskStatus.RUNNING,
                 _stale(now, stuck_after, overrides),
             )
             .values(status=TaskStatus.STUCK, finished_at=now)
@@ -149,7 +150,7 @@ def purge_old_executions() -> int:
         count = result.rowcount or 0
         delivered = session.execute(
             delete(OutboxMessage)
-            .where(OutboxMessage.status == OutboxStatus.DELIVERED)  # ty: ignore[invalid-argument-type]
+            .where(col(OutboxMessage.status) == OutboxStatus.DELIVERED)
             .where(OutboxMessage.delivered_at < cutoff)
         )
         count += delivered.rowcount or 0

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@simple-module-py/background-tasks",
-  "version": "0.0.38",
+  "version": "0.0.40",
   "private": true,
   "description": "Frontend assets for the BackgroundTasks module",
   "peerDependencies": {

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "simple_module_background_tasks"
-version = "0.0.38"
+version = "0.0.40"
 description = "Celery + Redis task queue with admin UI for monitoring and retrying failed/stuck tasks"
 readme = "README.md"
 license = "MIT"
@@ -21,12 +21,12 @@ classifiers = [
     "Typing :: Typed",
 ]
 dependencies = [
-    "simple_module_core==0.0.38",
-    "simple_module_db==0.0.38",
-    "simple_module_hosting==0.0.38",
-    "simple_module_settings==0.0.38",
-    "celery[redis]>=5.4",
-    "redis>=5",
+    "simple_module_core==0.0.40",
+    "simple_module_db==0.0.40",
+    "simple_module_hosting==0.0.40",
+    "simple_module_settings==0.0.40",
+    "celery[redis]>=5.4,<6",
+    "redis>=5,<7",
 ]
 
 [project.entry-points.simple_module]

{simple_module_background_tasks-0.0.38 → simple_module_background_tasks-0.0.40}/tests-js/background_tasks_OutboxPage.test.tsx

@@ -1,6 +1,6 @@
 import '@testing-library/jest-dom/vitest';
 import { configureI18n, keys } from '@simple-module-py/i18n';
-import { fireEvent, render, screen, waitFor } from '@testing-library/react';
+import { fireEvent, render, screen, waitFor, within } from '@testing-library/react';
 import type { ComponentProps } from 'react';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 
@@ -134,21 +134,27 @@ describe('background_tasks Outbox page', () => {
 
   it('asks before discarding and calls nothing when the operator declines', () => {
     const fetchMock = stubFetch(204);
-    const confirmSpy = vi.spyOn(window, 'confirm').mockReturnValue(false);
     render(<Outbox {...(state.props as unknown as ComponentProps<typeof Outbox>)} />);
     fireEvent.click(screen.getByRole('button', { name: ob.discard }));
 
-    expect(confirmSpy).toHaveBeenCalledTimes(1);
+    const dialog = screen.getByRole('alertdialog');
+    fireEvent.click(
+      within(dialog).getByRole('button', { name: keys.background_tasks.retry_dialog.cancel }),
+    );
+    expect(screen.queryByRole('alertdialog')).toBeNull();
     expect(fetchMock).not.toHaveBeenCalled();
     expect(reload).not.toHaveBeenCalled();
   });
 
   it('discards with a DELETE once confirmed', async () => {
     const fetchMock = stubFetch(204);
-    vi.spyOn(window, 'confirm').mockReturnValue(true);
     render(<Outbox {...(state.props as unknown as ComponentProps<typeof Outbox>)} />);
     fireEvent.click(screen.getByRole('button', { name: ob.discard }));
 
+    expect(fetchMock).not.toHaveBeenCalled();
+    fireEvent.click(
+      within(screen.getByRole('alertdialog')).getByRole('button', { name: ob.discard }),
+    );
     await waitFor(() => expect(toast.success).toHaveBeenCalledWith(ob.discarded));
     expect(requestsOf(fetchMock)).toContainEqual({
       url: '/api/background_tasks/admin/outbox/m1',
@@ -159,9 +165,11 @@ describe('background_tasks Outbox page', () => {
 
   it('toasts a discard failure', async () => {
     stubFetch(500);
-    vi.spyOn(window, 'confirm').mockReturnValue(true);
     render(<Outbox {...(state.props as unknown as ComponentProps<typeof Outbox>)} />);
     fireEvent.click(screen.getByRole('button', { name: ob.discard }));
+    fireEvent.click(
+      within(screen.getByRole('alertdialog')).getByRole('button', { name: ob.discard }),
+    );
     await waitFor(() => expect(toast.error).toHaveBeenCalledWith(ob.discard_failed));
   });