bazis-async-request 2.3.0__tar.gz → 2.4.0__tar.gz

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/.github/workflows/release.yml

@@ -42,9 +42,12 @@ jobs:
             echo "::error::Tag v$VERSION already exists"
             exit 1
           fi
-          LAST_TAG=$(git tag --list 'v*' --sort=-v:refname | head -n 1)
+          # versionsort.suffix: a pre-release (v2.4.0-rc1) sorts before its release (v2.4.0)
+          LAST_TAG=$(git -c versionsort.suffix=- tag --list 'v*' --sort=-v:refname | head -n 1)
           echo "Last release: ${LAST_TAG:-none}, new release: v$VERSION"
-          if [ -n "$LAST_TAG" ] && [ "$(printf '%s\n%s\n' "${LAST_TAG#v}" "$VERSION" | sort -V | tail -n 1)" != "$VERSION" ]; then
+          # sort -V orders "~" before anything, as versionsort.suffix does with "-"
+          NEWEST=$(printf '%s\n%s\n' "${LAST_TAG#v}" "$VERSION" | sed 's/-/~/' | sort -V | tail -n 1)
+          if [ -n "$LAST_TAG" ] && [ "$NEWEST" != "${VERSION/-/\~}" ]; then
             echo "::error::Version $VERSION is not newer than $LAST_TAG"
             exit 1
           fi

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/.github/workflows/tests.yml

@@ -20,7 +20,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: astral-sh/setup-uv@v6
-      - run: uvx ruff check bazis tests
+      - run: uvx ruff check bazis tests sample
 
   tests:
     name: tests (python ${{ matrix.python }}, ${{ matrix.resolution }})

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/CLAUDE.md

@@ -38,7 +38,7 @@ to the database name): migrate it first (`python manage.py migrate` and
 The tests marked `run_with_consumer` are skipped without Kafka settings. A local Kafka
 without Docker: download the Kafka binaries and start a single KRaft node.
 
-Lint: `ruff check bazis tests`. CI also runs `python manage.py makemigrations --check
+Lint: `ruff check bazis tests sample`. CI also runs `python manage.py makemigrations --check
 --dry-run` in `sample`: commit the migrations of model changes, including the sample apps.
 
 ## Releasing

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazis-async-request
-Version: 2.3.0
+Version: 2.4.0
 Summary: Async Background Requests module for Bazis framework.
 Author-email: Ilya Kharyn <ilya.tt07@gmail.com>
 Maintainer-email: Ilya Kharyn <ilya.tt07@gmail.com>
@@ -17,7 +17,7 @@ Classifier: Framework :: Django
 Classifier: Framework :: FastAPI
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: bazis>=2.3.1
+Requires-Dist: bazis>=2.4.0
 Requires-Dist: bazis-async-background>=2.3.0
 Provides-Extra: test
 Requires-Dist: bazis-test-utils>=2.3.0; extra == "test"
@@ -236,7 +236,15 @@ This adds the endpoint: `GET /api/v1/async_background_response/{task_id}/`
 
 ### Project-Level Middleware
 
-AsyncRequestMiddleware is registered automatically when `bazis.contrib.async_request` is loaded.
+Add the middleware to the application (it is not added automatically):
+
+```python
+from bazis.contrib.async_request.middleware import AsyncRequestMiddleware
+from bazis.core.app import app
+
+app.add_middleware(AsyncRequestMiddleware)
+```
+
 Any request can be moved to background using the `X-Async-Background: true` header.
 
 **Location**: `bazis.contrib.async_request.middleware.AsyncRequestMiddleware`
@@ -298,7 +306,9 @@ Runs 5 consumers in separate processes. Suitable for local development or deploy
 
 **Parameters**:
 
-- `--consumers-count` — number of consumers to run (default: 1)
+- `--consumers-count` — number of consumers to run (default: 15)
+- `--restart-delay-sec` — delay before restarting a consumer that exited (default: 1.0)
+- `--max-restarts` — restarts of a failed consumer before it is given up (default: unlimited)
 
 ## Working with Frontend
 

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/README.md

@@ -206,7 +206,15 @@ This adds the endpoint: `GET /api/v1/async_background_response/{task_id}/`
 
 ### Project-Level Middleware
 
-AsyncRequestMiddleware is registered automatically when `bazis.contrib.async_request` is loaded.
+Add the middleware to the application (it is not added automatically):
+
+```python
+from bazis.contrib.async_request.middleware import AsyncRequestMiddleware
+from bazis.core.app import app
+
+app.add_middleware(AsyncRequestMiddleware)
+```
+
 Any request can be moved to background using the `X-Async-Background: true` header.
 
 **Location**: `bazis.contrib.async_request.middleware.AsyncRequestMiddleware`
@@ -268,7 +276,9 @@ Runs 5 consumers in separate processes. Suitable for local development or deploy
 
 **Parameters**:
 
-- `--consumers-count` — number of consumers to run (default: 1)
+- `--consumers-count` — number of consumers to run (default: 15)
+- `--restart-delay-sec` — delay before restarting a consumer that exited (default: 1.0)
+- `--max-restarts` — restarts of a failed consumer before it is given up (default: unlimited)
 
 ## Working with Frontend
 

bazis_async_request-2.4.0/bazis/contrib/async_request/AGENTS.md

@@ -0,0 +1,75 @@
+# bazis-async-request — guide for AI agents
+
+Runs any HTTP request of a Bazis API in the background: a request with the header
+`X-Async-Background` is queued in Kafka (bazis-async-background) and answered 202; a
+consumer replays it through the ASGI application and stores the response for
+`GET /async_background_response/{task_id}/`. Use it for slow endpoints and bulk changes.
+
+## Setup
+
+```bash
+BS_INSTALLED_APPS='[..., "bazis.contrib.async_request", "bazis.contrib.async_background"]'
+BS_KAFKA_TASKS='["bazis.contrib.async_request.tasks"]'   # the consumer of the requests
+BS_KAFKA_BOOTSTRAP_SERVERS=kafka:9092
+BS_KAFKA_TOPIC_ASYNC_BG=myproject_async_request
+BS_KAFKA_GROUP_ID=myproject
+```
+
+```python
+# the main module of the application (as sample/sample/main.py)
+from bazis.contrib.async_request.middleware import AsyncRequestMiddleware
+from bazis.core.app import app
+
+app.add_middleware(AsyncRequestMiddleware)      # not added automatically
+
+# the root router
+router.register('bazis.contrib.async_background.router')    # async_request.E001
+```
+
+- Services and consumers as in bazis-async-background: Kafka, Redis, and
+  `python manage.py kafka_consumer_single` (or `kafka_consumer_multiple`) with the same
+  settings and database as the API.
+- Without Kafka settings the middleware executes these requests synchronously and only
+  logs a warning (`async_request.W001`).
+
+## Client
+
+- Send the request as usual plus `X-Async-Background: true` (the header's presence is
+  enough) and `Authorization: Bearer <token>`: a session JWT, or an anonymous token of
+  bazis-ws (16–128 characters `A-Z a-z 0-9 _ -`). Without a valid token: 401. The request
+  is replayed with the same header: routes that read the user (bazis-users, permit, author)
+  answer 401 to an anonymous token, so use it only for routes that do not.
+- Answer: 202 `{"data": null, "meta": {"async_request_id": <id>, "async_background_id": <id>}}`
+  (the same task id). Status updates arrive on the WebSocket channel of the token.
+- Result: `GET .../async_background_response/{task_id}/` with the same token returns
+  `{"task_id", "endpoint", "status", "headers", "response"}` of the replayed request
+  (an HTTP error is a `completed` task with its status); `{"status": "not ready"}` before.
+
+## Endpoints only for background requests
+
+```python
+from fastapi import Depends
+from bazis.contrib.async_request.utils import require_async
+
+@router.post('/reports/generate/', dependencies=[Depends(require_async)])
+async def generate_report(...): ...
+
+class ShopRouteSet(JsonapiRouteBase):
+    @inject_make(CrudApiAction.UPDATE)          # bazis.core.routes_abstract.initial
+    class InjectRequireAsync:
+        async_request: None = Depends(require_async)   # the annotation is required
+```
+
+A direct request to such an endpoint is 409.
+
+## Rules
+
+- Recognize the requests of the consumer only with `is_internal_request(scope)`
+  (`SCOPE_INTERNAL_KEY` in the ASGI scope, which clients cannot set). Never trust a
+  header: `X-Async-Background-Internal` is ignored.
+- Only JSON bodies (an object or a list of objects) are queued: another body (multipart,
+  form, binary) is replayed as `{}`.
+- The queued request keeps all headers, `Authorization` included, in the Kafka topic; it
+  runs with the client's token, so the token must still be valid when the consumer runs it.
+- Requests with the same `data.id` in the body go to the same Kafka partition.
+- WebSocket requests and the results route are never queued.

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis/contrib/async_request/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '2.3.0'
-__version_tuple__ = version_tuple = (2, 3, 0)
+__version__ = version = '2.4.0'
+__version_tuple__ = version_tuple = (2, 4, 0)
 
-__commit_id__ = commit_id = 'g7f4029675'
+__commit_id__ = commit_id = 'g5ed041f2b'

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis/contrib/async_request/apps.py

@@ -23,3 +23,8 @@ class AsyncRequestConfig(BaseConfig):
     name = "bazis.contrib.async_request"
     verbose_name = _("AsyncRequest")
     default = True
+
+    def ready(self):
+        super().ready()
+
+        from . import checks  # noqa: F401  registers the system checks

bazis_async_request-2.4.0/bazis/contrib/async_request/bazis_manifest.toml

@@ -0,0 +1,52 @@
+# What the package is for and how to use it, for tools and AI agents (see AGENTS.md).
+# `import` paths and `check` ids are verified by tests/test_manifest.py.
+
+[package]
+name = "bazis-async-request"
+summary = "run any HTTP request of the API in the background through Kafka (X-Async-Background)"
+solves = [
+    "move slow requests or bulk changes to the background without new endpoints",
+    "restrict an endpoint to requests executed in the background",
+]
+requires = ["bazis", "bazis-async-background"]
+pairs_well = ["bazis-users", "bazis-permit"]
+
+[[extension_points]]
+name = "AsyncRequestMiddleware"
+import = "bazis.contrib.async_request.middleware.AsyncRequestMiddleware"
+use_when = "add to the application: app.add_middleware(AsyncRequestMiddleware)"
+
+[[extension_points]]
+name = "require_async"
+import = "bazis.contrib.async_request.utils.require_async"
+use_when = "a dependency that allows an endpoint only for background requests (409 otherwise)"
+
+[[extension_points]]
+name = "is_internal_request"
+import = "bazis.contrib.async_request.utils.is_internal_request"
+use_when = "whether a request (ASGI scope) is executed by the consumer"
+
+[[extension_points]]
+name = "consumer_async_requests"
+import = "bazis.contrib.async_request.tasks.consumer_async_requests"
+use_when = "the consumer of the requests: list bazis.contrib.async_request.tasks in KAFKA_TASKS"
+
+[[pitfalls]]
+text = "without Kafka settings the requests with X-Async-Background are executed synchronously"
+check = "async_request.W001"
+
+[[pitfalls]]
+text = "without the route of bazis.contrib.async_background.router the middleware fails on every HTTP request"
+check = "async_request.E001"
+
+[[pitfalls]]
+text = "the middleware is not added automatically: app.add_middleware(AsyncRequestMiddleware)"
+
+[[pitfalls]]
+text = "a header must never mark a request as internal: use is_internal_request(scope)"
+
+[[pitfalls]]
+text = "only JSON bodies are queued: multipart, form and binary bodies are replayed as {}"
+
+[[pitfalls]]
+text = "a dependency in an inject_make class without a type annotation is ignored"

bazis_async_request-2.4.0/bazis/contrib/async_request/checks.py

@@ -0,0 +1,70 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""
+Django system checks of bazis-async-request (see `manage.py bazis_doctor`).
+"""
+
+from django.conf import settings
+from django.core.checks import Error, Warning, register
+
+
+@register()
+def check_kafka_enabled(app_configs, **kwargs):
+    """
+    Without Kafka the middleware executes the requests sent with `X-Async-Background`
+    synchronously, and only logs a warning.
+    """
+    # the settings of bazis-async-background are missing if BS_BAZIS_APPS does not list it
+    if not getattr(settings, 'KAFKA_ENABLED', False):
+        return [
+            Warning(
+                'Kafka is not configured: the requests sent with X-Async-Background are '
+                'executed synchronously.',
+                hint=(
+                    'Set BS_KAFKA_BOOTSTRAP_SERVERS and BS_KAFKA_TOPIC_ASYNC_BG (and list '
+                    'bazis.contrib.async_background in BS_BAZIS_APPS if it is set).'
+                ),
+                id='async_request.W001',
+            )
+        ]
+    return []
+
+
+@register()
+def check_response_route(app_configs, **kwargs):
+    """
+    The middleware looks up the route of the results to let its requests through: without
+    it every HTTP request through the middleware fails. Runs when the application is
+    loaded (`manage.py bazis_doctor`).
+    """
+    from bazis.core.introspect import loaded_app
+
+    if (app := loaded_app()) is None:
+        return []
+
+    from starlette.routing import NoMatchFound
+
+    try:
+        app.url_path_for('get_async_background_response', task_id='__dummy__')
+    except NoMatchFound:
+        return [
+            Error(
+                'The route of the background results is not registered: '
+                'AsyncRequestMiddleware fails on every HTTP request.',
+                hint="Register it: router.register('bazis.contrib.async_background.router').",
+                id='async_request.E001',
+            )
+        ]
+    return []

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis/contrib/async_request/middleware.py

@@ -33,6 +33,16 @@ from .utils import build_request_payload, is_internal_request
 logger = logging.getLogger(__name__)
 
 
+def partition_marker(body) -> str | None:
+    """
+    The id of the JSON:API resource of the body: the requests of one resource are kept in
+    one Kafka partition, in order.
+    """
+    data = body.get("data") if isinstance(body, dict) else None
+    item_id = data.get("id") if isinstance(data, dict) else None
+    return str(item_id) if item_id is not None else None
+
+
 class AsyncRequestMiddleware:
     def __init__(self, app):
         self.app = app
@@ -88,9 +98,7 @@ class AsyncRequestMiddleware:
             topic_name=settings.KAFKA_TOPIC_ASYNC_BG,
             channel_name=channel_name,
             payload=payload,
-            partition_marker=(
-                payload.body.get("data", {}).get("id") if isinstance(payload.body, dict) else None
-            ),
+            partition_marker=partition_marker(payload.body),
         )
 
         response = JSONResponse(

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis/contrib/async_request/utils.py

@@ -37,8 +37,13 @@ def build_request_payload(request: Request) -> AsyncRequestPayload:
     """Creates a payload for sending to Kafka."""
     body_raw: bytes = request.scope.get("_cached_body") or getattr(request, "_body", b"")
     try:
-        body: dict = json.loads(body_raw.decode("utf-8")) if body_raw else {}
-    except json.JSONDecodeError:
+        body = json.loads(body_raw.decode("utf-8")) if body_raw else {}
+    except ValueError:
+        # not JSON (multipart, binary): the body is not replayed
+        body = {}
+    if not isinstance(body, dict | list) or (
+        isinstance(body, list) and not all(isinstance(it, dict) for it in body)
+    ):
         body = {}
 
     headers: list[tuple[str, str]] = []

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis_async_request.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bazis-async-request
-Version: 2.3.0
+Version: 2.4.0
 Summary: Async Background Requests module for Bazis framework.
 Author-email: Ilya Kharyn <ilya.tt07@gmail.com>
 Maintainer-email: Ilya Kharyn <ilya.tt07@gmail.com>
@@ -17,7 +17,7 @@ Classifier: Framework :: Django
 Classifier: Framework :: FastAPI
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
-Requires-Dist: bazis>=2.3.1
+Requires-Dist: bazis>=2.4.0
 Requires-Dist: bazis-async-background>=2.3.0
 Provides-Extra: test
 Requires-Dist: bazis-test-utils>=2.3.0; extra == "test"
@@ -236,7 +236,15 @@ This adds the endpoint: `GET /api/v1/async_background_response/{task_id}/`
 
 ### Project-Level Middleware
 
-AsyncRequestMiddleware is registered automatically when `bazis.contrib.async_request` is loaded.
+Add the middleware to the application (it is not added automatically):
+
+```python
+from bazis.contrib.async_request.middleware import AsyncRequestMiddleware
+from bazis.core.app import app
+
+app.add_middleware(AsyncRequestMiddleware)
+```
+
 Any request can be moved to background using the `X-Async-Background: true` header.
 
 **Location**: `bazis.contrib.async_request.middleware.AsyncRequestMiddleware`
@@ -298,7 +306,9 @@ Runs 5 consumers in separate processes. Suitable for local development or deploy
 
 **Parameters**:
 
-- `--consumers-count` — number of consumers to run (default: 1)
+- `--consumers-count` — number of consumers to run (default: 15)
+- `--restart-delay-sec` — delay before restarting a consumer that exited (default: 1.0)
+- `--max-restarts` — restarts of a failed consumer before it is given up (default: unlimited)
 
 ## Working with Frontend
 

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis_async_request.egg-info/SOURCES.txt

@@ -8,9 +8,12 @@ pytest.ini
 .github/workflows/release.yml
 .github/workflows/tests.yml
 .github/workflows/update-licenses.yml
+bazis/contrib/async_request/AGENTS.md
 bazis/contrib/async_request/__init__.py
 bazis/contrib/async_request/_version.py
 bazis/contrib/async_request/apps.py
+bazis/contrib/async_request/bazis_manifest.toml
+bazis/contrib/async_request/checks.py
 bazis/contrib/async_request/middleware.py
 bazis/contrib/async_request/schemas.py
 bazis/contrib/async_request/tasks.py
@@ -23,6 +26,7 @@ bazis_async_request.egg-info/scm_file_list.json
 bazis_async_request.egg-info/scm_version.json
 bazis_async_request.egg-info/top_level.txt
 docs/releases/2.3.0.md
+docs/releases/2.4.0.md
 sample/Dockerfile
 sample/docker-compose.kafka.yml
 sample/docker-compose.test.yml
@@ -55,6 +59,7 @@ tests/__init__.py
 tests/conftest.py
 tests/test_decorator.py
 tests/test_internal.py
+tests/test_manifest.py
 tests/test_multiple_order_requests.py
 tests/test_order_access.py
 tests/test_order_patch.py

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis_async_request.egg-info/requires.txt

@@ -1,4 +1,4 @@
-bazis>=2.3.1
+bazis>=2.4.0
 bazis-async-background>=2.3.0
 
 [dev]

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis_async_request.egg-info/scm_file_list.json

@@ -8,13 +8,17 @@
     ".gitignore",
     "CLAUDE.md",
     "README.md",
+    "bazis/contrib/async_request/AGENTS.md",
     "bazis/contrib/async_request/__init__.py",
     "bazis/contrib/async_request/apps.py",
+    "bazis/contrib/async_request/bazis_manifest.toml",
+    "bazis/contrib/async_request/checks.py",
     "bazis/contrib/async_request/middleware.py",
     "bazis/contrib/async_request/schemas.py",
     "bazis/contrib/async_request/tasks.py",
     "bazis/contrib/async_request/utils.py",
     "docs/releases/2.3.0.md",
+    "docs/releases/2.4.0.md",
     "pyproject.toml",
     "pytest.ini",
     "sample/Dockerfile",
@@ -49,6 +53,7 @@
     "tests/conftest.py",
     "tests/test_decorator.py",
     "tests/test_internal.py",
+    "tests/test_manifest.py",
     "tests/test_multiple_order_requests.py",
     "tests/test_order_access.py",
     "tests/test_order_patch.py",

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/bazis_async_request.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
-  "tag": "2.3.0",
+  "tag": "2.4.0",
   "distance": 0,
-  "node": "g7f4029675c3d5a89dc6151d1962037bd0313b25f",
+  "node": "g5ed041f2b5971a61028577e5aab70968628fa1fa",
   "dirty": false,
   "branch": "HEAD",
   "node_date": "2026-10-01"

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/docs/releases/2.3.0.md

@@ -20,7 +20,7 @@ Requires Bazis 2.3.1 and bazis-async-background 2.3.
 - **Consumers did not start with current FastStream** (`auto_commit` was removed): the
   subscriber uses `subscriber_kwargs()` of bazis-async-background.
 - The replayed request kept the `Content-Length` of the original request with a re-encoded
-  body and lacked the ASGI version and lifespan `state`; `receive` no longer returns the
+  body and lacked the ASGI version and the `state` key; `receive` no longer returns the
   request again in a loop (streaming responses spun the CPU).
 - The path of the replayed request was decoded twice (`%2541` became `A`) and the
   `root_path` was lost: the payload now stores `path`, `raw_path` and `root_path` of the

bazis_async_request-2.4.0/docs/releases/2.4.0.md

@@ -0,0 +1,14 @@
+# bazis-async-request 2.4.0
+
+Requires Bazis 2.4.
+
+## Tools and AI agents
+
+- The package ships `AGENTS.md` (setup, the client protocol, `require_async` and the
+  security rules) and `bazis_manifest.toml` for tools and AI agents (see `docs/agents.md`
+  of Bazis).
+- New system checks (`manage.py bazis_doctor`):
+  - `async_request.W001`: Kafka is not configured, so the requests sent with
+    `X-Async-Background` are executed synchronously;
+  - `async_request.E001`: the route of the results (`bazis.contrib.async_background.router`)
+    is not registered, so `AsyncRequestMiddleware` fails on every HTTP request.

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/pyproject.toml

@@ -33,7 +33,7 @@ classifiers = [
     "Framework :: FastAPI",
 ]
 dependencies = [
-    "bazis>=2.3.1",
+    "bazis>=2.4.0",
     "bazis-async-background>=2.3.0",
 ]
 

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/sample/test.env

@@ -15,7 +15,7 @@ BS_KAFKA_CONSUMER_LIFETIME_JITTER_SEC=300
 PYTHONPATH=/app
 
 BS_DEBUG=true
-BS_SECRET_KEY=1232434535465476587689780999
+BS_SECRET_KEY=local-secret-key-that-is-long-enough-0123456789
 
 BS_HOST_URL=http://localhost:9000
 

{bazis_async_request-2.3.0 → bazis_async_request-2.4.0}/tests/test_internal.py

@@ -117,3 +117,50 @@ def test_payload_keeps_the_path_as_received():
     assert payload.path == "/prefix/api/v1/file/%41 b/"
     assert payload.raw_path == "/prefix/api/v1/file/%2541%20b/"
     assert payload.root_path == "/prefix"
+
+
+@pytest.mark.parametrize('body', [b'\xff\xfe binary', b'"a string"', b'[1, 2]'])
+def test_payload_of_a_body_that_is_not_a_resource(body):
+    """
+    A binary body failed with UnicodeDecodeError and a JSON body that is not an object (or
+    a list of objects) failed the validation of the payload: 500.
+    """
+    from starlette.requests import Request
+
+    from bazis.contrib.async_request.utils import build_request_payload
+
+    request = Request(
+        {
+            'type': 'http',
+            'method': 'POST',
+            'scheme': 'http',
+            'http_version': '1.1',
+            'path': '/api/v1/files/',
+            'raw_path': b'/api/v1/files/',
+            'query_string': b'',
+            'headers': [],
+            'client': ('127.0.0.1', 1),
+            'server': ('testserver', 80),
+        }
+    )
+    request._body = body
+    assert build_request_payload(request).body == {}
+
+
+@pytest.mark.parametrize(
+    'body, marker',
+    [
+        ({'data': {'id': 'a1', 'type': 'x.y'}}, 'a1'),
+        ({'data': {'id': 7}}, '7'),
+        ({'data': [{'id': 'a1'}]}, None),
+        ({'data': None}, None),
+        ([{'data': {'id': 'a1'}}], None),
+    ],
+)
+def test_partition_marker(body, marker):
+    """
+    The relationships bodies (`data` is a list or null) failed with AttributeError: 500.
+    """
+    from bazis.contrib.async_request.middleware import partition_marker
+
+    assert partition_marker(body) == marker

bazis_async_request-2.4.0/tests/test_manifest.py

@@ -0,0 +1,36 @@
+# Copyright 2026 EcoFuture Technology Services LLC and contributors
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from fastapi import FastAPI
+
+from bazis.contrib.async_request.checks import check_kafka_enabled, check_response_route
+from bazis.core.introspect import validate_manifest
+
+
+def test_manifest_is_valid():
+    assert validate_manifest('bazis.contrib.async_request') == []
+
+
+def test_kafka_enabled_check(settings):
+    settings.KAFKA_ENABLED = False
+    assert [it.id for it in check_kafka_enabled(None)] == ['async_request.W001']
+    settings.KAFKA_ENABLED = True
+    assert check_kafka_enabled(None) == []
+
+
+def test_response_route_check(sample_app, monkeypatch):
+    # the sample project registers bazis.contrib.async_background.router
+    assert check_response_route(None) == []
+    monkeypatch.setattr('bazis.core.introspect.loaded_app', lambda: FastAPI())
+    assert [it.id for it in check_response_route(None)] == ['async_request.E001']