use std::fmt;
use std::time::Duration;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, serde::Serialize)]
#[serde(transparent)]
pub struct ApiStatus(u16);
pub(crate) const TRANSIENT: [u16; 5] = [408, 500, 502, 503, 504];
impl ApiStatus {
pub(crate) fn new(code: u16) -> Self {
Self(code)
}
pub fn code(self) -> u16 {
self.0
}
pub fn class(self) -> ApiClass {
self.class_with_retry_after(None)
}
pub fn class_with_retry_after(self, retry_after: Option<Duration>) -> ApiClass {
match self.0 {
200 => ApiClass::Ok,
204 => ApiClass::NoContent,
400 => ApiClass::BadRequest,
401 => ApiClass::Unauthorized,
402 => ApiClass::InsufficientCredits,
413 => ApiClass::PayloadTooLarge,
429 => ApiClass::RateLimited { retry_after },
500 => ApiClass::ServerError,
408 | 502 | 503 | 504 => ApiClass::Draining { retry_after },
_ => ApiClass::Other,
}
}
pub fn is_transient(self) -> bool {
TRANSIENT.contains(&self.0)
}
pub fn is_success(self) -> bool {
(200..300).contains(&self.0)
}
}
impl fmt::Display for ApiStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "api status {}", self.0)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum ApiClass {
Ok,
NoContent,
BadRequest,
Unauthorized,
InsufficientCredits,
PayloadTooLarge,
RateLimited {
retry_after: Option<Duration>,
},
ServerError,
Draining {
retry_after: Option<Duration>,
},
Other,
}
#[cfg(test)]
mod tests {
#![allow(
clippy::unwrap_used,
clippy::expect_used,
clippy::panic,
clippy::unreachable,
clippy::indexing_slicing,
clippy::string_slice
)]
use super::*;
#[test]
fn maps_every_documented_code() {
let cases = [
(200u16, ApiClass::Ok),
(204, ApiClass::NoContent),
(400, ApiClass::BadRequest),
(401, ApiClass::Unauthorized),
(402, ApiClass::InsufficientCredits),
(413, ApiClass::PayloadTooLarge),
(429, ApiClass::RateLimited { retry_after: None }),
(500, ApiClass::ServerError),
(503, ApiClass::Draining { retry_after: None }),
(408, ApiClass::Draining { retry_after: None }),
(502, ApiClass::Draining { retry_after: None }),
(504, ApiClass::Draining { retry_after: None }),
];
for (code, class) in cases {
assert_eq!(ApiStatus::new(code).class(), class, "code {code}");
}
assert_eq!(ApiStatus::new(418).class(), ApiClass::Other);
}
#[test]
fn retry_after_rides_along_when_a_header_supplied_it() {
let wait = Some(Duration::from_secs(7));
assert_eq!(
ApiStatus::new(429).class_with_retry_after(wait),
ApiClass::RateLimited { retry_after: wait }
);
assert_eq!(
ApiStatus::new(503).class_with_retry_after(wait),
ApiClass::Draining { retry_after: wait }
);
assert_eq!(
ApiStatus::new(502).class_with_retry_after(wait),
ApiClass::Draining { retry_after: wait }
);
}
#[test]
fn display_names_the_call_plane() {
assert_eq!(ApiStatus::new(403).to_string(), "api status 403");
}
#[test]
fn code_round_trips() {
assert_eq!(ApiStatus::new(204).code(), 204);
assert!(ApiStatus::new(204).is_success());
assert!(!ApiStatus::new(500).is_success());
}
}