atrg-testing 0.1.3

Test utilities for at-rust-go applications
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
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Test application builder — in-memory everything, no network.

use atrg_auth::session;
use atrg_core::config::{AppConfig, AuthConfig, Config, DatabaseConfig};
use atrg_core::state::AppState;
use atrg_db::DbPool;
use std::sync::Arc;

/// Build a test [`AppState`] backed by in-memory SQLite.
///
/// Migrations are applied automatically. No outbound network calls are made.
pub async fn test_state() -> AppState {
    let db = atrg_db::connect("sqlite::memory:").await.expect("test db");
    atrg_db::run_internal_migrations(&db)
        .await
        .expect("migrations");

    let config = Config {
        app: AppConfig {
            name: "test-app".into(),
            host: "127.0.0.1".into(),
            port: 3000,
            secret_key: "test-secret-key-at-least-32-chars!!".into(),
            cors_origins: vec![],
            environment: "development".into(),
        },
        auth: AuthConfig {
            client_id: "http://localhost:3000/client-metadata.json".into(),
            redirect_uri: "http://localhost:3000/auth/callback".into(),
            scope: "atproto transition:generic".into(),
            post_login_redirect: "/".into(),
        },
        database: DatabaseConfig {
            url: "sqlite::memory:".into(),
        },
        jetstream: None,
        firehose: None,
        feed_generator: None,
        labeler: None,
        rate_limit: None,
    };

    AppState {
        config: Arc::new(config),
        db,
        http: reqwest::Client::new(),
        identity: Arc::new(atrg_identity::IdentityResolver::with_defaults(
            reqwest::Client::new(),
        )),
    }
}

/// Build a test [`AppState`] and an [`atrg_core::AtrgApp`] ready for `oneshot` testing.
pub async fn test_app() -> (atrg_core::AtrgApp, AppState) {
    let state = test_state().await;
    let app = atrg_core::AtrgApp::new();
    (app, state)
}

/// Seed a session into the test database for a given user.
///
/// Returns the session ID that can be used in `Authorization: Bearer <id>`
/// or `Cookie: atrg_session=<id>` headers.
pub async fn seed_session(pool: &DbPool, did: &str, handle: &str) -> String {
    let session_id = session::generate_session_id();
    let expires = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .expect("system clock before UNIX epoch")
        .as_secs() as i64
        + 86400; // 24 hours

    session::create_session(
        pool,
        &session_id,
        did,
        handle,
        "test_access_token",
        Some("test_refresh_token"),
        expires,
    )
    .await
    .expect("seed session");

    session_id
}

#[cfg(test)]
mod tests {
    use super::*;

    #[tokio::test]
    async fn test_state_works() {
        let state = test_state().await;
        assert_eq!(state.config.app.name, "test-app");
    }

    #[tokio::test]
    async fn test_app_works() {
        let (_app, state) = test_app().await;
        assert_eq!(state.config.app.name, "test-app");
    }

    #[tokio::test]
    async fn seed_and_find_session() {
        let state = test_state().await;
        let sid = seed_session(&state.db, "did:plc:test", "test.user").await;
        assert!(!sid.is_empty());

        let found = session::find_session(&state.db, &sid).await.unwrap();
        assert!(found.is_some());
        let s = found.unwrap();
        assert_eq!(s.did, "did:plc:test");
        assert_eq!(s.handle, "test.user");
    }
}