catalyst 0.2.9

A lightweight API testing tool
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

use std::fmt;

/// Unified error type for all Catalyst operations
#[derive(Debug)]
pub enum CatalystError {
    FileError(String),
    CommandError(crate::engine::commands::CommandError),
    HttpError(String),
    JsonError(String),
    ValidationError(String),
    ConfigError(String),
    VariableError(String),
    TestError(String),
    IoError(std::io::Error),
    SerdeError(serde_json::Error),
}

impl fmt::Display for CatalystError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            CatalystError::FileError(msg) => write!(f, "File operation failed: {msg}"),
            CatalystError::CommandError(err) => write!(f, "Command execution failed: {err}"),
            CatalystError::HttpError(msg) => write!(f, "HTTP request failed: {msg}"),
            CatalystError::JsonError(msg) => write!(f, "JSON processing failed: {msg}"),
            CatalystError::ValidationError(msg) => write!(f, "Validation failed: {msg}"),
            CatalystError::ConfigError(msg) => write!(f, "Configuration error: {msg}"),
            CatalystError::VariableError(msg) => write!(f, "Variable substitution failed: {msg}"),
            CatalystError::TestError(msg) => write!(f, "Test execution failed: {msg}"),
            CatalystError::IoError(err) => write!(f, "IO operation failed: {err}"),
            CatalystError::SerdeError(err) => write!(f, "JSON serialization/deserialization failed: {err}"),
        }
    }
}

impl std::error::Error for CatalystError {
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            CatalystError::CommandError(err) => Some(err),
            CatalystError::IoError(err) => Some(err),
            CatalystError::SerdeError(err) => Some(err),
            _ => None,
        }
    }
}

impl From<crate::engine::commands::CommandError> for CatalystError {
    fn from(err: crate::engine::commands::CommandError) -> Self {
        CatalystError::CommandError(err)
    }
}

impl From<std::io::Error> for CatalystError {
    fn from(err: std::io::Error) -> Self {
        CatalystError::IoError(err)
    }
}

impl From<serde_json::Error> for CatalystError {
    fn from(err: serde_json::Error) -> Self {
        CatalystError::SerdeError(err)
    }
}

/// Result type alias for Catalyst operations
pub type CatalystResult<T> = Result<T, CatalystError>;

impl CatalystError {
    /// Create a file error with context
    pub fn file_error(msg: impl Into<String>) -> Self {
        CatalystError::FileError(msg.into())
    }
    
    /// Create an HTTP error with context  
    pub fn http_error(msg: impl Into<String>) -> Self {
        CatalystError::HttpError(msg.into())
    }
    
    /// Create a JSON error with context
    pub fn json_error(msg: impl Into<String>) -> Self {
        CatalystError::JsonError(msg.into())
    }
    
    /// Create a validation error with context
    pub fn validation_error(msg: impl Into<String>) -> Self {
        CatalystError::ValidationError(msg.into())
    }
    
    /// Create a configuration error with context
    pub fn config_error(msg: impl Into<String>) -> Self {
        CatalystError::ConfigError(msg.into())
    }
    
    /// Create a variable substitution error with context
    pub fn variable_error(msg: impl Into<String>) -> Self {
        CatalystError::VariableError(msg.into())
    }
    
    /// Create a test execution error with context
    pub fn test_error(msg: impl Into<String>) -> Self {
        CatalystError::TestError(msg.into())
    }
}

/// Extension trait to convert string results to CatalystError
pub trait StringResultExt<T> {
    fn map_file_err(self) -> CatalystResult<T>;
    fn map_http_err(self) -> CatalystResult<T>;
    fn map_json_err(self) -> CatalystResult<T>;
    fn map_validation_err(self) -> CatalystResult<T>;
    fn map_config_err(self) -> CatalystResult<T>;
    fn map_variable_err(self) -> CatalystResult<T>;
    fn map_test_err(self) -> CatalystResult<T>;
}

impl<T> StringResultExt<T> for Result<T, String> {
    fn map_file_err(self) -> CatalystResult<T> {
        self.map_err(CatalystError::file_error)
    }
    
    fn map_http_err(self) -> CatalystResult<T> {
        self.map_err(CatalystError::http_error)
    }
    
    fn map_json_err(self) -> CatalystResult<T> {
        self.map_err(CatalystError::json_error)
    }
    
    fn map_validation_err(self) -> CatalystResult<T> {
        self.map_err(CatalystError::validation_error)
    }
    
    fn map_config_err(self) -> CatalystResult<T> {
        self.map_err(CatalystError::config_error)
    }
    
    fn map_variable_err(self) -> CatalystResult<T> {
        self.map_err(CatalystError::variable_error)
    }
    
    fn map_test_err(self) -> CatalystResult<T> {
        self.map_err(CatalystError::test_error)
    }
}