django-ninja-problems 0.1.0__tar.gz

django_ninja_problems-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Jansem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

django_ninja_problems-0.1.0/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: django-ninja-problems
+Version: 0.1.0
+Summary: RFC 7807 and RFC 9457 Problem Details for Django Ninja APIs
+Author: Jansem
+License-Expression: MIT
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Requires-Dist: django-ninja>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-django>=4.8.0; extra == "dev"
+Dynamic: license-file
+
+# django-ninja-problems
+
+RFC 7807 and RFC 9457 Problem Details for Django Ninja APIs.
+
+## Installation
+
+```bash
+pip install django-ninja-problems
+```
+
+## Quick Start
+
+```python
+from ninja import NinjaAPI
+from django_ninja_problems import register_problem_handlers
+
+api = NinjaAPI()
+register_problem_handlers(api)
+```
+
+## Supported Exceptions
+
+- `ninja.errors.HttpError`
+- `django.http.Http404` and `ObjectDoesNotExist`
+- `ninja.errors.ValidationError` and `pydantic.ValidationError` (HTTP 422)
+- `django.core.exceptions.ValidationError` (HTTP 400 or 409)
+- `django.db.IntegrityError` (HTTP 409)
+- Custom authentication exceptions (HTTP 401)
+- Unexpected `Exception` (HTTP 500 masked in production)

django_ninja_problems-0.1.0/README.md

@@ -0,0 +1,29 @@
+# django-ninja-problems
+
+RFC 7807 and RFC 9457 Problem Details for Django Ninja APIs.
+
+## Installation
+
+```bash
+pip install django-ninja-problems
+```
+
+## Quick Start
+
+```python
+from ninja import NinjaAPI
+from django_ninja_problems import register_problem_handlers
+
+api = NinjaAPI()
+register_problem_handlers(api)
+```
+
+## Supported Exceptions
+
+- `ninja.errors.HttpError`
+- `django.http.Http404` and `ObjectDoesNotExist`
+- `ninja.errors.ValidationError` and `pydantic.ValidationError` (HTTP 422)
+- `django.core.exceptions.ValidationError` (HTTP 400 or 409)
+- `django.db.IntegrityError` (HTTP 409)
+- Custom authentication exceptions (HTTP 401)
+- Unexpected `Exception` (HTTP 500 masked in production)

django_ninja_problems-0.1.0/pyproject.toml

@@ -0,0 +1,38 @@
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "django-ninja-problems"
+version = "0.1.0"
+description = "RFC 7807 and RFC 9457 Problem Details for Django Ninja APIs"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "Jansem" }]
+classifiers = [
+    "Framework :: Django",
+    "Programming Language :: Python :: 3",
+    "Topic :: Internet :: WWW/HTTP",
+]
+dependencies = [
+    "django>=4.2",
+    "django-ninja>=1.0.0",
+    "pydantic>=2.0.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.0.0",
+    "pytest-django>=4.8.0",
+]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.setuptools.package-data]
+django_ninja_problems = ["py.typed"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]

django_ninja_problems-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

django_ninja_problems-0.1.0/src/django_ninja_problems/__init__.py

@@ -0,0 +1,26 @@
+from .exceptions import (
+    BadRequestProblem,
+    ConflictProblem,
+    ForbiddenProblem,
+    NotFoundProblem,
+    ProblemException,
+    UnauthorizedProblem,
+    UnprocessableEntityProblem,
+)
+from .handlers import create_problem_response
+from .registrar import register_problem_handlers
+from .schemas import ErrorItem, ProblemDetails
+
+__all__ = [
+    "BadRequestProblem",
+    "ConflictProblem",
+    "ErrorItem",
+    "ForbiddenProblem",
+    "NotFoundProblem",
+    "ProblemDetails",
+    "ProblemException",
+    "UnauthorizedProblem",
+    "UnprocessableEntityProblem",
+    "create_problem_response",
+    "register_problem_handlers",
+]

django_ninja_problems-0.1.0/src/django_ninja_problems/exceptions.py

@@ -0,0 +1,113 @@
+from typing import Any
+from .schemas import ErrorItem
+
+
+class ProblemException(Exception):
+    def __init__(
+        self,
+        status: int = 500,
+        title: str = "Internal Server Error",
+        detail: str | None = None,
+        type: str = "about:blank",
+        instance: str | None = None,
+        errors: list[ErrorItem] | None = None,
+        **extra: Any,
+    ) -> None:
+        self.status = status
+        self.title = title
+        self.detail = detail
+        self.type = type
+        self.instance = instance
+        self.errors = errors
+        self.extra = extra
+        super().__init__(detail or title)
+
+
+class BadRequestProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = None,
+        errors: list[ErrorItem] | None = None,
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=400,
+            title="Bad Request",
+            detail=detail,
+            errors=errors,
+            **extra,
+        )
+
+
+class UnauthorizedProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "Authentication credentials were not provided or are invalid.",
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=401,
+            title="Unauthorized",
+            detail=detail,
+            **extra,
+        )
+
+
+class ForbiddenProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "You do not have permission to perform this action.",
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=403,
+            title="Forbidden",
+            detail=detail,
+            **extra,
+        )
+
+
+class NotFoundProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "The requested resource was not found.",
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=404,
+            title="Not Found",
+            detail=detail,
+            **extra,
+        )
+
+
+class ConflictProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "A conflict occurred with the current state of the resource.",
+        errors: list[ErrorItem] | None = None,
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=409,
+            title="Conflict",
+            detail=detail,
+            errors=errors,
+            **extra,
+        )
+
+
+class UnprocessableEntityProblem(ProblemException):
+    def __init__(
+        self,
+        detail: str | None = "Unable to process the contained instructions.",
+        errors: list[ErrorItem] | None = None,
+        **extra: Any,
+    ) -> None:
+        super().__init__(
+            status=422,
+            title="Unprocessable Entity",
+            detail=detail,
+            errors=errors,
+            **extra,
+        )

django_ninja_problems-0.1.0/src/django_ninja_problems/formatters.py

@@ -0,0 +1,94 @@
+import re
+from typing import Any
+from django.core.exceptions import ValidationError as DjangoValidationError
+from django.db import IntegrityError
+from .schemas import ErrorItem
+
+
+def format_pydantic_location(location: tuple[Any, ...]) -> str:
+    parts = [str(item) for item in location if str(item) not in {"body", "query", "path", "header", "cookie"}]
+    return ".".join(parts) if parts else ".".join(str(item) for item in location)
+
+
+def format_pydantic_errors(errors: list[dict[str, Any]]) -> list[ErrorItem]:
+    formatted: list[ErrorItem] = []
+    for error in errors:
+        loc = error.get("loc", ())
+        field = format_pydantic_location(loc)
+        message = str(error.get("msg", "Invalid value"))
+        code = str(error.get("type", "value_error"))
+        formatted.append(ErrorItem(field=field, message=message, code=code))
+    return formatted
+
+
+def format_django_validation_error(exc: DjangoValidationError) -> list[ErrorItem]:
+    formatted: list[ErrorItem] = []
+    if hasattr(exc, "error_dict"):
+        for field, error_list in exc.error_dict.items():
+            for item in error_list:
+                formatted.append(
+                    ErrorItem(
+                        field=field,
+                        message=str(item.message if hasattr(item, "message") else item),
+                        code=getattr(item, "code", "invalid"),
+                    )
+                )
+        return formatted
+
+    if hasattr(exc, "error_list"):
+        for item in exc.error_list:
+            formatted.append(
+                ErrorItem(
+                    field=None,
+                    message=str(item.message if hasattr(item, "message") else item),
+                    code=getattr(item, "code", "invalid"),
+                )
+            )
+        return formatted
+
+    for message in exc.messages:
+        formatted.append(ErrorItem(field=None, message=str(message), code="invalid"))
+    return formatted
+
+
+def is_unique_constraint_violation(exc: Exception) -> bool:
+    if isinstance(exc, DjangoValidationError):
+        if hasattr(exc, "error_dict"):
+            for errors in exc.error_dict.values():
+                for error in errors:
+                    if getattr(error, "code", None) == "unique":
+                        return True
+        return False
+
+    if isinstance(exc, IntegrityError):
+        message = str(exc).lower()
+        unique_indicators = [
+            "unique constraint",
+            "duplicate key",
+            "already exists",
+            "unique_violation",
+        ]
+        return any(indicator in message for indicator in unique_indicators)
+
+    return False
+
+
+def format_integrity_error_detail(exc: IntegrityError) -> str:
+    message = str(exc)
+    lower_message = message.lower()
+
+    if "unique constraint" in lower_message or "duplicate key" in lower_message:
+        match = re.search(r"Key \((.*?)\)=\((.*?)\) already exists", message)
+        if match:
+            field_name, field_value = match.groups()
+            return f"A record with {field_name} '{field_value}' already exists."
+        match = re.search(r"UNIQUE constraint failed: (.*)", message)
+        if match:
+            column = match.group(1).split(".")[-1]
+            return f"A record with this {column} already exists."
+        return "A record with identical unique fields already exists."
+
+    if "foreign key constraint" in lower_message or "foreign_key_violation" in lower_message:
+        return "Referenced resource does not exist or cannot be modified due to dependent records."
+
+    return "A database integrity constraint was violated."

django_ninja_problems-0.1.0/src/django_ninja_problems/handlers.py

@@ -0,0 +1,186 @@
+from http import HTTPStatus
+from typing import Any
+from django.core.exceptions import ObjectDoesNotExist, ValidationError as DjangoValidationError
+from django.db import IntegrityError
+from django.http import Http404, HttpRequest, HttpResponse
+from ninja import NinjaAPI
+from ninja.errors import HttpError, ValidationError as NinjaValidationError
+from pydantic import ValidationError as PydanticValidationError
+
+from .exceptions import ProblemException
+from .formatters import (
+    format_django_validation_error,
+    format_integrity_error_detail,
+    format_pydantic_errors,
+    is_unique_constraint_violation,
+)
+from .schemas import ProblemDetails
+
+
+def resolve_http_title(status_code: int) -> str:
+    try:
+        return HTTPStatus(status_code).phrase
+    except ValueError:
+        return "HTTP Error"
+
+
+def create_problem_response(
+    api: NinjaAPI,
+    request: HttpRequest,
+    problem: ProblemDetails,
+) -> HttpResponse:
+    payload = problem.model_dump(exclude_none=True)
+    response = api.create_response(request, payload, status=problem.status)
+    response["Content-Type"] = "application/problem+json"
+    return response
+
+
+def handle_problem_exception(
+    request: HttpRequest,
+    exc: ProblemException,
+    api: NinjaAPI,
+) -> HttpResponse:
+    problem = ProblemDetails(
+        type=exc.type,
+        title=exc.title,
+        status=exc.status,
+        detail=exc.detail,
+        instance=exc.instance or request.path,
+        errors=exc.errors,
+        **exc.extra,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_http_error(
+    request: HttpRequest,
+    exc: HttpError,
+    api: NinjaAPI,
+) -> HttpResponse:
+    status_code = exc.status_code
+    detail = None
+    title = resolve_http_title(status_code)
+
+    if isinstance(exc.message, str):
+        detail = exc.message
+    elif isinstance(exc.message, dict):
+        detail = exc.message.get("detail") or exc.message.get("texto") or str(exc.message)
+        title = exc.message.get("title") or exc.message.get("titulo") or title
+
+    problem = ProblemDetails(
+        title=title,
+        status=status_code,
+        detail=detail,
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_not_found(
+    request: HttpRequest,
+    exc: Http404 | ObjectDoesNotExist,
+    api: NinjaAPI,
+) -> HttpResponse:
+    detail_message = str(exc)
+    detail = detail_message if detail_message and not detail_message.startswith("<") else "The requested resource was not found."
+    problem = ProblemDetails(
+        title="Not Found",
+        status=404,
+        detail=detail,
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_ninja_validation_error(
+    request: HttpRequest,
+    exc: NinjaValidationError | PydanticValidationError,
+    api: NinjaAPI,
+) -> HttpResponse:
+    raw_errors = exc.errors() if callable(getattr(exc, "errors", None)) else getattr(exc, "errors", [])
+    errors = format_pydantic_errors(raw_errors if isinstance(raw_errors, list) else [])
+    problem = ProblemDetails(
+        title="Unprocessable Entity",
+        status=422,
+        detail="The request body or parameters failed validation.",
+        instance=request.path,
+        errors=errors,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_django_validation_error(
+    request: HttpRequest,
+    exc: DjangoValidationError,
+    api: NinjaAPI,
+) -> HttpResponse:
+    errors = format_django_validation_error(exc)
+    if is_unique_constraint_violation(exc):
+        problem = ProblemDetails(
+            title="Conflict",
+            status=409,
+            detail="A record with conflicting unique values already exists.",
+            instance=request.path,
+            errors=errors,
+        )
+        return create_problem_response(api, request, problem)
+
+    problem = ProblemDetails(
+        title="Bad Request",
+        status=400,
+        detail="The submitted data failed validation.",
+        instance=request.path,
+        errors=errors,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_integrity_error(
+    request: HttpRequest,
+    exc: IntegrityError,
+    api: NinjaAPI,
+) -> HttpResponse:
+    detail = format_integrity_error_detail(exc)
+    problem = ProblemDetails(
+        title="Conflict",
+        status=409,
+        detail=detail,
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_authentication_error(
+    request: HttpRequest,
+    exc: Exception,
+    api: NinjaAPI,
+) -> HttpResponse:
+    if isinstance(exc, HttpError) and exc.message:
+        detail = exc.message if isinstance(exc.message, str) else str(exc.message)
+    elif str(exc):
+        detail = str(exc)
+    else:
+        detail = "Authentication credentials were not provided or are invalid."
+
+    problem = ProblemDetails(
+        title="Unauthorized",
+        status=401,
+        detail=detail,
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)
+
+
+def handle_unexpected_exception(
+    request: HttpRequest,
+    exc: Exception,
+    api: NinjaAPI,
+    debug: bool,
+) -> HttpResponse:
+    problem = ProblemDetails(
+        title="Internal Server Error",
+        status=500,
+        detail=f"{type(exc).__name__}: {exc}" if debug else "An unexpected error occurred while processing the request.",
+        instance=request.path,
+    )
+    return create_problem_response(api, request, problem)

django_ninja_problems-0.1.0/src/django_ninja_problems/registrar.py

@@ -0,0 +1,83 @@
+from typing import Any, Callable
+from django.conf import settings
+from django.core.exceptions import ObjectDoesNotExist, ValidationError as DjangoValidationError
+from django.db import IntegrityError
+from django.http import Http404, HttpRequest, HttpResponse
+from ninja import NinjaAPI
+from ninja.errors import AuthenticationError, HttpError, ValidationError as NinjaValidationError
+from pydantic import ValidationError as PydanticValidationError
+
+from .exceptions import ProblemException
+from .handlers import (
+    handle_authentication_error,
+    handle_django_validation_error,
+    handle_http_error,
+    handle_integrity_error,
+    handle_ninja_validation_error,
+    handle_not_found,
+    handle_problem_exception,
+    handle_unexpected_exception,
+)
+
+
+def register_problem_handlers(
+    api: NinjaAPI,
+    *,
+    debug: bool | None = None,
+    auth_exceptions: tuple[type[Exception], ...] | None = None,
+    custom_handlers: dict[type[Exception], Callable[[HttpRequest, Any], HttpResponse]] | None = None,
+) -> None:
+    is_debug = getattr(settings, "DEBUG", False) if debug is None else debug
+
+    api.add_exception_handler(
+        ProblemException,
+        lambda request, exc: handle_problem_exception(request, exc, api),
+    )
+    api.add_exception_handler(
+        HttpError,
+        lambda request, exc: handle_http_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        Http404,
+        lambda request, exc: handle_not_found(request, exc, api),
+    )
+    api.add_exception_handler(
+        ObjectDoesNotExist,
+        lambda request, exc: handle_not_found(request, exc, api),
+    )
+    api.add_exception_handler(
+        NinjaValidationError,
+        lambda request, exc: handle_ninja_validation_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        PydanticValidationError,
+        lambda request, exc: handle_ninja_validation_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        DjangoValidationError,
+        lambda request, exc: handle_django_validation_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        IntegrityError,
+        lambda request, exc: handle_integrity_error(request, exc, api),
+    )
+    api.add_exception_handler(
+        AuthenticationError,
+        lambda request, exc: handle_authentication_error(request, exc, api),
+    )
+
+    if auth_exceptions:
+        for auth_exc in auth_exceptions:
+            api.add_exception_handler(
+                auth_exc,
+                lambda request, exc: handle_authentication_error(request, exc, api),
+            )
+
+    if custom_handlers:
+        for exc_class, handler in custom_handlers.items():
+            api.add_exception_handler(exc_class, handler)
+
+    api.add_exception_handler(
+        Exception,
+        lambda request, exc: handle_unexpected_exception(request, exc, api, is_debug),
+    )

django_ninja_problems-0.1.0/src/django_ninja_problems/schemas.py

@@ -0,0 +1,19 @@
+from typing import Any
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ErrorItem(BaseModel):
+    field: str | None = None
+    message: str
+    code: str | None = None
+
+
+class ProblemDetails(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+    type: str = "about:blank"
+    title: str
+    status: int
+    detail: str | None = None
+    instance: str | None = None
+    errors: list[ErrorItem] | None = None

django_ninja_problems-0.1.0/src/django_ninja_problems.egg-info/PKG-INFO

@@ -0,0 +1,49 @@
+Metadata-Version: 2.4
+Name: django-ninja-problems
+Version: 0.1.0
+Summary: RFC 7807 and RFC 9457 Problem Details for Django Ninja APIs
+Author: Jansem
+License-Expression: MIT
+Classifier: Framework :: Django
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: django>=4.2
+Requires-Dist: django-ninja>=1.0.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0.0; extra == "dev"
+Requires-Dist: pytest-django>=4.8.0; extra == "dev"
+Dynamic: license-file
+
+# django-ninja-problems
+
+RFC 7807 and RFC 9457 Problem Details for Django Ninja APIs.
+
+## Installation
+
+```bash
+pip install django-ninja-problems
+```
+
+## Quick Start
+
+```python
+from ninja import NinjaAPI
+from django_ninja_problems import register_problem_handlers
+
+api = NinjaAPI()
+register_problem_handlers(api)
+```
+
+## Supported Exceptions
+
+- `ninja.errors.HttpError`
+- `django.http.Http404` and `ObjectDoesNotExist`
+- `ninja.errors.ValidationError` and `pydantic.ValidationError` (HTTP 422)
+- `django.core.exceptions.ValidationError` (HTTP 400 or 409)
+- `django.db.IntegrityError` (HTTP 409)
+- Custom authentication exceptions (HTTP 401)
+- Unexpected `Exception` (HTTP 500 masked in production)

django_ninja_problems-0.1.0/src/django_ninja_problems.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+src/django_ninja_problems/__init__.py
+src/django_ninja_problems/exceptions.py
+src/django_ninja_problems/formatters.py
+src/django_ninja_problems/handlers.py
+src/django_ninja_problems/py.typed
+src/django_ninja_problems/registrar.py
+src/django_ninja_problems/schemas.py
+src/django_ninja_problems.egg-info/PKG-INFO
+src/django_ninja_problems.egg-info/SOURCES.txt
+src/django_ninja_problems.egg-info/dependency_links.txt
+src/django_ninja_problems.egg-info/requires.txt
+src/django_ninja_problems.egg-info/top_level.txt
+tests/test_problems.py

django_ninja_problems-0.1.0/src/django_ninja_problems.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

django_ninja_problems-0.1.0/src/django_ninja_problems.egg-info/requires.txt

@@ -0,0 +1,7 @@
+django>=4.2
+django-ninja>=1.0.0
+pydantic>=2.0.0
+
+[dev]
+pytest>=8.0.0
+pytest-django>=4.8.0

django_ninja_problems-0.1.0/src/django_ninja_problems.egg-info/top_level.txt

@@ -0,0 +1 @@
+django_ninja_problems

django_ninja_problems-0.1.0/tests/test_problems.py

@@ -0,0 +1,231 @@
+import pytest
+from django.core.exceptions import ObjectDoesNotExist, ValidationError as DjangoValidationError
+from django.db import IntegrityError
+from django.http import Http404
+from ninja import NinjaAPI, Schema
+from ninja.errors import AuthenticationError, HttpError
+from ninja.testing import TestClient
+
+from django_ninja_problems import (
+    BadRequestProblem,
+    ConflictProblem,
+    ForbiddenProblem,
+    NotFoundProblem,
+    ProblemException,
+    UnauthorizedProblem,
+    UnprocessableEntityProblem,
+    register_problem_handlers,
+)
+
+
+class CustomAuthException(Exception):
+    pass
+
+
+class SampleInput(Schema):
+    name: str
+    age: int
+
+
+def build_test_api(debug: bool = False) -> NinjaAPI:
+    api = NinjaAPI()
+    register_problem_handlers(
+        api,
+        debug=debug,
+        auth_exceptions=(CustomAuthException,),
+    )
+
+    @api.get("/problem-custom")
+    def get_custom_problem(request):
+        raise NotFoundProblem(detail="Custom item not found.")
+
+    @api.get("/problem-base")
+    def get_base_problem(request):
+        raise ProblemException(status=418, title="I'm a teapot", detail="Teapot exception")
+
+    @api.get("/http-error-str")
+    def get_http_error_str(request):
+        raise HttpError(403, "Access is denied.")
+
+    @api.get("/http-error-dict")
+    def get_http_error_dict(request):
+        raise HttpError(400, {"titulo": "Dado inválido", "texto": "Valor fora da faixa permitida."})
+
+    @api.get("/not-found-django")
+    def get_not_found_django(request):
+        raise Http404("Item not found.")
+
+    @api.get("/does-not-exist")
+    def get_does_not_exist(request):
+        raise ObjectDoesNotExist("Object was deleted.")
+
+    @api.post("/validation")
+    def post_validation(request, data: SampleInput):
+        return {"status": "ok"}
+
+    @api.get("/django-val-error")
+    def get_django_val_error(request):
+        raise DjangoValidationError({"name": ["Name is mandatory."]})
+
+    @api.get("/django-unique-error")
+    def get_django_unique_error(request):
+        raise DjangoValidationError({"email": [DjangoValidationError("Email already registered.", code="unique")]})
+
+    @api.get("/integrity-error")
+    def get_integrity_error(request):
+        raise IntegrityError("UNIQUE constraint failed: auth_user.username")
+
+    @api.get("/auth-error")
+    def get_auth_error(request):
+        raise AuthenticationError(401, "Token expired")
+
+    @api.get("/custom-auth-error")
+    def get_custom_auth_error(request):
+        raise CustomAuthException("Invalid OIDC Token")
+
+    @api.get("/server-error")
+    def get_server_error(request):
+        raise ZeroDivisionError("division by zero")
+
+    return api
+
+
+def test_problem_exception_subclass():
+    client = TestClient(build_test_api())
+    response = client.get("/problem-custom")
+    assert response.status_code == 404
+    assert response.headers["Content-Type"] == "application/problem+json"
+    data = response.json()
+    assert data["type"] == "about:blank"
+    assert data["title"] == "Not Found"
+    assert data["status"] == 404
+    assert data["detail"] == "Custom item not found."
+    assert data["instance"] == "/problem-custom"
+
+
+def test_problem_exception_base():
+    client = TestClient(build_test_api())
+    response = client.get("/problem-base")
+    assert response.status_code == 418
+    assert response.headers["Content-Type"] == "application/problem+json"
+    data = response.json()
+    assert data["title"] == "I'm a teapot"
+    assert data["status"] == 418
+    assert data["detail"] == "Teapot exception"
+
+
+def test_http_error_string():
+    client = TestClient(build_test_api())
+    response = client.get("/http-error-str")
+    assert response.status_code == 403
+    assert response.headers["Content-Type"] == "application/problem+json"
+    data = response.json()
+    assert data["title"] == "Forbidden"
+    assert data["status"] == 403
+    assert data["detail"] == "Access is denied."
+
+
+def test_http_error_dict():
+    client = TestClient(build_test_api())
+    response = client.get("/http-error-dict")
+    assert response.status_code == 400
+    data = response.json()
+    assert data["title"] == "Dado inválido"
+    assert data["detail"] == "Valor fora da faixa permitida."
+    assert data["status"] == 400
+
+
+def test_http_404_and_does_not_exist():
+    client = TestClient(build_test_api())
+    res_404 = client.get("/not-found-django")
+    assert res_404.status_code == 404
+    assert res_404.json()["title"] == "Not Found"
+    assert res_404.json()["detail"] == "Item not found."
+
+    res_dne = client.get("/does-not-exist")
+    assert res_dne.status_code == 404
+    assert res_dne.json()["title"] == "Not Found"
+    assert res_dne.json()["detail"] == "Object was deleted."
+
+
+def test_validation_error_422():
+    client = TestClient(build_test_api())
+    response = client.post("/validation", json={"name": "Alice", "age": "not-a-number"})
+    assert response.status_code == 422
+    assert response.headers["Content-Type"] == "application/problem+json"
+    data = response.json()
+    assert data["title"] == "Unprocessable Entity"
+    assert data["status"] == 422
+    assert "errors" in data
+    assert len(data["errors"]) > 0
+    assert any(err["field"].endswith("age") for err in data["errors"])
+
+
+def test_django_validation_error():
+    client = TestClient(build_test_api())
+    response = client.get("/django-val-error")
+    assert response.status_code == 400
+    data = response.json()
+    assert data["title"] == "Bad Request"
+    assert data["status"] == 400
+    assert any(err["field"] == "name" for err in data["errors"])
+
+
+def test_django_validation_unique_to_conflict():
+    client = TestClient(build_test_api())
+    response = client.get("/django-unique-error")
+    assert response.status_code == 409
+    data = response.json()
+    assert data["title"] == "Conflict"
+    assert data["status"] == 409
+    assert any(err["field"] == "email" for err in data["errors"])
+
+
+def test_integrity_error():
+    client = TestClient(build_test_api())
+    response = client.get("/integrity-error")
+    assert response.status_code == 409
+    data = response.json()
+    assert data["title"] == "Conflict"
+    assert data["status"] == 409
+    assert "already exists" in data["detail"]
+
+
+def test_authentication_error():
+    client = TestClient(build_test_api())
+    response = client.get("/auth-error")
+    assert response.status_code == 401
+    data = response.json()
+    assert data["title"] == "Unauthorized"
+    assert data["status"] == 401
+    assert data["detail"] == "Token expired"
+
+
+def test_custom_auth_exception():
+    client = TestClient(build_test_api())
+    response = client.get("/custom-auth-error")
+    assert response.status_code == 401
+    data = response.json()
+    assert data["title"] == "Unauthorized"
+    assert data["status"] == 401
+    assert data["detail"] == "Invalid OIDC Token"
+
+
+def test_unexpected_error_debug_false():
+    client = TestClient(build_test_api(debug=False))
+    response = client.get("/server-error")
+    assert response.status_code == 500
+    data = response.json()
+    assert data["title"] == "Internal Server Error"
+    assert data["status"] == 500
+    assert data["detail"] == "An unexpected error occurred while processing the request."
+
+
+def test_unexpected_error_debug_true():
+    client = TestClient(build_test_api(debug=True))
+    response = client.get("/server-error")
+    assert response.status_code == 500
+    data = response.json()
+    assert data["title"] == "Internal Server Error"
+    assert data["status"] == 500
+    assert "ZeroDivisionError" in data["detail"]