You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@superset.apache.org by ms...@apache.org on 2026/07/22 09:00:09 UTC

(superset) 01/01: feat(async): cancel running chart queries under GLOBAL_ASYNC_QUERIES

This is an automated email from the ASF dual-hosted git repository.

msyavuz pushed a commit to branch msyavuz/fix/gaq-stop-query
in repository https://gitbox.apache.org/repos/asf/superset.git

commit 464aa02d04f9731b50c428efb309d769eef547ce
Author: Mehmet Salih Yavuz <sa...@proton.me>
AuthorDate: Wed Jul 22 11:59:26 2026 +0300

    feat(async): cancel running chart queries under GLOBAL_ASYNC_QUERIES
---
 .../src/components/Chart/chartAction.ts            |  29 ++++--
 .../src/middleware/asyncEvent.test.ts              |  36 +++++++
 superset-frontend/src/middleware/asyncEvent.ts     |  32 +++++-
 superset/async_events/api.py                       |  72 +++++++++++++-
 superset/async_events/async_query_manager.py       |  93 ++++++++++++++++++
 superset/async_events/cache_backend.py             |  18 ++++
 superset/tasks/async_queries.py                    |  13 ++-
 .../async_events/async_query_manager_tests.py      | 108 +++++++++++++++++++++
 tests/unit_tests/tasks/test_async_queries.py       |  55 +++++++++++
 9 files changed, 447 insertions(+), 9 deletions(-)

diff --git a/superset-frontend/src/components/Chart/chartAction.ts b/superset-frontend/src/components/Chart/chartAction.ts
index 65b94f231b0..03178704c1c 100644
--- a/superset-frontend/src/components/Chart/chartAction.ts
+++ b/superset-frontend/src/components/Chart/chartAction.ts
@@ -699,6 +699,7 @@ export function handleChartDataResponse(
   response: Response,
   json: { result: QueryData[] },
   useLegacyApi?: boolean,
+  signal?: AbortSignal,
 ): Promise<QueryData[]> | QueryData[] {
   if (isFeatureEnabled(FeatureFlag.GlobalAsyncQueries)) {
     // deal with getChartDataRequest transforming the response data
@@ -711,13 +712,16 @@ export function handleChartDataResponse(
         // Query is running asynchronously and we must await the results.
         // When status is 202, result contains async event data (job_id, channel_id, etc.)
         // which differs from QueryData. We cast through unknown to handle this safely.
+        // The signal lets a Stop action abort the wait and cancel the job.
         if (useLegacyApi) {
           return waitForAsyncData(
             result[0] as unknown as Parameters<typeof waitForAsyncData>[0],
+            signal,
           ) as Promise<QueryData[]>;
         }
         return waitForAsyncData(
           result as unknown as Parameters<typeof waitForAsyncData>[0],
+          signal,
         ) as Promise<QueryData[]>;
       default:
         throw new Error(
@@ -780,15 +784,25 @@ export function exploreJSON(
     const [useLegacyApi] = getQuerySettings(formData);
     const chartDataRequestCaught = chartDataRequest
       .then(({ response, json }) =>
-        handleChartDataResponse(response, json, useLegacyApi),
+        handleChartDataResponse(
+          response,
+          json,
+          useLegacyApi,
+          controller.signal,
+        ),
       )
       .then(queriesResponse => {
-        // Drop stale responses: if a newer query has started for this chart,
-        // its controller will have replaced ours in state, so ignore this
-        // response to avoid clobbering newer data with older results.
+        // Drop stale responses: if this request was aborted (Stop, or a newer
+        // query that aborted ours), or a newer query has since replaced our
+        // controller in state, ignore the result so we don't clobber newer
+        // data or a 'stopped' status. Checking the signal is authoritative
+        // because the reducer nulls out queryController when a query stops.
         if (key != null) {
           const currentController = getState().charts?.[key]?.queryController;
-          if (currentController && currentController !== controller) {
+          if (
+            controller.signal.aborted ||
+            (currentController != null && currentController !== controller)
+          ) {
             return undefined;
           }
         }
@@ -847,7 +861,10 @@ export function exploreJSON(
           // so a slow earlier request can't mark a newer one as failed.
           if (key != null) {
             const currentController = getState().charts?.[key]?.queryController;
-            if (currentController && currentController !== controller) {
+            if (
+              controller.signal.aborted ||
+              (currentController != null && currentController !== controller)
+            ) {
               return undefined;
             }
           }
diff --git a/superset-frontend/src/middleware/asyncEvent.test.ts b/superset-frontend/src/middleware/asyncEvent.test.ts
index e78e95769b7..d58ab22fa4a 100644
--- a/superset-frontend/src/middleware/asyncEvent.test.ts
+++ b/superset-frontend/src/middleware/asyncEvent.test.ts
@@ -130,6 +130,42 @@ describe('asyncEvent middleware', () => {
       expect(fetchMock.callHistory.calls(CACHED_DATA_ENDPOINT)).toHaveLength(1);
     });
 
+    test('rejects with an AbortError and cancels the job when the signal aborts', async () => {
+      const CANCEL_ENDPOINT = 'glob:*/api/v1/async_event/*/cancel';
+      fetchMock.post(CANCEL_ENDPOINT, { status: 200, body: {} });
+
+      const controller = new AbortController();
+      const promise = asyncEvent.waitForAsyncData(
+        asyncPendingEvent,
+        controller.signal,
+      );
+      controller.abort();
+
+      let error: any = null;
+      try {
+        await promise;
+      } catch (err) {
+        error = err;
+      }
+      expect(error?.name).toBe('AbortError');
+      // The cancel POST is fire-and-forget; let its microtask flush.
+      await new Promise(resolve => setTimeout(resolve, 0));
+      expect(fetchMock.callHistory.calls(CANCEL_ENDPOINT)).toHaveLength(1);
+    });
+
+    test('rejects immediately when given an already-aborted signal', async () => {
+      const CANCEL_ENDPOINT = 'glob:*/api/v1/async_event/*/cancel';
+      fetchMock.post(CANCEL_ENDPOINT, { status: 200, body: {} });
+
+      const controller = new AbortController();
+      controller.abort();
+
+      await expect(
+        asyncEvent.waitForAsyncData(asyncPendingEvent, controller.signal),
+      ).rejects.toMatchObject({ name: 'AbortError' });
+      expect(fetchMock.callHistory.calls(CANCEL_ENDPOINT)).toHaveLength(1);
+    });
+
     test('rejects on event error status', async () => {
       fetchMock.clearHistory().removeRoutes();
       fetchMock.get(EVENTS_ENDPOINT, {
diff --git a/superset-frontend/src/middleware/asyncEvent.ts b/superset-frontend/src/middleware/asyncEvent.ts
index b22a34d3f1b..d97fe6dbb1f 100644
--- a/superset-frontend/src/middleware/asyncEvent.ts
+++ b/superset-frontend/src/middleware/asyncEvent.ts
@@ -102,9 +102,38 @@ const fetchCachedData = async (
   return { status, data };
 };
 
-export const waitForAsyncData = async (asyncResponse: AsyncEvent) =>
+const cancelAsyncJob = (jobId: string) => {
+  // Best-effort server-side cancel; the request stops the running Celery task
+  // so it no longer consumes warehouse resources. Failures are non-fatal: the
+  // client has already stopped waiting on the job.
+  SupersetClient.post({
+    endpoint: `/api/v1/async_event/${jobId}/cancel`,
+  }).catch(() => {});
+};
+
+export const waitForAsyncData = async (
+  asyncResponse: AsyncEvent,
+  signal?: AbortSignal,
+) =>
   new Promise((resolve, reject) => {
     const jobId = asyncResponse.job_id;
+
+    const onAbort = () => {
+      // Stop listening for this job and ask the server to cancel it, then
+      // reject with an AbortError so callers treat this like a fetch abort.
+      removeListener(jobId);
+      cancelAsyncJob(jobId);
+      reject(new DOMException('The user aborted a request.', 'AbortError'));
+    };
+
+    if (signal) {
+      if (signal.aborted) {
+        onAbort();
+        return;
+      }
+      signal.addEventListener('abort', onAbort, { once: true });
+    }
+
     const listener = async (asyncEvent: AsyncEvent) => {
       switch (asyncEvent.status) {
         case JOB_STATUS.DONE: {
@@ -126,6 +155,7 @@ export const waitForAsyncData = async (asyncResponse: AsyncEvent) =>
           logging.warn('received event with status', asyncEvent.status);
         }
       }
+      signal?.removeEventListener('abort', onAbort);
       removeListener(jobId);
     };
     addListener(jobId, listener);
diff --git a/superset/async_events/api.py b/superset/async_events/api.py
index 55539d86aa4..5df135e37c2 100644
--- a/superset/async_events/api.py
+++ b/superset/async_events/api.py
@@ -21,8 +21,12 @@ from flask_appbuilder import expose
 from flask_appbuilder.api import safe
 from flask_appbuilder.security.decorators import permission_name, protect
 
-from superset.async_events.async_query_manager import AsyncQueryTokenException
+from superset.async_events.async_query_manager import (
+    AsyncQueryJobException,
+    AsyncQueryTokenException,
+)
 from superset.extensions import async_query_manager, event_logger
+from superset.utils.core import get_user_id
 from superset.views.base_api import BaseSupersetApi, statsd_metrics
 
 logger = logging.getLogger(__name__)
@@ -99,3 +103,69 @@ class AsyncEventsRestApi(BaseSupersetApi):
             return self.response_401()
 
         return self.response(200, result=events)
+
+    @expose("/<job_id>/cancel", methods=("POST",))
+    @event_logger.log_this
+    @protect()
+    @safe
+    @statsd_metrics
+    @permission_name("list")
+    def cancel(self, job_id: str) -> Response:
+        """Cancel a running async query job.
+        ---
+        post:
+          summary: Cancel a running async query job
+          description: >-
+            Revokes the Celery task backing an in-flight async query. The
+            caller is authorized against the job's original owner (channel and
+            user), both resolved server-side from the request, so a client
+            cannot cancel a job it did not submit.
+          parameters:
+          - in: path
+            name: job_id
+            required: true
+            description: The job ID returned when the async query was submitted
+            schema:
+              type: string
+          responses:
+            200:
+              description: Job cancelled
+              content:
+                application/json:
+                  schema:
+                    type: object
+                    properties:
+                      result:
+                        type: object
+                        properties:
+                          job_id:
+                            type: string
+                          status:
+                            type: string
+            401:
+              $ref: '#/components/responses/401'
+            403:
+              $ref: '#/components/responses/403'
+            404:
+              $ref: '#/components/responses/404'
+            500:
+              $ref: '#/components/responses/500'
+        """
+        try:
+            async_channel_id = async_query_manager.parse_channel_id_from_request(
+                request
+            )
+        except AsyncQueryTokenException:
+            return self.response_401()
+
+        try:
+            async_query_manager.cancel_job(job_id, async_channel_id, get_user_id())
+        except AsyncQueryTokenException:
+            return self.response_403()
+        except AsyncQueryJobException:
+            return self.response_404()
+
+        return self.response(
+            200,
+            result={"job_id": job_id, "status": async_query_manager.STATUS_CANCELLED},
+        )
diff --git a/superset/async_events/async_query_manager.py b/superset/async_events/async_query_manager.py
index 7cfbd6892df..45e47ac434a 100644
--- a/superset/async_events/async_query_manager.py
+++ b/superset/async_events/async_query_manager.py
@@ -106,6 +106,10 @@ class AsyncQueryManager:
     STATUS_RUNNING = "running"
     STATUS_ERROR = "error"
     STATUS_DONE = "done"
+    STATUS_CANCELLED = "cancelled"
+    # Redis key prefix (within the GAQ stream namespace) for the per-job record
+    # that authorizes cancellation and flags a job as cancelled for the worker.
+    _JOB_REGISTRY_PREFIX = "job-cancel:"
 
     def __init__(self) -> None:
         super().__init__()
@@ -276,10 +280,32 @@ class AsyncQueryManager:
 
     def init_job(self, channel_id: str, user_id: Optional[int]) -> dict[str, Any]:
         job_id = str(uuid.uuid4())
+        self._register_cancellable_job(job_id, channel_id, user_id)
         return build_job_metadata(
             channel_id, job_id, user_id, status=self.STATUS_PENDING
         )
 
+    def _job_registry_key(self, job_id: str) -> str:
+        return f"{self._stream_prefix}{self._JOB_REGISTRY_PREFIX}{job_id}"
+
+    def _register_cancellable_job(
+        self, job_id: str, channel_id: str, user_id: Optional[int]
+    ) -> None:
+        """
+        Persist the identity a later cancel request must match. Keyed by
+        ``job_id`` (also the Celery task id — see ``submit_chart_data_job``) so
+        the cancel endpoint can authorize the caller against the job's original
+        owner without trusting the client-supplied id. Expires with the JWT so
+        it never outlives the job it guards.
+        """
+        if not self._cache:
+            return
+        self._cache.set(
+            self._job_registry_key(job_id),
+            json.dumps({"channel_id": channel_id, "user_id": user_id}),
+            ex=self._jwt_expiration_seconds or None,
+        )
+
     # pylint: disable=too-many-arguments
     def submit_explore_json_job(
         self,
@@ -302,6 +328,9 @@ class AsyncQueryManager:
                 response_type,
                 force,
             ],
+            # Use job_id as the Celery task id so the cancel endpoint can revoke
+            # the running task by the id the client already holds.
+            task_id=job_metadata["job_id"],
             expires=self._jwt_expiration_seconds,
         )
         return job_metadata
@@ -327,6 +356,9 @@ class AsyncQueryManager:
                 else job_metadata,
                 form_data,
             ],
+            # Use job_id as the Celery task id so the cancel endpoint can revoke
+            # the running task by the id the client already holds.
+            task_id=job_metadata["job_id"],
             expires=self._jwt_expiration_seconds,
         )
         return job_metadata
@@ -380,3 +412,64 @@ class AsyncQueryManager:
 
         self._cache.xadd(scoped_stream_name, event_data, "*", self._stream_limit)
         self._cache.xadd(full_stream_name, event_data, "*", self._stream_limit_firehose)
+
+        # Once a job reaches a terminal state its cancel record is dead weight
+        # (and a stale record would let a caller "cancel" a finished job), so
+        # drop it. TTL is the backstop if this is never reached.
+        if status in (self.STATUS_DONE, self.STATUS_ERROR, self.STATUS_CANCELLED):
+            if job_id := job_metadata.get("job_id"):
+                self._cache.delete(self._job_registry_key(job_id))
+
+    def is_job_cancelled(self, job_id: str) -> bool:
+        """Whether ``cancel_job`` has flagged this job for cancellation."""
+        if not self._cache:
+            return False
+        raw = self._cache.get(self._job_registry_key(job_id))
+        if raw is None:
+            return False
+        try:
+            return bool(json.loads(raw).get("cancelled"))
+        except (ValueError, AttributeError):
+            return False
+
+    def cancel_job(self, job_id: str, channel_id: str, user_id: Optional[int]) -> None:
+        """
+        Authorize and cancel a running async job.
+
+        The caller's ``channel_id`` and ``user_id`` (resolved server-side from
+        the request, never taken from the client) must match the job's original
+        owner. On success the running Celery task is revoked; the SIGUSR1 it
+        receives surfaces as ``SoftTimeLimitExceeded`` in the worker, which
+        reads the cancelled flag set here and emits the terminal
+        ``STATUS_CANCELLED`` event — so exactly one terminal event is written.
+
+        :raises AsyncQueryJobException: the job is unknown or already terminal
+        :raises AsyncQueryTokenException: the caller does not own the job
+        """
+        if not self._cache:
+            raise CacheBackendNotInitialized("Cache backend not initialized")
+
+        key = self._job_registry_key(job_id)
+        raw = self._cache.get(key)
+        if raw is None:
+            raise AsyncQueryJobException("Job not found or already completed")
+
+        record = json.loads(raw)
+        if record.get("channel_id") != channel_id or record.get("user_id") != user_id:
+            raise AsyncQueryTokenException("Not authorized to cancel this job")
+
+        # Flag before revoking so the worker's timeout handler, which may fire
+        # almost immediately, reliably sees the cancellation.
+        self._cache.set(
+            key,
+            json.dumps({**record, "cancelled": True}),
+            ex=self._jwt_expiration_seconds or None,
+        )
+
+        # pylint: disable=import-outside-toplevel
+        from superset.extensions import celery_app
+
+        # SIGUSR1 raises SoftTimeLimitExceeded inside the running task rather
+        # than hard-killing the process, so the worker can emit its terminal
+        # event before exiting.
+        celery_app.control.revoke(job_id, terminate=True, signal="SIGUSR1")
diff --git a/superset/async_events/cache_backend.py b/superset/async_events/cache_backend.py
index 55c22715165..4e528b82694 100644
--- a/superset/async_events/cache_backend.py
+++ b/superset/async_events/cache_backend.py
@@ -99,6 +99,15 @@ class RedisCacheBackend(RedisCache):
         """
         return self._cache.set(name, value, ex=ex, px=px, nx=nx, xx=xx)
 
+    def get(self, name: str) -> Any:
+        """
+        Get the raw value at key ``name``.
+
+        :param name: Key name
+        :returns: The stored value (bytes), or None if the key is absent
+        """
+        return self._cache.get(name)
+
     def delete(self, *names: str) -> int:
         """
         Delete one or more keys.
@@ -283,6 +292,15 @@ class RedisSentinelCacheBackend(RedisSentinelCache):
         """
         return self._cache.set(name, value, ex=ex, px=px, nx=nx, xx=xx)
 
+    def get(self, name: str) -> Any:
+        """
+        Get the raw value at key ``name``.
+
+        :param name: Key name
+        :returns: The stored value (bytes), or None if the key is absent
+        """
+        return self._cache.get(name)
+
     def delete(self, *names: str) -> int:
         """
         Delete one or more keys.
diff --git a/superset/tasks/async_queries.py b/superset/tasks/async_queries.py
index f9aa9efc2fe..38f46d65eee 100644
--- a/superset/tasks/async_queries.py
+++ b/superset/tasks/async_queries.py
@@ -106,7 +106,18 @@ def load_chart_data_into_cache(
                 result_url=result_url,
             )
         except SoftTimeLimitExceeded as ex:
-            logger.warning("A timeout occurred while loading chart data, error: %s", ex)
+            # SoftTimeLimitExceeded is raised both by a genuine timeout and by a
+            # user-initiated cancel (revoke sends SIGUSR1). Emit the matching
+            # terminal event so a cancelled job is reported as cancelled.
+            if async_query_manager.is_job_cancelled(job_metadata["job_id"]):
+                logger.info("Chart data load was cancelled by the user")
+                async_query_manager.update_job(
+                    job_metadata, async_query_manager.STATUS_CANCELLED
+                )
+            else:
+                logger.warning(
+                    "A timeout occurred while loading chart data, error: %s", ex
+                )
             raise
         except Exception as ex:
             # Extract SIP-40 style errors when available
diff --git a/tests/unit_tests/async_events/async_query_manager_tests.py b/tests/unit_tests/async_events/async_query_manager_tests.py
index 421f4159fbb..00ef606ea43 100644
--- a/tests/unit_tests/async_events/async_query_manager_tests.py
+++ b/tests/unit_tests/async_events/async_query_manager_tests.py
@@ -24,6 +24,7 @@ from pytest import fixture, mark, raises  # noqa: PT013
 
 from superset import security_manager
 from superset.async_events.async_query_manager import (
+    AsyncQueryJobException,
     AsyncQueryManager,
     AsyncQueryTokenException,
 )
@@ -31,6 +32,7 @@ from superset.async_events.cache_backend import (
     RedisCacheBackend,
     RedisSentinelCacheBackend,
 )
+from superset.utils import json
 
 JWT_TOKEN_SECRET = "some_secret"  # noqa: S105
 JWT_TOKEN_COOKIE_NAME = "superset_async_jwt"  # noqa: S105
@@ -268,6 +270,7 @@ def test_submit_chart_data_job_as_guest_user(
             },
             {},
         ],
+        task_id=ANY,
         expires=3600,
     )
 
@@ -376,7 +379,112 @@ def test_submit_explore_json_job_as_guest_user(
             "json",
             False,
         ],
+        task_id=ANY,
         expires=3600,
     )
 
     assert "guest_token" not in job_meta
+
+
+@fixture
+def cancellable_manager():
+    """A manager wired to a mock Redis backend for cancellation tests."""
+    manager = AsyncQueryManager()
+    manager._jwt_expiration_seconds = 3600
+    manager._stream_prefix = "async-events-"
+    manager._cache = mock.Mock(spec=RedisCacheBackend)
+    return manager
+
+
+def test_init_job_registers_cancellable_record(cancellable_manager):
+    """init_job persists the owner identity a later cancel must match."""
+    cancellable_manager.init_job("chan-1", 7)
+
+    cancellable_manager._cache.set.assert_called_once()
+    key, value = cancellable_manager._cache.set.call_args.args
+    assert key.startswith("async-events-job-cancel:")
+    assert json.loads(value) == {"channel_id": "chan-1", "user_id": 7}
+
+
+def test_cancel_job_authorized_revokes_task(cancellable_manager):
+    cancellable_manager._cache.get.return_value = json.dumps(
+        {"channel_id": "chan-1", "user_id": 7}
+    )
+
+    with mock.patch("superset.extensions.celery_app") as celery_app:
+        cancellable_manager.cancel_job("job-1", "chan-1", 7)
+
+    celery_app.control.revoke.assert_called_once_with(
+        "job-1", terminate=True, signal="SIGUSR1"
+    )
+    # The job is flagged cancelled so the worker emits STATUS_CANCELLED.
+    flagged = json.loads(cancellable_manager._cache.set.call_args.args[1])
+    assert flagged["cancelled"] is True
+
+
+def test_cancel_job_wrong_user_is_rejected(cancellable_manager):
+    cancellable_manager._cache.get.return_value = json.dumps(
+        {"channel_id": "chan-1", "user_id": 7}
+    )
+
+    with (
+        mock.patch("superset.extensions.celery_app") as celery_app,
+        raises(AsyncQueryTokenException),
+    ):
+        cancellable_manager.cancel_job("job-1", "chan-1", 999)
+
+    celery_app.control.revoke.assert_not_called()
+
+
+def test_cancel_job_wrong_channel_is_rejected(cancellable_manager):
+    """A matching user on a different channel still cannot cancel the job."""
+    cancellable_manager._cache.get.return_value = json.dumps(
+        {"channel_id": "chan-1", "user_id": 7}
+    )
+
+    with (
+        mock.patch("superset.extensions.celery_app") as celery_app,
+        raises(AsyncQueryTokenException),
+    ):
+        cancellable_manager.cancel_job("job-1", "other-chan", 7)
+
+    celery_app.control.revoke.assert_not_called()
+
+
+def test_cancel_job_unknown_raises(cancellable_manager):
+    cancellable_manager._cache.get.return_value = None
+
+    with (
+        mock.patch("superset.extensions.celery_app") as celery_app,
+        raises(AsyncQueryJobException),
+    ):
+        cancellable_manager.cancel_job("job-1", "chan-1", 7)
+
+    celery_app.control.revoke.assert_not_called()
+
+
+def test_is_job_cancelled(cancellable_manager):
+    cancellable_manager._cache.get.return_value = json.dumps(
+        {"channel_id": "chan-1", "user_id": 7, "cancelled": True}
+    )
+    assert cancellable_manager.is_job_cancelled("job-1") is True
+
+    cancellable_manager._cache.get.return_value = json.dumps(
+        {"channel_id": "chan-1", "user_id": 7}
+    )
+    assert cancellable_manager.is_job_cancelled("job-1") is False
+
+    cancellable_manager._cache.get.return_value = None
+    assert cancellable_manager.is_job_cancelled("job-1") is False
+
+
+def test_update_job_clears_registry_on_terminal_status(cancellable_manager):
+    cancellable_manager._stream_limit = 100
+    cancellable_manager._stream_limit_firehose = 1000
+    job_metadata = {"channel_id": "chan-1", "job_id": "job-1", "user_id": 7}
+
+    cancellable_manager.update_job(job_metadata, AsyncQueryManager.STATUS_DONE)
+
+    cancellable_manager._cache.delete.assert_called_once_with(
+        "async-events-job-cancel:job-1"
+    )
diff --git a/tests/unit_tests/tasks/test_async_queries.py b/tests/unit_tests/tasks/test_async_queries.py
index c442f309549..8fce597f588 100644
--- a/tests/unit_tests/tasks/test_async_queries.py
+++ b/tests/unit_tests/tasks/test_async_queries.py
@@ -18,6 +18,7 @@ from typing import Any
 from unittest import mock
 
 import pytest
+from celery.exceptions import SoftTimeLimitExceeded
 from flask_babel import lazy_gettext as _
 
 from superset.commands.chart.exceptions import ChartDataQueryFailedError
@@ -63,6 +64,60 @@ def test_load_chart_data_into_cache_with_error(
     )
 
 
+@mock.patch("superset.tasks.async_queries.security_manager")
+@mock.patch("superset.tasks.async_queries.async_query_manager")
+@mock.patch("superset.tasks.async_queries.ChartDataQueryContextSchema")
+def test_load_chart_data_into_cache_cancelled_emits_cancelled_status(
+    mock_query_context_schema_cls, mock_async_query_manager, mock_security_manager
+):
+    """A revoke (SoftTimeLimitExceeded + cancel flag) reports STATUS_CANCELLED."""
+    from superset.tasks.async_queries import load_chart_data_into_cache
+
+    job_metadata = {"user_id": 1, "job_id": "job-1"}
+    form_data: dict[str, Any] = {}
+
+    mock_security_manager.get_user_by_id.return_value = mock.MagicMock()
+    mock_async_query_manager.STATUS_CANCELLED = "cancelled"
+    # Sync Mock: is_job_cancelled is a plain method, but patching the manager
+    # yields an AsyncMock whose calls would otherwise return truthy coroutines.
+    mock_async_query_manager.is_job_cancelled = mock.Mock(return_value=True)
+    mock_query_context_schema_cls.return_value.load.side_effect = (
+        SoftTimeLimitExceeded()
+    )
+
+    with pytest.raises(SoftTimeLimitExceeded):
+        load_chart_data_into_cache(job_metadata, form_data)
+
+    mock_async_query_manager.is_job_cancelled.assert_called_once_with("job-1")
+    mock_async_query_manager.update_job.assert_called_once_with(
+        job_metadata, "cancelled"
+    )
+
+
+@mock.patch("superset.tasks.async_queries.security_manager")
+@mock.patch("superset.tasks.async_queries.async_query_manager")
+@mock.patch("superset.tasks.async_queries.ChartDataQueryContextSchema")
+def test_load_chart_data_into_cache_timeout_does_not_emit_cancelled(
+    mock_query_context_schema_cls, mock_async_query_manager, mock_security_manager
+):
+    """A genuine timeout (no cancel flag) must not report a terminal event."""
+    from superset.tasks.async_queries import load_chart_data_into_cache
+
+    job_metadata = {"user_id": 1, "job_id": "job-1"}
+    form_data: dict[str, Any] = {}
+
+    mock_security_manager.get_user_by_id.return_value = mock.MagicMock()
+    mock_async_query_manager.is_job_cancelled = mock.Mock(return_value=False)
+    mock_query_context_schema_cls.return_value.load.side_effect = (
+        SoftTimeLimitExceeded()
+    )
+
+    with pytest.raises(SoftTimeLimitExceeded):
+        load_chart_data_into_cache(job_metadata, form_data)
+
+    mock_async_query_manager.update_job.assert_not_called()
+
+
 @mock.patch("superset.tasks.async_queries.security_manager")
 @mock.patch("superset.tasks.async_queries.async_query_manager")
 @mock.patch("superset.tasks.async_queries.ChartDataQueryContextSchema")