tranquil-pds/tests/server.rs

mod common;
use common::*;

use reqwest::StatusCode;
use serde_json::{Value, json};

#[tokio::test]
async fn test_health() {
    let client = client();
    let res = client
        .get(format!("{}/health", base_url().await))
        .send()
        .await
        .expect("Failed to send request");

    assert_eq!(res.status(), StatusCode::OK);
    assert_eq!(res.text().await.unwrap(), "OK");
}

#[tokio::test]
async fn test_describe_server() {
    let client = client();
    let res = client
        .get(format!(
            "{}/xrpc/com.atproto.server.describeServer",
            base_url().await
        ))
        .send()
        .await
        .expect("Failed to send request");

    assert_eq!(res.status(), StatusCode::OK);
    let body: Value = res.json().await.expect("Response was not valid JSON");
    assert!(body.get("availableUserDomains").is_some());
}

#[tokio::test]
async fn test_create_session() {
    let client = client();

    let handle = format!("user_{}", uuid::Uuid::new_v4());
    let payload = json!({
        "handle": handle,
        "email": format!("{}@example.com", handle),
        "password": "password"
    });
    let _ = client
        .post(format!(
            "{}/xrpc/com.atproto.server.createAccount",
            base_url().await
        ))
        .json(&payload)
        .send()
        .await;

    let payload = json!({
        "identifier": handle,
        "password": "password"
    });

    let res = client
        .post(format!(
            "{}/xrpc/com.atproto.server.createSession",
            base_url().await
        ))
        .json(&payload)
        .send()
        .await
        .expect("Failed to send request");

    assert_eq!(res.status(), StatusCode::OK);
    let body: Value = res.json().await.expect("Response was not valid JSON");
    assert!(body.get("accessJwt").is_some());
}

#[tokio::test]
async fn test_create_session_missing_identifier() {
    let client = client();
    let payload = json!({
        "password": "password"
    });

    let res = client
        .post(format!(
            "{}/xrpc/com.atproto.server.createSession",
            base_url().await
        ))
        .json(&payload)
        .send()
        .await
        .expect("Failed to send request");

    assert!(
        res.status() == StatusCode::BAD_REQUEST || res.status() == StatusCode::UNPROCESSABLE_ENTITY,
        "Expected 400 or 422 for missing identifier, got {}",
        res.status()
    );
}

#[tokio::test]
async fn test_create_account_invalid_handle() {
    let client = client();
    let payload = json!({
        "handle": "invalid!handle.com",
        "email": "test@example.com",
        "password": "password"
    });

    let res = client
        .post(format!(
            "{}/xrpc/com.atproto.server.createAccount",
            base_url().await
        ))
        .json(&payload)
        .send()
        .await
        .expect("Failed to send request");

    assert_eq!(
        res.status(),
        StatusCode::BAD_REQUEST,
        "Expected 400 for invalid handle chars"
    );
}

#[tokio::test]
async fn test_get_session() {
    let client = client();
    let res = client
        .get(format!(
            "{}/xrpc/com.atproto.server.getSession",
            base_url().await
        ))
        .bearer_auth(AUTH_TOKEN)
        .send()
        .await
        .expect("Failed to send request");

    assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
}

#[tokio::test]
async fn test_refresh_session() {
    let client = client();

    let handle = format!("refresh_user_{}", uuid::Uuid::new_v4());
    let payload = json!({
        "handle": handle,
        "email": format!("{}@example.com", handle),
        "password": "password"
    });
    let _ = client
        .post(format!(
            "{}/xrpc/com.atproto.server.createAccount",
            base_url().await
        ))
        .json(&payload)
        .send()
        .await;

    let login_payload = json!({
        "identifier": handle,
        "password": "password"
    });
    let res = client
        .post(format!(
            "{}/xrpc/com.atproto.server.createSession",
            base_url().await
        ))
        .json(&login_payload)
        .send()
        .await
        .expect("Failed to login");

    assert_eq!(res.status(), StatusCode::OK);
    let body: Value = res.json().await.expect("Invalid JSON");
    let refresh_jwt = body["refreshJwt"]
        .as_str()
        .expect("No refreshJwt")
        .to_string();
    let access_jwt = body["accessJwt"]
        .as_str()
        .expect("No accessJwt")
        .to_string();

    let res = client
        .post(format!(
            "{}/xrpc/com.atproto.server.refreshSession",
            base_url().await
        ))
        .bearer_auth(&refresh_jwt)
        .send()
        .await
        .expect("Failed to refresh");

    assert_eq!(res.status(), StatusCode::OK);
    let body: Value = res.json().await.expect("Invalid JSON");
    assert!(body["accessJwt"].as_str().is_some());
    assert!(body["refreshJwt"].as_str().is_some());
    assert_ne!(body["accessJwt"].as_str().unwrap(), access_jwt);
    assert_ne!(body["refreshJwt"].as_str().unwrap(), refresh_jwt);
}

#[tokio::test]
async fn test_delete_session() {
    let client = client();
    let res = client
        .post(format!(
            "{}/xrpc/com.atproto.server.deleteSession",
            base_url().await
        ))
        .bearer_auth(AUTH_TOKEN)
        .send()
        .await
        .expect("Failed to send request");

    assert_eq!(res.status(), StatusCode::UNAUTHORIZED);
}