second-brain-api 0.13.2

HTTP API server for second-brain: REST endpoints for recall, remember, and ingest
Documentation
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());
}

/// A receiver that answers 503 to its first `failures` posts.
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);
}