p1-taskqueue 0.1.0__tar.gz

p1_taskqueue-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: p1-taskqueue
+Version: 0.1.0
+Summary: A Task Queue Wrapper for Dekoruma Backend
+Author-email: Chalvin <engineering@dekoruma.com>
+Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue
+Project-URL: Repository, https://github.com/Dekoruma/p1-taskqueue.git
+Project-URL: Issues, https://github.com/Dekoruma/p1-taskqueue/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: celery>=5.4.0
+Requires-Dist: flower>=2.0.1
+Requires-Dist: redis>=6.2.0
+Requires-Dist: kombu>=5.3.4
+Requires-Dist: django>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+
+# TaskQueue
+
+A Task Queue Wrapper for Dekoruma Backend
+
+## Description
+
+TaskQueue is a Python package that provides a  wrapper around Celery for task queue management. It includes automatic queue setup, Dead Letter Queue (DLQ) routing, and dynamic task execution capabilities.
+
+
+## Deploy
+- Push changes to main
+- Create new TAG with version name (i.e 0.1.3)
+- Check status on the Actions page on Github

p1_taskqueue-0.1.0/README.md

@@ -0,0 +1,13 @@
+# TaskQueue
+
+A Task Queue Wrapper for Dekoruma Backend
+
+## Description
+
+TaskQueue is a Python package that provides a  wrapper around Celery for task queue management. It includes automatic queue setup, Dead Letter Queue (DLQ) routing, and dynamic task execution capabilities.
+
+
+## Deploy
+- Push changes to main
+- Create new TAG with version name (i.e 0.1.3)
+- Check status on the Actions page on Github

p1_taskqueue-0.1.0/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "p1-taskqueue"
+version = "0.1.0"
+description = "A Task Queue Wrapper for Dekoruma Backend"
+authors = [
+    {name = "Chalvin", email = "engineering@dekoruma.com"}
+]
+readme = "README.md"
+requires-python = ">=3.11"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+]
+dependencies = [
+    "celery>=5.4.0",
+    "flower>=2.0.1",
+    "redis>=6.2.0",
+    "kombu>=5.3.4",
+    "django>=4.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0.0",
+    "pytest-cov>=4.0.0",
+    "black>=23.0.0",
+    "flake8>=6.0.0",
+    "mypy>=1.0.0",
+    "pre-commit>=3.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/Dekoruma/p1-taskqueue"
+Repository = "https://github.com/Dekoruma/p1-taskqueue.git"
+Issues = "https://github.com/Dekoruma/p1-taskqueue/issues"
+
+[tool.setuptools.packages.find]
+where = ["src"]

p1_taskqueue-0.1.0/setup.cfg

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

p1_taskqueue-0.1.0/src/p1_taskqueue.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: p1-taskqueue
+Version: 0.1.0
+Summary: A Task Queue Wrapper for Dekoruma Backend
+Author-email: Chalvin <engineering@dekoruma.com>
+Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue
+Project-URL: Repository, https://github.com/Dekoruma/p1-taskqueue.git
+Project-URL: Issues, https://github.com/Dekoruma/p1-taskqueue/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: celery>=5.4.0
+Requires-Dist: flower>=2.0.1
+Requires-Dist: redis>=6.2.0
+Requires-Dist: kombu>=5.3.4
+Requires-Dist: django>=4.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0.0; extra == "dev"
+Requires-Dist: pytest-cov>=4.0.0; extra == "dev"
+Requires-Dist: black>=23.0.0; extra == "dev"
+Requires-Dist: flake8>=6.0.0; extra == "dev"
+Requires-Dist: mypy>=1.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.0.0; extra == "dev"
+
+# TaskQueue
+
+A Task Queue Wrapper for Dekoruma Backend
+
+## Description
+
+TaskQueue is a Python package that provides a  wrapper around Celery for task queue management. It includes automatic queue setup, Dead Letter Queue (DLQ) routing, and dynamic task execution capabilities.
+
+
+## Deploy
+- Push changes to main
+- Create new TAG with version name (i.e 0.1.3)
+- Check status on the Actions page on Github

p1_taskqueue-0.1.0/src/p1_taskqueue.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/p1_taskqueue.egg-info/PKG-INFO
+src/p1_taskqueue.egg-info/SOURCES.txt
+src/p1_taskqueue.egg-info/dependency_links.txt
+src/p1_taskqueue.egg-info/requires.txt
+src/p1_taskqueue.egg-info/top_level.txt
+src/taskqueue/__init__.py
+src/taskqueue/celery_app.py
+src/taskqueue/cmanager.py
+tests/test_celery_app.py
+tests/test_cmanager.py
+tests/test_test_utils.py

p1_taskqueue-0.1.0/src/p1_taskqueue.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

p1_taskqueue-0.1.0/src/p1_taskqueue.egg-info/requires.txt

@@ -0,0 +1,13 @@
+celery>=5.4.0
+flower>=2.0.1
+redis>=6.2.0
+kombu>=5.3.4
+django>=4.0.0
+
+[dev]
+pytest>=7.0.0
+pytest-cov>=4.0.0
+black>=23.0.0
+flake8>=6.0.0
+mypy>=1.0.0
+pre-commit>=3.0.0

p1_taskqueue-0.1.0/src/p1_taskqueue.egg-info/top_level.txt

@@ -0,0 +1 @@
+taskqueue

p1_taskqueue-0.1.0/src/taskqueue/__init__.py

@@ -0,0 +1,12 @@
+"""
+TaskQueue - A Task Queue Wrapper for Dekoruma Backend.
+"""
+
+__version__ = "0.1.0"
+__author__ = "Chalvin"
+__email__ = "engineering@dekoruma.com"
+
+from .cmanager import cm
+from .celery_app import celery_app
+
+__all__ = ["cm", "celery_app"]

p1_taskqueue-0.1.0/src/taskqueue/celery_app.py

@@ -0,0 +1,92 @@
+"""
+Celery application setup for TaskQueue.
+Reads configuration from Django settings and auto-configures queues with DLQ.
+"""
+from celery import Celery
+from kombu import Exchange
+from kombu import Queue
+
+
+def get_django_settings():
+    """Get Django settings, fail fast if not properly configured."""
+    try:
+        from django.conf import settings
+        return settings
+    except ImportError:
+        raise ImportError("[TaskQueue] Django settings not found.")
+
+
+def create_celery_app():
+    """Create and configure the Celery application."""
+    settings = get_django_settings()
+
+    app_name = getattr(settings, 'TASKQUEUE_APP_NAME', 'taskqueue')
+    app = Celery(app_name)
+
+    celery_config = {
+        'broker_url': getattr(settings, 'CELERY_BROKER_URL', 'amqp://localhost:5672//'),
+        'result_backend': getattr(settings, 'CELERY_RESULT_BACKEND', 'rpc://localhost:5672//'),
+        'task_serializer': getattr(settings, 'CELERY_TASK_SERIALIZER', 'pickle'),
+        'result_serializer': getattr(settings, 'CELERY_RESULT_SERIALIZER', 'pickle'),
+        'accept_content': getattr(settings, 'CELERY_ACCEPT_CONTENT', ['pickle']),
+        'timezone': getattr(settings, 'CELERY_TIMEZONE', 'UTC+7'),
+        'task_track_started': getattr(settings, 'CELERY_TASK_TRACK_STARTED', True),
+        'task_time_limit': getattr(settings, 'CELERY_TASK_TIME_LIMIT', 30 * 60),
+        'task_soft_time_limit': getattr(settings, 'CELERY_TASK_SOFT_TIME_LIMIT', 25 * 60),
+        'task_always_eager': getattr(settings, 'CELERY_TASK_ALWAYS_EAGER', False),
+        'task_eager_propagates': getattr(settings, 'CELERY_TASK_EAGER_PROPAGATES', True),
+        'task_acks_late': True,
+        'task_reject_on_worker_lost': True,
+        'worker_prefetch_multiplier': 1,
+        'worker_max_tasks_per_child': 1000,
+    }
+
+    setup_queues(app, settings, celery_config)
+    app.conf.update(celery_config)
+    app.autodiscover_tasks(['taskqueue'])
+
+    return app
+
+
+def setup_queues(app, settings, celery_config):
+    app_name = getattr(settings, 'TASKQUEUE_APP_NAME', 'taskqueue')
+    queue_names = getattr(settings, 'TASKQUEUE_QUEUES',
+                          ['default', 'high', 'low'])
+    if queue_names is None:
+        queue_names = ['default', 'high', 'low']
+    dlq_name_prefix = getattr(settings, 'TASKQUEUE_DLQ_NAME_PREFIX', 'dlq')
+
+    # Create exchanges
+    main_exchange = Exchange(app_name, type='direct')
+    dlx_exchange = Exchange(f'{app_name}.dlx', type='direct')
+
+    queues = []
+
+    for queue_name in queue_names:
+        dlq_name = f'{dlq_name_prefix}.{queue_name}'
+
+        queue = Queue(
+            queue_name,
+            main_exchange,
+            routing_key=queue_name,
+            queue_arguments={
+                'x-dead-letter-exchange': f'{app_name}.dlx',
+                'x-dead-letter-routing-key': dlq_name
+            }
+        )
+        queues.append(queue)
+
+    for queue_name in queue_names:
+        dlq_name = f'{dlq_name_prefix}.{queue_name}'
+        dlq = Queue(dlq_name, dlx_exchange, routing_key=dlq_name)
+        queues.append(dlq)
+
+    celery_config.update({
+        'task_default_queue': 'default',
+        'task_default_exchange': app_name,
+        'task_default_exchange_type': 'direct',
+        'task_queues': tuple(queues),
+    })
+
+
+celery_app = create_celery_app()

p1_taskqueue-0.1.0/src/taskqueue/cmanager.py

@@ -0,0 +1,252 @@
+import importlib
+import inspect
+import logging
+from datetime import datetime
+from datetime import timedelta
+from typing import Any
+from typing import Dict
+from typing import Tuple
+
+from celery import shared_task
+from celery.exceptions import Reject
+
+# Setup logger
+logger = logging.getLogger(__name__)
+
+# Enqueue operation type constants
+K_ENQUEUE_OP_TYPE_ENQUEUE = 'enqueue'
+K_ENQUEUE_OP_TYPE_ENQUEUE_AT = 'enqueue_at'
+K_ENQUEUE_OP_TYPE_ENQUEUE_IN = 'enqueue_in'
+
+K_MAX_RETRY_COUNT = 3
+K_DEFAULT_RETRY_COUNTDOWN = 10
+
+
+def _is_class_method(func: Any) -> bool:
+    return inspect.ismethod(func) or (
+        hasattr(func, "__self__") and getattr(func, "__self__") is not None
+    )
+
+
+def _split_function_and_queue_kwargs(kwargs: Dict[str, Any]) -> Tuple[Dict[str, Any], Dict[str, Any]]:
+    # To prevent confusion whether a kwargs is for function or queue kwargs(i.e celery options and on_commit),
+    # ignore confusing kwargs while give warning
+    supported_queue_keys = {"channel", "retry", "on_commit", "job_timeout"}
+    ignored_non_function_keys = {
+        "queue", "countdown", "eta", "expires", "priority", "task_id", "routing_key",
+        "serializer", "compression", "headers", "link", "link_error", "retry_policy",
+        "shadow", "time_limit", "soft_time_limit", "reply_to", "group_id", "chord", "chain",
+        "result_ttl", "failure_ttl", "ttl", "depends_on", "at_front", "meta", "retry_count",
+    }
+
+    queue_kwargs: Dict[str, Any] = {}
+    func_kwargs: Dict[str, Any] = {}
+
+    for key, value in kwargs.items():
+        if key in supported_queue_keys:
+            queue_kwargs[key] = value
+        elif key in ignored_non_function_keys:
+            logger.warning(
+                f"[CManager] Unsupported celery args detected: {key}. Ignored.")
+            continue
+        else:
+            func_kwargs[key] = value
+
+    return func_kwargs, queue_kwargs
+
+
+def _build_dynamic_task_call(func: Any, *args: Any, **func_kwargs: Any) -> Tuple[str, list, dict]:
+    if _is_class_method(func):
+        instance = getattr(func, "__self__")
+        klass = instance.__class__
+        module_path = klass.__module__
+        class_name = klass.__name__
+        method_name = func.__name__
+        task_name = "taskqueue.cmanager.dynamic_class_method_executor"
+        task_args = [module_path, class_name,
+                     method_name, list(args), dict(func_kwargs)]
+        task_kwargs: Dict[str, Any] = {}
+        return task_name, task_args, task_kwargs
+
+    module_path = getattr(func, "__module__", None)
+    function_name = getattr(func, "__name__", None)
+    if not module_path or not function_name:
+        raise ValueError(
+            "Unsupported callable type for Celery enqueue. Provide a module-level function or a class method.")
+
+    task_name = "taskqueue.cmanager.dynamic_function_executor"
+    task_args = [module_path, function_name, list(args), dict(func_kwargs)]
+    task_kwargs = {}
+    return task_name, task_args, task_kwargs
+
+
+class CManager:
+
+    def __init__(self) -> None:
+        pass
+
+    def _get_celery_app(self):
+        """Get the auto-configured Celery app instance."""
+        # Use taskqueue's built-in auto-configured celery app
+        from .celery_app import celery_app
+        return celery_app
+
+    def enqueue(self, *args: Any, **kwargs: Any) -> None:
+        self._enqueue_op(
+            *args, enqueue_op_type=K_ENQUEUE_OP_TYPE_ENQUEUE, **kwargs)
+
+    def enqueue_at(self, *args: Any, **kwargs: Any) -> None:
+        self._enqueue_op(
+            *args, enqueue_op_type=K_ENQUEUE_OP_TYPE_ENQUEUE_AT, **kwargs)
+
+    def enqueue_in(self, *args: Any, **kwargs: Any) -> None:
+        self._enqueue_op(
+            *args, enqueue_op_type=K_ENQUEUE_OP_TYPE_ENQUEUE_IN, **kwargs)
+
+    def _enqueue_op(self, *args: Any, **kwargs: Any) -> None:
+        on_commit = kwargs.pop('on_commit', False)
+        if on_commit:
+            try:
+                from django.db import transaction
+                transaction.on_commit(
+                    lambda: self._enqueue_op_base(*args, **kwargs))
+            except ImportError:
+                raise RuntimeError(
+                    "Django is not installed. Please install Django to use on_commit.")
+        else:
+            self._enqueue_op_base(*args, **kwargs)
+
+    def _enqueue_op_base(self, *args: Any, **kwargs: Any) -> None:
+        enqueue_op_type = kwargs.pop(
+            'enqueue_op_type', K_ENQUEUE_OP_TYPE_ENQUEUE)
+
+        try:
+            if enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE:
+                if not args:
+                    raise ValueError(
+                        "enqueue requires a callable as the first positional argument")
+                func = args[0]
+                func_args = args[1:]
+
+            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_AT:
+                if len(args) < 2:
+                    raise ValueError(
+                        "enqueue_at requires (eta_datetime, func, *func_args)")
+                eta: datetime = args[0]
+                func = args[1]
+                func_args = args[2:]
+
+            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_IN:
+                if len(args) < 2:
+                    raise ValueError(
+                        "enqueue_in requires (countdown_delta, func, *func_args)")
+                delta: timedelta = args[0]
+                func = args[1]
+                func_args = args[2:]
+            else:
+                raise ValueError(
+                    f"Unknown enqueue operation type: {enqueue_op_type}")
+
+            func_kwargs, queue_kwargs = _split_function_and_queue_kwargs(
+                kwargs)
+
+            if enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_AT:
+                queue_kwargs = dict(queue_kwargs)
+                queue_kwargs["eta"] = eta
+            elif enqueue_op_type == K_ENQUEUE_OP_TYPE_ENQUEUE_IN:
+                queue_kwargs = dict(queue_kwargs)
+                queue_kwargs["countdown"] = int(delta.total_seconds())
+
+            task_name, task_args, task_kwargs = _build_dynamic_task_call(
+                func, *func_args, **func_kwargs)
+
+            self._send_task(task_name, task_args, task_kwargs, queue_kwargs)
+
+            logger.info('[_enqueue_op_base %s] Submit Celery Task SUCCESS, task_name: %s args: %s, kwargs: %s' % (
+                enqueue_op_type, task_name, task_args, task_kwargs))
+
+        except Exception as e:
+            logger.exception('[_enqueue_op_base %s] Submit Celery Task FAILED, error: %s, args: %s, kwargs: %s' % (
+                enqueue_op_type, str(e), args, kwargs))
+            raise e
+
+    def _send_task(self, task_name: str, task_args: list, task_kwargs: dict, queue_kwargs: Dict[str, Any]) -> None:
+        celery_app = self._get_celery_app()
+
+        queue_name = queue_kwargs.pop("channel", None)
+        job_timeout = queue_kwargs.pop("job_timeout", None)
+        retry_policy = queue_kwargs.pop("retry", None)
+
+        send_opts: Dict[str, Any] = {}
+        if queue_name:
+            send_opts["queue"] = queue_name
+        if job_timeout is not None:
+            send_opts["time_limit"] = job_timeout
+        if "countdown" in queue_kwargs:
+            send_opts["countdown"] = queue_kwargs["countdown"]
+        if "eta" in queue_kwargs:
+            send_opts["eta"] = queue_kwargs["eta"]
+
+        task_kwargs_with_retry = dict(task_kwargs)
+        if retry_policy is None:
+            task_kwargs_with_retry["retry"] = {
+                "max_retries": K_MAX_RETRY_COUNT, "countdown": K_DEFAULT_RETRY_COUNTDOWN}
+        else:
+            task_kwargs_with_retry["retry"] = retry_policy
+
+        celery_app.send_task(task_name, args=task_args,
+                             kwargs=task_kwargs_with_retry, **send_opts)
+
+
+cm = CManager()
+
+
+# Dynamic task executors - handle function and class method execution
+@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT)
+def dynamic_function_executor(self, module_path, function_name, args=None, kwargs=None, retry=None):
+    try:
+        module = importlib.import_module(module_path)
+        function = getattr(module, function_name)
+        args = args or []
+        kwargs = kwargs or {}
+        return function(*args, **kwargs)
+    except Exception as e:
+        current_retries = getattr(self.request, 'retries', 0) or 0
+        max_retries = self.max_retries or K_MAX_RETRY_COUNT
+        if isinstance(retry, dict) and 'max_retries' in retry:
+            max_retries = retry['max_retries']
+
+        if current_retries >= max_retries:
+            raise Reject(str(e), requeue=False)
+
+        countdown = K_DEFAULT_RETRY_COUNTDOWN
+        if isinstance(retry, dict) and 'countdown' in retry:
+            countdown = retry['countdown']
+
+        raise self.retry(exc=e, countdown=countdown, max_retries=max_retries)
+
+
+@shared_task(bind=True, max_retries=K_MAX_RETRY_COUNT)
+def dynamic_class_method_executor(self, module_path, class_name, method_name, args=None, kwargs=None, retry=None):
+    try:
+        module = importlib.import_module(module_path)
+        class_obj = getattr(module, class_name)
+        instance = class_obj()
+        method = getattr(instance, method_name)
+        args = args or []
+        kwargs = kwargs or {}
+        return method(*args, **kwargs)
+    except Exception as e:
+        current_retries = getattr(self.request, 'retries', 0) or 0
+        max_retries = self.max_retries or K_MAX_RETRY_COUNT
+        if isinstance(retry, dict) and 'max_retries' in retry:
+            max_retries = retry['max_retries']
+
+        if current_retries >= max_retries:
+            raise Reject(str(e), requeue=False)
+
+        countdown = K_DEFAULT_RETRY_COUNTDOWN
+        if isinstance(retry, dict) and 'countdown' in retry:
+            countdown = retry['countdown']
+
+        raise self.retry(exc=e, countdown=countdown, max_retries=max_retries)

p1_taskqueue-0.1.0/tests/test_celery_app.py

@@ -0,0 +1,186 @@
+"""Tests for the celery_app module."""
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+import pytest
+from taskqueue.celery_app import create_celery_app
+from taskqueue.celery_app import get_django_settings
+from taskqueue.celery_app import setup_queues
+
+
+class TestGetDjangoSettings:
+
+    def test_get_django_settings_given_django_available_expect_return_settings(self):
+        with patch('django.conf.settings') as mock_settings:
+            result = get_django_settings()
+            assert result == mock_settings
+
+    def test_get_django_settings_given_django_not_available_expect_raise_import_error(self):
+        with patch('builtins.__import__', side_effect=ImportError("No module named 'django'")):
+            with pytest.raises(ImportError, match="\\[TaskQueue\\] Django settings not found\\."):
+                get_django_settings()
+
+
+class TestCreateCeleryApp:
+
+    @patch('taskqueue.celery_app.setup_queues')
+    @patch('taskqueue.celery_app.get_django_settings')
+    @patch('taskqueue.celery_app.Celery')
+    def test_create_celery_app_given_valid_settings_expect_celery_app_created(
+        self, mock_celery_class, mock_get_settings, mock_setup_queues
+    ):
+        mock_settings = MagicMock()
+        mock_settings.TASKQUEUE_APP_NAME = 'testapp'
+        mock_settings.CELERY_BROKER_URL = 'redis://localhost:6379/0'
+        mock_settings.CELERY_RESULT_BACKEND = 'redis://localhost:6379/0'
+        mock_settings.CELERY_TASK_SERIALIZER = 'pickle'
+        mock_settings.CELERY_RESULT_SERIALIZER = 'pickle'
+        mock_settings.CELERY_ACCEPT_CONTENT = ['pickle']
+        mock_settings.CELERY_TIMEZONE = 'UTC'
+        mock_settings.CELERY_TASK_TRACK_STARTED = True
+        mock_settings.CELERY_TASK_TIME_LIMIT = 1800
+        mock_settings.CELERY_TASK_SOFT_TIME_LIMIT = 1500
+        mock_settings.CELERY_TASK_ALWAYS_EAGER = False
+        mock_settings.CELERY_TASK_EAGER_PROPAGATES = True
+
+        mock_get_settings.return_value = mock_settings
+        mock_app = MagicMock()
+        mock_celery_class.return_value = mock_app
+
+        result = create_celery_app()
+
+        mock_celery_class.assert_called_once_with('testapp')
+        mock_setup_queues.assert_called_once()
+        mock_app.conf.update.assert_called_once()
+        mock_app.autodiscover_tasks.assert_called_once_with(['taskqueue'])
+        assert result == mock_app
+
+    @patch('taskqueue.celery_app.setup_queues')
+    @patch('taskqueue.celery_app.get_django_settings')
+    @patch('taskqueue.celery_app.Celery')
+    def test_create_celery_app_given_missing_settings_expect_defaults_used(
+        self, mock_celery_class, mock_get_settings, mock_setup_queues
+    ):
+        mock_settings = MagicMock()
+        del mock_settings.TASKQUEUE_APP_NAME
+        del mock_settings.CELERY_BROKER_URL
+        del mock_settings.CELERY_RESULT_BACKEND
+        del mock_settings.CELERY_TASK_SERIALIZER
+        del mock_settings.CELERY_RESULT_SERIALIZER
+        del mock_settings.CELERY_ACCEPT_CONTENT
+        del mock_settings.CELERY_TIMEZONE
+        del mock_settings.CELERY_TASK_TRACK_STARTED
+        del mock_settings.CELERY_TASK_TIME_LIMIT
+        del mock_settings.CELERY_TASK_SOFT_TIME_LIMIT
+        del mock_settings.CELERY_TASK_ALWAYS_EAGER
+        del mock_settings.CELERY_TASK_EAGER_PROPAGATES
+
+        mock_get_settings.return_value = mock_settings
+        mock_app = MagicMock()
+        mock_celery_class.return_value = mock_app
+
+        result = create_celery_app()
+
+        mock_celery_class.assert_called_once_with('taskqueue')
+        assert result == mock_app
+
+
+class TestSetupQueues:
+    """Test setup_queues function."""
+
+    def test_setup_queues_given_valid_settings_expect_queues_configured(self):
+        """Test that setup_queues configures queues and DLQs correctly."""
+        mock_app = MagicMock()
+        mock_settings = MagicMock()
+        mock_settings.TASKQUEUE_APP_NAME = 'testapp'
+        mock_settings.TASKQUEUE_QUEUES = ['default', 'high', 'low']
+        mock_settings.TASKQUEUE_DLQ_NAME_PREFIX = 'dlq'
+
+        celery_config = {}
+
+        setup_queues(mock_app, mock_settings, celery_config)
+
+        # Assertions
+        assert celery_config['task_default_queue'] == 'default'
+        assert celery_config['task_default_exchange'] == 'testapp'
+        assert celery_config['task_default_exchange_type'] == 'direct'
+        assert len(celery_config['task_queues']) == 6
+
+        main_queues = [q for q in celery_config['task_queues']
+                       if not q.name.startswith('dlq.')]
+        assert len(main_queues) == 3
+        assert any(q.name == 'default' for q in main_queues)
+        assert any(q.name == 'high' for q in main_queues)
+        assert any(q.name == 'low' for q in main_queues)
+
+        dlq_queues = [q for q in celery_config['task_queues']
+                      if q.name.startswith('dlq.')]
+        assert len(dlq_queues) == 3
+        assert any(q.name == 'dlq.default' for q in dlq_queues)
+        assert any(q.name == 'dlq.high' for q in dlq_queues)
+        assert any(q.name == 'dlq.low' for q in dlq_queues)
+
+    def test_setup_queues_given_missing_settings_expect_defaults_used(self):
+        mock_app = MagicMock()
+        mock_settings = MagicMock()
+        del mock_settings.TASKQUEUE_APP_NAME
+        del mock_settings.TASKQUEUE_QUEUES
+        del mock_settings.TASKQUEUE_DLQ_NAME_PREFIX
+
+        celery_config = {}
+
+        setup_queues(mock_app, mock_settings, celery_config)
+
+        assert celery_config['task_default_queue'] == 'default'
+        assert celery_config['task_default_exchange'] == 'taskqueue'
+        assert celery_config['task_default_exchange_type'] == 'direct'
+        assert len(celery_config['task_queues']) == 6
+
+    def test_setup_queues_given_single_queue_expect_correct_configuration(self):
+        mock_app = MagicMock()
+        mock_settings = MagicMock()
+        mock_settings.TASKQUEUE_APP_NAME = 'singleapp'
+        mock_settings.TASKQUEUE_QUEUES = ['single']
+        mock_settings.TASKQUEUE_DLQ_NAME_PREFIX = 'dead'
+
+        celery_config = {}
+
+        setup_queues(mock_app, mock_settings, celery_config)
+
+        assert len(celery_config['task_queues']) == 2
+
+        main_queue = next(
+            q for q in celery_config['task_queues'] if q.name == 'single')
+        assert main_queue.queue_arguments['x-dead-letter-exchange'] == 'singleapp.dlx'
+        assert main_queue.queue_arguments['x-dead-letter-routing-key'] == 'dead.single'
+
+        dlq = next(
+            q for q in celery_config['task_queues'] if q.name == 'dead.single')
+        assert dlq.exchange.name == 'singleapp.dlx'
+
+
+class TestCeleryAppIntegration:
+    """Integration tests for the celery_app module."""
+
+    @patch('taskqueue.celery_app.get_django_settings')
+    def test_celery_app_import_given_django_configured_expect_app_created(self, mock_get_settings):
+        mock_settings = MagicMock()
+        mock_settings.TASKQUEUE_APP_NAME = 'testapp'
+        mock_settings.CELERY_BROKER_URL = 'redis://localhost:6379/0'
+        mock_settings.CELERY_RESULT_BACKEND = 'redis://localhost:6379/0'
+        mock_settings.CELERY_TASK_SERIALIZER = 'pickle'
+        mock_settings.CELERY_RESULT_SERIALIZER = 'pickle'
+        mock_settings.CELERY_ACCEPT_CONTENT = ['pickle']
+        mock_settings.CELERY_TIMEZONE = 'UTC'
+        mock_settings.CELERY_TASK_TRACK_STARTED = True
+        mock_settings.CELERY_TASK_TIME_LIMIT = 1800
+        mock_settings.CELERY_TASK_SOFT_TIME_LIMIT = 1500
+        mock_settings.CELERY_TASK_ALWAYS_EAGER = False
+        mock_settings.CELERY_TASK_EAGER_PROPAGATES = True
+        mock_settings.TASKQUEUE_QUEUES = ['default']
+        mock_settings.TASKQUEUE_DLQ_NAME_PREFIX = 'dlq'
+
+        mock_get_settings.return_value = mock_settings
+
+        from taskqueue.celery_app import celery_app
+        assert celery_app is not None

p1_taskqueue-0.1.0/tests/test_cmanager.py

@@ -0,0 +1,308 @@
+from datetime import datetime
+from datetime import timedelta
+from unittest.mock import Mock
+from unittest.mock import patch
+
+import pytest
+from taskqueue.cmanager import _build_dynamic_task_call
+from taskqueue.cmanager import _is_class_method
+from taskqueue.cmanager import _split_function_and_queue_kwargs
+from taskqueue.cmanager import CManager
+from taskqueue.cmanager import K_DEFAULT_RETRY_COUNTDOWN
+from taskqueue.cmanager import K_MAX_RETRY_COUNT
+# Import the functions and classes to test
+
+
+class TestClass:
+
+    def test_method(self):
+        pass
+
+    @classmethod
+    def class_method(cls):
+        pass
+
+    @staticmethod
+    def static_method():
+        pass
+
+
+def test_function():
+    """Test function for testing function detection."""
+
+
+class TestIsClassMethod:
+
+    def test__is_class_method_given_function_expect_return_false(self):
+        result = _is_class_method(test_function)
+        assert result is False
+
+    def test__is_class_method_given_class_method_expect_return_true(self):
+        instance = TestClass()
+        result = _is_class_method(instance.test_method)
+        assert result is True
+
+    def test__is_class_method_given_classmethod_decorator_expect_return_true(self):
+        result = _is_class_method(TestClass.class_method)
+        assert result is True
+
+    def test__is_class_method_given_staticmethod_decorator_expect_return_false(self):
+        result = _is_class_method(TestClass.static_method)
+        assert result is False
+
+    def test__is_class_method_given_unbound_method_expect_return_false(self):
+        result = _is_class_method(TestClass.test_method)
+        assert result is False
+
+
+class TestSplitFunctionAndQueueKwargs:
+
+    def test__split_function_and_queue_kwargs_given_mixed_kwargs_expect_correct_split(self):
+        kwargs = {
+            'channel': 'high',
+            'retry': {'max_retries': 5},
+            'on_commit': True,
+            'job_timeout': 300,
+            'user_id': 123,
+            'data': {'key': 'value'}
+        }
+
+        func_kwargs, queue_kwargs = _split_function_and_queue_kwargs(kwargs)
+
+        assert func_kwargs == {'user_id': 123, 'data': {'key': 'value'}}
+        assert queue_kwargs == {
+            'channel': 'high',
+            'retry': {'max_retries': 5},
+            'on_commit': True,
+            'job_timeout': 300
+        }
+
+    def test__split_function_and_queue_kwargs_given_only_function_kwargs_expect_empty_queue_kwargs(self):
+        kwargs = {'user_id': 123, 'data': 'test'}
+
+        func_kwargs, queue_kwargs = _split_function_and_queue_kwargs(kwargs)
+
+        assert func_kwargs == {'user_id': 123, 'data': 'test'}
+        assert queue_kwargs == {}
+
+    def test__split_function_and_queue_kwargs_given_only_queue_kwargs_expect_empty_func_kwargs(self):
+        kwargs = {'channel': 'default', 'retry': {'max_retries': 3}}
+
+        func_kwargs, queue_kwargs = _split_function_and_queue_kwargs(kwargs)
+
+        assert func_kwargs == {}
+        assert queue_kwargs == {
+            'channel': 'default', 'retry': {'max_retries': 3}}
+
+    def test__split_function_and_queue_kwargs_given_ignored_celery_keys_expect_they_are_ignored(self):
+        kwargs = {
+            'queue': 'default',
+            'countdown': 10,
+            'eta': datetime.now(),
+            'priority': 1,
+            'user_id': 123
+        }
+
+        func_kwargs, queue_kwargs = _split_function_and_queue_kwargs(kwargs)
+
+        assert func_kwargs == {'user_id': 123}
+        assert queue_kwargs == {}
+
+
+class TestBuildDynamicTaskCall:
+
+    def test__build_dynamic_task_call_given_function_expect_function_executor_task(self):
+        task_name, task_args, task_kwargs = _build_dynamic_task_call(
+            test_function, 1, 2, key='value'
+        )
+
+        assert task_name == "taskqueue.cmanager.dynamic_function_executor"
+        assert task_args == ['tests.test_cmanager',
+                             'test_function', [1, 2], {'key': 'value'}]
+        assert task_kwargs == {}
+
+    def test__build_dynamic_task_call_given_bound_method_expect_class_method_executor_task(self):
+        instance = TestClass()
+        task_name, task_args, task_kwargs = _build_dynamic_task_call(
+            instance.test_method, 1, 2, key='value'
+        )
+
+        assert task_name == "taskqueue.cmanager.dynamic_class_method_executor"
+        assert task_args == ['tests.test_cmanager',
+                             'TestClass', 'test_method', [1, 2], {'key': 'value'}]
+        assert task_kwargs == {}
+
+    def test__build_dynamic_task_call_given_function_without_module_expect_raise_value_error(self):
+        mock_func = Mock()
+        mock_func.__module__ = None
+        mock_func.__name__ = 'test_func'
+
+        with pytest.raises(ValueError, match="Unsupported callable type for Celery enqueue"):
+            _build_dynamic_task_call(mock_func)
+
+    def test__build_dynamic_task_call_given_function_without_name_expect_raise_value_error(self):
+        mock_func = Mock()
+        mock_func.__module__ = 'test_module'
+        mock_func.__name__ = None
+
+        with pytest.raises(ValueError, match="Unsupported callable type for Celery enqueue"):
+            _build_dynamic_task_call(mock_func)
+
+
+class TestCManager:
+
+    @patch('taskqueue.cmanager.logger')
+    @patch.object(CManager, '_send_task')
+    def test_cmanager_enqueue_given_function_expect_send_task_called(self, mock_send_task, mock_logger):
+        cm = CManager()
+        cm.enqueue(test_function, 1, 2, key='value')
+
+        mock_send_task.assert_called_once()
+        call_args = mock_send_task.call_args
+        assert call_args[0][0] == "taskqueue.cmanager.dynamic_function_executor"
+
+    @patch('taskqueue.cmanager.logger')
+    @patch.object(CManager, '_send_task')
+    def test_cmanager_enqueue_at_given_datetime_and_function_expect_send_task_called_with_eta(self, mock_send_task, mock_logger):
+        cm = CManager()
+        eta = datetime.now()
+        cm.enqueue_at(eta, test_function, 1, 2)
+
+        mock_send_task.assert_called_once()
+        call_args = mock_send_task.call_args
+        assert call_args[0][0] == "taskqueue.cmanager.dynamic_function_executor"
+
+    @patch('taskqueue.cmanager.logger')
+    @patch.object(CManager, '_send_task')
+    def test_cmanager_enqueue_in_given_timedelta_and_function_expect_send_task_called_with_countdown(self, mock_send_task, mock_logger):
+        cm = CManager()
+        delta = timedelta(seconds=60)
+        cm.enqueue_in(delta, test_function, 1, 2)
+
+        mock_send_task.assert_called_once()
+        call_args = mock_send_task.call_args
+        assert call_args[0][0] == "taskqueue.cmanager.dynamic_function_executor"
+
+    def test_cmanager_enqueue_given_no_args_expect_raise_value_error(self):
+        cm = CManager()
+        with pytest.raises(ValueError, match="enqueue requires a callable as the first positional argument"):
+            cm.enqueue()
+
+    def test_cmanager_enqueue_at_given_insufficient_args_expect_raise_value_error(self):
+        cm = CManager()
+        with pytest.raises(ValueError, match="enqueue_at requires \\(eta_datetime, func, \\*func_args\\)"):
+            cm.enqueue_at(datetime.now())
+
+    def test_cmanager_enqueue_in_given_insufficient_args_expect_raise_value_error(self):
+        cm = CManager()
+        with pytest.raises(ValueError, match="enqueue_in requires \\(countdown_delta, func, \\*func_args\\)"):
+            cm.enqueue_in(timedelta(seconds=10))
+
+    def test_cmanager_enqueue_op_given_unknown_type_expect_raise_value_error(self):
+        cm = CManager()
+        with pytest.raises(ValueError, match="Unknown enqueue operation type: invalid"):
+            cm._enqueue_op_base(test_function, enqueue_op_type='invalid')
+
+    @patch('django.db.transaction.on_commit')
+    @patch.object(CManager, '_enqueue_op_base')
+    def test_cmanager_enqueue_op_given_on_commit_true_expect_transaction_on_commit_called(self, mock_enqueue_op_base, mock_on_commit):
+        cm = CManager()
+        cm._enqueue_op(test_function, on_commit=True)
+
+        mock_on_commit.assert_called_once()
+
+    @patch('django.db.transaction.on_commit')
+    @patch.object(CManager, '_enqueue_op_base')
+    def test_cmanager_enqueue_op_given_on_commit_false_expect_enqueue_op_base_called_directly(self, mock_enqueue_op_base, mock_on_commit):
+        cm = CManager()
+        cm._enqueue_op(test_function, on_commit=False)
+
+        mock_enqueue_op_base.assert_called_once()
+        mock_on_commit.assert_not_called()
+
+    @patch('taskqueue.celery_app.celery_app')
+    def test_cmanager__send_task_given_task_args_expect_celery_app_send_task_called(self, mock_celery_app):
+        cm = CManager()
+        cm._send_task("test.task", [1, 2], {
+                      "key": "value"}, {"channel": "high"})
+
+        mock_celery_app.send_task.assert_called_once()
+        call_args = mock_celery_app.send_task.call_args
+        # send_task is called with keyword arguments
+        args, kwargs = call_args
+        assert args[0] == "test.task"
+        assert kwargs["args"] == [1, 2]
+        # The retry policy is added automatically, so we need to check for both
+        expected_kwargs = {"key": "value", "retry": {
+            "max_retries": K_MAX_RETRY_COUNT, "countdown": K_DEFAULT_RETRY_COUNTDOWN}}
+        assert kwargs["kwargs"] == expected_kwargs
+        assert kwargs["queue"] == "high"
+
+    @patch('taskqueue.celery_app.celery_app')
+    def test_cmanager__send_task_given_no_retry_policy_expect_default_retry_policy_applied(self, mock_celery_app):
+        cm = CManager()
+        cm._send_task("test.task", [], {}, {})
+
+        mock_celery_app.send_task.assert_called_once()
+        call_args = mock_celery_app.send_task.call_args
+        args, kwargs = call_args
+        assert kwargs["kwargs"]["retry"] == {
+            "max_retries": K_MAX_RETRY_COUNT,
+            "countdown": K_DEFAULT_RETRY_COUNTDOWN
+        }
+
+    @patch('taskqueue.celery_app.celery_app')
+    def test_cmanager__send_task_given_custom_retry_policy_expect_custom_policy_used(self, mock_celery_app):
+        cm = CManager()
+        custom_retry = {"max_retries": 5, "countdown": 20}
+        cm._send_task("test.task", [], {}, {"retry": custom_retry})
+
+        mock_celery_app.send_task.assert_called_once()
+        call_args = mock_celery_app.send_task.call_args
+        args, kwargs = call_args
+        assert kwargs["kwargs"]["retry"] == custom_retry
+
+
+class TestDynamicTaskExecutors:
+
+    def test_dynamic_function_executor_given_valid_module_and_function_expect_function_executed(self):
+        """Test that dynamic_function_executor is properly decorated."""
+        from taskqueue.cmanager import dynamic_function_executor
+
+        # Just verify the function exists and is decorated
+        assert hasattr(dynamic_function_executor, 'delay')
+        assert hasattr(dynamic_function_executor, 'apply_async')
+
+    def test_dynamic_class_method_executor_given_valid_class_and_method_expect_method_executed(self):
+        """Test that dynamic_class_method_executor is properly decorated."""
+        from taskqueue.cmanager import dynamic_class_method_executor
+
+        # Just verify the function exists and is decorated
+        assert hasattr(dynamic_class_method_executor, 'delay')
+        assert hasattr(dynamic_class_method_executor, 'apply_async')
+
+    @patch('taskqueue.cmanager.importlib.import_module')
+    def test_dynamic_function_executor_given_import_error_expect_retry_raised(self, mock_import_module):
+        mock_import_module.side_effect = ImportError("Module not found")
+
+        from taskqueue.cmanager import dynamic_function_executor
+
+        with pytest.raises(Exception):  # retry is raised
+            dynamic_function_executor("invalid_module", "test_function")
+
+    @patch('taskqueue.cmanager.importlib.import_module')
+    def test_dynamic_function_executor_given_max_retries_reached_expect_reject_raised(self, mock_import_module):
+        mock_import_module.side_effect = ImportError("Module not found")
+
+        from taskqueue.cmanager import dynamic_function_executor
+
+        # Mock the request object to simulate max retries reached
+        mock_self = Mock()
+        mock_self.request.retries = K_MAX_RETRY_COUNT
+        mock_self.max_retries = K_MAX_RETRY_COUNT
+
+        with pytest.raises(Exception):  # Reject should be raised
+            dynamic_function_executor(
+                mock_self, "invalid_module", "test_function",
+                retry={"max_retries": K_MAX_RETRY_COUNT}
+            )

p1_taskqueue-0.1.0/tests/test_test_utils.py

@@ -0,0 +1,294 @@
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+from libs.test_utils import celery_worker_burst
+from libs.test_utils import clear_all_celery_queues
+
+
+class TestClearAllCeleryQueues:
+
+    @patch('libs.test_utils.current_app')
+    def test_clear_all_celery_queues_given_multiple_queues_expect_all_purged(self, mock_current_app):
+        mock_queue1 = MagicMock()
+        mock_queue2 = MagicMock()
+        mock_queue_factory1 = MagicMock(return_value=mock_queue1)
+        mock_queue_factory2 = MagicMock(return_value=mock_queue2)
+
+        mock_current_app.amqp.queues.keys.return_value = ['queue1', 'queue2']
+        mock_current_app.amqp.queues = {
+            'queue1': mock_queue_factory1,
+            'queue2': mock_queue_factory2
+        }
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        clear_all_celery_queues()
+
+        mock_queue_factory1.assert_called_once_with(mock_chan)
+        mock_queue_factory2.assert_called_once_with(mock_chan)
+        mock_queue1.purge.assert_called_once()
+        mock_queue2.purge.assert_called_once()
+
+    @patch('libs.test_utils.current_app')
+    def test_clear_all_celery_queues_given_empty_queues_expect_no_purge_calls(self, mock_current_app):
+        mock_current_app.amqp.queues.keys.return_value = []
+        mock_current_app.amqp.queues = {}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        clear_all_celery_queues()
+
+        mock_conn.channel.assert_called_once()
+
+
+class TestCeleryWorkerBurst:
+
+    @patch('libs.test_utils.current_app')
+    @patch('libs.test_utils.loads')
+    def test_celery_worker_burst_given_matching_function_executor_expect_execution(self, mock_loads, mock_current_app):
+        mock_task = MagicMock()
+        mock_current_app.tasks = {
+            'taskqueue.cmanager.dynamic_function_executor': mock_task}
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.dynamic_function_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+        mock_message.acknowledged = False
+
+        mock_loads.return_value = [
+            ['module.submodule', 'test_function', [], {}], {}]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'default': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        with patch('libs.test_utils.logger') as mock_logger:
+            celery_worker_burst(['module.submodule.test_function'])
+
+            mock_logger.info.assert_any_call(
+                "Executing task: module.submodule.test_function")
+            mock_logger.info.assert_any_call(
+                "Successfully executed task: module.submodule.test_function")
+
+        mock_message.ack.assert_called_once()
+        mock_task.apply.assert_called_once_with(
+            args=['module.submodule', 'test_function', [], {}],
+            kwargs={}
+        )
+
+    @patch('libs.test_utils.current_app')
+    @patch('libs.test_utils.loads')
+    def test_celery_worker_burst_given_matching_class_method_executor_expect_execution(self, mock_loads, mock_current_app):
+        mock_task = MagicMock()
+        mock_current_app.tasks = {
+            'taskqueue.cmanager.dynamic_class_method_executor': mock_task}
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.dynamic_class_method_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+        mock_message.acknowledged = False
+
+        mock_loads.return_value = [
+            ['module.submodule', 'TestClass', 'test_method', [], {}], {}]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'default': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        with patch('libs.test_utils.logger') as mock_logger:
+            celery_worker_burst(['module.submodule.TestClass.test_method'])
+
+            mock_logger.info.assert_any_call(
+                "Executing task: module.submodule.TestClass.test_method")
+            mock_logger.info.assert_any_call(
+                "Successfully executed task: module.submodule.TestClass.test_method")
+
+        mock_message.ack.assert_called_once()
+        mock_task.apply.assert_called_once_with(
+            args=['module.submodule', 'TestClass', 'test_method', [], {}],
+            kwargs={}
+        )
+
+    @patch('libs.test_utils.current_app')
+    @patch('libs.test_utils.loads')
+    def test_celery_worker_burst_given_non_matching_function_expect_skip(self, mock_loads, mock_current_app):
+        mock_task = MagicMock()
+        mock_current_app.tasks = {
+            'taskqueue.cmanager.dynamic_function_executor': mock_task}
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.dynamic_function_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+        mock_message.acknowledged = False
+
+        mock_loads.return_value = [
+            ['module.submodule', 'other_function', [], {}], {}]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'default': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        celery_worker_burst(['module.submodule.test_function'])
+
+        mock_message.ack.assert_called_once()
+        mock_task.apply.assert_not_called()
+
+    @patch('libs.test_utils.current_app')
+    def test_celery_worker_burst_given_invalid_task_name_expect_warning_and_skip(self, mock_current_app):
+        mock_current_app.tasks = {}
+
+        mock_message = MagicMock()
+        mock_message.headers = {'task': 'invalid.task.name'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+        mock_message.acknowledged = False
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'default': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        with patch('libs.test_utils.logger') as mock_logger:
+            celery_worker_burst(['some.function'])
+
+            mock_logger.warning.assert_called_once_with(
+                "Invalid task 'invalid.task.name'. Skipping.")
+            mock_message.ack.assert_called_once()
+
+    @patch('libs.test_utils.current_app')
+    def test_celery_worker_burst_given_no_messages_expect_no_processing(self, mock_current_app):
+        mock_queue = MagicMock()
+        mock_queue.get.return_value = None
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'default': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        celery_worker_burst(['some.function'])
+
+        mock_queue.get.assert_called_once_with(no_ack=False)
+
+    @patch('libs.test_utils.current_app')
+    @patch('libs.test_utils.loads')
+    def test_celery_worker_burst_given_custom_channel_expect_correct_queue_used(self, mock_loads, mock_current_app):
+        mock_task = MagicMock()
+        mock_current_app.tasks = {
+            'taskqueue.cmanager.dynamic_function_executor': mock_task}
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.dynamic_function_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+        mock_message.acknowledged = False
+
+        mock_loads.return_value = [
+            ['module.submodule', 'test_function', [], {}], {}]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'custom_queue': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        with patch('libs.test_utils.logger') as mock_logger:
+            celery_worker_burst(
+                ['module.submodule.test_function'], channel='custom_queue')
+
+            mock_logger.info.assert_any_call(
+                "Executing task: module.submodule.test_function")
+            mock_logger.info.assert_any_call(
+                "Successfully executed task: module.submodule.test_function")
+
+        mock_queue_factory.assert_called_once_with(mock_chan)
+
+    @patch('libs.test_utils.current_app')
+    @patch('libs.test_utils.loads')
+    def test_celery_worker_burst_given_task_processing_error_expect_error_logged_and_ack(self, mock_loads, mock_current_app):
+        mock_task = MagicMock()
+        mock_task.apply.side_effect = Exception("Task execution failed")
+        mock_current_app.tasks = {
+            'taskqueue.cmanager.dynamic_function_executor': mock_task}
+
+        mock_message = MagicMock()
+        mock_message.headers = {
+            'task': 'taskqueue.cmanager.dynamic_function_executor'}
+        mock_message.body = b'mock_body'
+        mock_message.content_type = 'application/json'
+        mock_message.content_encoding = 'utf-8'
+
+        # Mock the acknowledged property to simulate ack behavior
+        def get_acknowledged():
+            return mock_message.ack.called
+        type(mock_message).acknowledged = property(
+            lambda self: get_acknowledged())
+
+        mock_loads.return_value = [
+            ['module.submodule', 'test_function', [], {}], {}]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_queue_factory = MagicMock(return_value=mock_queue)
+        mock_current_app.amqp.queues = {'default': mock_queue_factory}
+
+        mock_conn = MagicMock()
+        mock_chan = MagicMock()
+        mock_current_app.connection_for_read.return_value.__enter__.return_value = mock_conn
+        mock_conn.channel.return_value.__enter__.return_value = mock_chan
+
+        with patch('libs.test_utils.logger') as mock_logger:
+            celery_worker_burst(['module.submodule.test_function'])
+
+            mock_logger.info.assert_any_call(
+                "Executing task: module.submodule.test_function")
+            mock_logger.error.assert_called_once_with(
+                "Failed to process task taskqueue.cmanager.dynamic_function_executor: Exception: Task execution failed"
+            )
+            mock_message.ack.assert_called_once()