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

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

@@ -143,6 +143,7 @@ class SQSLambdaTaskMessage(BaseModel):
 
 `handler(event, context)` in `handler.py`:
 - Processes each SQS record independently
+- Calls `django.db.close_old_connections()` before each record to close database connections that have become unusable between warm invocations (idle timeouts, RDS failovers, network interruptions)
 - Passes `record["messageId"]` as `message_id` to `execute_immediately()` — this becomes the `TaskRecord` primary key, enabling deduplication on redelivery
 - Returns `{"batchItemFailures": [...]}` for partial-batch failure reporting
 - Only pre-execution failures (malformed message, import error, misconfiguration) are reported as `batchItemFailures` — task logic failures are caught and recorded as `FAILED` TaskRecords without raising
@@ -215,11 +216,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 +253,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 +285,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.7.0}/.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
@@ -42,13 +43,14 @@ django-lambda-tasks/
 - `decorators.py` — defines `LambdaTaskWrapper` and `@lambda_task` decorator factory; enforces kwargs-only at decoration time; validates timeouts (> 0, soft < hard) at decoration time; upper-bound timeout validation deferred to execution time based on queue type
 - `models.py` — `TaskRecord` (Django ORM), `SQSLambdaTaskMessage` (Pydantic, SQS schema + execution logic), `SQSLambdaTask` (Pydantic, holds message + routing; `_execute()` inspects queue config to publish to SQS, submit to Batch via `submit_batch_job`, execute eagerly, or submit to the local process pool; `execute_on_commit()` registers `_execute` with `transaction.on_commit`)
 - `local_executor.py` — `ProcessPoolExecutor`-based async local execution; `get_pool()` lazily creates a module-level pool; `submit_task()` fire-and-forget submission; `_execute_in_worker()` deserializes and runs the task in a child process; `_pool_initializer()` calls `django.setup()` per worker (and sets `SIGINT` to `SIG_IGN` so workers ignore Ctrl+C); `_install_shutdown_handlers()` installs main-thread `SIGINT`/`SIGTERM` handlers that release the pool before chaining to the previous handler
-- `handler.py` — Lambda entry point (`handler(event, context)`); cold-start init (memory limit → temporary log handler → `resolve_environment()` → `resolve_secrets_into_env()` → handler removed → conditional `django.setup()`) runs inside the handler on first invocation, guarded by `_cold_start_done` sentinel; processes SQS records independently; returns `batchItemFailures`. Also provides `main()` as the AWS Batch container entry point (`python -m lambda_tasks.handler`) — reads `LAMBDA_TASKS_MESSAGE` env var, constructs a synthetic SQS event, and delegates to `handler()`
+- `handler.py` — Lambda entry point (`handler(event, context)`); cold-start init (memory limit → temporary log handler → `resolve_environment()` → `resolve_secrets_into_env()` → handler removed → conditional `django.setup()`) runs inside the handler on first invocation, guarded by `_cold_start_done` sentinel; calls `db.close_old_connections()` before each SQS record to handle stale connections on warm starts; processes SQS records independently; returns `batchItemFailures`. Also provides `main()` as the AWS Batch container entry point (`python -m lambda_tasks.handler`) — reads `LAMBDA_TASKS_MESSAGE` env var, constructs a synthetic SQS event, and delegates to `handler()`
 - `environment_loader.py` — loads env vars from a Secrets Manager secret at cold start; validates flat JSON format; idempotent via `_loaded` sentinel
 - `secret_loader.py` — resolves `LAMBDA_TASKS_SECRET_*` env vars from Secrets Manager before Django starts; validates format, detects conflicts, batches API calls; idempotent via `_loaded` sentinel
 - `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 → django_lambda_tasks-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-lambda-tasks
-Version: 0.6.6
+Version: 0.7.0
 Summary: Run async tasks in a lambda function
 Requires-Python: >=3.10
 Requires-Dist: awslambdaric
@@ -193,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`
@@ -208,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
@@ -517,6 +547,8 @@ lambda_tasks.handler.handler
 
 The handler performs cold-start initialisation on the first invocation (not at module import time) to avoid Lambda init-duration timeouts. The sequence is: temporary log handler attached → `resolve_environment()` → `resolve_secrets_into_env()` → log handler removed → conditional `django.setup()`. A module-level sentinel ensures this runs only once; subsequent warm invocations skip it entirely.
 
+Before processing each SQS record, the handler calls `django.db.close_old_connections()` to close any database connections that have become unusable between invocations. Lambda containers are reused across invocations (warm starts), but database connections may be closed server-side due to idle timeouts, RDS failovers, or network interruptions. Without this, the first database query in a task would fail with `OperationalError: the connection is closed`.
+
 Ensure the Lambda execution environment has `DJANGO_SETTINGS_MODULE` set and that all task modules are importable (i.e. your application code is on the Python path).
 
 | Environment Variable | Required | Description |

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.7.0}/README.md

@@ -181,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`
@@ -196,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
@@ -505,6 +535,8 @@ lambda_tasks.handler.handler
 
 The handler performs cold-start initialisation on the first invocation (not at module import time) to avoid Lambda init-duration timeouts. The sequence is: temporary log handler attached → `resolve_environment()` → `resolve_secrets_into_env()` → log handler removed → conditional `django.setup()`. A module-level sentinel ensures this runs only once; subsequent warm invocations skip it entirely.
 
+Before processing each SQS record, the handler calls `django.db.close_old_connections()` to close any database connections that have become unusable between invocations. Lambda containers are reused across invocations (warm starts), but database connections may be closed server-side due to idle timeouts, RDS failovers, or network interruptions. Without this, the first database query in a task would fail with `OperationalError: the connection is closed`.
+
 Ensure the Lambda execution environment has `DJANGO_SETTINGS_MODULE` set and that all task modules are importable (i.e. your application code is on the Python path).
 
 | Environment Variable | Required | Description |

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.7.0}/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.7.0/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.7.0}/lambda_tasks/handler.py

@@ -21,6 +21,7 @@ import urllib.request
 import uuid
 
 import django
+from django import db
 from django.apps import apps
 
 from lambda_tasks.environment_loader import resolve_environment
@@ -132,6 +133,7 @@ def handler(event: dict, context: object) -> dict:
 
     for record in event["Records"]:
         try:
+            db.close_old_connections()
             SQSLambdaTaskMessage.model_validate_json(
                 record["body"]
             ).execute_immediately(message_id=record["messageId"])

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.7.0}/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.7.0}/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.7.0}/pyproject.toml

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

{django_lambda_tasks-0.6.6 → django_lambda_tasks-0.7.0}/tests/test_handler.py

@@ -26,6 +26,14 @@ from hypothesis import strategies as st
 
 from lambda_tasks.handler import handler
 
+
+@pytest.fixture(autouse=True)
+def _patch_close_old_connections():
+    """Prevent close_old_connections from triggering the DB access guard in unit tests."""
+    with patch("lambda_tasks.handler.db.close_old_connections"):
+        yield
+
+
 # ---------------------------------------------------------------------------
 # Signature test
 # ---------------------------------------------------------------------------
@@ -457,3 +465,71 @@ class TestColdStartLogging:
 
         assert lambda_tasks_logger.handlers == []
         assert lambda_tasks_logger.level == logging.NOTSET
+
+
+# ---------------------------------------------------------------------------
+# Stale connection handling
+# ---------------------------------------------------------------------------
+
+
+class TestHandlerClosesOldConnections:
+    def test_close_old_connections_called_before_each_record(self):
+        """close_old_connections() is called before processing each SQS record."""
+        call_order = []
+
+        def _track_close():
+            call_order.append("close")
+
+        def _make_message(body: str):
+            msg = MagicMock()
+
+            def _execute(**kwargs):
+                call_order.append("execute")
+
+            msg.execute_immediately.side_effect = _execute
+            return msg
+
+        records = [
+            _make_record("msg-1", _valid_body()),
+            _make_record("msg-2", _valid_body()),
+        ]
+
+        with (
+            patch(
+                "lambda_tasks.handler.db.close_old_connections",
+                side_effect=_track_close,
+            ),
+            _patch_model_validate(_make_message),
+        ):
+            handler(event={"Records": records}, context=None)
+
+        assert call_order == ["close", "execute", "close", "execute"]
+
+    def test_close_old_connections_called_even_when_record_fails(self):
+        """close_old_connections() is called before each record, including ones that fail."""
+        close_count = 0
+
+        def _track_close():
+            nonlocal close_count
+            close_count += 1
+
+        def _make_message(body: str):
+            msg = MagicMock()
+            msg.execute_immediately.side_effect = RuntimeError("boom")
+            return msg
+
+        records = [
+            _make_record("msg-1", _valid_body()),
+            _make_record("msg-2", _valid_body()),
+        ]
+
+        with (
+            patch(
+                "lambda_tasks.handler.db.close_old_connections",
+                side_effect=_track_close,
+            ),
+            _patch_model_validate(_make_message),
+        ):
+            handler(event={"Records": records}, context=None)
+
+        assert close_count == 2

django_lambda_tasks-0.7.0/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