Skip to main content

pyforge_django/
error.rs

1// Author: Abdulwahed Mansour
2//! Django-specific error types with mapping to Django's exception hierarchy.
3//!
4//! Uses pyforge-core's `FieldValidationError` for field-level errors.
5//! `DjangoError` wraps these with Django-specific variants.
6
7use pyforge::exceptions::{PyTypeError, PyValueError};
8use pyforge::PyErr;
9
10// Re-export from pyforge-core — single source of truth for field validation errors.
11pub use pyforge_core::error::FieldValidationError;
12
13/// Top-level error type for all pyforge-django operations.
14///
15/// Each variant maps directly to a Django exception class.
16#[derive(Debug, thiserror::Error)]
17pub enum DjangoError {
18    #[error("validation error on field '{field}': {message}")]
19    FieldValidation { field: String, message: String },
20
21    #[error("batch validation failed: {} field errors", .0.len())]
22    BatchValidation(Vec<FieldValidationError>),
23
24    #[error("serialization error on field '{field}': {message}")]
25    Serialization { field: String, message: String },
26
27    #[error("type conversion error: expected {expected}, got {actual}")]
28    TypeConversion { expected: String, actual: String },
29
30    #[error("field '{field}' is required but received null")]
31    NullField { field: String },
32
33    #[error("python error: {0}")]
34    Python(String),
35}
36
37impl From<DjangoError> for PyErr {
38    fn from(err: DjangoError) -> PyErr {
39        match &err {
40            DjangoError::FieldValidation { .. }
41            | DjangoError::BatchValidation(_)
42            | DjangoError::NullField { .. } => PyValueError::new_err(err.to_string()),
43            DjangoError::TypeConversion { .. } => PyTypeError::new_err(err.to_string()),
44            DjangoError::Serialization { .. } => PyValueError::new_err(err.to_string()),
45            DjangoError::Python(msg) => PyValueError::new_err(msg.clone()),
46        }
47    }
48}
49
50#[cfg(test)]
51mod tests {
52    use super::*;
53    use std::collections::HashMap;
54
55    #[test]
56    fn field_validation_error_formats_correctly() {
57        let err = DjangoError::FieldValidation {
58            field: "email".into(),
59            message: "Enter a valid email address".into(),
60        };
61        assert!(err.to_string().contains("email"));
62    }
63
64    #[test]
65    fn null_field_error_formats_correctly() {
66        let err = DjangoError::NullField {
67            field: "username".into(),
68        };
69        assert!(err.to_string().contains("username"));
70    }
71
72    #[test]
73    fn type_conversion_error_formats_correctly() {
74        let err = DjangoError::TypeConversion {
75            expected: "i64".into(),
76            actual: "str".into(),
77        };
78        let msg = err.to_string();
79        assert!(msg.contains("i64"));
80        assert!(msg.contains("str"));
81    }
82
83    #[test]
84    fn batch_validation_error_reports_count() {
85        let errors = vec![
86            FieldValidationError {
87                field_name: "age".into(),
88                message: "Must be positive".into(),
89                code: "min_value".into(),
90                params: HashMap::new(),
91            },
92            FieldValidationError {
93                field_name: "name".into(),
94                message: "Too long".into(),
95                code: "max_length".into(),
96                params: HashMap::from([("max_length".into(), "255".into())]),
97            },
98        ];
99        let err = DjangoError::BatchValidation(errors);
100        assert!(err.to_string().contains("2 field errors"));
101    }
102}