sqlrite/
error.rs

1use thiserror::Error;
2
3use std::result;
4
5use sqlparser::parser::ParserError;
6
7/// This is a type that encapsulated the `std::result` with the enum `SQLRiteError`
8/// and makes function signatures easier to read.
9pub type Result<T> = result::Result<T, SQLRiteError>;
10
11/// SQLRiteError is an enum with all the standardized errors available for returning
12///
13#[derive(Error, Debug)]
14pub enum SQLRiteError {
15    #[error("Not Implemented error: {0}")]
16    NotImplemented(String),
17    #[error("General error: {0}")]
18    General(String),
19    #[error("Internal error: {0}")]
20    Internal(String),
21    #[error("Unknown command error: {0}")]
22    UnknownCommand(String),
23    #[error("SQL error: {0:?}")]
24    SqlError(#[from] ParserError),
25    #[error("IO error: {0}")]
26    Io(#[from] std::io::Error),
27}
28
29// `std::io::Error` has no `PartialEq`, so we implement one by value-of-message.
30// Used by existing tests that compare error variants.
31impl PartialEq for SQLRiteError {
32    fn eq(&self, other: &Self) -> bool {
33        use SQLRiteError::*;
34        match (self, other) {
35            (NotImplemented(a), NotImplemented(b)) => a == b,
36            (General(a), General(b)) => a == b,
37            (Internal(a), Internal(b)) => a == b,
38            (UnknownCommand(a), UnknownCommand(b)) => a == b,
39            (SqlError(a), SqlError(b)) => format!("{a:?}") == format!("{b:?}"),
40            (Io(a), Io(b)) => a.kind() == b.kind() && a.to_string() == b.to_string(),
41            _ => false,
42        }
43    }
44}
45
46/// Returns SQLRiteError::General error from String
47#[allow(dead_code)]
48pub fn sqlrite_error(message: &str) -> SQLRiteError {
49    SQLRiteError::General(message.to_owned())
50}
51
52#[cfg(test)]
53mod tests {
54    use super::*;
55
56    #[test]
57    fn sqlrite_error_test() {
58        let input = String::from("test error");
59        let expected = SQLRiteError::General("test error".to_string());
60
61        let result = sqlrite_error(&input);
62        assert_eq!(result, expected);
63    }
64
65    #[test]
66    fn sqlrite_display_not_implemented_test() {
67        let error_string = String::from("Feature not implemented.");
68        let input = SQLRiteError::NotImplemented(error_string.clone());
69
70        let expected = format!("Not Implemented error: {}", error_string);
71        let result = format!("{}", input);
72        assert_eq!(result, expected);
73    }
74
75    #[test]
76    fn sqlrite_display_general_test() {
77        let error_string = String::from("General error.");
78        let input = SQLRiteError::General(error_string.clone());
79
80        let expected = format!("General error: {}", error_string);
81        let result = format!("{}", input);
82        assert_eq!(result, expected);
83    }
84
85    #[test]
86    fn sqlrite_display_internal_test() {
87        let error_string = String::from("Internet error.");
88        let input = SQLRiteError::Internal(error_string.clone());
89
90        let expected = format!("Internal error: {}", error_string);
91        let result = format!("{}", input);
92        assert_eq!(result, expected);
93    }
94
95    #[test]
96    fn sqlrite_display_sqlrite_test() {
97        let error_string = String::from("SQL error.");
98        let input = SQLRiteError::SqlError(ParserError::ParserError(error_string.clone()));
99
100        let expected = format!("SQL error: ParserError(\"{}\")", error_string);
101        let result = format!("{}", input);
102        assert_eq!(result, expected);
103    }
104
105    #[test]
106    fn sqlrite_unknown_test() {
107        let error_string = String::from("Unknown error.");
108        let input = SQLRiteError::UnknownCommand(error_string.clone());
109
110        let expected = format!("Unknown command error: {}", error_string);
111        let result = format!("{}", input);
112        assert_eq!(result, expected);
113    }
114}
sqlrite/error.rs

sqlrite/
error.rs
