second-brain-api 0.13.4

HTTP API server for second-brain: REST endpoints for recall, remember, and ingest
Documentation
mod common;

use axum::http::StatusCode;
use second_brain_core::sqlite_store::SqliteStore;
use second_brain_sync::keyring::Keyring;
use serde_json::json;
use tower::ServiceExt;

use common::{app_in, get, json_body, post_json, upgrade_from_sync_key};

const SHARED_SYNC_KEY: [u8; 32] = [3; 32];
const NOW: i64 = 1_790_000_000_000_000;

#[tokio::test]
async fn a_device_is_listed_previewed_and_removed_through_the_daemon() {
    let local_dir = tempfile::tempdir().unwrap();
    let local = SqliteStore::in_memory("m".to_string()).unwrap();
    upgrade_from_sync_key(&local, local_dir.path(), SHARED_SYNC_KEY, &["p"]);
    let peer_dir = tempfile::tempdir().unwrap();
    let peer = SqliteStore::in_memory("p".to_string()).unwrap();
    upgrade_from_sync_key(&peer, peer_dir.path(), SHARED_SYNC_KEY, &["m"]);
    let from_peer = Keyring::load(&peer, peer_dir.path())
        .unwrap()
        .handshake_for("m", None)
        .unwrap();
    Keyring::load(&local, local_dir.path())
        .unwrap()
        .accept("p", &from_peer, NOW)
        .unwrap();
    let (app, _) = app_in(local, local_dir.path());

    let list = json_body(app.clone().oneshot(get("/v1/devices")).await.unwrap()).await;
    let devices = list["devices"].as_array().unwrap();
    assert_eq!(devices.len(), 2, "{list}");
    assert_eq!(devices[0]["machine_id"], "m");
    assert_eq!(devices[0]["this_device"], true);
    assert_eq!(devices[1]["machine_id"], "p");
    assert_eq!(devices[1]["revoked"], false);

    let preview = app
        .clone()
        .oneshot(post_json(
            "/v1/devices/remove",
            json!({"device": "p", "dry_run": true}),
        ))
        .await
        .unwrap();
    assert_eq!(preview.status(), StatusCode::OK);
    let preview = json_body(preview).await;
    assert_eq!(preview["revoked"][0]["machine_id"], "p", "{preview}");
    assert!(preview.get("epoch").is_none(), "{preview}");

    let changed = app
        .clone()
        .oneshot(post_json(
            "/v1/devices/remove",
            json!({"device": "p", "expected": ["p", "q"]}),
        ))
        .await
        .unwrap();
    assert_eq!(changed.status(), StatusCode::BAD_REQUEST);
    let changed = json_body(changed).await.to_string();
    assert!(changed.contains("run it again"), "{changed}");

    let removed = app
        .clone()
        .oneshot(post_json(
            "/v1/devices/remove",
            json!({"device": "p", "expected": ["p"]}),
        ))
        .await
        .unwrap();
    assert_eq!(removed.status(), StatusCode::OK);
    let removed = json_body(removed).await;
    assert_eq!(removed["epoch"], 2, "{removed}");
    assert_eq!(removed["revoked"][0]["revoked"], true, "{removed}");

    let list = json_body(app.clone().oneshot(get("/v1/devices")).await.unwrap()).await;
    assert_eq!(list["devices"][1]["revoked"], true, "{list}");

    for (body, expected) in [
        (json!({"device": "p"}), "already removed"),
        (json!({"device": "m"}), "can't remove itself"),
        (json!({"device": "nowhere"}), "no device named nowhere"),
        (
            json!({"device": "p", "keep": ["nowhere"]}),
            "no device named nowhere",
        ),
    ] {
        let refused = app
            .clone()
            .oneshot(post_json("/v1/devices/remove", body.clone()))
            .await
            .unwrap();
        assert_eq!(refused.status(), StatusCode::BAD_REQUEST, "{body}");
        let text = json_body(refused).await.to_string();
        assert!(text.contains(expected), "{body}: {text}");
    }
}