pubky-homeserver 0.12.0

A Pubky homeserver implementation.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92

use super::super::app_state::AppState;
use crate::shared::{HttpResult, Z32Pubkey};
use axum::{
    extract::{Path, State},
    http::StatusCode,
    response::IntoResponse,
};

/// Disable a user account.
///
/// # Errors
///
/// - `400` if the pubkey is invalid.
/// - `404` if the user does not exist.
///
pub async fn disable_user(
    State(state): State<AppState>,
    Path(pubkey): Path<Z32Pubkey>,
) -> HttpResult<impl IntoResponse> {
    state.context.user_service.admin_disable(&pubkey.0).await?;
    Ok((StatusCode::OK, "Ok"))
}

/// Enable a user account.
///
/// # Errors
///
/// - `400` if the pubkey is invalid.
/// - `404` if the user does not exist.
///
pub async fn enable_user(
    State(state): State<AppState>,
    Path(pubkey): Path<Z32Pubkey>,
) -> HttpResult<impl IntoResponse> {
    state.context.user_service.admin_enable(&pubkey.0).await?;
    Ok((StatusCode::OK, "Ok"))
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    use super::super::super::app_state::AppState;
    use super::*;
    use crate::AppContext;
    use axum::routing::post;
    use axum::Router;
    use pubky_common::crypto::Keypair;

    #[tokio::test]
    #[pubky_test_utils::test]
    async fn test_disable_enable_user() {
        let context = AppContext::test().await;
        let pubkey = Keypair::random().public_key();

        // Create new user
        context.user_service.create(&pubkey).await.unwrap();

        // Check that the tenant is enabled
        let user = context.user_service.get(&pubkey).await.unwrap();
        assert!(!user.disabled);

        // Setup server
        let app_state = AppState::new(Arc::clone(&context));
        let router = Router::new()
            .route("/users/{pubkey}/disable", post(disable_user))
            .route("/users/{pubkey}/enable", post(enable_user))
            .with_state(app_state);

        // Disable the tenant
        let server = axum_test::TestServer::new(router).unwrap();
        let pubkey_path = pubkey.z32();
        let response = server
            .post(format!("/users/{}/disable", pubkey_path).as_str())
            .await;
        assert_eq!(response.status_code(), StatusCode::OK);

        // Check that the tenant is disabled
        let user = context.user_service.get(&pubkey).await.unwrap();
        assert!(user.disabled);

        // Enable the tenant again
        let response = server
            .post(format!("/users/{}/enable", pubkey_path).as_str())
            .await;
        assert_eq!(response.status_code(), StatusCode::OK);

        // Check that the tenant is enabled
        let user = context.user_service.get(&pubkey).await.unwrap();
        assert!(!user.disabled);
    }
}