106 lines
3.3 KiB
Rust
106 lines
3.3 KiB
Rust
use super::*;
|
|
|
|
fn name() -> PeerName {
|
|
PeerName::parse("beta").unwrap()
|
|
}
|
|
|
|
/// Every peer failure reaches REST and MCP with the same class.
|
|
#[test]
|
|
fn mapping_table() {
|
|
let rows = [
|
|
(
|
|
PeerError::NotFound,
|
|
"not_found",
|
|
"peer beta: not found on peer",
|
|
),
|
|
(
|
|
PeerError::BadRequest("bad limit".into()),
|
|
"bad_request",
|
|
"peer beta: bad limit",
|
|
),
|
|
(
|
|
PeerError::Rejected,
|
|
"unavailable",
|
|
"peer beta: peer rejected credentials",
|
|
),
|
|
(PeerError::Timeout, "unavailable", "peer beta: timeout"),
|
|
(
|
|
PeerError::Unreachable,
|
|
"unavailable",
|
|
"peer beta: unreachable",
|
|
),
|
|
(PeerError::Dns, "unavailable", "peer beta: dns"),
|
|
(PeerError::Tls, "unavailable", "peer beta: tls_error"),
|
|
(PeerError::Http(502), "unavailable", "peer beta: http_502"),
|
|
(PeerError::Oversize, "unavailable", "peer beta: oversize"),
|
|
(PeerError::Saturated, "unavailable", "peer beta: saturated"),
|
|
(
|
|
PeerError::TokenFile("missing".into()),
|
|
"unavailable",
|
|
"peer beta: token_file",
|
|
),
|
|
(
|
|
PeerError::Malformed("not json".into()),
|
|
"internal",
|
|
"peer beta: malformed response",
|
|
),
|
|
];
|
|
for (err, code, message) in rows {
|
|
let app = peer_error_to_app(&name(), &err);
|
|
assert_eq!(app.code(), code, "{err:?}");
|
|
assert_eq!(app.message(), message, "{err:?}");
|
|
assert_ne!(
|
|
app.status(),
|
|
axum::http::StatusCode::UNAUTHORIZED,
|
|
"{err:?}"
|
|
);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn rejected_is_never_unauthorized() {
|
|
let app = peer_error_to_app(&name(), &PeerError::Rejected);
|
|
assert_eq!(app.status(), axum::http::StatusCode::SERVICE_UNAVAILABLE);
|
|
}
|
|
|
|
#[test]
|
|
fn token_file_detail_never_leaks() {
|
|
let app = peer_error_to_app(
|
|
&name(),
|
|
&PeerError::TokenFile("/run/credentials/secret".into()),
|
|
);
|
|
assert!(!format!("{app:?}").contains("/run/credentials"));
|
|
assert!(!app.message().contains("/run/credentials"));
|
|
}
|
|
|
|
#[test]
|
|
fn bad_request_class_string_drops_the_peer_message() {
|
|
let msg = "http://peer.example/path?token=abc";
|
|
let err = PeerError::BadRequest(msg.into());
|
|
assert_eq!(err.class_str(), "bad_request");
|
|
assert!(!err.class_str().contains("http://"));
|
|
assert!(!err.class_str().contains("token"));
|
|
let app = peer_error_to_app(&name(), &err);
|
|
assert_eq!(app.message(), format!("peer beta: {msg}"));
|
|
}
|
|
|
|
#[test]
|
|
fn peer_config_error_is_the_process_config_error() {
|
|
let err: PeerConfigError = crate::config::ConfigError::Invalid("peers".into());
|
|
assert!(matches!(err, crate::config::ConfigError::Invalid(_)));
|
|
}
|
|
|
|
#[test]
|
|
fn coarse_class() {
|
|
assert_eq!(PeerError::Rejected.class(), CheckClass::Unauthorized);
|
|
assert_eq!(PeerError::Timeout.class(), CheckClass::Timeout);
|
|
assert_eq!(PeerError::Dns.class(), CheckClass::Unreachable);
|
|
assert_eq!(PeerError::Saturated.class(), CheckClass::Unreachable);
|
|
assert_eq!(PeerError::Http(500).class(), CheckClass::HttpError);
|
|
assert_eq!(
|
|
PeerError::Malformed("x".into()).class(),
|
|
CheckClass::HttpError
|
|
);
|
|
assert_eq!(PeerError::Tls.class(), CheckClass::TlsError);
|
|
}
|