webserver_colin_ugo/error/
mod.rs

1use std::fmt;
2use std::io;
3
4/// Type d'erreur personnalisé pour le serveur web
5#[derive(Debug)]
6pub enum ServerError {
7    /// Erreurs d'E/S pendant les opérations du serveur
8    IoError(io::Error),
9    /// Erreurs d'analyse HTTP
10    ParseError(String),
11    /// Erreurs de fichier non trouvé
12    NotFound(String),
13    /// Erreurs de méthode non autorisée
14    MethodNotAllowed(String),
15    /// Erreurs de serveur interne
16    InternalServerError(String),
17}
18
19impl fmt::Display for ServerError {
20    /// Affiche l'erreur dans un format lisible
21    ///
22    /// # Arguments
23    ///
24    /// * `f` - Un tampon de formatage pour écrire l'erreur.
25    ///
26    /// # Retourne
27    ///
28    /// * `fmt::Result` - Un résultat indiquant si l'écriture a réussi ou échoué.
29    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
30        match self {
31            ServerError::IoError(e) => write!(f, "Erreur d'E/S: {}", e),
32            ServerError::ParseError(s) => write!(f, "Erreur d'analyse: {}", s),
33            ServerError::NotFound(s) => write!(f, "Non trouvé: {}", s),
34            ServerError::MethodNotAllowed(s) => write!(f, "Méthode non autorisée: {}", s),
35            ServerError::InternalServerError(s) => write!(f, "Erreur interne du serveur: {}", s),
36        }
37    }
38}
39
40impl std::error::Error for ServerError {}
41
42impl From<io::Error> for ServerError {
43    /// Convertit une erreur d'E/S en erreur de serveur
44    ///
45    /// # Arguments
46    ///
47    /// * `error` - Une erreur d'E/S à convertir.
48    fn from(error: io::Error) -> Self {
49        ServerError::IoError(error)
50    }
51}
52
53#[cfg(test)]
54mod tests {
55    use super::*;
56    use std::error::Error;
57    use std::io;
58
59    #[test]
60    fn test_server_error_display() {
61        let errors = [
62            ServerError::ParseError("Invalid request".to_string()),
63            ServerError::NotFound("file.html".to_string()),
64            ServerError::MethodNotAllowed("POST".to_string()),
65            ServerError::InternalServerError("I/O error".to_string()),
66        ];
67
68        for error in errors.iter() {
69            let message = format!("{}", error);
70            assert!(!message.is_empty(), "Error message should not be empty");
71        }
72    }
73
74    #[test]
75    fn test_from_io_error() {
76        let io_error = io::Error::new(io::ErrorKind::NotFound, "file not found");
77        let server_error = ServerError::from(io_error);
78        
79        match server_error {
80            ServerError::IoError(_) => assert!(true),
81            _ => panic!("Expected ServerError::IoError"),
82        }
83    }
84
85    #[test]
86    fn test_error_trait() {
87        let error = ServerError::ParseError("Test error".to_string());
88        let _: &dyn Error = &error; // Vérifier que ServerError implémente Error
89    }
90}