django-lambda-tasks 0.1.0__tar.gz → 0.1.1__tar.gz

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/.kiro/steering/product.md

@@ -121,13 +121,13 @@ class SQSLambdaTaskMessage(BaseModel):
 
 `resolve_secrets_into_env()` in `secret_loader.py` runs once at Lambda cold start, before `django.setup()`.
 
-Any env var prefixed `AWS_SECRETS_MANAGER_` is treated as a Secrets Manager reference. The unprefixed name is the target env var.
+Any env var prefixed `LAMBDA_TASKS_SECRET_` is treated as a Secrets Manager reference. The unprefixed name is the target env var.
 
 Required format: `<arn>:<json-key>:<version-stage>:<version-id>` (10 colon-separated segments, all fields non-empty).
 
 Behaviour:
 - All references are validated before any AWS call — malformed references raise `ValueError` immediately
-- Setting both `AWS_SECRETS_MANAGER_FOO` and `FOO` is a configuration error and raises `ValueError`
+- Setting both `LAMBDA_TASKS_SECRET_FOO` and `FOO` is a configuration error and raises `ValueError`
 - Calls are batched by `(ARN, version-stage, version-id)` — one `GetSecretValue` per unique combination
 - Fetched secrets are cached in-process; warm invocations pay no extra cost
 

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/.kiro/steering/structure.md

@@ -17,7 +17,7 @@ django-lambda-tasks/
 │   ├── logging.py              # task_logger — invocation-scoped LoggerAdapter
 │   ├── models.py               # TaskRecord, SQSLambdaTaskMessage, SQSLambdaTask
 │   ├── settings.py             # LambdaTasksSettings (lazy Django settings reader)
-│   ├── secret_loader.py        # Resolves AWS_SECRETS_MANAGER_* env vars at cold start
+│   ├── secret_loader.py        # Resolves LAMBDA_TASKS_SECRET_* env vars at cold start
 │   ├── timeouts.py             # TimeoutContext implementation
 │   └── migrations/             # Django migrations for TaskRecord
 ├── tests/                      # pytest test suite
@@ -39,7 +39,7 @@ django-lambda-tasks/
 - `decorators.py` — defines `@lambda_task`; enforces kwargs-only at decoration time
 - `models.py` — `TaskRecord` (Django ORM), `SQSLambdaTaskMessage` (Pydantic, SQS schema + execution logic), `SQSLambdaTask` (Pydantic, holds message + routing; `_execute()` publishes to SQS or executes eagerly; `execute_on_commit()` registers `_execute` with `transaction.on_commit`)
 - `handler.py` — Lambda entry point; calls `resolve_secrets_into_env()` then `django.setup()` at cold start; processes SQS records independently; returns `batchItemFailures`
-- `secret_loader.py` — resolves `AWS_SECRETS_MANAGER_*` env vars from Secrets Manager before Django starts; validates format, detects conflicts, batches API calls, caches results in-process
+- `secret_loader.py` — resolves `LAMBDA_TASKS_SECRET_*` env vars from Secrets Manager before Django starts; validates format, detects conflicts, batches API calls, caches results in-process
 - `logging.py` — `task_logger` singleton; `invocation_id` set/cleared around each task execution
 - `settings.py` — `LambdaTasksSettings` instantiated fresh per use (reads live Django settings)
 - `admin.py` — Django admin registration for `TaskRecord`

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-lambda-tasks
-Version: 0.1.0
+Version: 0.1.1
 Summary: Run async tasks in a lambda function
 Requires-Python: >=3.10
 Requires-Dist: boto3
@@ -403,15 +403,15 @@ Ensure the Lambda execution environment has `DJANGO_SETTINGS_MODULE` set and tha
 
 The Lambda handler supports loading secret values from AWS Secrets Manager into the environment before Django starts. This lets your Django settings file read from `os.environ` as normal while keeping secrets out of plaintext environment variables.
 
-Set any env var with the prefix `AWS_SECRETS_MANAGER_` to a full Secrets Manager dynamic reference. The unprefixed name becomes the target env var:
+Set any env var with the prefix `LAMBDA_TASKS_SECRET_` to a full Secrets Manager dynamic reference. The unprefixed name becomes the target env var:
 
 ```
-AWS_SECRETS_MANAGER_DATABASE_URL=arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_DATABASE_URL=arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWSCURRENT:v1
 ```
 
 At cold start, before `django.setup()` is called, the handler calls `resolve_secrets_into_env()` which:
 
-1. Scans all env vars for the `AWS_SECRETS_MANAGER_` prefix
+1. Scans all env vars for the `LAMBDA_TASKS_SECRET_` prefix
 2. Validates every reference — malformed references raise immediately so the container fails to start rather than misconfiguring Django silently
 3. Groups references by `(ARN, version-stage, version-id)` and makes one `GetSecretValue` call per unique combination
 4. Extracts the named JSON key from the secret and writes it into `os.environ`
@@ -435,8 +435,8 @@ arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWS
 Multiple env vars can reference different keys from the same secret — only one `GetSecretValue` call is made for that `(ARN, version-stage, version-id)` combination:
 
 ```
-AWS_SECRETS_MANAGER_DATABASE_URL=arn:...:myapp/prod:DATABASE_URL:AWSCURRENT:v1
-AWS_SECRETS_MANAGER_SECRET_KEY=arn:...:myapp/prod:SECRET_KEY:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_DATABASE_URL=arn:...:myapp/prod:DATABASE_URL:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_SECRET_KEY=arn:...:myapp/prod:SECRET_KEY:AWSCURRENT:v1
 ```
 
 #### Validation errors
@@ -445,7 +445,7 @@ The following all raise `ValueError` at cold start, preventing the Lambda contai
 
 - Wrong number of colon-separated segments (must be exactly 10)
 - Empty `json-key`, `version-stage`, or `version-id`
-- Both `AWS_SECRETS_MANAGER_FOO` and `FOO` are set — use one or the other
+- Both `LAMBDA_TASKS_SECRET_FOO` and `FOO` are set — use one or the other
 - The named JSON key does not exist in the fetched secret
 - The secret value is not valid JSON
 

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/README.md

@@ -393,15 +393,15 @@ Ensure the Lambda execution environment has `DJANGO_SETTINGS_MODULE` set and tha
 
 The Lambda handler supports loading secret values from AWS Secrets Manager into the environment before Django starts. This lets your Django settings file read from `os.environ` as normal while keeping secrets out of plaintext environment variables.
 
-Set any env var with the prefix `AWS_SECRETS_MANAGER_` to a full Secrets Manager dynamic reference. The unprefixed name becomes the target env var:
+Set any env var with the prefix `LAMBDA_TASKS_SECRET_` to a full Secrets Manager dynamic reference. The unprefixed name becomes the target env var:
 
 ```
-AWS_SECRETS_MANAGER_DATABASE_URL=arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_DATABASE_URL=arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWSCURRENT:v1
 ```
 
 At cold start, before `django.setup()` is called, the handler calls `resolve_secrets_into_env()` which:
 
-1. Scans all env vars for the `AWS_SECRETS_MANAGER_` prefix
+1. Scans all env vars for the `LAMBDA_TASKS_SECRET_` prefix
 2. Validates every reference — malformed references raise immediately so the container fails to start rather than misconfiguring Django silently
 3. Groups references by `(ARN, version-stage, version-id)` and makes one `GetSecretValue` call per unique combination
 4. Extracts the named JSON key from the secret and writes it into `os.environ`
@@ -425,8 +425,8 @@ arn:aws:secretsmanager:eu-west-1:123456789012:secret:myapp/prod:DATABASE_URL:AWS
 Multiple env vars can reference different keys from the same secret — only one `GetSecretValue` call is made for that `(ARN, version-stage, version-id)` combination:
 
 ```
-AWS_SECRETS_MANAGER_DATABASE_URL=arn:...:myapp/prod:DATABASE_URL:AWSCURRENT:v1
-AWS_SECRETS_MANAGER_SECRET_KEY=arn:...:myapp/prod:SECRET_KEY:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_DATABASE_URL=arn:...:myapp/prod:DATABASE_URL:AWSCURRENT:v1
+LAMBDA_TASKS_SECRET_SECRET_KEY=arn:...:myapp/prod:SECRET_KEY:AWSCURRENT:v1
 ```
 
 #### Validation errors
@@ -435,7 +435,7 @@ The following all raise `ValueError` at cold start, preventing the Lambda contai
 
 - Wrong number of colon-separated segments (must be exactly 10)
 - Empty `json-key`, `version-stage`, or `version-id`
-- Both `AWS_SECRETS_MANAGER_FOO` and `FOO` are set — use one or the other
+- Both `LAMBDA_TASKS_SECRET_FOO` and `FOO` are set — use one or the other
 - The named JSON key does not exist in the fetched secret
 - The secret value is not valid JSON
 

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/lambda_tasks/handler.py

@@ -10,16 +10,15 @@ import logging
 import os
 
 import django
-from django.apps import apps as django_apps
+from django.apps import apps
 
-from lambda_tasks.models import SQSLambdaTaskMessage
 from lambda_tasks.secret_loader import resolve_secrets_into_env
 
 # Cold-start Django setup — runs once per Lambda container.
 # Secrets are resolved first so Django settings can reference the populated
-# env vars.  resolve_secrets_into_env() is idempotent and caches fetched
+# env vars. resolve_secrets_into_env() is idempotent and caches fetched
 # secrets in-process, so subsequent invocations pay no extra cost.
-if os.environ.get("DJANGO_SETTINGS_MODULE") and not django_apps.ready:
+if os.environ.get("DJANGO_SETTINGS_MODULE") and not apps.ready:
     resolve_secrets_into_env()
     django.setup()
 
@@ -32,6 +31,9 @@ def handler(*, event: dict, context: object) -> dict:
 
     Returns a partial-batch failure report so AWS only re-drives failed records.
     """
+    # Local import due to AppRegistryNotReady
+    from lambda_tasks.models import SQSLambdaTaskMessage
+
     batch_item_failures: list[dict] = []
 
     for record in event["Records"]:

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/lambda_tasks/secret_loader.py

@@ -1,14 +1,14 @@
 """
 Resolves environment variables that reference AWS Secrets Manager ARNs.
 
-Any env var prefixed with ``AWS_SECRETS_MANAGER_`` is treated as a pointer
+Any env var prefixed with ``LAMBDA_TASKS_SECRET_`` is treated as a pointer
 to a secret value.  The unprefixed name is the target env var to populate.
 
 Required value format
 ---------------------
 Every reference must follow the full dynamic reference syntax::
 
-    AWS_SECRETS_MANAGER_DJANGO_ADMIN_URL=arn:aws:secretsmanager:eu-west-1:123:secret:my-secret:DJANGO_ADMIN_URL:AWSCURRENT:v1
+    LAMBDA_TASKS_SECRET_DJANGO_ADMIN_URL=arn:aws:secretsmanager:eu-west-1:123:secret:my-secret:DJANGO_ADMIN_URL:AWSCURRENT:v1
 
 That is: ``<arn>:<json-key>:<version-stage>:<version-id>``
 
@@ -16,7 +16,7 @@ All four suffix segments must be present and non-empty.
 A malformed reference raises ``ValueError`` immediately so the Lambda
 container fails at cold start rather than silently misconfiguring Django.
 
-It is a configuration error to set both ``AWS_SECRETS_MANAGER_FOO`` and
+It is a configuration error to set both ``LAMBDA_TASKS_SECRET_FOO`` and
 ``FOO`` — use one or the other.  Having both raises ``ValueError`` at cold
 start so the misconfiguration is caught immediately.
 
@@ -35,7 +35,7 @@ import boto3
 
 logger = logging.getLogger(__name__)
 
-_PREFIX = "AWS_SECRETS_MANAGER_"
+_PREFIX = "LAMBDA_TASKS_SECRET_"
 
 # Module-level cache: (arn, version_stage, version_id) → raw secret string.
 # Populated on first call; reused for the lifetime of the Lambda container.
@@ -128,14 +128,14 @@ def _fetch_secret(*, client: object, ref: _SecretReference) -> dict[str, str]:
 
 
 def resolve_secrets_into_env() -> None:
-    """Scan env vars for ``AWS_SECRETS_MANAGER_*`` references and resolve them.
+    """Scan env vars for ``LAMBDA_TASKS_SECRET_*`` references and resolve them.
 
     For each matching env var the resolved value is written back into
     ``os.environ`` under the unprefixed name.
 
     Raises ``ValueError`` at cold start if:
     - A reference is malformed (wrong segment count, any empty field)
-    - The target env var is already set — use ``AWS_SECRETS_MANAGER_FOO`` or
+    - The target env var is already set — use ``LAMBDA_TASKS_SECRET_FOO`` or
       ``FOO``, not both
 
     This function is idempotent — calling it multiple times is safe and cheap
@@ -157,7 +157,7 @@ def resolve_secrets_into_env() -> None:
     if conflicts:
         raise ValueError(
             "The following environment variables are set both directly and via "
-            f"AWS_SECRETS_MANAGER_*: {', '.join(sorted(conflicts))}. "
+            f"LAMBDA_TASKS_SECRET_*: {', '.join(sorted(conflicts))}. "
             "Use one or the other, not both."
         )
 

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/pyproject.toml

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

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/tests/test_handler.py

@@ -46,7 +46,7 @@ def _valid_body(task_name: str = "my_module.my_task", **kwargs) -> str:
 def _patch_model_validate(side_effect):
     """Patch SQSLambdaTaskMessage.model_validate_json in the handler module."""
     return patch(
-        "lambda_tasks.handler.SQSLambdaTaskMessage.model_validate_json",
+        "lambda_tasks.models.SQSLambdaTaskMessage.model_validate_json",
         side_effect=side_effect,
     )
 
@@ -252,7 +252,6 @@ def test_property_11_batch_records_processed_independently(flags):
 def test_property_4_django_setup_before_execute_task(monkeypatch):
     import importlib
 
-    import django
     import django.apps
 
     import lambda_tasks.handler as handler_module
@@ -272,7 +271,7 @@ def test_property_4_django_setup_before_execute_task(monkeypatch):
         return MagicMock()
 
     monkeypatch.setattr(
-        "lambda_tasks.handler.SQSLambdaTaskMessage.model_validate_json",
+        "lambda_tasks.models.SQSLambdaTaskMessage.model_validate_json",
         spy_model_validate,
     )
 

{django_lambda_tasks-0.1.0 → django_lambda_tasks-0.1.1}/tests/test_secret_loader.py

@@ -43,7 +43,7 @@ def clear_cache():
 
 class TestParseReferenceValid:
     def test_returns_named_tuple_with_arn_and_key(self):
-        ref = _parse_reference(env_var="AWS_SECRETS_MANAGER_X", value=VALID_REF)
+        ref = _parse_reference(env_var="LAMBDA_TASKS_SECRET_X", value=VALID_REF)
         assert ref.arn == ARN
         assert ref.json_key == "MY_KEY"
         assert ref.version_stage == "AWSCURRENT"
@@ -51,7 +51,7 @@ class TestParseReferenceValid:
 
     def test_version_id_populated(self):
         value = f"{ARN}:DJANGO_ADMIN_URL:AWSCURRENT:abc123"
-        ref = _parse_reference(env_var="AWS_SECRETS_MANAGER_X", value=value)
+        ref = _parse_reference(env_var="LAMBDA_TASKS_SECRET_X", value=value)
         assert ref.arn == ARN
         assert ref.json_key == "DJANGO_ADMIN_URL"
         assert ref.version_stage == "AWSCURRENT"
@@ -66,43 +66,43 @@ class TestParseReferenceValid:
 class TestParseReferenceInvalid:
     def test_plain_arn_rejected(self):
         with pytest.raises(ValueError, match="10 colon-separated segments"):
-            _parse_reference(env_var="AWS_SECRETS_MANAGER_X", value=ARN)
+            _parse_reference(env_var="LAMBDA_TASKS_SECRET_X", value=ARN)
 
     def test_empty_json_key_rejected(self):
         # 10 segments but key is empty
         value = f"{ARN}::AWSCURRENT:abc123"
         with pytest.raises(ValueError, match="missing the json-key"):
-            _parse_reference(env_var="AWS_SECRETS_MANAGER_X", value=value)
+            _parse_reference(env_var="LAMBDA_TASKS_SECRET_X", value=value)
 
     def test_empty_version_stage_rejected(self):
         value = f"{ARN}:MY_KEY::abc123"
         with pytest.raises(ValueError, match="missing the version-stage"):
-            _parse_reference(env_var="AWS_SECRETS_MANAGER_X", value=value)
+            _parse_reference(env_var="LAMBDA_TASKS_SECRET_X", value=value)
 
     def test_empty_version_id_rejected(self):
         value = f"{ARN}:MY_KEY:AWSCURRENT:"
         with pytest.raises(ValueError, match="missing the version-id"):
-            _parse_reference(env_var="AWS_SECRETS_MANAGER_X", value=value)
+            _parse_reference(env_var="LAMBDA_TASKS_SECRET_X", value=value)
 
     def test_too_few_segments_rejected(self):
         with pytest.raises(ValueError, match="10 colon-separated segments"):
-            _parse_reference(env_var="AWS_SECRETS_MANAGER_X", value=f"{ARN}:KEY:")
+            _parse_reference(env_var="LAMBDA_TASKS_SECRET_X", value=f"{ARN}:KEY:")
 
     def test_too_many_segments_rejected(self):
         with pytest.raises(ValueError, match="10 colon-separated segments"):
             _parse_reference(
-                env_var="AWS_SECRETS_MANAGER_X",
+                env_var="LAMBDA_TASKS_SECRET_X",
                 value=f"{ARN}:KEY:STAGE:VER:EXTRA",
             )
 
     def test_error_message_includes_env_var_name(self):
-        with pytest.raises(ValueError, match="AWS_SECRETS_MANAGER_MY_VAR"):
-            _parse_reference(env_var="AWS_SECRETS_MANAGER_MY_VAR", value=ARN)
+        with pytest.raises(ValueError, match="LAMBDA_TASKS_SECRET_MY_VAR"):
+            _parse_reference(env_var="LAMBDA_TASKS_SECRET_MY_VAR", value=ARN)
 
     @given(st.text(min_size=1).filter(lambda s: s.count(":") != 9))
     def test_any_non_10_segment_value_rejected(self, value: str):
         with pytest.raises(ValueError):
-            _parse_reference(env_var="AWS_SECRETS_MANAGER_X", value=value)
+            _parse_reference(env_var="LAMBDA_TASKS_SECRET_X", value=value)
 
 
 # ---------------------------------------------------------------------------
@@ -112,13 +112,13 @@ class TestParseReferenceInvalid:
 
 class TestNoReferences:
     def test_no_prefixed_vars_makes_no_boto3_call(self, monkeypatch):
-        monkeypatch.delenv("AWS_SECRETS_MANAGER_ANYTHING", raising=False)
+        monkeypatch.delenv("LAMBDA_TASKS_SECRET_ANYTHING", raising=False)
         with patch("lambda_tasks.secret_loader.boto3") as mock_boto3:
             resolve_secrets_into_env()
         mock_boto3.client.assert_not_called()
 
     def test_no_prefixed_vars_leaves_env_unchanged(self, monkeypatch):
-        monkeypatch.delenv("AWS_SECRETS_MANAGER_ANYTHING", raising=False)
+        monkeypatch.delenv("LAMBDA_TASKS_SECRET_ANYTHING", raising=False)
         before = dict(os.environ)
         resolve_secrets_into_env()
         assert dict(os.environ) == before
@@ -131,14 +131,14 @@ class TestNoReferences:
 
 class TestMalformedReference:
     def test_plain_arn_raises_before_any_boto3_call(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_MY_VAR", ARN)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_MY_VAR", ARN)
         with patch("lambda_tasks.secret_loader.boto3") as mock_boto3:
-            with pytest.raises(ValueError, match="AWS_SECRETS_MANAGER_MY_VAR"):
+            with pytest.raises(ValueError, match="LAMBDA_TASKS_SECRET_MY_VAR"):
                 resolve_secrets_into_env()
         mock_boto3.client.assert_not_called()
 
     def test_empty_key_raises_before_any_boto3_call(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_MY_VAR", f"{ARN}::AWSCURRENT:abc123")
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_MY_VAR", f"{ARN}::AWSCURRENT:abc123")
         with patch("lambda_tasks.secret_loader.boto3") as mock_boto3:
             with pytest.raises(ValueError, match="missing the json-key"):
                 resolve_secrets_into_env()
@@ -152,7 +152,7 @@ class TestMalformedReference:
 
 class TestConflict:
     def test_raises_when_target_already_set(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_MY_VAR", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_MY_VAR", VALID_REF)
         monkeypatch.setenv("MY_VAR", "already-set")
 
         with patch("lambda_tasks.secret_loader.boto3"):
@@ -160,8 +160,8 @@ class TestConflict:
                 resolve_secrets_into_env()
 
     def test_error_message_lists_all_conflicts(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_VAR_A", VALID_REF)
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_VAR_B", VALID_REF2)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_VAR_A", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_VAR_B", VALID_REF2)
         monkeypatch.setenv("VAR_A", "x")
         monkeypatch.setenv("VAR_B", "y")
 
@@ -174,7 +174,7 @@ class TestConflict:
         assert "VAR_B" in msg
 
     def test_conflict_raises_before_any_boto3_call(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_MY_VAR", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_MY_VAR", VALID_REF)
         monkeypatch.setenv("MY_VAR", "already-set")
 
         with patch("lambda_tasks.secret_loader.boto3") as mock_boto3:
@@ -190,7 +190,7 @@ class TestConflict:
 
 class TestResolution:
     def test_sets_target_env_var(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_MY_VAR", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_MY_VAR", VALID_REF)
         monkeypatch.delenv("MY_VAR", raising=False)
 
         payload = json.dumps({"MY_KEY": "supersecret"})
@@ -204,7 +204,7 @@ class TestResolution:
         assert os.environ["MY_VAR"] == "supersecret"
 
     def test_missing_key_in_secret_raises(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_SOME_VAR", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_SOME_VAR", VALID_REF)
         monkeypatch.delenv("SOME_VAR", raising=False)
 
         client = MagicMock()
@@ -218,7 +218,7 @@ class TestResolution:
                 resolve_secrets_into_env()
 
     def test_invalid_json_in_secret_raises(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_SOME_VAR", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_SOME_VAR", VALID_REF)
         monkeypatch.delenv("SOME_VAR", raising=False)
 
         client = MagicMock()
@@ -239,8 +239,8 @@ class TestBatching:
     def test_single_api_call_for_same_arn(self, monkeypatch):
         ref_a = f"{ARN}:KEY_A:AWSCURRENT:AWSCURRENT"
         ref_b = f"{ARN}:KEY_B:AWSCURRENT:AWSCURRENT"
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_VAR_A", ref_a)
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_VAR_B", ref_b)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_VAR_A", ref_a)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_VAR_B", ref_b)
         monkeypatch.delenv("VAR_A", raising=False)
         monkeypatch.delenv("VAR_B", raising=False)
 
@@ -261,8 +261,8 @@ class TestBatching:
         assert os.environ["VAR_B"] == "val-b"
 
     def test_separate_api_calls_for_different_arns(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_VAR_A", VALID_REF)
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_VAR_B", VALID_REF2)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_VAR_A", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_VAR_B", VALID_REF2)
         monkeypatch.delenv("VAR_A", raising=False)
         monkeypatch.delenv("VAR_B", raising=False)
 
@@ -288,7 +288,7 @@ class TestBatching:
 
 class TestCaching:
     def test_second_call_makes_no_api_call(self, monkeypatch):
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_MY_VAR", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_MY_VAR", VALID_REF)
         monkeypatch.delenv("MY_VAR", raising=False)
 
         payload = json.dumps({"MY_KEY": "cached-value"})
@@ -307,7 +307,7 @@ class TestCaching:
         secret_loader._secret_cache[(ARN, "AWSCURRENT", "AWSCURRENT")] = {
             "MY_KEY": "pre-cached"
         }
-        monkeypatch.setenv("AWS_SECRETS_MANAGER_MY_VAR", VALID_REF)
+        monkeypatch.setenv("LAMBDA_TASKS_SECRET_MY_VAR", VALID_REF)
         monkeypatch.delenv("MY_VAR", raising=False)
 
         with patch("lambda_tasks.secret_loader.boto3") as mock_boto3: