p1-taskqueue 0.1.8__tar.gz → 0.1.9__tar.gz

{p1_taskqueue-0.1.8 → p1_taskqueue-0.1.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.8
+Version: 0.1.9
 Summary: A Task Queue Wrapper for Dekoruma Backend
 Author-email: Chalvin <engineering@dekoruma.com>
 Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue

{p1_taskqueue-0.1.8 → p1_taskqueue-0.1.9}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "p1-taskqueue"
 # DO NOT CHANGE THIS VERSION - it gets automatically replaced by CI/CD with the git tag version
-version = "0.1.8"
+version = "0.1.9"
 description = "A Task Queue Wrapper for Dekoruma Backend"
 authors = [
     {name = "Chalvin", email = "engineering@dekoruma.com"}

{p1_taskqueue-0.1.8 → p1_taskqueue-0.1.9}/src/p1_taskqueue.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: p1-taskqueue
-Version: 0.1.8
+Version: 0.1.9
 Summary: A Task Queue Wrapper for Dekoruma Backend
 Author-email: Chalvin <engineering@dekoruma.com>
 Project-URL: Homepage, https://github.com/Dekoruma/p1-taskqueue

{p1_taskqueue-0.1.8 → p1_taskqueue-0.1.9}/src/p1_taskqueue.egg-info/SOURCES.txt

@@ -12,5 +12,6 @@ src/taskqueue/libs/__init__.py
 src/taskqueue/libs/helper_test.py
 tests/test_celery_app.py
 tests/test_cmanager.py
+tests/test_helper_test_functions.py
 tests/test_return_values.py
 tests/test_test_utils.py

p1_taskqueue-0.1.9/src/taskqueue/libs/helper_test.py

@@ -0,0 +1,178 @@
+import logging
+from typing import List
+
+from celery import current_app
+from kombu.serialization import loads
+
+logger = logging.getLogger(__name__)
+
+
+def clear_all_celery_queues():
+    app = current_app
+    all_queue_names = list(app.amqp.queues.keys())
+    with app.connection_for_read() as conn:
+        with conn.channel() as chan:
+            for queue_name in all_queue_names:
+                queue = app.amqp.queues[queue_name](chan)
+                queue.purge()
+
+
+def celery_worker_burst(include_func_names: List[str], channel: str = "default"):
+    # This doesn't use celery as celery doesn't support filtering out functions
+    # this use kombu to get the message from the queue and then execute the task manually
+    app = current_app
+    included_set = set(include_func_names)
+    processed_count = 0
+    executed_count = 0
+
+    try:
+        with app.connection_for_read() as conn:
+            with conn.channel() as chan:
+                queue = app.amqp.queues[channel](chan)
+
+                while True:
+                    message = queue.get(no_ack=False)
+                    if not message:
+                        break
+
+                    processed_count += 1
+                    task_name = message.headers.get("task")
+
+                    if not task_name or task_name not in app.tasks:
+                        # task is not registered in celery
+                        logger.warning(
+                            f"Invalid task '{task_name}'. Skipping.")
+                        message.ack()
+                        continue
+
+                    try:
+                        task_obj = app.tasks[task_name]
+                        accept = {"application/json",
+                                  "application/x-python-serialize"}
+                        decoded_body = loads(
+                            message.body, message.content_type, message.content_encoding, accept=accept
+                        )
+
+                        task_args = decoded_body[0] if decoded_body else []
+                        task_kwargs = decoded_body[1] if len(
+                            decoded_body) > 1 else {}
+
+                        full_func_name = ""
+                        if task_name.endswith("dynamic_function_executor"):
+                            module_path = task_kwargs.get('module_path', '')
+                            function_name = task_kwargs.get(
+                                'function_name', '')
+                            if module_path and function_name:
+                                full_func_name = f"{module_path}.{function_name}"
+                        elif task_name.endswith("dynamic_class_method_executor"):
+                            module_path = task_kwargs.get('module_path', '')
+                            class_name = task_kwargs.get('class_name', '')
+                            method_name = task_kwargs.get('method_name', '')
+                            if module_path and class_name and method_name:
+                                full_func_name = f"{module_path}.{class_name}.{method_name}"
+
+                        should_execute = full_func_name in included_set if full_func_name else False
+
+                        if should_execute:
+                            logger.info(f"Executing task: {full_func_name}")
+                            message.ack()
+                            task_obj.apply(args=task_args, kwargs=task_kwargs)
+                            executed_count += 1
+                            logger.info(
+                                f"Successfully executed task: {full_func_name}")
+                        else:
+                            logger.info(
+                                f"Skipping: {full_func_name or task_name}")
+                            message.ack()
+
+                    except Exception as e:
+                        logger.error(
+                            f"Failed to process task {task_name}: {type(e).__name__}: {e}")
+                        if message and not message.acknowledged:
+                            message.ack()
+
+    except Exception as e:
+        logger.error(
+            f"Failed to connect to queue {channel}: {type(e).__name__}: {e}")
+
+
+def get_queued_tasks(channel: str = "default"):
+    app = current_app
+    queued_tasks = []
+
+    try:
+        with app.connection_for_read() as conn:
+            with conn.channel() as chan:
+                queue = app.amqp.queues[channel](chan)
+
+                while True:
+                    message = queue.get(no_ack=True)
+                    if not message:
+                        break
+
+                    task_name = message.headers.get("task")
+
+                    try:
+                        accept = {"application/json",
+                                  "application/x-python-serialize"}
+                        decoded_body = loads(
+                            message.body, message.content_type, message.content_encoding, accept=accept
+                        )
+
+                        task_args = decoded_body[0] if decoded_body else []
+                        task_kwargs = decoded_body[1] if len(
+                            decoded_body) > 1 else {}
+
+                        full_func_name = ""
+                        if task_name and task_name.endswith("dynamic_function_executor"):
+                            module_path = task_kwargs.get('module_path', '')
+                            function_name = task_kwargs.get(
+                                'function_name', '')
+                            if module_path and function_name:
+                                full_func_name = f"{module_path}.{function_name}"
+                        elif task_name and task_name.endswith("dynamic_class_method_executor"):
+                            module_path = task_kwargs.get('module_path', '')
+                            class_name = task_kwargs.get('class_name', '')
+                            method_name = task_kwargs.get('method_name', '')
+                            if module_path and class_name and method_name:
+                                full_func_name = f"{module_path}.{class_name}.{method_name}"
+
+                        queued_tasks.append({
+                            'task_name': task_name,
+                            'full_func_name': full_func_name,
+                            'args': task_args,
+                            'kwargs': task_kwargs,
+                            'headers': message.headers
+                        })
+
+                    except Exception as e:
+                        logger.warning(f"Failed to decode message: {e}")
+                        continue
+
+    except Exception as e:
+        logger.error(
+            f"Failed to get queued tasks from queue {channel}: {type(e).__name__}: {e}")
+
+    return queued_tasks
+
+
+def is_task_in_queue(expected_func_name: str, channel: str = "default"):
+    queued_tasks = get_queued_tasks(channel)
+    for task in queued_tasks:
+        if task['full_func_name'] == expected_func_name:
+            return True
+    logger.info(
+        f"Task {expected_func_name} not found in queue {channel}. Queued tasks: {[task['full_func_name'] for task in queued_tasks]}")
+    return False
+
+
+def assert_task_in_queue(expected_func_name: str, channel: str = "default", msg: str = None):
+    if not is_task_in_queue(expected_func_name, channel):
+        error_msg = msg or f"Task '{expected_func_name}' not found in queue '{channel}'"
+        raise AssertionError(error_msg)
+
+
+def assert_task_not_in_queue(expected_func_name: str, channel: str = "default", msg: str = None):
+    if is_task_in_queue(expected_func_name, channel):
+        error_msg = msg or f"Task '{expected_func_name}' found in queue '{channel}'"
+        raise AssertionError(error_msg)

{p1_taskqueue-0.1.8 → p1_taskqueue-0.1.9}/tests/test_cmanager.py

@@ -13,7 +13,7 @@ from taskqueue.cmanager import K_MAX_RETRY_COUNT
 from taskqueue.cmanager import taskqueue_class
 
 
-class TestClass:
+class SampleClass:
 
     def test_method(self):
         pass
@@ -28,7 +28,7 @@ class TestClass:
 
 
 @taskqueue_class
-class TestClassWithInit:
+class SampleClassWithInit:
 
     def __init__(self, name, age=0, **kwargs):
         self.name = name
@@ -43,7 +43,7 @@ class TestClassWithInit:
 
 
 @taskqueue_class
-class TestClassWithVarArgs:
+class SampleClassWithVarArgs:
 
     def __init__(self, name, *args, **kwargs):
         self.name = name
@@ -55,7 +55,7 @@ class TestClassWithVarArgs:
 
 
 @taskqueue_class
-class TestClassWithComplexInit:
+class SampleClassWithComplexInit:
 
     def __init__(self, required, optional=10, *extra, **options):
         self.required = required
@@ -68,7 +68,7 @@ class TestClassWithComplexInit:
 
 
 @taskqueue_class
-class TestClassWithDifferentParamNames:
+class SampleClassWithDifferentParamNames:
 
     def __init__(self, cognito_form_reimbursement_dict):
         self.data = cognito_form_reimbursement_dict
@@ -88,20 +88,20 @@ class TestIsClassMethod:
         assert result is False
 
     def test__is_class_method_given_class_method_expect_return_true(self):
-        instance = TestClass()
+        instance = SampleClass()
         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)
+        result = _is_class_method(SampleClass.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)
+        result = _is_class_method(SampleClass.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)
+        result = _is_class_method(SampleClass.test_method)
         assert result is False
 
 
@@ -176,7 +176,7 @@ class TestBuildDynamicTaskCall:
         }
 
     def test__build_dynamic_task_call_given_bound_method_expect_class_method_executor_task(self):
-        instance = TestClass()
+        instance = SampleClass()
         task_name, task_args, task_kwargs = _build_dynamic_task_call(
             instance.test_method, 1, 2, key='value'
         )
@@ -185,7 +185,7 @@ class TestBuildDynamicTaskCall:
         assert task_args == []
         assert task_kwargs == {
             'module_path': 'tests.test_cmanager',
-            'class_name': 'TestClass',
+            'class_name': 'SampleClass',
             'method_name': 'test_method',
             'args': [1, 2],
             'kwargs': {'key': 'value'},
@@ -373,48 +373,50 @@ class TestExtractInitArgs:
 
     def test_extract_init_args_from_instance_given_instance_with_init_args_expect_args_extracted(self):
         from taskqueue.cmanager import _extract_init_args_from_instance
-        instance = TestClassWithInit("John", age=25)
-        
+        instance = SampleClassWithInit("John", age=25)
+
         init_args, init_kwargs = _extract_init_args_from_instance(instance)
         assert init_args == ["John"]
         assert init_kwargs == {"age": 25}
 
     def test_extract_init_args_from_instance_given_kwargs_only_expect_extracted(self):
         from taskqueue.cmanager import _extract_init_args_from_instance
-        instance = TestClassWithInit("Jane", age=30)
-        
+        instance = SampleClassWithInit("Jane", age=30)
+
         init_args, init_kwargs = _extract_init_args_from_instance(instance)
         assert init_args == ["Jane"]
         assert init_kwargs == {"age": 30}
 
     def test_extract_init_args_from_instance_given_no_init_expect_empty(self):
         from taskqueue.cmanager import _extract_init_args_from_instance
-        instance = TestClass()
-        
+        instance = SampleClass()
+
         init_args, init_kwargs = _extract_init_args_from_instance(instance)
         assert init_args == []
         assert init_kwargs == {}
 
     def test_extract_init_args_from_instance_given_var_args_expect_captured(self):
         from taskqueue.cmanager import _extract_init_args_from_instance
-        instance = TestClassWithVarArgs("Alice", "extra1", "extra2", city="NYC")
-        
+        instance = SampleClassWithVarArgs(
+            "Alice", "extra1", "extra2", city="NYC")
+
         init_args, init_kwargs = _extract_init_args_from_instance(instance)
         assert init_args == ["Alice", "extra1", "extra2"]
         assert init_kwargs == {"city": "NYC"}
 
     def test_extract_init_args_from_instance_given_var_kwargs_expect_captured(self):
         from taskqueue.cmanager import _extract_init_args_from_instance
-        instance = TestClassWithInit("Bob", age=30, city="LA", country="USA")
-        
+        instance = SampleClassWithInit("Bob", age=30, city="LA", country="USA")
+
         init_args, init_kwargs = _extract_init_args_from_instance(instance)
         assert init_args == ["Bob"]
         assert init_kwargs == {"age": 30, "city": "LA", "country": "USA"}
 
     def test_extract_init_args_from_instance_given_complex_init_expect_all_captured(self):
         from taskqueue.cmanager import _extract_init_args_from_instance
-        instance = TestClassWithComplexInit(5, 15, 20, 25, multiplier=2, debug=True)
-        
+        instance = SampleClassWithComplexInit(
+            5, 15, 20, 25, multiplier=2, debug=True)
+
         init_args, init_kwargs = _extract_init_args_from_instance(instance)
         assert init_args == [5, 15, 20, 25]
         assert init_kwargs == {"multiplier": 2, "debug": True}
@@ -422,10 +424,10 @@ class TestExtractInitArgs:
     def test_extract_init_args_from_instance_given_different_param_names_expect_works(self):
         from taskqueue.cmanager import _extract_init_args_from_instance
         from collections import OrderedDict
-        
+
         test_dict = OrderedDict([("key1", "value1"), ("key2", "value2")])
-        instance = TestClassWithDifferentParamNames(test_dict)
-        
+        instance = SampleClassWithDifferentParamNames(test_dict)
+
         init_args, init_kwargs = _extract_init_args_from_instance(instance)
         assert init_args == [test_dict]
         assert init_kwargs == {}
@@ -434,8 +436,8 @@ class TestExtractInitArgs:
 class TestTaskqueueClassDecorator:
 
     def test_taskqueue_class_decorator_given_class_expect_init_args_captured(self):
-        instance = TestClassWithInit("John", age=25)
-        
+        instance = SampleClassWithInit("John", age=25)
+
         assert hasattr(instance, '_taskqueue_init_args')
         assert hasattr(instance, '_taskqueue_init_kwargs')
         assert instance._taskqueue_init_args == ["John"]
@@ -444,8 +446,8 @@ class TestTaskqueueClassDecorator:
     def test_taskqueue_class_decorator_given_different_param_names_expect_captured(self):
         from collections import OrderedDict
         test_dict = OrderedDict([("key1", "value1")])
-        instance = TestClassWithDifferentParamNames(test_dict)
-        
+        instance = SampleClassWithDifferentParamNames(test_dict)
+
         assert instance._taskqueue_init_args == [test_dict]
         assert instance._taskqueue_init_kwargs == {}
         assert instance.data == test_dict
@@ -454,7 +456,7 @@ class TestTaskqueueClassDecorator:
 class TestBuildDynamicTaskCallWithInitArgs:
 
     def test__build_dynamic_task_call_given_instance_with_init_args_expect_init_args_passed(self):
-        instance = TestClassWithInit("John", age=25)
+        instance = SampleClassWithInit("John", age=25)
         task_name, task_args, task_kwargs = _build_dynamic_task_call(
             instance.process, "arg1", key='value'
         )
@@ -463,7 +465,7 @@ class TestBuildDynamicTaskCallWithInitArgs:
         assert task_args == []
         assert task_kwargs == {
             'module_path': 'tests.test_cmanager',
-            'class_name': 'TestClassWithInit',
+            'class_name': 'SampleClassWithInit',
             'method_name': 'process',
             'args': ['arg1'],
             'kwargs': {'key': 'value'},
@@ -472,7 +474,7 @@ class TestBuildDynamicTaskCallWithInitArgs:
         }
 
     def test__build_dynamic_task_call_given_instance_without_decorator_expect_empty_defaults(self):
-        instance = TestClass()
+        instance = SampleClass()
         task_name, task_args, task_kwargs = _build_dynamic_task_call(
             instance.test_method, 1, 2, key='value'
         )
@@ -481,7 +483,7 @@ class TestBuildDynamicTaskCallWithInitArgs:
         assert task_args == []
         assert task_kwargs == {
             'module_path': 'tests.test_cmanager',
-            'class_name': 'TestClass',
+            'class_name': 'SampleClass',
             'method_name': 'test_method',
             'args': [1, 2],
             'kwargs': {'key': 'value'},
@@ -495,10 +497,10 @@ class TestDynamicClassMethodExecutorWithInitArgs:
 
     def test_dynamic_class_method_executor_given_init_args_expect_instance_created_with_args(self):
         from taskqueue.cmanager import dynamic_class_method_executor
-        
+
         result = dynamic_class_method_executor(
             module_path="tests.test_cmanager",
-            class_name="TestClassWithInit",
+            class_name="SampleClassWithInit",
             method_name="process",
             args=[],
             kwargs={},
@@ -506,15 +508,15 @@ class TestDynamicClassMethodExecutorWithInitArgs:
             init_kwargs={"age": 35},
             retry=None
         )
-        
+
         assert result is None
 
     def test_dynamic_class_method_executor_given_no_init_args_expect_backward_compatible(self):
         from taskqueue.cmanager import dynamic_class_method_executor
-        
+
         result = dynamic_class_method_executor(
             module_path="tests.test_cmanager",
-            class_name="TestClass",
+            class_name="SampleClass",
             method_name="test_method",
             args=[],
             kwargs={},
@@ -522,15 +524,15 @@ class TestDynamicClassMethodExecutorWithInitArgs:
             init_kwargs=None,
             retry=None
         )
-        
+
         assert result is None
 
     def test_dynamic_class_method_executor_given_var_args_and_kwargs_expect_works(self):
         from taskqueue.cmanager import dynamic_class_method_executor
-        
+
         result = dynamic_class_method_executor(
             module_path="tests.test_cmanager",
-            class_name="TestClassWithVarArgs",
+            class_name="SampleClassWithVarArgs",
             method_name="process",
             args=[],
             kwargs={},
@@ -538,5 +540,5 @@ class TestDynamicClassMethodExecutorWithInitArgs:
             init_kwargs={"city": "NYC", "country": "USA"},
             retry=None
         )
-        
+
         assert result is None

p1_taskqueue-0.1.9/tests/test_helper_test_functions.py

@@ -0,0 +1,350 @@
+"""Tests for the helper_test module."""
+from unittest.mock import MagicMock
+from unittest.mock import patch
+
+import pytest
+from taskqueue.libs.helper_test import assert_task_in_queue
+from taskqueue.libs.helper_test import assert_task_not_in_queue
+from taskqueue.libs.helper_test import celery_worker_burst
+from taskqueue.libs.helper_test import clear_all_celery_queues
+from taskqueue.libs.helper_test import get_queued_tasks
+from taskqueue.libs.helper_test import is_task_in_queue
+
+
+def setup_celery_connection_mocks(mock_current_app):
+    """Helper to setup Celery connection and channel mocks."""
+    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
+    return mock_conn, mock_chan
+
+
+class TestHelperTest:
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    def test_clear_all_celery_queues_given_multiple_queues_expect_all_purged(self, mock_current_app):
+        mock_conn, mock_chan = setup_celery_connection_mocks(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
+        }
+
+        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('taskqueue.libs.helper_test.current_app')
+    def test_clear_all_celery_queues_given_empty_queues_expect_no_purge_calls(self, mock_current_app):
+        mock_conn, mock_chan = setup_celery_connection_mocks(mock_current_app)
+
+        mock_current_app.amqp.queues.keys.return_value = []
+        mock_current_app.amqp.queues = {}
+
+        clear_all_celery_queues()
+
+        mock_conn.channel.assert_called_once()
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    def test_get_queued_tasks_given_empty_queue_expect_empty_list(self, mock_current_app):
+        mock_queue = MagicMock()
+        mock_queue.get.return_value = None
+        mock_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        result = get_queued_tasks('default')
+
+        assert result == []
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    @patch('taskqueue.libs.helper_test.loads')
+    def test_get_queued_tasks_given_function_executor_expect_correct_parsing(self, mock_loads, mock_current_app):
+        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_loads.return_value = [[], {
+            'module_path': 'my.module',
+            'function_name': 'my_function',
+            'args': [],
+            'kwargs': {}
+        }]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        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
+
+        result = get_queued_tasks('default')
+
+        assert len(result) == 1
+        assert result[0]['task_name'] == 'taskqueue.cmanager.dynamic_function_executor'
+        assert result[0]['full_func_name'] == 'my.module.my_function'
+        assert result[0]['args'] == []
+        assert result[0]['kwargs']['module_path'] == 'my.module'
+        assert result[0]['kwargs']['function_name'] == 'my_function'
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    @patch('taskqueue.libs.helper_test.loads')
+    def test_get_queued_tasks_given_class_method_executor_expect_correct_parsing(self, mock_loads, mock_current_app):
+        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_loads.return_value = [[], {
+            'module_path': 'my.module',
+            'class_name': 'MyClass',
+            'method_name': 'my_method',
+            'args': [],
+            'kwargs': {}
+        }]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        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
+
+        result = get_queued_tasks('default')
+
+        assert len(result) == 1
+        assert result[0]['task_name'] == 'taskqueue.cmanager.dynamic_class_method_executor'
+        assert result[0]['full_func_name'] == 'my.module.MyClass.my_method'
+        assert result[0]['args'] == []
+        assert result[0]['kwargs']['module_path'] == 'my.module'
+        assert result[0]['kwargs']['class_name'] == 'MyClass'
+        assert result[0]['kwargs']['method_name'] == 'my_method'
+
+    @patch('taskqueue.libs.helper_test.get_queued_tasks')
+    def test_is_task_in_queue_given_task_exists_expect_true(self, mock_get_queued_tasks):
+        mock_get_queued_tasks.return_value = [
+            {'full_func_name': 'my.module.my_function'},
+            {'full_func_name': 'other.module.other_function'}
+        ]
+
+        result = is_task_in_queue('my.module.my_function')
+
+        assert result is True
+
+    @patch('taskqueue.libs.helper_test.get_queued_tasks')
+    def test_is_task_in_queue_given_task_not_exists_expect_false(self, mock_get_queued_tasks):
+        mock_get_queued_tasks.return_value = [
+            {'full_func_name': 'other.module.other_function'}
+        ]
+
+        result = is_task_in_queue('my.module.my_function')
+
+        assert result is False
+
+    @patch('taskqueue.libs.helper_test.get_queued_tasks')
+    def test_is_task_in_queue_given_custom_channel_expect_channel_used(self, mock_get_queued_tasks):
+        mock_get_queued_tasks.return_value = [
+            {'full_func_name': 'my.module.my_function'}
+        ]
+
+        result = is_task_in_queue('my.module.my_function', channel='high')
+
+        assert result is True
+        mock_get_queued_tasks.assert_called_once_with('high')
+
+    @patch('taskqueue.libs.helper_test.is_task_in_queue')
+    def test_assert_task_in_queue_given_task_exists_expect_no_exception(self, mock_is_task_in_queue):
+        mock_is_task_in_queue.return_value = True
+
+        assert_task_in_queue('my.module.my_function')
+
+    @patch('taskqueue.libs.helper_test.is_task_in_queue')
+    def test_assert_task_in_queue_given_task_not_exists_expect_assertion_error(self, mock_is_task_in_queue):
+        mock_is_task_in_queue.return_value = False
+
+        with pytest.raises(AssertionError, match="Task 'my.module.my_function' not found in queue 'default'"):
+            assert_task_in_queue('my.module.my_function')
+
+    @patch('taskqueue.libs.helper_test.is_task_in_queue')
+    def test_assert_task_in_queue_given_custom_message_expect_custom_error(self, mock_is_task_in_queue):
+        mock_is_task_in_queue.return_value = False
+
+        with pytest.raises(AssertionError, match="Custom error message"):
+            assert_task_in_queue('my.module.my_function',
+                                 msg="Custom error message")
+
+    @patch('taskqueue.libs.helper_test.is_task_in_queue')
+    def test_assert_task_in_queue_given_custom_channel_expect_channel_used(self, mock_is_task_in_queue):
+        mock_is_task_in_queue.return_value = True
+
+        assert_task_in_queue('my.module.my_function', channel='high')
+
+        mock_is_task_in_queue.assert_called_once_with(
+            'my.module.my_function', 'high')
+
+    @patch('taskqueue.libs.helper_test.is_task_in_queue')
+    def test_assert_task_not_in_queue_given_task_not_exists_expect_no_exception(self, mock_is_task_in_queue):
+        mock_is_task_in_queue.return_value = False
+
+        assert_task_not_in_queue('my.module.my_function')
+
+    @patch('taskqueue.libs.helper_test.is_task_in_queue')
+    def test_assert_task_not_in_queue_given_task_exists_expect_assertion_error(self, mock_is_task_in_queue):
+        mock_is_task_in_queue.return_value = True
+
+        with pytest.raises(AssertionError, match="Task 'my.module.my_function' found in queue 'default'"):
+            assert_task_not_in_queue('my.module.my_function')
+
+    @patch('taskqueue.libs.helper_test.is_task_in_queue')
+    def test_assert_task_not_in_queue_given_custom_message_expect_custom_error(self, mock_is_task_in_queue):
+        mock_is_task_in_queue.return_value = True
+
+        with pytest.raises(AssertionError, match="Custom error message"):
+            assert_task_not_in_queue(
+                'my.module.my_function', msg="Custom error message")
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    @patch('taskqueue.libs.helper_test.loads')
+    def test_celery_worker_burst_given_matching_function_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_path': 'my.module',
+            'function_name': 'my_function',
+            'args': [],
+            'kwargs': {}
+        }]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        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('taskqueue.libs.helper_test.logger') as mock_logger:
+            celery_worker_burst(['my.module.my_function'])
+
+            mock_logger.info.assert_any_call(
+                "Executing task: my.module.my_function")
+            mock_logger.info.assert_any_call(
+                "Successfully executed task: my.module.my_function")
+
+        mock_message.ack.assert_called_once()
+        mock_task.apply.assert_called_once()
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    @patch('taskqueue.libs.helper_test.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_path': 'other.module',
+            'function_name': 'other_function',
+            'args': [],
+            'kwargs': {}
+        }]
+
+        mock_queue = MagicMock()
+        mock_queue.get.side_effect = [mock_message, None]
+        mock_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        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(['my.module.my_function'])
+
+        mock_message.ack.assert_called_once()
+        mock_task.apply.assert_not_called()
+
+    @patch('taskqueue.libs.helper_test.current_app')
+    def test_celery_worker_burst_given_invalid_task_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_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        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('taskqueue.libs.helper_test.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('taskqueue.libs.helper_test.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_current_app.amqp.queues = {
+            'default': MagicMock(return_value=mock_queue)}
+
+        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)

p1_taskqueue-0.1.8/src/taskqueue/libs/helper_test.py

@@ -1,93 +0,0 @@
-import logging
-from typing import List
-
-from celery import current_app
-from kombu.serialization import loads
-
-logger = logging.getLogger(__name__)
-
-
-def clear_all_celery_queues():
-    app = current_app
-    all_queue_names = list(app.amqp.queues.keys())
-    with app.connection_for_read() as conn:
-        with conn.channel() as chan:
-            for queue_name in all_queue_names:
-                queue = app.amqp.queues[queue_name](chan)
-                queue.purge()
-
-
-def celery_worker_burst(include_func_names: List[str], channel: str = "default"):
-    # This doesn't use celery as celery doesn't support filtering out functions
-    # this use kombu to get the message from the queue and then execute the task manually
-    app = current_app
-    included_set = set(include_func_names)
-    processed_count = 0
-    executed_count = 0
-
-    try:
-        with app.connection_for_read() as conn:
-            with conn.channel() as chan:
-                queue = app.amqp.queues[channel](chan)
-
-                while True:
-                    message = queue.get(no_ack=False)
-                    if not message:
-                        break
-
-                    processed_count += 1
-                    task_name = message.headers.get("task")
-
-                    if not task_name or task_name not in app.tasks:
-                        # task is not registered in celery
-                        logger.warning(
-                            f"Invalid task '{task_name}'. Skipping.")
-                        message.ack()
-                        continue
-
-                    try:
-                        task_obj = app.tasks[task_name]
-                        accept = {"application/json",
-                                  "application/x-python-serialize"}
-                        decoded_body = loads(
-                            message.body, message.content_type, message.content_encoding, accept=accept
-                        )
-
-                        task_args = decoded_body[0] if decoded_body else []
-                        task_kwargs = decoded_body[1] if len(
-                            decoded_body) > 1 else {}
-
-                        full_func_name = ""
-                        if task_name.endswith("dynamic_function_executor"):
-                            module_path = task_kwargs.get('module_path', '')
-                            function_name = task_kwargs.get('function_name', '')
-                            full_func_name = f"{module_path}.{function_name}"
-                        elif task_name.endswith("dynamic_class_method_executor"):
-                            module_path = task_kwargs.get('module_path', '')
-                            class_name = task_kwargs.get('class_name', '')
-                            method_name = task_kwargs.get('method_name', '')
-                            full_func_name = f"{module_path}.{class_name}.{method_name}"
-
-                        should_execute = full_func_name in included_set if full_func_name else False
-
-                        if should_execute:
-                            logger.info(f"Executing task: {full_func_name}")
-                            message.ack()
-                            task_obj.apply(args=task_args, kwargs=task_kwargs)
-                            executed_count += 1
-                            logger.info(
-                                f"Successfully executed task: {full_func_name}")
-                        else:
-                            logger.info(
-                                f"Skipping: {full_func_name or task_name}")
-                            message.ack()
-
-                    except Exception as e:
-                        logger.error(
-                            f"Failed to process task {task_name}: {type(e).__name__}: {e}")
-                        if message and not message.acknowledged:
-                            message.ack()
-
-    except Exception as e:
-        logger.error(
-            f"Failed to connect to queue {channel}: {type(e).__name__}: {e}")