django-tasks-pubsub 0.1.1__tar.gz

django_tasks_pubsub-0.1.1/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: django-tasks-pubsub
+Version: 0.1.1
+Summary: Django tasks backend for Google Cloud Pub/Sub
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: django>=6.0.5
+Requires-Dist: google-cloud-pubsub>=2.38.0
+
+hello, world.

django_tasks_pubsub-0.1.1/README.md

@@ -0,0 +1 @@
+hello, world.

django_tasks_pubsub-0.1.1/django_tasks_pubsub/__init__.py

@@ -0,0 +1,7 @@
+from .backend import PubSubBackend
+from .pubsub_task_decorator import pubsub_task
+
+__all__ = [
+    "PubSubBackend",
+    "pubsub_task",
+]

django_tasks_pubsub-0.1.1/django_tasks_pubsub/backend.py

@@ -0,0 +1,110 @@
+import dataclasses
+import json
+from dataclasses import dataclass
+from datetime import datetime
+from typing import Optional
+
+from django.conf import settings
+from django.tasks import Task
+from django.tasks.backends.base import BaseTaskBackend
+from django.tasks.base import TaskResult as BaseTaskResult, TaskResultStatus
+from django.utils import timezone
+from django.utils.crypto import get_random_string
+
+from django_tasks_pubsub.publisher import get_publisher
+from django_tasks_pubsub.publisher import publish
+from django_tasks_pubsub.pubsub_task_decorator import PubSubMetaData
+
+
+@dataclass(frozen=True)
+class TaskPayload:
+    backend: str
+    module_path: str
+    name: str
+    priority: int
+    queue_name: str
+    takes_context: bool
+    run_after: Optional[datetime] = None
+
+
+@dataclass(frozen=True)
+class Payload:
+    task: TaskPayload
+    task_id: str
+    enqueued_at: str
+    args: list
+    kwargs: dict
+
+
+class TaskResult(BaseTaskResult):
+    pass
+
+
+class PubSubBackend(BaseTaskBackend):
+    @staticmethod
+    def get_pubsub_metadata(task: Task) -> PubSubMetaData:
+        task_func = getattr(task, "func")
+
+        return getattr(task_func, "__pubsub_metadata", PubSubMetaData())
+
+    def get_topic_id(self, task: Task):
+        return (
+            self.get_pubsub_metadata(task=task).topic_id
+            or settings.PUBSUB_DEFAULT_TOPIC_ID
+        )
+
+    def get_topic_path(self, task: Task):
+        topic_id = self.get_topic_id(task)
+
+        publisher = get_publisher()
+
+        topic_path = publisher.topic_path(
+            settings.PUBSUB_PROJECT_ID,
+            topic_id,
+        )
+
+        return topic_path
+
+    def enqueue(self, task: Task, args, kwargs):
+        enqueued_at = timezone.now()
+        task_id = get_random_string(32)
+
+        payload: Payload = Payload(
+            task=TaskPayload(
+                backend=task.backend,
+                module_path=task.module_path,
+                name=task.name,
+                priority=task.priority,
+                queue_name=task.queue_name,
+                takes_context=task.takes_context,
+            ),
+            task_id=task_id,
+            enqueued_at=enqueued_at.isoformat(),
+            args=args,
+            kwargs=kwargs,
+        )
+        # Data to send to the queue.
+        data = json.dumps(
+            dataclasses.asdict(payload),
+        ).encode("utf-8")
+
+        topic_path = self.get_topic_path(
+            task,
+        )
+
+        publish(topic=topic_path, data=data)
+
+        return TaskResult(
+            id=task_id,
+            task=task,
+            enqueued_at=enqueued_at,
+            started_at=None,
+            finished_at=None,
+            status=TaskResultStatus.READY,
+            args=args,
+            kwargs=kwargs,
+            last_attempted_at=None,
+            backend=task.backend,
+            errors=[],
+            worker_ids=[],
+        )

django_tasks_pubsub-0.1.1/django_tasks_pubsub/dispatcher.py

@@ -0,0 +1,54 @@
+import importlib
+from datetime import datetime
+
+from django.tasks import TaskContext
+from django.tasks.base import TaskResultStatus
+
+from django_tasks_pubsub.backend import Payload, TaskResult
+
+
+def dispatch(payload: Payload):
+    module_path = payload.task.module_path
+    task_name = payload.task.name
+
+    try:
+        module = importlib.import_module(module_path)
+    except ModuleNotFoundError:
+        module_path, task_name_from_path = module_path.rsplit(".", 1)
+        module = importlib.import_module(module_path)
+        task_name = task_name or task_name_from_path
+
+    # This is the decorated task function, decoration makes it a Task object
+    task = getattr(module, task_name)
+
+    # Actual task function that we can call
+    task_function = getattr(task, "func", task)
+
+    if payload.task.takes_context:
+        context = TaskContext(
+            task_result=TaskResult(
+                id=payload.task_id,
+                task=task,
+                enqueued_at=datetime.fromisoformat(payload.enqueued_at),
+                started_at=None,
+                finished_at=None,
+                status=TaskResultStatus.READY,
+                args=payload.args,
+                kwargs=payload.kwargs,
+                last_attempted_at=None,
+                backend=payload.task.backend,
+                errors=[],
+                worker_ids=[],
+            ),
+        )
+        task_function(
+            context,
+            *payload.args,
+            **payload.kwargs,
+        )
+        return
+
+    task_function(
+        *payload.args,
+        **payload.kwargs,
+    )

django_tasks_pubsub-0.1.1/django_tasks_pubsub/publisher.py

@@ -0,0 +1,14 @@
+from google.cloud import pubsub_v1
+
+_publisher: pubsub_v1.PublisherClient | None = None
+
+
+def get_publisher():
+    global _publisher
+    if _publisher is None:
+        _publisher = pubsub_v1.PublisherClient()
+    return _publisher
+
+
+def publish(topic: str, data: bytes):
+    get_publisher().publish(topic=topic, data=data)

django_tasks_pubsub-0.1.1/django_tasks_pubsub/pubsub_task_decorator.py

@@ -0,0 +1,19 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True, slots=True, kw_only=True)
+class PubSubMetaData:
+    topic_id: str | None = None
+
+
+def pubsub_task(topic_id: str | None = None):
+    def wrapper(func: Callable):
+        setattr(
+            func,
+            "__pubsub_metadata",
+            PubSubMetaData(topic_id=topic_id),
+        )
+        return func
+
+    return wrapper

django_tasks_pubsub-0.1.1/django_tasks_pubsub/views.py

@@ -0,0 +1,71 @@
+import base64
+import json
+import logging
+
+from django.http import HttpResponse
+from django.utils.decorators import method_decorator
+from django.views import View
+from django.views.decorators.csrf import csrf_exempt
+
+from django_tasks_pubsub.dispatcher import dispatch
+from django_tasks_pubsub.backend import Payload, TaskPayload
+
+
+@method_decorator(csrf_exempt, name="dispatch")
+class PubSubPushView(View):
+    """
+    Receives Pub/Sub push messages and dispatches them to TASK_DISPATCH_FUNCTION.
+
+    Pub/Sub push format:
+    {
+      "message": {
+        "data": "<base64-encoded JSON payload>",
+        "messageId": "...",
+        "publishTime": "..."
+      },
+      "subscription": "projects/.../subscriptions/..."
+    }
+
+    Returns 204 on success (Pub/Sub ACKs on any 2xx).
+    Returns 500 on task failure (Pub/Sub will retry).
+    Returns 400 on malformed message (no retry).
+    """
+
+    def post(self, request):
+        try:
+            envelope = json.loads(request.body)
+        except (json.JSONDecodeError, ValueError):
+            logging.error("PubSubPushView: invalid JSON body")
+            return HttpResponse(status=400)
+
+        encoded_data = envelope.get("message", {}).get("data", "")
+        if not encoded_data:
+            logging.error("PubSubPushView: missing message.data")
+            return HttpResponse(status=400)
+
+        try:
+            payload_dict = json.loads(base64.b64decode(encoded_data))
+        except Exception as exc:
+            logging.error(f"PubSubPushView: failed to decode message: {exc}")
+            return HttpResponse(status=400)
+
+        try:
+            payload = Payload(
+                task=TaskPayload(
+                    **payload_dict.pop("task"),
+                ),
+                **payload_dict,
+            )
+        except Exception as exc:
+            logging.exception(f"PubSubPushView: failed to create payload: {exc}")
+            return HttpResponse(status=400)
+
+        logging.info(f"PubSubPushView: dispatching task_type={payload.task.name!r}")
+
+        try:
+            dispatch(payload=payload)
+        except BaseException as exc:
+            logging.exception(f"PubSubPushView: task failed: {payload!r} error={exc}")
+            return HttpResponse(status=500)
+
+        return HttpResponse(status=204)

django_tasks_pubsub-0.1.1/django_tasks_pubsub.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: django-tasks-pubsub
+Version: 0.1.1
+Summary: Django tasks backend for Google Cloud Pub/Sub
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+Requires-Dist: django>=6.0.5
+Requires-Dist: google-cloud-pubsub>=2.38.0
+
+hello, world.

django_tasks_pubsub-0.1.1/django_tasks_pubsub.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+django_tasks_pubsub/__init__.py
+django_tasks_pubsub/backend.py
+django_tasks_pubsub/dispatcher.py
+django_tasks_pubsub/publisher.py
+django_tasks_pubsub/pubsub_task_decorator.py
+django_tasks_pubsub/views.py
+django_tasks_pubsub.egg-info/PKG-INFO
+django_tasks_pubsub.egg-info/SOURCES.txt
+django_tasks_pubsub.egg-info/dependency_links.txt
+django_tasks_pubsub.egg-info/requires.txt
+django_tasks_pubsub.egg-info/top_level.txt
+tests/test_dispatching_with_pubsub_task_backend.py
+tests/test_enqueing_with_pubsub_task_backend.py
+tests/test_pubsub_view.py

django_tasks_pubsub-0.1.1/django_tasks_pubsub.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_tasks_pubsub-0.1.1/django_tasks_pubsub.egg-info/requires.txt

@@ -0,0 +1,2 @@
+django>=6.0.5
+google-cloud-pubsub>=2.38.0

django_tasks_pubsub-0.1.1/django_tasks_pubsub.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_tasks_pubsub

django_tasks_pubsub-0.1.1/pyproject.toml

@@ -0,0 +1,18 @@
+[project]
+name = "django-tasks-pubsub"
+version = "v0.1.1"
+description = "Django tasks backend for Google Cloud Pub/Sub"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "django>=6.0.5",
+    "google-cloud-pubsub>=2.38.0",
+]
+
+[dependency-groups]
+dev = [
+    "build>=1.5.0",
+    "coverage>=7.14.0",
+    "mypy>=2.1.0",
+    "ruff>=0.15.13",
+]

django_tasks_pubsub-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

django_tasks_pubsub-0.1.1/tests/test_dispatching_with_pubsub_task_backend.py

@@ -0,0 +1,119 @@
+from unittest.mock import patch, Mock
+
+from django.tasks import task, TaskContext, Task
+from django.test import SimpleTestCase
+from django.test.utils import override_settings
+
+from django_tasks_pubsub.dispatcher import dispatch
+from django_tasks_pubsub.backend import Payload, TaskPayload
+
+sample_task_with_context_mock = Mock()
+
+
+@task(takes_context=True)
+def sample_task_with_context(context: TaskContext, specified_arg, *args, **kwargs):
+    sample_task_with_context_mock(
+        context,
+        specified_arg,
+        *args,
+        **kwargs,
+    )
+
+
+@override_settings(PUBSUB_PROJECT_ID="project_name")
+@override_settings(PUBSUB_DEFAULT_TOPIC_ID="default_topic_id")
+@override_settings(TASKS={"default": {"BACKEND": "django_tasks_pubsub.PubSubBackend"}})
+class TestPubSubBackendEnqueuing(SimpleTestCase):
+    def setUp(self):
+        self.get_topic_path_patcher = patch(
+            "django_tasks_pubsub.google_cloud_pubsub_backend.GoogleCloudPubSubBackend.get_topic_path",
+            return_value="expected/topic/path",
+        )
+        self.get_topic_path_mock = self.get_topic_path_patcher.start()
+
+    def tearDown(self):
+        self.get_topic_path_patcher.stop()
+
+
+class TestPubSubTaskDispatching(SimpleTestCase):
+    def setUp(self):
+        sample_task_with_context_mock.reset_mock()
+
+    def test_dispatching_task_with_context_passes_expected_context_to_task_function(
+        self,
+    ):
+        payload = Payload(
+            task=TaskPayload(
+                backend="default",
+                module_path="tests.test_dispatching_with_pubsub_task_backend",
+                name="sample_task_with_context",
+                priority=0,
+                queue_name="default",
+                takes_context=True,
+            ),
+            task_id="test-task-id",
+            enqueued_at="2026-05-12T10:00:00+00:00",
+            args=[
+                "spec_arg",
+                "arg1",
+                "arg2",
+            ],
+            kwargs={
+                "kwarg1": "val1",
+                "kwarg2": "val2",
+            },
+        )
+
+        dispatch(payload)
+
+        sample_task_with_context_mock.assert_called_once()
+
+        context: TaskContext = sample_task_with_context_mock.call_args.args[0]
+
+        self.assertIsNotNone(context)
+
+        with self.subTest("context contains the task result id"):
+            self.assertEqual(context.task_result.id, "test-task-id")
+
+        with self.subTest("task receives expected args and kwargs after context"):
+            sample_task_with_context_mock.assert_called_once_with(
+                context,
+                "spec_arg",
+                "arg1",
+                "arg2",
+                kwarg1="val1",
+                kwarg2="val2",
+            )
+
+        # SubTest
+        with self.subTest("context should be TaskContext"):
+            self.assertIsInstance(context, TaskContext)
+
+        called_task_result_task: Task = context.task_result.task
+
+        self.assertIsNotNone(
+            called_task_result_task,
+        )
+
+        self.assertIsInstance(
+            called_task_result_task,
+            Task,
+        )
+
+        # SubTest should have ALL the expected properties set
+        with self.subTest(
+            "should have ALL the expected properties set at the task oject"
+        ):
+            self.assertEqual(called_task_result_task.name, "sample_task_with_context")
+            self.assertEqual(called_task_result_task.backend, "default")
+            self.assertEqual(
+                called_task_result_task.module_path,
+                "tests.test_dispatching_with_pubsub_task_backend.sample_task_with_context",
+            )
+            self.assertEqual(called_task_result_task.priority, 0)
+            self.assertEqual(called_task_result_task.queue_name, "default")
+            self.assertEqual(called_task_result_task.takes_context, True)
+            self.assertEqual(
+                called_task_result_task.func,
+                sample_task_with_context.func,
+            )

django_tasks_pubsub-0.1.1/tests/test_enqueing_with_pubsub_task_backend.py

@@ -0,0 +1,211 @@
+import json
+from datetime import datetime
+from unittest.mock import patch, Mock
+
+from django.tasks import task
+from django.test import SimpleTestCase
+from django.test.utils import override_settings
+
+from django_tasks_pubsub import pubsub_task
+
+
+@task
+def sample_task(specified_arg, *args, **kwargs):
+    pass
+
+
+@task(takes_context=True)
+def sample_task_with_context(context, specified_arg, *args, **kwargs):
+    pass
+
+
+@task
+@pubsub_task("test-topic-name")
+def sample_task_with_pubsub_topic(specified_arg, *args, **kwargs):
+    pass
+
+
+sample_task_with_pubsub_topic_watchdog = Mock()
+
+
+@task
+@pubsub_task("test-topic-name")
+def sample_task_with_pubsub_topic_with_watchdog(*args, **kwargs):
+    sample_task_with_pubsub_topic_watchdog(
+        *args,
+        **kwargs,
+    )
+
+
+@override_settings(PUBSUB_PROJECT_ID="project_name")
+@override_settings(PUBSUB_DEFAULT_TOPIC_ID="default_topic_id")
+@override_settings(TASKS={"default": {"BACKEND": "django_tasks_pubsub.PubSubBackend"}})
+class TestPubsubTopicGeneration(SimpleTestCase):
+    @override_settings(PUBSUB_DEFAULT_TOPIC_ID="other_default_topic_id")
+    @patch("django_tasks_pubsub.backend.get_publisher")
+    @patch("django_tasks_pubsub.backend.publish", return_value="")
+    def test_enqueuing_a_task_with_out_topic_defined_should_use_default(
+        self, mocked_publish_method, mocked_get_publisher
+    ):
+        class DummyPublisher:
+            def __init__(self):
+                self.topic_path = Mock()
+
+        dummy_publisher = DummyPublisher()
+
+        mocked_get_publisher.return_value = dummy_publisher
+
+        sample_task.enqueue(
+            "spec_arg",
+            "arg1",
+        )
+
+        dummy_publisher.topic_path.assert_called_once_with(
+            "project_name",
+            "other_default_topic_id",
+        )
+
+    @patch("django_tasks_pubsub.backend.get_publisher")
+    @patch("django_tasks_pubsub.backend.publish", return_value="")
+    def test_enqueuing_a_task_with_pubsub_topic(
+        self, mocked_publish_method, mocked_get_publisher
+    ):
+        class DummyPublisher:
+            def __init__(self):
+                self.topic_path = Mock()
+
+        dummy_publisher = DummyPublisher()
+
+        mocked_get_publisher.return_value = dummy_publisher
+
+        sample_task_with_pubsub_topic.enqueue(
+            "spec_arg",
+            "arg1",
+        )
+
+        dummy_publisher.topic_path.assert_called_once_with(
+            "project_name",
+            "test-topic-name",
+        )
+
+    @patch("django_tasks_pubsub.backend.publish", return_value="")
+    @patch(
+        "django_tasks_pubsub.PubSubBackend.get_topic_path",
+        return_value="expected/topic/path",
+    )
+    def test_enqueuing_task_should_use_value_from_get_topic_path(
+        self, mocked_get_topic_path, mocked_publish_method
+    ):
+        sample_task.enqueue(
+            "spec_arg",
+            "arg1",
+            "arg2",
+        )
+
+        self.assertEqual(mocked_publish_method.call_count, 1)
+        self.assertEqual(
+            mocked_publish_method.call_args.kwargs["topic"],
+            "expected/topic/path",
+        )
+
+
+@override_settings(TASKS={"default": {"BACKEND": "django_tasks_pubsub.PubSubBackend"}})
+class TestPubSubBackendEnqueuing(SimpleTestCase):
+    def setUp(self):
+        self.get_topic_path_patcher = patch(
+            "django_tasks_pubsub.backend.PubSubBackend.get_topic_path",
+            return_value="expected/topic/path",
+        )
+        self.get_topic_path_mock = self.get_topic_path_patcher.start()
+
+    def tearDown(self):
+        self.get_topic_path_patcher.stop()
+
+    @patch("django_tasks_pubsub.backend.publish", return_value="")
+    def test_enqueuing_a_task_with_the_pub_sub_backend_should_not_raise_an_error(
+        self, mocked_publish_method
+    ):
+        sample_task.enqueue(
+            "spec_arg",
+            "arg1",
+            "arg2",
+            kwarg1="val1",
+            kwarg2="val2",
+        )
+
+        self.assertEqual(mocked_publish_method.call_count, 1)
+
+        with self.subTest("payload data is serialized as expected"):
+            payload_data = mocked_publish_method.call_args.kwargs["data"]
+            payload = json.loads(payload_data.decode("utf-8"))
+
+            self.assertIn("task", payload)
+            self.assertIn("task_id", payload)
+            self.assertIn("enqueued_at", payload)
+            self.assertIn("args", payload)
+            self.assertIn("kwargs", payload)
+
+            datetime.fromisoformat(payload["enqueued_at"])
+
+            self.assertEqual(
+                payload["args"],
+                ["spec_arg", "arg1", "arg2"],
+            )
+            self.assertEqual(
+                payload["kwargs"],
+                {
+                    "kwarg1": "val1",
+                    "kwarg2": "val2",
+                },
+            )
+
+            self.assertEqual(payload["task"]["name"], "sample_task")
+            self.assertEqual(payload["task"]["takes_context"], False)
+            self.assertEqual(
+                payload["task"]["module_path"],
+                "tests.test_enqueing_with_pubsub_task_backend.sample_task",
+            )
+            self.assertEqual(
+                payload["task"]["name"],
+                "sample_task",
+            )
+
+            self.assertIsNone(
+                payload["task"]["run_after"],
+            )
+
+    @patch("django_tasks_pubsub.backend.publish", return_value="")
+    def test_enqueuing_a_task_with_context_with_the_pub_sub_backend_should_not_raise_an_error(
+        self, mocked_publish_method
+    ):
+        sample_task_with_context.enqueue(
+            "spec_arg",
+            "arg1",
+            "arg2",
+            kwarg1="val1",
+            kwarg2="val2",
+        )
+
+        self.assertEqual(mocked_publish_method.call_count, 1)
+
+
+class TestPubSubTopicEnqueuingWithImmediateBackend(SimpleTestCase):
+    @override_settings(
+        TASKS={
+            "default": {"BACKEND": "django.tasks.backends.immediate.ImmediateBackend"}
+        }
+    )
+    def test_enqueuing_a_task_with_pubsub_topic_should_raise_an_error(self):
+        sample_task_with_pubsub_topic_with_watchdog.enqueue(
+            "arg1",
+            "arg2",
+        )
+
+        self.assertEqual(sample_task_with_pubsub_topic_watchdog.call_count, 1)
+
+        self.assertEqual(
+            sample_task_with_pubsub_topic_watchdog.call_args.args[0], "arg1"
+        )
+        self.assertEqual(
+            sample_task_with_pubsub_topic_watchdog.call_args.args[1], "arg2"
+        )

django_tasks_pubsub-0.1.1/tests/test_pubsub_view.py

@@ -0,0 +1,120 @@
+import base64
+import json
+from unittest.mock import patch, Mock
+
+from django.tasks import task
+from django.test import RequestFactory, SimpleTestCase
+
+from django_tasks_pubsub.backend import Payload, TaskPayload
+from django_tasks_pubsub.views import PubSubPushView
+
+sample_task_function_mock = Mock()
+
+
+@task
+def sample_task_function(specified_arg, *args, **kwargs):
+    sample_task_function_mock(specified_arg, *args, **kwargs)
+
+
+class TestDjangoTasksPubSubPushView(SimpleTestCase):
+    def setUp(self):
+        self.request_factory = RequestFactory()
+
+    def build_pubsub_push_request(self, payload: dict):
+        encoded_payload = base64.b64encode(
+            json.dumps(payload).encode("utf-8"),
+        ).decode("utf-8")
+
+        envelope = {
+            "message": {
+                "data": encoded_payload,
+                "messageId": "test-message-id",
+                "publishTime": "2026-05-12T10:00:00Z",
+            },
+            "subscription": "projects/test-project/subscriptions/test-subscription",
+        }
+
+        return self.request_factory.post(
+            "/pubsub/",
+            data=json.dumps(envelope),
+            content_type="application/json",
+        )
+
+    @patch("django_tasks_pubsub.views.dispatch")
+    def test_pubsub_view_calls_dispatch_with_expected_payload(self, mocked_dispatch):
+        payload = {
+            "task": {
+                "backend": "default",
+                "module_path": "django_tasks_pubsub.tests.test_pubsub_view",
+                "name": "sample_task",
+                "priority": 0,
+                "queue_name": "default",
+                "takes_context": False,
+            },
+            "task_id": "test-task-id",
+            "enqueued_at": "2026-05-12T10:00:00+00:00",
+            "args": [
+                "spec_arg",
+                "arg1",
+                "arg2",
+            ],
+            "kwargs": {
+                "kwarg1": "val1",
+                "kwarg2": "val2",
+            },
+        }
+
+        request = self.build_pubsub_push_request(payload)
+
+        response = PubSubPushView.as_view()(request)
+
+        self.assertEqual(response.status_code, 204)
+
+        with self.subTest("dispatch is called once"):
+            mocked_dispatch.assert_called_once()
+
+        with self.subTest("dispatch is called with payload object"):
+            mocked_dispatch.assert_called_once_with(
+                payload=Payload(
+                    task=TaskPayload(**payload.pop("task")),
+                    **payload,
+                )
+            )
+
+    def test_pubsub_view_calls_actual_task_function_with_expected_arguments(self):
+        payload = {
+            "task": {
+                "backend": "default",
+                "module_path": "tests.test_pubsub_view",
+                "name": "sample_task_function",
+                "priority": 0,
+                "queue_name": "default",
+                "takes_context": False,
+            },
+            "task_id": "test-task-id",
+            "enqueued_at": "2026-05-12T10:00:00+00:00",
+            "args": [
+                "spec_arg",
+                "arg1",
+                "arg2",
+            ],
+            "kwargs": {
+                "kwarg1": "val1",
+                "kwarg2": "val2",
+            },
+        }
+
+        request = self.build_pubsub_push_request(payload)
+
+        response = PubSubPushView.as_view()(request)
+
+        self.assertEqual(response.status_code, 204)
+
+        with self.subTest("actual task function is called with expected arguments"):
+            sample_task_function_mock.assert_called_once_with(
+                "spec_arg",
+                "arg1",
+                "arg2",
+                kwarg1="val1",
+                kwarg2="val2",
+            )