rustauth-plugins 0.2.0

Official RustAuth plugin modules.
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140

use std::sync::Arc;

use rustauth_core::db::MemoryAdapter;
use rustauth_plugins::email_otp::EmailOtpOptions;

use super::common::*;

#[tokio::test]
async fn send_verification_on_sign_up_hook_sends_otp() {
    let adapter = Arc::new(MemoryAdapter::new());
    let sender = CaptureSender::default();
    let router = router(
        adapter.clone(),
        sender.clone(),
        EmailOtpOptions {
            send_verification_on_sign_up: true,
            ..EmailOtpOptions::default()
        },
    )
    .unwrap();

    let response = router
        .handle_async(
            json_request(
                "/sign-up/email",
                r#"{"name":"Ada","email":"ada@example.com","password":"valid-password"}"#,
                None,
            )
            .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(sender.count_after_dispatch(1).await, 1);
    assert!(
        verification_value(&adapter, "email-verification-otp-ada@example.com")
            .await
            .is_some()
    );
}

#[tokio::test]
async fn send_verification_otp_returns_before_slow_sender_finishes(
) -> Result<(), Box<dyn std::error::Error>> {
    use std::sync::atomic::{AtomicUsize, Ordering};
    use std::time::{Duration, Instant};

    struct SlowSender {
        started: Arc<AtomicUsize>,
    }

    impl rustauth_plugins::email_otp::SendEmailOtp for SlowSender {
        fn send_email_otp(
            &self,
            _payload: rustauth_plugins::email_otp::EmailOtpPayload,
            _request: Option<&http::Request<Vec<u8>>>,
        ) -> rustauth_core::outbound::OutboundSendFuture {
            let started = Arc::clone(&self.started);
            Box::pin(async move {
                started.fetch_add(1, Ordering::SeqCst);
                tokio::time::sleep(Duration::from_secs(2)).await;
                Ok(())
            }) as rustauth_core::outbound::OutboundSendFuture
        }
    }

    let started = Arc::new(AtomicUsize::new(0));
    let adapter = Arc::new(MemoryAdapter::new());
    create_user(&adapter, "ada@example.com", false).await;
    let options = EmailOtpOptions {
        sender: Some(Arc::new(SlowSender {
            started: Arc::clone(&started),
        })),
        ..EmailOtpOptions::default()
    };
    let router = router_with_async_outbound(adapter, CaptureSender::default(), options)?;

    let request_started = Instant::now();
    let response = router
        .handle_async(json_request(
            "/email-otp/send-verification-otp",
            r#"{"email":"ada@example.com","type":"email-verification"}"#,
            None,
        )?)
        .await?;
    let elapsed = request_started.elapsed();

    assert_eq!(response.status(), StatusCode::OK);
    assert!(
        elapsed < Duration::from_millis(100),
        "email-otp send took {elapsed:?}"
    );
    assert_eq!(started.load(Ordering::SeqCst), 0);

    for _ in 0..100 {
        if started.load(Ordering::SeqCst) == 1 {
            break;
        }
        tokio::time::sleep(Duration::from_millis(5)).await;
    }
    assert_eq!(started.load(Ordering::SeqCst), 1);
    Ok(())
}

#[tokio::test]
async fn override_default_send_verification_email_sends_otp() {
    let adapter = Arc::new(MemoryAdapter::new());
    create_user(&adapter, "ada@example.com", false).await;
    let sender = CaptureSender::default();
    let router = router(
        adapter.clone(),
        sender.clone(),
        EmailOtpOptions {
            override_default_email_verification: true,
            ..EmailOtpOptions::default()
        },
    )
    .unwrap();

    let response = router
        .handle_async(
            json_request(
                "/send-verification-email",
                r#"{"email":"ada@example.com"}"#,
                None,
            )
            .unwrap(),
        )
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(sender.count_after_dispatch(1).await, 1);
    assert!(
        verification_value(&adapter, "email-verification-otp-ada@example.com")
            .await
            .is_some()
    );
}