fastapi-errors-plus 0.6.0__tar.gz → 0.6.2__tar.gz

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/LICENSE

@@ -23,3 +23,4 @@ SOFTWARE.
 
 
 
+

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-errors-plus
-Version: 0.6.0
+Version: 0.6.2
 Summary: Universal library for documenting errors in FastAPI endpoints
 Author-email: Igor Selivanov <seligoroff@gmail.com>
 License: MIT
@@ -335,6 +335,102 @@ Any class implementing this protocol (through structural typing) can be used wit
 
 Both approaches work together — you can mix them in the same `Errors()` call!
 
+## Using Pydantic with ErrorDTO
+
+**Note:** Pydantic is **not required** to use this library. This section is for projects that already use Pydantic and want to integrate it with the ErrorDTO protocol.
+
+Since the library uses structural typing (Protocol), any class that implements the required attributes (`status_code`, `message`, `to_example()`) will work, including Pydantic models.
+
+### Simple Pydantic Model as ErrorDTO
+
+```python
+from pydantic import BaseModel, Field
+from fastapi_errors_plus import Errors
+from typing import Dict, Any
+
+class PydanticErrorDTO(BaseModel):
+    """Pydantic model implementing ErrorDTO Protocol."""
+    status_code: int = Field(..., ge=400, le=599, description="HTTP status code")
+    message: str = Field(..., min_length=1, description="Error message")
+    
+    def to_example(self) -> Dict[str, Any]:
+        """Generate example for OpenAPI."""
+        return {
+            self.message: {
+                "value": {"detail": self.message},
+            },
+        }
+
+# Usage
+notification_error = PydanticErrorDTO(
+    status_code=404,
+    message="Notification not found",
+)
+
+@router.delete(
+    "/{id}",
+    responses=Errors(notification_error),
+)
+def delete_item(id: int):
+    pass
+```
+
+**Benefits:**
+- Runtime validation through Pydantic
+- Type safety
+- Automatic field documentation
+- Works with ErrorDTO Protocol through structural typing
+
+### Complex ErrorDTO with Pydantic
+
+For errors with additional fields:
+
+```python
+from pydantic import BaseModel, Field
+from fastapi_errors_plus import Errors
+from typing import Dict, Any, Optional
+
+class DetailedErrorDTO(BaseModel):
+    """Pydantic model for errors with additional fields."""
+    status_code: int = Field(..., ge=400, le=599)
+    message: str = Field(..., min_length=1)
+    error_code: Optional[str] = Field(None, description="Internal error code")
+    timestamp: Optional[str] = Field(None, description="Error timestamp")
+    
+    def to_example(self) -> Dict[str, Any]:
+        """Generate example for OpenAPI."""
+        example = {"detail": self.message}
+        if self.error_code:
+            example["error_code"] = self.error_code
+        if self.timestamp:
+            example["timestamp"] = self.timestamp
+        
+        return {
+            self.message: {
+                "value": example,
+            },
+        }
+
+# Usage
+validation_error = DetailedErrorDTO(
+    status_code=422,
+    message="Validation failed",
+    error_code="VALIDATION_ERROR",
+    timestamp="2025-01-15T10:30:00Z",
+)
+```
+
+**When to use Pydantic with ErrorDTO:**
+- Your project already uses Pydantic extensively
+- You need runtime validation for error objects
+- You want automatic field documentation
+- You have complex error structures with multiple fields
+
+**When not to use Pydantic:**
+- Your project doesn't use Pydantic (use `BaseErrorDTO` or `StandardErrorDTO` instead)
+- You need simple error objects (dataclasses are sufficient)
+- You want to keep dependencies minimal
+
 ## Best Practice: Connecting Exceptions and ErrorDTO
 
 ### Problem

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/README.md

@@ -309,6 +309,102 @@ Any class implementing this protocol (through structural typing) can be used wit
 
 Both approaches work together — you can mix them in the same `Errors()` call!
 
+## Using Pydantic with ErrorDTO
+
+**Note:** Pydantic is **not required** to use this library. This section is for projects that already use Pydantic and want to integrate it with the ErrorDTO protocol.
+
+Since the library uses structural typing (Protocol), any class that implements the required attributes (`status_code`, `message`, `to_example()`) will work, including Pydantic models.
+
+### Simple Pydantic Model as ErrorDTO
+
+```python
+from pydantic import BaseModel, Field
+from fastapi_errors_plus import Errors
+from typing import Dict, Any
+
+class PydanticErrorDTO(BaseModel):
+    """Pydantic model implementing ErrorDTO Protocol."""
+    status_code: int = Field(..., ge=400, le=599, description="HTTP status code")
+    message: str = Field(..., min_length=1, description="Error message")
+    
+    def to_example(self) -> Dict[str, Any]:
+        """Generate example for OpenAPI."""
+        return {
+            self.message: {
+                "value": {"detail": self.message},
+            },
+        }
+
+# Usage
+notification_error = PydanticErrorDTO(
+    status_code=404,
+    message="Notification not found",
+)
+
+@router.delete(
+    "/{id}",
+    responses=Errors(notification_error),
+)
+def delete_item(id: int):
+    pass
+```
+
+**Benefits:**
+- Runtime validation through Pydantic
+- Type safety
+- Automatic field documentation
+- Works with ErrorDTO Protocol through structural typing
+
+### Complex ErrorDTO with Pydantic
+
+For errors with additional fields:
+
+```python
+from pydantic import BaseModel, Field
+from fastapi_errors_plus import Errors
+from typing import Dict, Any, Optional
+
+class DetailedErrorDTO(BaseModel):
+    """Pydantic model for errors with additional fields."""
+    status_code: int = Field(..., ge=400, le=599)
+    message: str = Field(..., min_length=1)
+    error_code: Optional[str] = Field(None, description="Internal error code")
+    timestamp: Optional[str] = Field(None, description="Error timestamp")
+    
+    def to_example(self) -> Dict[str, Any]:
+        """Generate example for OpenAPI."""
+        example = {"detail": self.message}
+        if self.error_code:
+            example["error_code"] = self.error_code
+        if self.timestamp:
+            example["timestamp"] = self.timestamp
+        
+        return {
+            self.message: {
+                "value": example,
+            },
+        }
+
+# Usage
+validation_error = DetailedErrorDTO(
+    status_code=422,
+    message="Validation failed",
+    error_code="VALIDATION_ERROR",
+    timestamp="2025-01-15T10:30:00Z",
+)
+```
+
+**When to use Pydantic with ErrorDTO:**
+- Your project already uses Pydantic extensively
+- You need runtime validation for error objects
+- You want automatic field documentation
+- You have complex error structures with multiple fields
+
+**When not to use Pydantic:**
+- Your project doesn't use Pydantic (use `BaseErrorDTO` or `StandardErrorDTO` instead)
+- You need simple error objects (dataclasses are sufficient)
+- You want to keep dependencies minimal
+
 ## Best Practice: Connecting Exceptions and ErrorDTO
 
 ### Problem

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/fastapi_errors_plus/__init__.py

@@ -10,5 +10,5 @@ __all__ = [
     "BaseErrorDTO",  # Base implementation (optional)
     "StandardErrorDTO",  # Extended implementation (optional)
 ]
-__version__ = "0.6.0"
+__version__ = "0.6.2"
 

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/fastapi_errors_plus/base.py

@@ -122,3 +122,4 @@ class StandardErrorDTO(BaseErrorDTO):
 
 
 
+

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/fastapi_errors_plus/errors.py

@@ -140,7 +140,7 @@ class Errors(Mapping):
         
         if add_422:
             self._add_standard_error(
-                status.HTTP_422_UNPROCESSABLE_ENTITY,
+                status.HTTP_422_UNPROCESSABLE_CONTENT,
                 "Validation Error",
                 {"detail": "Validation error"},
             )
@@ -239,7 +239,7 @@ class Errors(Mapping):
     STANDARD_DESCRIPTIONS = {
         status.HTTP_401_UNAUTHORIZED: "Unauthorized",
         status.HTTP_403_FORBIDDEN: "Forbidden",
-        status.HTTP_422_UNPROCESSABLE_ENTITY: "Validation Error",
+        status.HTTP_422_UNPROCESSABLE_CONTENT: "Validation Error",
         status.HTTP_500_INTERNAL_SERVER_ERROR: "Internal Server Error",
     }
     
@@ -263,7 +263,7 @@ class Errors(Mapping):
         standard_keys = {
             status.HTTP_401_UNAUTHORIZED: "StandardUnauthorized",
             status.HTTP_403_FORBIDDEN: "StandardForbidden",
-            status.HTTP_422_UNPROCESSABLE_ENTITY: "StandardValidationError",
+            status.HTTP_422_UNPROCESSABLE_CONTENT: "StandardValidationError",
             status.HTTP_500_INTERNAL_SERVER_ERROR: "StandardInternalServerError",
         }
         example_key = standard_keys.get(status_code, f"Standard{status_code}")

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/fastapi_errors_plus/protocol.py

@@ -50,3 +50,4 @@ class ErrorDTO(Protocol):
 
 
 
+

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/fastapi_errors_plus.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-errors-plus
-Version: 0.6.0
+Version: 0.6.2
 Summary: Universal library for documenting errors in FastAPI endpoints
 Author-email: Igor Selivanov <seligoroff@gmail.com>
 License: MIT
@@ -335,6 +335,102 @@ Any class implementing this protocol (through structural typing) can be used wit
 
 Both approaches work together — you can mix them in the same `Errors()` call!
 
+## Using Pydantic with ErrorDTO
+
+**Note:** Pydantic is **not required** to use this library. This section is for projects that already use Pydantic and want to integrate it with the ErrorDTO protocol.
+
+Since the library uses structural typing (Protocol), any class that implements the required attributes (`status_code`, `message`, `to_example()`) will work, including Pydantic models.
+
+### Simple Pydantic Model as ErrorDTO
+
+```python
+from pydantic import BaseModel, Field
+from fastapi_errors_plus import Errors
+from typing import Dict, Any
+
+class PydanticErrorDTO(BaseModel):
+    """Pydantic model implementing ErrorDTO Protocol."""
+    status_code: int = Field(..., ge=400, le=599, description="HTTP status code")
+    message: str = Field(..., min_length=1, description="Error message")
+    
+    def to_example(self) -> Dict[str, Any]:
+        """Generate example for OpenAPI."""
+        return {
+            self.message: {
+                "value": {"detail": self.message},
+            },
+        }
+
+# Usage
+notification_error = PydanticErrorDTO(
+    status_code=404,
+    message="Notification not found",
+)
+
+@router.delete(
+    "/{id}",
+    responses=Errors(notification_error),
+)
+def delete_item(id: int):
+    pass
+```
+
+**Benefits:**
+- Runtime validation through Pydantic
+- Type safety
+- Automatic field documentation
+- Works with ErrorDTO Protocol through structural typing
+
+### Complex ErrorDTO with Pydantic
+
+For errors with additional fields:
+
+```python
+from pydantic import BaseModel, Field
+from fastapi_errors_plus import Errors
+from typing import Dict, Any, Optional
+
+class DetailedErrorDTO(BaseModel):
+    """Pydantic model for errors with additional fields."""
+    status_code: int = Field(..., ge=400, le=599)
+    message: str = Field(..., min_length=1)
+    error_code: Optional[str] = Field(None, description="Internal error code")
+    timestamp: Optional[str] = Field(None, description="Error timestamp")
+    
+    def to_example(self) -> Dict[str, Any]:
+        """Generate example for OpenAPI."""
+        example = {"detail": self.message}
+        if self.error_code:
+            example["error_code"] = self.error_code
+        if self.timestamp:
+            example["timestamp"] = self.timestamp
+        
+        return {
+            self.message: {
+                "value": example,
+            },
+        }
+
+# Usage
+validation_error = DetailedErrorDTO(
+    status_code=422,
+    message="Validation failed",
+    error_code="VALIDATION_ERROR",
+    timestamp="2025-01-15T10:30:00Z",
+)
+```
+
+**When to use Pydantic with ErrorDTO:**
+- Your project already uses Pydantic extensively
+- You need runtime validation for error objects
+- You want automatic field documentation
+- You have complex error structures with multiple fields
+
+**When not to use Pydantic:**
+- Your project doesn't use Pydantic (use `BaseErrorDTO` or `StandardErrorDTO` instead)
+- You need simple error objects (dataclasses are sufficient)
+- You want to keep dependencies minimal
+
 ## Best Practice: Connecting Exceptions and ErrorDTO
 
 ### Problem

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "fastapi-errors-plus"
-version = "0.6.0"
+version = "0.6.2"
 description = "Universal library for documenting errors in FastAPI endpoints"
 readme = "README.md"
 requires-python = ">=3.8"
@@ -45,9 +45,23 @@ testpaths = ["tests"]
 python_files = "test_*.py"
 python_classes = "Test*"
 python_functions = "test_*"
+markers = [
+    "unit: Unit tests for individual components",
+    "integration: Integration tests with FastAPI application",
+]
+addopts = [
+    "--cov=fastapi_errors_plus",
+    "--cov-report=term-missing",
+    "--cov-report=html:tests/htmlcov",
+    "--cov-report=xml:tests/coverage.xml",
+    "--cov-branch",
+    "--cov-fail-under=80",
+    "-v",
+]
 
 [tool.coverage.run]
 source = ["fastapi_errors_plus"]
+data_file = "tests/.coverage"
 omit = [
     "*/tests/*",
     "*/__pycache__/*",

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/tests/test_app.py

@@ -1,5 +1,7 @@
 """Test FastAPI application for integration testing."""
 
+from typing import Dict, Any
+
 from fastapi import APIRouter, FastAPI, status
 from fastapi_errors_plus import BaseErrorDTO, Errors, StandardErrorDTO
 from tests.conftest import SimpleErrorDTO
@@ -11,6 +13,57 @@ app = FastAPI(title="Test API for fastapi-errors-plus")
 router = APIRouter()
 
 
+# Domain Exception pattern for testing (Best Practice example)
+class DomainException(Exception):
+    """Base exception implementing ErrorDTO protocol."""
+    status_code: int
+    message: str
+    
+    def to_example(self) -> Dict[str, Any]:
+        """Generate example for OpenAPI."""
+        return {
+            self.message: {
+                "value": {"detail": self.message},
+            },
+        }
+    
+    @classmethod
+    def for_openapi(cls):
+        """Returns instance for OpenAPI documentation."""
+        return cls()
+
+
+class MockItemNotFoundError(DomainException):
+    """Test item not found error."""
+    status_code = status.HTTP_404_NOT_FOUND
+    message = "Test item not found"
+    
+    def __init__(self, item_id: str = ""):
+        self.item_id = item_id
+        super().__init__(self.message)
+    
+    @classmethod
+    def for_openapi(cls):
+        """Returns instance for OpenAPI documentation."""
+        return cls(item_id="test_id")
+
+
+class MockItemAccessDeniedError(DomainException):
+    """Test item access denied error."""
+    status_code = status.HTTP_403_FORBIDDEN
+    message = "Test item access denied"
+    
+    def __init__(self, item_id: str = "", user_id: str = ""):
+        self.item_id = item_id
+        self.user_id = user_id
+        super().__init__(self.message)
+    
+    @classmethod
+    def for_openapi(cls):
+        """Returns instance for OpenAPI documentation."""
+        return cls(item_id="test_id", user_id="test_user")
+
+
 # Example 1: Standard flags only
 @router.get(
     "/standard-flags",
@@ -220,6 +273,20 @@ def create_item_mixed_base_dto(item_id: int):
     return {"message": f"Item {item_id} created"}
 
 
+# Example 11: Domain Exception as ErrorDTO (Best Practice pattern)
+@router.delete(
+    "/domain-exception/{item_id}",
+    responses=Errors(
+        MockItemNotFoundError.for_openapi(),      # Using for_openapi() pattern
+        MockItemAccessDeniedError.for_openapi(),  # Using for_openapi() pattern
+        unauthorized_401=True,                    # Standard flag
+    ),
+)
+def delete_item_domain_exception(item_id: str):
+    """Endpoint demonstrating Domain Exception as ErrorDTO pattern."""
+    return {"message": f"Item {item_id} deleted"}
+
+
 # Register router
 app.include_router(router, prefix="/api/v1", tags=["test"])
 

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/tests/test_base.py

@@ -6,6 +6,7 @@ from fastapi import status
 from fastapi_errors_plus import BaseErrorDTO, Errors, StandardErrorDTO
 
 
+@pytest.mark.unit
 class TestBaseErrorDTO:
     """Tests for BaseErrorDTO class."""
     
@@ -69,6 +70,7 @@ class TestBaseErrorDTO:
         assert examples["Item not found"]["value"] == {"detail": "Item not found"}
 
 
+@pytest.mark.unit
 class TestStandardErrorDTO:
     """Tests for StandardErrorDTO class."""
     
@@ -197,6 +199,7 @@ class TestStandardErrorDTO:
         assert "InvalidToken" in examples  # From StandardErrorDTO
 
 
+@pytest.mark.unit
 class TestBaseErrorDTOInheritance:
     """Tests for inheritance from BaseErrorDTO."""
     
@@ -254,6 +257,7 @@ class TestBaseErrorDTOInheritance:
         assert "Custom" in examples
 
 
+@pytest.mark.unit
 class TestBaseErrorDTOCompatibility:
     """Tests for compatibility with structural typing (Protocol)."""
     
@@ -304,3 +308,4 @@ class TestBaseErrorDTOCompatibility:
 
 
 
+

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/tests/test_errors.py

@@ -9,6 +9,7 @@ from fastapi_errors_plus import Errors
 from tests.conftest import SimpleErrorDTO
 
 
+@pytest.mark.unit
 class TestErrorsStandardFlags:
     """Tests for standard HTTP status flags."""
     
@@ -36,8 +37,8 @@ class TestErrorsStandardFlags:
         errors = Errors(validation_error=True)
         responses = errors
         
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses
-        assert responses[status.HTTP_422_UNPROCESSABLE_ENTITY]["description"] == "Validation Error"
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
+        assert responses[status.HTTP_422_UNPROCESSABLE_CONTENT]["description"] == "Validation Error"
     
     def test_internal_server_error_flag(self):
         """Test generation of 500 Internal Server Error from flag."""
@@ -68,8 +69,8 @@ class TestErrorsStandardFlags:
         errors = Errors(validation_error_422=True)
         responses = errors
         
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses
-        assert responses[status.HTTP_422_UNPROCESSABLE_ENTITY]["description"] == "Validation Error"
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
+        assert responses[status.HTTP_422_UNPROCESSABLE_CONTENT]["description"] == "Validation Error"
     
     def test_internal_server_error_500_flag(self):
         """Test generation of 500 Internal Server Error from explicit flag."""
@@ -108,7 +109,7 @@ class TestErrorsStandardFlags:
         
         assert status.HTTP_401_UNAUTHORIZED in responses
         assert status.HTTP_403_FORBIDDEN in responses
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
         assert status.HTTP_500_INTERNAL_SERVER_ERROR in responses
         assert len(responses) == 4
     
@@ -133,11 +134,12 @@ class TestErrorsStandardFlags:
         
         assert status.HTTP_401_UNAUTHORIZED in responses
         assert status.HTTP_403_FORBIDDEN in responses
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
         assert status.HTTP_500_INTERNAL_SERVER_ERROR in responses
         assert len(responses) == 4
 
 
+@pytest.mark.unit
 class TestErrorsDict:
     """Tests for dict-based errors."""
     
@@ -214,6 +216,7 @@ class TestErrorsDict:
         assert "SessionNotFound" in examples
 
 
+@pytest.mark.unit
 class TestErrorsErrorDTO:
     """Tests for ErrorDTO-based errors."""
     
@@ -240,6 +243,7 @@ class TestErrorsErrorDTO:
         assert len(responses) == 2
 
 
+@pytest.mark.unit
 class TestErrorsMergeExamples:
     """Tests for merging examples for the same status code."""
     
@@ -296,6 +300,7 @@ class TestErrorsMergeExamples:
         assert "examples" in content or "example" in content
 
 
+@pytest.mark.unit
 class TestErrorsMixed:
     """Tests for mixed usage (flags + dict + ErrorDTO)."""
     
@@ -327,6 +332,7 @@ class TestErrorsMixed:
         assert len(responses) == 4
 
 
+@pytest.mark.unit
 class TestErrorsEdgeCases:
     """Tests for edge cases."""
     
@@ -337,7 +343,7 @@ class TestErrorsEdgeCases:
         
         assert isinstance(responses, Mapping)
         # validation_error=True by default, so 422 should be present
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
         assert len(responses) == 1
     
     def test_validation_error_default_true(self):
@@ -345,15 +351,15 @@ class TestErrorsEdgeCases:
         errors = Errors()
         responses = errors
         
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses
-        assert responses[status.HTTP_422_UNPROCESSABLE_ENTITY]["description"] == "Validation Error"
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
+        assert responses[status.HTTP_422_UNPROCESSABLE_CONTENT]["description"] == "Validation Error"
     
     def test_validation_error_can_be_disabled(self):
         """Test that validation_error can be explicitly set to False."""
         errors = Errors(validation_error=False)
         responses = errors
         
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY not in responses
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT not in responses
         assert len(responses) == 0
     
     def test_validation_error_422_default_true(self):
@@ -361,28 +367,28 @@ class TestErrorsEdgeCases:
         errors = Errors()
         responses = errors
         
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
     
     def test_validation_error_422_can_be_disabled(self):
         """Test that validation_error_422 can be explicitly set to False."""
         errors = Errors(validation_error_422=False)
         responses = errors
         
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY not in responses
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT not in responses
     
     def test_validation_error_explicit_true_still_works(self):
         """Test that explicit validation_error=True still works (backward compatibility)."""
         errors = Errors(validation_error=True)
         responses = errors
         
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
     
     def test_validation_error_old_and_new_flags(self):
         """Test that both old and new validation_error flags work together."""
         errors = Errors(validation_error=False, validation_error_422=False)
         responses = errors
         
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY not in responses
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT not in responses
     
     def test_validation_error_with_other_errors(self):
         """Test validation_error=True by default with other errors."""
@@ -391,7 +397,7 @@ class TestErrorsEdgeCases:
         
         assert status.HTTP_401_UNAUTHORIZED in responses
         assert status.HTTP_403_FORBIDDEN in responses
-        assert status.HTTP_422_UNPROCESSABLE_ENTITY in responses  # Default True
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses  # Default True
         assert len(responses) == 3
     
     def test_no_flags_no_errors(self):
@@ -446,6 +452,7 @@ class TestErrorsEdgeCases:
         assert len(errors) == 1
 
 
+@pytest.mark.unit
 class TestUniqueKeys:
     """Tests for unique key generation to prevent collisions."""
     
@@ -522,6 +529,7 @@ class TestUniqueKeys:
         assert unique_key == "CustomExample_4"
 
 
+@pytest.mark.unit
 class TestErrorsValidation:
     """Tests for ErrorDTO validation."""
     
@@ -608,6 +616,7 @@ class TestErrorsValidation:
         assert "BadObject" in error_msg
 
 
+@pytest.mark.unit
 class TestDTODescriptionPriority:
     """Tests for DTO description priority over standard flags."""
     
@@ -654,3 +663,93 @@ class TestDTODescriptionPriority:
         # Dict description should be preserved (dict > DTO)
         assert errors[401]["description"] == "My Custom Description"
 
+
+@pytest.mark.unit
+class TestPydanticIntegration:
+    """Tests for Pydantic model integration with ErrorDTO Protocol.
+    
+    These tests are optional - they will be skipped if Pydantic is not installed.
+    This demonstrates that the library works with Pydantic models through structural typing,
+    but Pydantic is not a required dependency.
+    """
+    
+    def test_pydantic_model_as_error_dto(self):
+        """Test that Pydantic models work with ErrorDTO Protocol (with proper skip)."""
+        try:
+            from pydantic import BaseModel, Field
+            from typing import Dict, Any
+        except ImportError:
+            pytest.skip("Pydantic is not installed - this is expected and OK")
+        
+        class PydanticErrorDTO(BaseModel):
+            """Pydantic model implementing ErrorDTO Protocol."""
+            status_code: int = Field(..., ge=400, le=599)
+            message: str = Field(..., min_length=1)
+            
+            def to_example(self) -> Dict[str, Any]:
+                """Generate example for OpenAPI."""
+                return {
+                    self.message: {
+                        "value": {"detail": self.message},
+                    },
+                }
+        
+        # Create instance
+        error = PydanticErrorDTO(
+            status_code=404,
+            message="Not found",
+        )
+        
+        # Use with Errors class
+        errors = Errors(error, validation_error=False)
+        responses = errors
+        
+        assert status.HTTP_404_NOT_FOUND in responses
+        assert responses[status.HTTP_404_NOT_FOUND]["description"] == "Not found"
+    
+    def test_pydantic_model_with_additional_fields(self):
+        """Test Pydantic model with additional fields."""
+        try:
+            from pydantic import BaseModel, Field
+            from typing import Dict, Any, Optional
+        except ImportError:
+            pytest.skip("Pydantic is not installed - this is expected and OK")
+        
+        class DetailedErrorDTO(BaseModel):
+            """Pydantic model for errors with additional fields."""
+            status_code: int = Field(..., ge=400, le=599)
+            message: str = Field(..., min_length=1)
+            error_code: Optional[str] = Field(None, description="Internal error code")
+            
+            def to_example(self) -> Dict[str, Any]:
+                """Generate example for OpenAPI."""
+                example = {"detail": self.message}
+                if self.error_code:
+                    example["error_code"] = self.error_code
+                
+                return {
+                    self.message: {
+                        "value": example,
+                    },
+                }
+        
+        # Create instance
+        error = DetailedErrorDTO(
+            status_code=422,
+            message="Validation failed",
+            error_code="VALIDATION_ERROR",
+        )
+        
+        # Use with Errors class
+        errors = Errors(error, validation_error=False)
+        responses = errors
+        
+        assert status.HTTP_422_UNPROCESSABLE_CONTENT in responses
+        assert responses[status.HTTP_422_UNPROCESSABLE_CONTENT]["description"] == "Validation failed"
+        
+        # Check that error_code is in the example
+        examples = responses[status.HTTP_422_UNPROCESSABLE_CONTENT]["content"]["application/json"]["examples"]
+        example_value = examples["Validation failed"]["value"]
+        assert example_value["detail"] == "Validation failed"
+        assert example_value["error_code"] == "VALIDATION_ERROR"
+

{fastapi_errors_plus-0.6.0 → fastapi_errors_plus-0.6.2}/tests/test_integration.py

@@ -4,8 +4,10 @@ from fastapi import status
 from fastapi.testclient import TestClient
 
 from tests.test_app import app
+import pytest
 
 
+@pytest.mark.integration
 class TestOpenAPIGeneration:
     """Tests for OpenAPI specification generation."""
     
@@ -39,6 +41,7 @@ class TestOpenAPIGeneration:
         assert "/api/v1/mixed-base-dto/{item_id}" in paths
 
 
+@pytest.mark.integration
 class TestStandardFlagsEndpoint:
     """Tests for standard flags endpoint."""
     
@@ -71,6 +74,7 @@ class TestStandardFlagsEndpoint:
         assert "example" in error_401["content"]["application/json"]
 
 
+@pytest.mark.integration
 class TestDictErrorsEndpoint:
     """Tests for dict errors endpoint."""
     
@@ -100,6 +104,7 @@ class TestDictErrorsEndpoint:
         assert "application/json" in error_404["content"]
 
 
+@pytest.mark.integration
 class TestErrorDTOEndpoint:
     """Tests for ErrorDTO endpoint."""
     
@@ -129,6 +134,7 @@ class TestErrorDTOEndpoint:
         assert "examples" in error_404["content"]["application/json"]
 
 
+@pytest.mark.integration
 class TestMixedEndpoint:
     """Tests for mixed endpoint (flags + dict + ErrorDTO)."""
     
@@ -166,6 +172,7 @@ class TestMixedEndpoint:
         assert responses["409"]["description"] == "Conflict"
 
 
+@pytest.mark.integration
 class TestMergeExamplesEndpoint:
     """Tests for merge examples endpoint."""
     
@@ -187,6 +194,7 @@ class TestMergeExamplesEndpoint:
         assert "Error 2" in examples
 
 
+@pytest.mark.integration
 class TestEmptyErrorsEndpoint:
     """Tests for empty errors endpoint."""
     
@@ -206,6 +214,7 @@ class TestEmptyErrorsEndpoint:
         assert len(error_codes) == 0
 
 
+@pytest.mark.integration
 class TestMergeFlagDictEndpoint:
     """Tests for merge flag and dict endpoint."""
     
@@ -226,6 +235,7 @@ class TestMergeFlagDictEndpoint:
         assert "SessionNotFound" in examples
 
 
+@pytest.mark.integration
 class TestBaseErrorDTOEndpoint:
     """Tests for BaseErrorDTO endpoint."""
     
@@ -257,6 +267,7 @@ class TestBaseErrorDTOEndpoint:
         assert "Item not found" in examples
 
 
+@pytest.mark.integration
 class TestStandardErrorDTOEndpoint:
     """Tests for StandardErrorDTO endpoint."""
     
@@ -301,6 +312,7 @@ class TestStandardErrorDTOEndpoint:
         assert "RoleHasNoAccess" in examples
 
 
+@pytest.mark.integration
 class TestMixedBaseDTOEndpoint:
     """Tests for mixed BaseErrorDTO + StandardErrorDTO + flags endpoint."""
     
@@ -319,6 +331,95 @@ class TestMixedBaseDTOEndpoint:
         assert "500" in responses  # From flag
 
 
+@pytest.mark.integration
+class TestDomainExceptionEndpoint:
+    """Tests for Domain Exception as ErrorDTO endpoint (Best Practice pattern)."""
+    
+    def test_responses_in_openapi(self):
+        """Test that Domain Exception responses are in OpenAPI."""
+        client = TestClient(app)
+        response = client.get("/openapi.json")
+        schema = response.json()
+        
+        endpoint = schema["paths"]["/api/v1/domain-exception/{item_id}"]["delete"]
+        responses = endpoint["responses"]
+        
+        assert "401" in responses  # From flag
+        assert "403" in responses  # From MockItemAccessDeniedError.for_openapi()
+        assert "404" in responses  # From MockItemNotFoundError.for_openapi()
+    
+    def test_404_response_structure_from_domain_exception(self):
+        """Test 404 response structure from Domain Exception."""
+        client = TestClient(app)
+        response = client.get("/openapi.json")
+        schema = response.json()
+        
+        endpoint = schema["paths"]["/api/v1/domain-exception/{item_id}"]["delete"]
+        error_404 = endpoint["responses"]["404"]
+        
+        assert error_404["description"] == "Test item not found"
+        assert "content" in error_404
+        assert "application/json" in error_404["content"]
+        assert "examples" in error_404["content"]["application/json"]
+        examples = error_404["content"]["application/json"]["examples"]
+        assert "Test item not found" in examples
+    
+    def test_403_response_structure_from_domain_exception(self):
+        """Test 403 response structure from Domain Exception."""
+        client = TestClient(app)
+        response = client.get("/openapi.json")
+        schema = response.json()
+        
+        endpoint = schema["paths"]["/api/v1/domain-exception/{item_id}"]["delete"]
+        error_403 = endpoint["responses"]["403"]
+        
+        assert error_403["description"] == "Test item access denied"
+        assert "content" in error_403
+        assert "application/json" in error_403["content"]
+        assert "examples" in error_403["content"]["application/json"]
+        examples = error_403["content"]["application/json"]["examples"]
+        assert "Test item access denied" in examples
+    
+    def test_for_openapi_method_returns_error_dto(self):
+        """Test that for_openapi() method returns instance implementing ErrorDTO."""
+        from tests.test_app import MockItemNotFoundError
+        
+        error_instance = MockItemNotFoundError.for_openapi()
+        
+        # Check that it implements ErrorDTO protocol
+        assert hasattr(error_instance, "status_code")
+        assert hasattr(error_instance, "message")
+        assert hasattr(error_instance, "to_example")
+        assert callable(error_instance.to_example)
+        
+        # Check values
+        assert error_instance.status_code == 404
+        assert error_instance.message == "Test item not found"
+        assert error_instance.item_id == "test_id"
+        
+        # Check to_example() works
+        example = error_instance.to_example()
+        assert isinstance(example, dict)
+        assert "Test item not found" in example
+    
+    def test_domain_exception_works_with_errors_class(self):
+        """Test that Domain Exception instances work with Errors class."""
+        from fastapi_errors_plus import Errors
+        from tests.test_app import MockItemNotFoundError, MockItemAccessDeniedError
+        
+        errors = Errors(
+            MockItemNotFoundError.for_openapi(),
+            MockItemAccessDeniedError.for_openapi(),
+        )
+        responses = errors
+        
+        assert 404 in responses
+        assert 403 in responses
+        assert responses[404]["description"] == "Test item not found"
+        assert responses[403]["description"] == "Test item access denied"
+
+
+@pytest.mark.integration
 class TestRealEndpoints:
     """Tests for actual endpoint responses."""
     
@@ -361,5 +462,13 @@ class TestRealEndpoints:
         
         assert response.status_code == 200
         assert response.json() == {"message": "Item 1 deleted"}
+    
+    def test_domain_exception_endpoint_works(self):
+        """Test that Domain Exception endpoint returns 200."""
+        client = TestClient(app)
+        response = client.delete("/api/v1/domain-exception/1")
+        
+        assert response.status_code == 200
+        assert response.json() == {"message": "Item 1 deleted"}