django-lambda-tasks 0.6.6__tar.gz → 0.6.7__tar.gz

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.6.7}/.kiro/steering/product.md

@@ -215,11 +215,25 @@ Statuses: `RUNNING`, `SUCCESS`, `FAILED`, `RETRYING`
 | `LAMBDA_TASKS_DEFAULT_HARD_TIMEOUT` | `300` | Hard timeout in seconds |
 | `LAMBDA_TASKS_EAGER` | `False` | Run tasks synchronously in-process (no SQS) |
 | `LAMBDA_TASKS_LOCAL_WORKERS` | `0` | Number of worker processes for async local execution (development only; mutually exclusive with `EAGER`) |
+| `LAMBDA_TASKS_NOOP_EXECUTION` | `False` | Drop all tasks silently (for local tests; mutually exclusive with `EAGER` and `LOCAL_WORKERS`) |
 | `LAMBDA_TASKS_MAX_RETRIES` | `2880` | Maximum retry attempts before `MaxRetriesExceededError` is raised (60 × 24 × 2) |
 | `LAMBDA_TASKS_SINGLETON_CACHE` | `"default"` | Django cache backend used for singleton task locks |
 
 `LAMBDA_TASKS_QUEUES` must be set and include a `"default"` key. The `"default"` queue must be an SQS queue. Both timeout values must be greater than zero and `soft_timeout` must always be strictly less than `hard_timeout`. The maximum allowed timeout depends on the queue type: 900 for SQS, 3600 for Batch.
 
+## Noop Execution Mode
+
+Set `LAMBDA_TASKS_NOOP_EXECUTION = True` to silently drop all tasks. Useful for local tests where task execution is irrelevant. When a task is dispatched, a warning is logged with the task name, kwargs, and queue, and execution returns immediately — no SQS message is sent, no task is executed.
+
+```python
+# settings/test.py
+LAMBDA_TASKS_NOOP_EXECUTION = True
+```
+
+`LAMBDA_TASKS_NOOP_EXECUTION` can only be set when `LAMBDA_TASKS_EAGER` is `False` and `LAMBDA_TASKS_LOCAL_WORKERS` is `0`. Setting it alongside either raises `ImproperlyConfigured`.
+
+A Django deployment check (`lambda_tasks.W001`) warns if this setting is enabled, ensuring it is not accidentally left on in production.
+
 ## Eager Mode
 
 Set `LAMBDA_TASKS_EAGER = True` to run tasks synchronously in-process (no SQS). Useful for local development and tests.
@@ -238,12 +252,15 @@ LAMBDA_TASKS_LOCAL_WORKERS = 4
 ```
 
 The execution mode hierarchy is:
-1. **Eager mode** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
-2. **Async local mode** (`LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
-3. **SQS mode** (default) — async, Lambda workers, timeouts enforced
+1. **Noop mode** (`LAMBDA_TASKS_NOOP_EXECUTION=True`) — tasks are dropped with a warning log
+2. **Eager mode** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
+3. **Async local mode** (`LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
+4. **SQS mode** (default) — async, Lambda workers, timeouts enforced
 
 `LAMBDA_TASKS_LOCAL_WORKERS` and `LAMBDA_TASKS_EAGER` are mutually exclusive — setting both raises `ImproperlyConfigured`. A negative value also raises `ImproperlyConfigured`.
 
+`LAMBDA_TASKS_NOOP_EXECUTION` is mutually exclusive with both `LAMBDA_TASKS_EAGER` and `LAMBDA_TASKS_LOCAL_WORKERS`.
+
 Key behaviours:
 - The process pool is created lazily on first task submission and reused for the server lifetime
 - Each worker process calls `django.setup()` once via the pool initializer
@@ -267,6 +284,18 @@ Relying on `atexit` alone loses this race in applications with a heavy shutdown
 
 `_shutdown_pool()` does **not** use `pool.shutdown(wait=True)`. `wait=True` blocks on joining the worker processes, and a worker that ran a heavy `django.setup()` is slow to exit — `concurrent.futures` does not unlink the pool's queue semaphores until the workers actually die, so the parent's near-instant `SIGKILL` still wins and the semaphores leak. Instead `_shutdown_pool()` **terminates the worker processes first** (a near-instant signal to children we own), then calls `pool.shutdown(wait=False, cancel_futures=True)`. With the workers already gone, the queue semaphores are unlinked in milliseconds — fast enough to beat the parent's `SIGKILL`.
 
+## Deployment Checks
+
+`lambda_tasks.checks` registers a Django deployment check (runs with `manage.py check --deploy`) that warns if any non-production execution mode is enabled:
+
+| ID | Condition | Message |
+|---|---|---|
+| `lambda_tasks.W001` | `LAMBDA_TASKS_NOOP_EXECUTION = True` | Tasks will be silently dropped |
+| `lambda_tasks.W002` | `LAMBDA_TASKS_EAGER = True` | Tasks will run synchronously in-process |
+| `lambda_tasks.W003` | `LAMBDA_TASKS_LOCAL_WORKERS > 0` | Tasks will run in a local process pool |
+
+The checks are registered via `AppConfig.ready()` and tagged with `deploy=True` so they only fire during `--deploy` checks.
+
 ## Logging
 
 Import `task_logger` to emit log records that are automatically prefixed with the active `message_id`:

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.6.7}/.kiro/steering/structure.md

@@ -12,6 +12,7 @@ django-lambda-tasks/
 │   ├── __init__.py
 │   ├── admin.py                # Django admin for TaskRecord
 │   ├── apps.py                 # Django AppConfig
+│   ├── checks.py               # Django deployment checks (noop, eager, local_workers)
 │   ├── decorators.py           # LambdaTaskWrapper, @lambda_task
 │   ├── handler.py              # AWS Lambda entry point + AWS Batch container entry point (main)
 │   ├── logging.py              # task_logger — invocation-scoped LoggerAdapter
@@ -48,7 +49,8 @@ django-lambda-tasks/
 - `logging.py` — `task_logger` singleton; `message_id` set/cleared around each task execution
 - `settings.py` — constants (`MAX_DELAY`, `MAX_TIMEOUT`, `MAX_BATCH_TIMEOUT`); `_is_sqs_queue()` and `_is_batch_queue()` helpers; `LambdaTasksSettings` instantiated fresh per use (reads live Django settings); `queue_max_timeout()` method returns 900 or 3600 based on queue type
 - `admin.py` — Django admin registration for `TaskRecord`
-- `apps.py` — Django `AppConfig`; `ready()` installs the local-executor shutdown signal handlers when `LOCAL_WORKERS > 0`
+- `apps.py` — Django `AppConfig`; `ready()` imports `checks` to register deployment checks and installs the local-executor shutdown signal handlers when `LOCAL_WORKERS > 0`
+- `checks.py` — Django deployment checks; `check_noop_not_in_production` warns if `NOOP_EXECUTION`, `EAGER`, or `LOCAL_WORKERS > 0` are set (runs with `manage.py check --deploy`)
 - `tasks.py` — built-in tasks; `cleanup_task_records` deletes old `TaskRecord` rows; `submit_batch_job` receives a serialized task message and submits it to AWS Batch via `batch.submit_job()`
 
 ## Conventions

django_lambda_tasks-0.6.6/README.md → django_lambda_tasks-0.6.7/PKG-INFO

@@ -1,3 +1,15 @@
+Metadata-Version: 2.4
+Name: django-lambda-tasks
+Version: 0.6.7
+Summary: Run async tasks in a lambda function
+Requires-Python: >=3.10
+Requires-Dist: awslambdaric
+Requires-Dist: boto3
+Requires-Dist: django
+Requires-Dist: pydantic
+Requires-Dist: redis
+Description-Content-Type: text/markdown
+
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda or AWS Batch outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler or Batch container. Task results, status, and metadata are persisted in the Django database.
@@ -181,9 +193,10 @@ LAMBDA_TASKS_LOCAL_WORKERS = 4
 Async local mode bridges the gap between eager mode and full SQS/Lambda deployment. Tasks execute in background worker processes with true parallelism and full timeout enforcement via `SIGALRM`, without requiring AWS infrastructure.
 
 The execution mode hierarchy is:
-1. **Eager** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
-2. **Async local** (`LAMBDA_TASKS_LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
-3. **SQS** (default) — async, Lambda workers, timeouts enforced
+1. **Noop** (`LAMBDA_TASKS_NOOP_EXECUTION=True`) — tasks are dropped with a warning log
+2. **Eager** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
+3. **Async local** (`LAMBDA_TASKS_LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
+4. **SQS** (default) — async, Lambda workers, timeouts enforced
 
 Key characteristics:
 - `LAMBDA_TASKS_LOCAL_WORKERS` and `LAMBDA_TASKS_EAGER` are mutually exclusive — setting both raises `ImproperlyConfigured`
@@ -196,6 +209,35 @@ Key characteristics:
 
 ---
 
+### Noop execution (testing)
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `LAMBDA_TASKS_NOOP_EXECUTION` | `bool` | `False` | When `True`, all tasks are silently dropped. A warning is logged with the task name, kwargs, and queue. |
+
+```python
+# settings/test.py
+LAMBDA_TASKS_NOOP_EXECUTION = True
+```
+
+Noop mode is useful for test suites where task execution is irrelevant and you want to avoid mocking SQS or running tasks at all. When a task is dispatched via `execute_on_commit()`, it logs a warning and returns immediately — no SQS message is sent, no task is executed, no `TaskRecord` is created.
+
+`LAMBDA_TASKS_NOOP_EXECUTION` is mutually exclusive with both `LAMBDA_TASKS_EAGER` and `LAMBDA_TASKS_LOCAL_WORKERS` — setting it alongside either raises `ImproperlyConfigured`.
+
+### Deployment checks
+
+A Django deployment check (runs with `manage.py check --deploy`) warns if any non-production execution mode is enabled:
+
+| Check ID | Condition | Message |
+|---|---|---|
+| `lambda_tasks.W001` | `LAMBDA_TASKS_NOOP_EXECUTION = True` | Tasks will be silently dropped |
+| `lambda_tasks.W002` | `LAMBDA_TASKS_EAGER = True` | Tasks will run synchronously in-process |
+| `lambda_tasks.W003` | `LAMBDA_TASKS_LOCAL_WORKERS > 0` | Tasks will run in a local process pool |
+
+Add `manage.py check --deploy` to your CI pipeline to catch these misconfigurations before they reach production.
+
+---
+
 ## Decorator options
 
 ```python

django_lambda_tasks-0.6.6/PKG-INFO → django_lambda_tasks-0.6.7/README.md

@@ -1,15 +1,3 @@
-Metadata-Version: 2.4
-Name: django-lambda-tasks
-Version: 0.6.6
-Summary: Run async tasks in a lambda function
-Requires-Python: >=3.10
-Requires-Dist: awslambdaric
-Requires-Dist: boto3
-Requires-Dist: django
-Requires-Dist: pydantic
-Requires-Dist: redis
-Description-Content-Type: text/markdown
-
 # Django Lambda Tasks
 
 A Django library for offloading work to AWS Lambda or AWS Batch outside of the request-response cycle. Tasks are defined with a decorator, enqueued to SQS on transaction commit, and executed by a Lambda handler or Batch container. Task results, status, and metadata are persisted in the Django database.
@@ -193,9 +181,10 @@ LAMBDA_TASKS_LOCAL_WORKERS = 4
 Async local mode bridges the gap between eager mode and full SQS/Lambda deployment. Tasks execute in background worker processes with true parallelism and full timeout enforcement via `SIGALRM`, without requiring AWS infrastructure.
 
 The execution mode hierarchy is:
-1. **Eager** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
-2. **Async local** (`LAMBDA_TASKS_LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
-3. **SQS** (default) — async, Lambda workers, timeouts enforced
+1. **Noop** (`LAMBDA_TASKS_NOOP_EXECUTION=True`) — tasks are dropped with a warning log
+2. **Eager** (`LAMBDA_TASKS_EAGER=True`) — synchronous, in-process, no timeouts
+3. **Async local** (`LAMBDA_TASKS_LOCAL_WORKERS > 0`) — async, separate processes, timeouts enforced
+4. **SQS** (default) — async, Lambda workers, timeouts enforced
 
 Key characteristics:
 - `LAMBDA_TASKS_LOCAL_WORKERS` and `LAMBDA_TASKS_EAGER` are mutually exclusive — setting both raises `ImproperlyConfigured`
@@ -208,6 +197,35 @@ Key characteristics:
 
 ---
 
+### Noop execution (testing)
+
+| Setting | Type | Default | Description |
+|---|---|---|---|
+| `LAMBDA_TASKS_NOOP_EXECUTION` | `bool` | `False` | When `True`, all tasks are silently dropped. A warning is logged with the task name, kwargs, and queue. |
+
+```python
+# settings/test.py
+LAMBDA_TASKS_NOOP_EXECUTION = True
+```
+
+Noop mode is useful for test suites where task execution is irrelevant and you want to avoid mocking SQS or running tasks at all. When a task is dispatched via `execute_on_commit()`, it logs a warning and returns immediately — no SQS message is sent, no task is executed, no `TaskRecord` is created.
+
+`LAMBDA_TASKS_NOOP_EXECUTION` is mutually exclusive with both `LAMBDA_TASKS_EAGER` and `LAMBDA_TASKS_LOCAL_WORKERS` — setting it alongside either raises `ImproperlyConfigured`.
+
+### Deployment checks
+
+A Django deployment check (runs with `manage.py check --deploy`) warns if any non-production execution mode is enabled:
+
+| Check ID | Condition | Message |
+|---|---|---|
+| `lambda_tasks.W001` | `LAMBDA_TASKS_NOOP_EXECUTION = True` | Tasks will be silently dropped |
+| `lambda_tasks.W002` | `LAMBDA_TASKS_EAGER = True` | Tasks will run synchronously in-process |
+| `lambda_tasks.W003` | `LAMBDA_TASKS_LOCAL_WORKERS > 0` | Tasks will run in a local process pool |
+
+Add `manage.py check --deploy` to your CI pipeline to catch these misconfigurations before they reach production.
+
+---
+
 ## Decorator options
 
 ```python

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.6.7}/lambda_tasks/apps.py

@@ -15,6 +15,7 @@ class LambdaTasksConfig(AppConfig):
         on Ctrl+C, before Django's autoreloader parent SIGKILLs this child. See
         ``local_executor._install_shutdown_handlers`` for the full rationale.
         """
+        import lambda_tasks.checks  # noqa: F401 — register deployment checks
         from lambda_tasks.local_executor import _install_shutdown_handlers
         from lambda_tasks.settings import LambdaTasksSettings
 

django_lambda_tasks-0.6.7/lambda_tasks/checks.py

@@ -0,0 +1,45 @@
+"""Django deployment checks for lambda_tasks."""
+
+from django.conf import settings as django_settings
+from django.core.checks import Warning, register
+
+
+@register("lambda_tasks", deploy=True)
+def check_noop_not_in_production(
+    *, app_configs: object, **kwargs: object
+) -> list[Warning]:
+    """Warn if any non-production execution mode is enabled."""
+    warnings: list[Warning] = []
+
+    if bool(getattr(django_settings, "LAMBDA_TASKS_NOOP_EXECUTION", False)):
+        warnings.append(
+            Warning(
+                "LAMBDA_TASKS_NOOP_EXECUTION is enabled. "
+                "Tasks will be silently dropped.",
+                hint="Set LAMBDA_TASKS_NOOP_EXECUTION = False for production.",
+                id="lambda_tasks.W001",
+            )
+        )
+
+    if bool(getattr(django_settings, "LAMBDA_TASKS_EAGER", False)):
+        warnings.append(
+            Warning(
+                "LAMBDA_TASKS_EAGER is enabled. "
+                "Tasks will run synchronously in-process.",
+                hint="Set LAMBDA_TASKS_EAGER = False for production.",
+                id="lambda_tasks.W002",
+            )
+        )
+
+    local_workers = int(getattr(django_settings, "LAMBDA_TASKS_LOCAL_WORKERS", 0))
+    if local_workers > 0:
+        warnings.append(
+            Warning(
+                "LAMBDA_TASKS_LOCAL_WORKERS is set to a positive value. "
+                "Tasks will run in a local process pool.",
+                hint="Set LAMBDA_TASKS_LOCAL_WORKERS = 0 for production.",
+                id="lambda_tasks.W003",
+            )
+        )
+
+    return warnings

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.6.7}/lambda_tasks/models.py

@@ -2,6 +2,7 @@
 
 import contextlib
 import datetime
+import logging
 import random
 import traceback
 import uuid
@@ -26,6 +27,8 @@ from lambda_tasks.settings import (
 )
 from lambda_tasks.timeouts import TimeoutContext
 
+logger = logging.getLogger("lambda_tasks")
+
 
 class MaxRetriesExceededError(Exception):
     def __init__(self, *, task_name: str, n_retries: int) -> None:
@@ -260,6 +263,13 @@ class SQSLambdaTask(BaseModel):
         """
         conf = LambdaTasksSettings()
 
+        if conf.NOOP_EXECUTION:
+            logger.warning(
+                f"Task {self.message.task_name} dropped (noop execution mode): "
+                f"kwargs={self.message.kwargs!r}, queue={self.queue!r}"
+            )
+            return
+
         if conf.EAGER:
             self.message.execute_immediately(message_id=str(uuid.uuid4()))
         elif conf.LOCAL_WORKERS > 0:

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.6.7}/lambda_tasks/settings.py

@@ -108,3 +108,16 @@ class LambdaTasksSettings:
             )
         else:
             return value
+
+    @property
+    def NOOP_EXECUTION(self) -> bool:
+        value = bool(getattr(django_settings, "LAMBDA_TASKS_NOOP_EXECUTION", False))
+        if value and self.EAGER:
+            raise ImproperlyConfigured(
+                "LAMBDA_TASKS_NOOP_EXECUTION and LAMBDA_TASKS_EAGER are mutually exclusive."
+            )
+        if value and int(getattr(django_settings, "LAMBDA_TASKS_LOCAL_WORKERS", 0)) > 0:
+            raise ImproperlyConfigured(
+                "LAMBDA_TASKS_NOOP_EXECUTION and LAMBDA_TASKS_LOCAL_WORKERS are mutually exclusive."
+            )
+        return value

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.6.7}/pyproject.toml

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

django_lambda_tasks-0.6.7/tests/test_noop_execution.py

@@ -0,0 +1,165 @@
+"""Tests for LAMBDA_TASKS_NOOP_EXECUTION setting and deployment check."""
+
+import logging
+from unittest.mock import patch
+
+import pytest
+from django.core.exceptions import ImproperlyConfigured
+
+DEFAULT_QUEUE = {
+    "queue_url": "https://sqs.us-east-1.amazonaws.com/000000000000/default"
+}
+QUEUES = {"default": DEFAULT_QUEUE}
+
+
+# ---------------------------------------------------------------------------
+# NOOP_EXECUTION setting property
+# ---------------------------------------------------------------------------
+
+
+def test_noop_execution_defaults_to_false():
+    from lambda_tasks.settings import LambdaTasksSettings
+
+    conf = LambdaTasksSettings()
+    assert conf.NOOP_EXECUTION is False
+
+
+def test_noop_execution_true(settings):
+    from lambda_tasks.settings import LambdaTasksSettings
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    conf = LambdaTasksSettings()
+    assert conf.NOOP_EXECUTION is True
+
+
+def test_noop_execution_with_eager_raises(settings):
+    from lambda_tasks.settings import LambdaTasksSettings
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = True
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    conf = LambdaTasksSettings()
+    with pytest.raises(ImproperlyConfigured):
+        _ = conf.NOOP_EXECUTION
+
+
+def test_noop_execution_with_local_workers_raises(settings):
+    from lambda_tasks.settings import LambdaTasksSettings
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 2
+    conf = LambdaTasksSettings()
+    with pytest.raises(ImproperlyConfigured):
+        _ = conf.NOOP_EXECUTION
+
+
+# ---------------------------------------------------------------------------
+# _execute() noop behaviour
+# ---------------------------------------------------------------------------
+
+
+def test_execute_noop_does_not_call_sqs(settings):
+    from lambda_tasks.models import SQSLambdaTask, SQSLambdaTaskMessage
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    settings.LAMBDA_TASKS_QUEUES = QUEUES
+
+    message = SQSLambdaTaskMessage(
+        task_name="myapp.tasks.my_task",
+        kwargs={"user_id": 1},
+        n_retries=0,
+    )
+    task = SQSLambdaTask(message=message, delay=0, queue="default")
+
+    with patch("lambda_tasks.models.boto3") as mock_boto3:
+        task._execute()
+        mock_boto3.client.assert_not_called()
+
+
+def test_execute_noop_logs_warning(settings, caplog):
+    from lambda_tasks.models import SQSLambdaTask, SQSLambdaTaskMessage
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    settings.LAMBDA_TASKS_QUEUES = QUEUES
+
+    message = SQSLambdaTaskMessage(
+        task_name="myapp.tasks.my_task",
+        kwargs={"user_id": 42},
+        n_retries=0,
+    )
+    task = SQSLambdaTask(message=message, delay=0, queue="default")
+
+    with caplog.at_level(logging.WARNING, logger="lambda_tasks"):
+        task._execute()
+
+    assert len(caplog.records) == 1
+    record = caplog.records[0]
+    assert record.levelname == "WARNING"
+    assert "myapp.tasks.my_task" in record.message
+    assert "noop" in record.message.lower()
+    assert "{'user_id': 42}" in record.message
+
+
+# ---------------------------------------------------------------------------
+# Django deployment check
+# ---------------------------------------------------------------------------
+
+
+def test_deployment_check_passes_when_all_false(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = False
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    errors = check_noop_not_in_production(app_configs=None)
+    assert errors == []
+
+
+def test_deployment_check_warns_noop(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    errors = check_noop_not_in_production(app_configs=None)
+    assert len(errors) == 1
+    assert errors[0].id == "lambda_tasks.W001"
+
+
+def test_deployment_check_warns_eager(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = False
+    settings.LAMBDA_TASKS_EAGER = True
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 0
+    errors = check_noop_not_in_production(app_configs=None)
+    assert len(errors) == 1
+    assert errors[0].id == "lambda_tasks.W002"
+
+
+def test_deployment_check_warns_local_workers(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = False
+    settings.LAMBDA_TASKS_EAGER = False
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 2
+    errors = check_noop_not_in_production(app_configs=None)
+    assert len(errors) == 1
+    assert errors[0].id == "lambda_tasks.W003"
+
+
+def test_deployment_check_warns_multiple(settings):
+    from lambda_tasks.checks import check_noop_not_in_production
+
+    settings.LAMBDA_TASKS_NOOP_EXECUTION = True
+    settings.LAMBDA_TASKS_EAGER = True
+    settings.LAMBDA_TASKS_LOCAL_WORKERS = 2
+    errors = check_noop_not_in_production(app_configs=None)
+    assert len(errors) == 3