use serde::{Deserialize, Serialize};
use std::fmt;
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, PartialOrd, Ord, Serialize, Deserialize)]
#[serde(transparent)]
pub struct PageStatus(u16);
impl PageStatus {
pub(crate) fn new(code: u16) -> Self {
Self(code)
}
pub fn code(self) -> u16 {
self.0
}
pub fn is_unknown(self) -> bool {
self.0 == 0
}
pub fn class(self) -> PageClass {
match self.0 {
200..=299 => PageClass::Ok,
400 => PageClass::BadRequest,
401 => PageClass::NeedsLogin,
403 => PageClass::Blocked,
404 => PageClass::NotFound,
429 => PageClass::TargetRateLimited,
500..=599 => PageClass::ServerError,
_ => PageClass::Other,
}
}
pub fn is_ok(self) -> bool {
matches!(self.class(), PageClass::Ok)
}
pub fn consumes_credits(self) -> bool {
!matches!(self.0, 500 | 503)
}
}
impl fmt::Display for PageStatus {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "target status {}", self.0)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub enum PageClass {
Ok,
BadRequest,
NeedsLogin,
Blocked,
NotFound,
TargetRateLimited,
ServerError,
Other,
}
impl PageClass {
pub fn is_retryable(self) -> bool {
matches!(
self,
PageClass::Blocked | PageClass::TargetRateLimited | PageClass::ServerError
)
}
}
#[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_the_codes_it_promises() {
let cases = [
(200u16, PageClass::Ok),
(201, PageClass::Ok),
(299, PageClass::Ok),
(400, PageClass::BadRequest),
(401, PageClass::NeedsLogin),
(403, PageClass::Blocked),
(404, PageClass::NotFound),
(429, PageClass::TargetRateLimited),
(500, PageClass::ServerError),
(502, PageClass::ServerError),
(503, PageClass::ServerError),
(504, PageClass::ServerError),
(526, PageClass::ServerError),
(599, PageClass::ServerError),
(301, PageClass::Other),
(999, PageClass::Other),
];
for (code, class) in cases {
assert_eq!(PageStatus::new(code).class(), class, "code {code}");
}
}
#[test]
fn only_target_500_and_503_are_free() {
assert!(!PageStatus::new(500).consumes_credits());
assert!(!PageStatus::new(503).consumes_credits());
for code in [200u16, 400, 401, 403, 404, 429, 502, 504, 526, 999] {
assert!(
PageStatus::new(code).consumes_credits(),
"code {code} should be billed"
);
}
for code in 100u16..=1000 {
let free = !PageStatus::new(code).consumes_credits();
assert_eq!(free, code == 500 || code == 503, "code {code}");
}
}
#[test]
fn display_names_the_target_plane() {
assert_eq!(PageStatus::new(403).to_string(), "target status 403");
}
#[test]
fn the_two_planes_print_differently_for_the_same_number() {
let api = crate::status::ApiStatus::new(403).to_string();
let page = PageStatus::new(403).to_string();
assert_ne!(api, page);
}
#[test]
fn the_two_planes_are_distinct_types() {
use std::any::TypeId;
assert_ne!(
TypeId::of::<PageStatus>(),
TypeId::of::<crate::status::ApiStatus>()
);
assert_ne!(TypeId::of::<PageStatus>(), TypeId::of::<u16>());
assert_ne!(
TypeId::of::<crate::status::ApiStatus>(),
TypeId::of::<u16>()
);
}
#[test]
fn deserializes_transparently_from_a_body() {
let status: PageStatus = serde_json::from_str("403").expect("a bare number");
assert_eq!(status.code(), 403);
assert_eq!(serde_json::to_string(&status).expect("serialize"), "403");
}
#[test]
fn retryable_covers_the_target_five_hundreds() {
assert!(PageStatus::new(502).class().is_retryable());
assert!(PageStatus::new(526).class().is_retryable());
assert!(!PageStatus::new(404).class().is_retryable());
}
}