django-lambda-tasks 0.4.0__tar.gz → 0.4.2__tar.gz

{django_lambda_tasks-0.4.0 → django_lambda_tasks-0.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-lambda-tasks
-Version: 0.4.0
+Version: 0.4.2
 Summary: Run async tasks in a lambda function
 Requires-Python: >=3.10
 Requires-Dist: awslambdaric

{django_lambda_tasks-0.4.0 → django_lambda_tasks-0.4.2}/lambda_tasks/admin.py

@@ -3,8 +3,13 @@
 from django.contrib import admin
 from django.db.models import DurationField, ExpressionWrapper, F, QuerySet
 from django.http import HttpRequest
+from django.utils.module_loading import import_string
 
-from lambda_tasks.models import TaskRecord
+from lambda_tasks.models import (
+    SQSLambdaTask,
+    SQSLambdaTaskMessage,
+    TaskRecord,
+)
 
 
 @admin.register(TaskRecord)
@@ -33,6 +38,7 @@ class TaskRecordAdmin(admin.ModelAdmin):
         "result",
         "traceback",
     )
+    actions = ["replay_tasks"]
 
     def get_queryset(self, request: HttpRequest) -> QuerySet:
         return (
@@ -52,3 +58,18 @@ class TaskRecordAdmin(admin.ModelAdmin):
             return None
         total_seconds = d.total_seconds()
         return f"{total_seconds:.3f}s"
+
+    @admin.action(description="Replay selected tasks", permissions=("change",))
+    def replay_tasks(self, request: HttpRequest, queryset: QuerySet) -> None:
+        for record in queryset:
+            queue = import_string(record.task_name).queue
+            task = SQSLambdaTask(
+                message=SQSLambdaTaskMessage(
+                    task_name=record.task_name,
+                    kwargs=record.kwargs,
+                    n_retries=0,
+                ),
+                delay=0,
+                queue=queue,
+            )
+            task.execute_on_commit()

{django_lambda_tasks-0.4.0 → django_lambda_tasks-0.4.2}/lambda_tasks/local_executor.py

@@ -1,10 +1,13 @@
 """Process pool executor for async local task execution."""
 
+import logging
 import uuid
-from concurrent.futures import ProcessPoolExecutor
+from concurrent.futures import Future, ProcessPoolExecutor
 
 from lambda_tasks.settings import LambdaTasksSettings
 
+logger = logging.getLogger(__name__)
+
 _pool: ProcessPoolExecutor | None = None
 
 
@@ -38,8 +41,18 @@ def _execute_in_worker(*, message_json: str, message_id: str) -> None:
     message.execute_immediately(message_id=message_id)
 
 
+def _log_worker_exception(future: Future) -> None:  # type: ignore[type-arg]
+    """Callback attached to each worker future. Logs unhandled exceptions."""
+    exception = future.exception()
+    if exception is not None:
+        logger.error("Worker process raised an exception", exc_info=exception)
+
+
 def submit_task(*, message_json: str) -> None:
     """Submit a task to the process pool. Fire-and-forget."""
     pool = get_pool()
     message_id = str(uuid.uuid4())
-    pool.submit(_execute_in_worker, message_json=message_json, message_id=message_id)
+    future = pool.submit(
+        _execute_in_worker, message_json=message_json, message_id=message_id
+    )
+    future.add_done_callback(_log_worker_exception)

{django_lambda_tasks-0.4.0 → django_lambda_tasks-0.4.2}/pyproject.toml

@@ -7,7 +7,7 @@ packages = ["lambda_tasks"]
 
 [project]
 name = "django-lambda-tasks"
-version = "0.4.0"
+version = "0.4.2"
 description = "Run async tasks in a lambda function"
 readme = "README.md"
 requires-python = ">=3.10"

django_lambda_tasks-0.4.2/tests/test_admin.py

@@ -0,0 +1,282 @@
+from unittest.mock import patch
+
+import pytest
+from django.contrib import admin
+from django.contrib.auth.models import Permission, User
+from django.contrib.contenttypes.models import ContentType
+from django.test import RequestFactory
+from django.utils.timezone import now
+
+import lambda_tasks.admin  # noqa: F401 — triggers @admin.register side-effect
+from lambda_tasks.models import SQSLambdaTask, TaskRecord, TaskStatus
+
+
+def test_task_record_registered_in_admin():
+    assert TaskRecord in admin.site._registry
+
+
+def test_task_record_admin_list_display():
+    assert admin.site._registry[TaskRecord].list_display == (
+        "pk",
+        "task_name",
+        "status",
+        "start_time",
+        "end_time",
+        "n_retries",
+        "duration",
+        "result",
+    )
+
+
+@pytest.fixture()
+def admin_user(db: None) -> User:
+    return User.objects.create_superuser(
+        username="admin", password="password", email="admin@example.com"
+    )
+
+
+@pytest.fixture()
+def task_record(db: None) -> TaskRecord:
+    return TaskRecord.objects.create(
+        id="00000000-0000-0000-0000-000000000001",
+        task_name="myapp.tasks.my_task",
+        kwargs={"user_id": 42},
+        n_retries=3,
+        status=TaskStatus.FAILED,
+        start_time=now(),
+        end_time=now(),
+    )
+
+
+@pytest.fixture()
+def _mock_import_string():
+    class _FakeWrapper:
+        queue = "default"
+
+    with patch("lambda_tasks.admin.import_string", return_value=_FakeWrapper()):
+        yield
+
+
+@pytest.mark.django_db()
+class TestReplayAction:
+    def test_replay_action_is_registered(self) -> None:
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = User(is_staff=True, is_superuser=True)
+        action_names = list(model_admin.get_actions(request).keys())
+        assert "replay_tasks" in action_names
+
+    def test_replay_enqueues_task_with_original_kwargs(
+        self, admin_user: User, task_record: TaskRecord, _mock_import_string: None
+    ) -> None:
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = admin_user
+
+        queryset = TaskRecord.objects.filter(pk=task_record.pk)
+
+        with patch(
+            "lambda_tasks.admin.SQSLambdaTask.execute_on_commit"
+        ) as mock_execute:
+            model_admin.replay_tasks(request, queryset)
+
+        mock_execute.assert_called_once()
+
+    def test_replay_resets_n_retries_to_zero(
+        self, admin_user: User, task_record: TaskRecord, _mock_import_string: None
+    ) -> None:
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = admin_user
+
+        queryset = TaskRecord.objects.filter(pk=task_record.pk)
+
+        built_tasks: list[SQSLambdaTask] = []
+
+        def capture_execute(self: SQSLambdaTask) -> None:
+            built_tasks.append(self)
+
+        with patch.object(SQSLambdaTask, "execute_on_commit", capture_execute):
+            model_admin.replay_tasks(request, queryset)
+
+        assert len(built_tasks) == 1
+        assert built_tasks[0].message.n_retries == 0
+
+    def test_replay_preserves_task_name(
+        self, admin_user: User, task_record: TaskRecord, _mock_import_string: None
+    ) -> None:
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = admin_user
+
+        queryset = TaskRecord.objects.filter(pk=task_record.pk)
+
+        built_tasks: list[SQSLambdaTask] = []
+
+        def capture_execute(self: SQSLambdaTask) -> None:
+            built_tasks.append(self)
+
+        with patch.object(SQSLambdaTask, "execute_on_commit", capture_execute):
+            model_admin.replay_tasks(request, queryset)
+
+        assert built_tasks[0].message.task_name == "myapp.tasks.my_task"
+        assert built_tasks[0].message.kwargs == {"user_id": 42}
+
+    def test_replay_uses_delay_zero(
+        self, admin_user: User, task_record: TaskRecord, _mock_import_string: None
+    ) -> None:
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = admin_user
+
+        queryset = TaskRecord.objects.filter(pk=task_record.pk)
+
+        built_tasks: list[SQSLambdaTask] = []
+
+        def capture_execute(self: SQSLambdaTask) -> None:
+            built_tasks.append(self)
+
+        with patch.object(SQSLambdaTask, "execute_on_commit", capture_execute):
+            model_admin.replay_tasks(request, queryset)
+
+        assert built_tasks[0].delay == 0
+
+    def test_replay_resolves_queue_from_wrapper(
+        self, admin_user: User, db: None
+    ) -> None:
+        record = TaskRecord.objects.create(
+            id="00000000-0000-0000-0000-000000000002",
+            task_name="myapp.tasks.custom_queue_task",
+            kwargs={"x": 1},
+            n_retries=0,
+            status=TaskStatus.FAILED,
+            start_time=now(),
+            end_time=now(),
+        )
+
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = admin_user
+
+        queryset = TaskRecord.objects.filter(pk=record.pk)
+
+        built_tasks: list[SQSLambdaTask] = []
+
+        def capture_execute(self: SQSLambdaTask) -> None:
+            built_tasks.append(self)
+
+        class _FakeWrapper:
+            queue = "high-priority"
+
+        with patch.object(SQSLambdaTask, "execute_on_commit", capture_execute):
+            with patch(
+                "lambda_tasks.admin.import_string",
+                return_value=_FakeWrapper(),
+            ):
+                model_admin.replay_tasks(request, queryset)
+
+        assert built_tasks[0].queue == "high-priority"
+
+    def test_replay_raises_on_import_error(
+        self, admin_user: User, task_record: TaskRecord
+    ) -> None:
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = admin_user
+
+        queryset = TaskRecord.objects.filter(pk=task_record.pk)
+
+        with patch(
+            "lambda_tasks.admin.import_string",
+            side_effect=ImportError("no such module"),
+        ):
+            with pytest.raises(ImportError, match="no such module"):
+                model_admin.replay_tasks(request, queryset)
+
+    def test_replay_raises_when_not_wrapper(
+        self, admin_user: User, task_record: TaskRecord
+    ) -> None:
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = admin_user
+
+        queryset = TaskRecord.objects.filter(pk=task_record.pk)
+
+        with patch(
+            "lambda_tasks.admin.import_string",
+            return_value="not a wrapper",
+        ):
+            with pytest.raises(AttributeError):
+                model_admin.replay_tasks(request, queryset)
+
+    def test_replay_multiple_records(
+        self, admin_user: User, db: None, _mock_import_string: None
+    ) -> None:
+        records = [
+            TaskRecord.objects.create(
+                id=f"00000000-0000-0000-0000-00000000000{i}",
+                task_name=f"myapp.tasks.task_{i}",
+                kwargs={"key": i},
+                n_retries=0,
+                status=TaskStatus.FAILED,
+                start_time=now(),
+                end_time=now(),
+            )
+            for i in range(3)
+        ]
+
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().post("/")
+        request.user = admin_user
+
+        queryset = TaskRecord.objects.filter(pk__in=[r.pk for r in records])
+
+        built_tasks: list[SQSLambdaTask] = []
+
+        def capture_execute(self: SQSLambdaTask) -> None:
+            built_tasks.append(self)
+
+        with patch.object(SQSLambdaTask, "execute_on_commit", capture_execute):
+            model_admin.replay_tasks(request, queryset)
+
+        assert len(built_tasks) == 3
+        task_names = {t.message.task_name for t in built_tasks}
+        assert task_names == {
+            "myapp.tasks.task_0",
+            "myapp.tasks.task_1",
+            "myapp.tasks.task_2",
+        }
+
+    def test_replay_action_hidden_without_change_permission(self, db: None) -> None:
+        user = User.objects.create_user(
+            username="viewer", password="password", is_staff=True
+        )
+        content_type = ContentType.objects.get_for_model(TaskRecord)
+        view_perm = Permission.objects.get(
+            codename="view_taskrecord", content_type=content_type
+        )
+        user.user_permissions.add(view_perm)
+
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().get("/")
+        request.user = user
+
+        action_names = list(model_admin.get_actions(request).keys())
+        assert "replay_tasks" not in action_names
+
+    def test_replay_action_visible_with_change_permission(self, db: None) -> None:
+        user = User.objects.create_user(
+            username="editor", password="password", is_staff=True
+        )
+        content_type = ContentType.objects.get_for_model(TaskRecord)
+        change_perm = Permission.objects.get(
+            codename="change_taskrecord", content_type=content_type
+        )
+        user.user_permissions.add(change_perm)
+
+        model_admin = admin.site._registry[TaskRecord]
+        request = RequestFactory().get("/")
+        request.user = user
+
+        action_names = list(model_admin.get_actions(request).keys())
+        assert "replay_tasks" in action_names

{django_lambda_tasks-0.4.0 → django_lambda_tasks-0.4.2}/tests/test_local_executor.py

@@ -344,7 +344,7 @@ class TestSubmitTask:
         assert str(parsed) == message_id
 
     def test_submit_task_does_not_wait_on_future(self, settings):
-        """submit_task() does not call .result() or .add_done_callback() on the Future.
+        """submit_task() does not call .result() on the Future.
 
         Validates: Requirements 3.4, 5.3
         """
@@ -363,7 +363,24 @@ class TestSubmitTask:
             )
 
         mock_future.result.assert_not_called()
-        mock_future.add_done_callback.assert_not_called()
+
+    def test_submit_task_attaches_exception_logging_callback(self, settings):
+        """submit_task() attaches _log_worker_exception as a done callback."""
+        from lambda_tasks.local_executor import _log_worker_exception, submit_task
+
+        settings.LAMBDA_TASKS_LOCAL_WORKERS = 2
+        settings.LAMBDA_TASKS_EAGER = False
+
+        mock_pool = MagicMock()
+        mock_future = MagicMock()
+        mock_pool.submit.return_value = mock_future
+
+        with patch("lambda_tasks.local_executor.get_pool", return_value=mock_pool):
+            submit_task(
+                message_json='{"task_name": "myapp.tasks.foo", "kwargs": {}, "n_retries": 0}'
+            )
+
+        mock_future.add_done_callback.assert_called_once_with(_log_worker_exception)
 
 
 # ---------------------------------------------------------------------------

django_lambda_tasks-0.4.0/tests/test_admin.py

@@ -1,21 +0,0 @@
-from django.contrib import admin
-
-import lambda_tasks.admin  # noqa: F401 — triggers @admin.register side-effect
-from lambda_tasks.models import TaskRecord
-
-
-def test_task_record_registered_in_admin():
-    assert TaskRecord in admin.site._registry
-
-
-def test_task_record_admin_list_display():
-    assert admin.site._registry[TaskRecord].list_display == (
-        "pk",
-        "task_name",
-        "status",
-        "start_time",
-        "end_time",
-        "n_retries",
-        "duration",
-        "result",
-    )