sz_rust_core/middleware/
order.rs1use std::fmt;
32
33#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
38pub enum MiddlewareKind {
39 Trace,
43 Cors,
47 Log,
51 RateLimit,
55 Auth,
59}
60
61impl MiddlewareKind {
62 pub fn as_str(self) -> &'static str {
64 match self {
65 MiddlewareKind::Trace => "trace",
66 MiddlewareKind::Cors => "cors",
67 MiddlewareKind::Log => "log",
68 MiddlewareKind::RateLimit => "rate_limit",
69 MiddlewareKind::Auth => "auth",
70 }
71 }
72
73 pub fn php_counterpart(self) -> &'static str {
75 match self {
76 MiddlewareKind::Trace => "\\think\\middleware\\SessionInit",
77 MiddlewareKind::Cors => "\\think\\middleware\\AllowCrossDomain",
78 MiddlewareKind::Log => "(none, sz-rust 自研,对齐 think-logger)",
79 MiddlewareKind::RateLimit => "(none, sz-rust 自研)",
80 MiddlewareKind::Auth => "app\\<app>\\middleware\\Auth",
81 }
82 }
83}
84
85impl fmt::Display for MiddlewareKind {
86 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
87 f.write_str(self.as_str())
88 }
89}
90
91pub const DEFAULT_ORDER: &[MiddlewareKind] = &[
109 MiddlewareKind::Trace,
110 MiddlewareKind::Cors,
111 MiddlewareKind::Log,
112 MiddlewareKind::RateLimit,
113 MiddlewareKind::Auth,
114];
115
116pub const PHP_GLOBAL_ORDER: &[MiddlewareKind] = &[MiddlewareKind::Trace, MiddlewareKind::Cors];
125
126#[cfg(test)]
127mod tests {
128 use super::*;
129
130 #[test]
135 fn test_middleware_kind_as_str() {
136 assert_eq!(MiddlewareKind::Trace.as_str(), "trace");
137 assert_eq!(MiddlewareKind::Cors.as_str(), "cors");
138 assert_eq!(MiddlewareKind::Log.as_str(), "log");
139 assert_eq!(MiddlewareKind::RateLimit.as_str(), "rate_limit");
140 assert_eq!(MiddlewareKind::Auth.as_str(), "auth");
141 }
142
143 #[test]
144 fn test_middleware_kind_display() {
145 assert_eq!(MiddlewareKind::Trace.to_string(), "trace");
146 assert_eq!(MiddlewareKind::Cors.to_string(), "cors");
147 assert_eq!(MiddlewareKind::Log.to_string(), "log");
148 assert_eq!(MiddlewareKind::RateLimit.to_string(), "rate_limit");
149 assert_eq!(MiddlewareKind::Auth.to_string(), "auth");
150 }
151
152 #[test]
153 fn test_middleware_kind_php_counterpart() {
154 assert_eq!(
156 MiddlewareKind::Trace.php_counterpart(),
157 "\\think\\middleware\\SessionInit"
158 );
159 assert_eq!(
160 MiddlewareKind::Cors.php_counterpart(),
161 "\\think\\middleware\\AllowCrossDomain"
162 );
163 assert_eq!(
164 MiddlewareKind::Auth.php_counterpart(),
165 "app\\<app>\\middleware\\Auth"
166 );
167 }
168
169 #[test]
170 fn test_middleware_kind_eq_hash() {
171 use std::collections::HashSet;
173 let set: HashSet<MiddlewareKind> = [
174 MiddlewareKind::Trace,
175 MiddlewareKind::Cors,
176 MiddlewareKind::Trace,
177 ]
178 .into_iter()
179 .collect();
180 assert_eq!(set.len(), 2);
181 assert!(set.contains(&MiddlewareKind::Trace));
182 assert!(set.contains(&MiddlewareKind::Cors));
183 assert!(!set.contains(&MiddlewareKind::Auth));
184 }
185
186 #[test]
187 fn test_middleware_kind_clone_copy() {
188 let kind = MiddlewareKind::Cors;
189 let cloned = kind; assert_eq!(kind, cloned);
191 }
192
193 #[test]
198 fn test_default_order_length() {
199 assert_eq!(DEFAULT_ORDER.len(), 5);
200 }
201
202 #[test]
203 fn test_default_order_trace_first() {
204 assert_eq!(DEFAULT_ORDER.first(), Some(&MiddlewareKind::Trace));
206 }
207
208 #[test]
209 fn test_default_order_auth_last() {
210 assert_eq!(DEFAULT_ORDER.last(), Some(&MiddlewareKind::Auth));
212 }
213
214 #[test]
215 fn test_default_order_cors_before_log() {
216 let cors_idx = DEFAULT_ORDER
218 .iter()
219 .position(|k| *k == MiddlewareKind::Cors)
220 .expect("Cors must be in DEFAULT_ORDER");
221 let log_idx = DEFAULT_ORDER
222 .iter()
223 .position(|k| *k == MiddlewareKind::Log)
224 .expect("Log must be in DEFAULT_ORDER");
225 assert!(cors_idx < log_idx, "Cors must execute before Log");
226 }
227
228 #[test]
229 fn test_default_order_rate_limit_before_auth() {
230 let rate_limit_idx = DEFAULT_ORDER
232 .iter()
233 .position(|k| *k == MiddlewareKind::RateLimit)
234 .expect("RateLimit must be in DEFAULT_ORDER");
235 let auth_idx = DEFAULT_ORDER
236 .iter()
237 .position(|k| *k == MiddlewareKind::Auth)
238 .expect("Auth must be in DEFAULT_ORDER");
239 assert!(
240 rate_limit_idx < auth_idx,
241 "RateLimit must execute before Auth"
242 );
243 }
244
245 #[test]
246 fn test_default_order_no_duplicates() {
247 use std::collections::HashSet;
249 let set: HashSet<MiddlewareKind> = DEFAULT_ORDER.iter().copied().collect();
250 assert_eq!(
251 set.len(),
252 DEFAULT_ORDER.len(),
253 "DEFAULT_ORDER has duplicates"
254 );
255 }
256
257 #[test]
258 fn test_default_order_contains_all_kinds() {
259 for kind in [
261 MiddlewareKind::Trace,
262 MiddlewareKind::Cors,
263 MiddlewareKind::Log,
264 MiddlewareKind::RateLimit,
265 MiddlewareKind::Auth,
266 ] {
267 assert!(
268 DEFAULT_ORDER.contains(&kind),
269 "DEFAULT_ORDER missing {kind}"
270 );
271 }
272 }
273
274 #[test]
279 fn test_php_global_order_length() {
280 assert_eq!(PHP_GLOBAL_ORDER.len(), 2);
282 }
283
284 #[test]
285 fn test_php_global_order_matches_php_app_middleware() {
286 assert_eq!(PHP_GLOBAL_ORDER[0], MiddlewareKind::Trace); assert_eq!(PHP_GLOBAL_ORDER[1], MiddlewareKind::Cors); }
292
293 #[test]
294 fn test_php_global_order_is_prefix_of_default() {
295 assert!(DEFAULT_ORDER.starts_with(PHP_GLOBAL_ORDER));
298 }
299}