use std::sync::{Arc, Mutex};
use std::time::Duration;
use axum::Json;
use axum::Router;
use axum::extract::State;
use axum::routing::post;
use chrono::Utc;
use second_brain_api::alert;
use second_brain_api::health::Health;
use second_brain_core::config::AlertConfig;
type Received = Arc<Mutex<Vec<serde_json::Value>>>;
async fn receiver() -> (String, Received) {
let received: Received = Arc::default();
let app = Router::new()
.route(
"/hook",
post(
|State(r): State<Received>, Json(body): Json<serde_json::Value>| async move {
r.lock().unwrap().push(body);
},
),
)
.with_state(received.clone());
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
(format!("http://{addr}/hook"), received)
}
async fn wait_for(received: &Received, n: usize) {
for _ in 0..100 {
if received.lock().unwrap().len() >= n {
return;
}
tokio::time::sleep(Duration::from_millis(50)).await;
}
}
#[tokio::test]
async fn the_webhook_fires_once_per_state_change() {
let (url, received) = receiver().await;
let config = AlertConfig {
webhook_url: Some(url),
..AlertConfig::default()
};
let tx = alert::start(&config, "laptop".to_string()).expect("a webhook is set");
let now = Utc::now();
let health = Health::new(now, Some(tx));
let later = now + chrono::Duration::minutes(10);
health.ingest_failed("database is locked", now);
health.ingest_failed("database is locked", later);
health.ingested(None, later);
health.ingested(None, later);
wait_for(&received, 2).await;
tokio::time::sleep(Duration::from_millis(300)).await;
let bodies = received.lock().unwrap().clone();
assert_eq!(bodies.len(), 2, "{bodies:?}");
assert_eq!(bodies[0]["state"], "degraded");
assert_eq!(bodies[0]["machine"], "laptop");
assert!(
bodies[0]["reason"]
.as_str()
.unwrap()
.contains("database is locked")
);
assert!(bodies[0]["at"].is_string());
assert_eq!(bodies[1]["state"], "ok");
assert!(bodies[1]["reason"].is_null());
}
#[tokio::test]
async fn nothing_is_sent_without_a_webhook() {
assert!(alert::start(&AlertConfig::default(), "laptop".to_string()).is_none());
}
async fn flaky_receiver(failures: usize) -> (String, Received) {
let received: Received = Arc::default();
let attempts = Arc::new(Mutex::new(0usize));
let app = Router::new()
.route(
"/hook",
post(
move |State(r): State<Received>, Json(body): Json<serde_json::Value>| {
let attempts = attempts.clone();
async move {
let mut n = attempts.lock().unwrap();
*n += 1;
if *n <= failures {
return axum::http::StatusCode::SERVICE_UNAVAILABLE;
}
r.lock().unwrap().push(body);
axum::http::StatusCode::OK
}
},
),
)
.with_state(received.clone());
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
(format!("http://{addr}/hook"), received)
}
fn hooked(url: String) -> Health {
let config = AlertConfig {
webhook_url: Some(url),
..AlertConfig::default()
};
let tx = alert::start(&config, "laptop".to_string()).expect("a webhook is set");
Health::new(Utc::now(), Some(tx))
}
#[tokio::test]
async fn a_failed_post_is_retried_until_it_is_delivered() {
let (url, received) = flaky_receiver(1).await;
let health = hooked(url);
health.announce(Utc::now());
wait_for(&received, 1).await;
let bodies = received.lock().unwrap().clone();
assert_eq!(bodies.len(), 1, "{bodies:?}");
assert_eq!(bodies[0]["state"], "ok");
}
#[tokio::test]
async fn a_newer_state_replaces_one_still_being_retried() {
let (url, received) = flaky_receiver(2).await;
let now = Utc::now();
let health = hooked(url);
health.ingest_failed("database is locked", now);
health.ingest_failed("database is locked", now + chrono::Duration::minutes(10));
tokio::time::sleep(Duration::from_millis(200)).await;
health.ingested(None, now + chrono::Duration::minutes(11));
wait_for(&received, 1).await;
tokio::time::sleep(Duration::from_millis(1500)).await;
let bodies = received.lock().unwrap().clone();
assert_eq!(bodies.len(), 1, "{bodies:?}");
assert_eq!(bodies[0]["state"], "ok");
}
#[tokio::test]
async fn a_post_the_receiver_refuses_is_not_retried() {
let attempts = Arc::new(Mutex::new(0usize));
let counted = attempts.clone();
let app = Router::new().route(
"/hook",
post(move || {
let counted = counted.clone();
async move {
*counted.lock().unwrap() += 1;
axum::http::StatusCode::NOT_FOUND
}
}),
);
let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
let addr = listener.local_addr().unwrap();
tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
let health = hooked(format!("http://{addr}/hook"));
health.announce(Utc::now());
tokio::time::sleep(Duration::from_millis(2500)).await;
assert_eq!(*attempts.lock().unwrap(), 1);
}