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

use super::*;

#[test]
fn exposes_device_authorization_plugin_id() {
    assert_eq!(
        rustauth_plugins::device_authorization::UPSTREAM_PLUGIN_ID,
        "device-authorization"
    );
}

#[test]
fn schema_contributes_device_code_table() -> Result<(), Box<dyn std::error::Error>> {
    let adapter = Arc::new(TestAdapter::default());
    let context = create_auth_context_with_adapter(
        RustAuthOptions {
            plugins: vec![device_authorization(DeviceAuthorizationOptions::default())?],
            secret: Some(secret().to_owned()),
            base_url: Some("http://localhost:3000".to_owned()),
            ..RustAuthOptions::default()
        },
        adapter,
    )?;

    let table = context
        .db_schema
        .table("device_code")
        .ok_or("missing table")?;
    assert_eq!(table.name, "device_codes");
    assert!(table.field("device_code").is_some_and(|field| field.unique));
    assert!(table.field("user_code").is_some_and(|field| field.unique));
    assert_eq!(
        table.field("device_code").map(|field| field.name.as_str()),
        Some("device_code")
    );
    assert_eq!(
        table.field("user_code").map(|field| field.name.as_str()),
        Some("user_code")
    );
    assert_eq!(
        table.field("user_id").map(|field| field.name.as_str()),
        Some("user_id")
    );
    assert_eq!(
        table.field("expires_at").map(|field| field.name.as_str()),
        Some("expires_at")
    );
    Ok(())
}

#[test]
fn schema_options_customize_physical_table_and_field_names(
) -> Result<(), Box<dyn std::error::Error>> {
    let adapter = Arc::new(TestAdapter::default());
    let context = create_auth_context_with_adapter(
        RustAuthOptions {
            plugins: vec![device_authorization(
                DeviceAuthorizationOptions::default().schema(
                    rustauth_plugins::device_authorization::DeviceAuthorizationSchemaOptions::new()
                        .table_name("oauth_device_codes")
                        .field_name("device_code", "device_code")
                        .field_name("user_code", "user_code"),
                ),
            )?],
            secret: Some(secret().to_owned()),
            base_url: Some("http://localhost:3000".to_owned()),
            ..RustAuthOptions::default()
        },
        adapter,
    )?;

    let table = context
        .db_schema
        .table("device_code")
        .ok_or("missing table")?;
    assert_eq!(table.name, "oauth_device_codes");
    assert_eq!(
        table.field("device_code").map(|field| field.name.as_str()),
        Some("device_code")
    );
    assert_eq!(
        table.field("user_code").map(|field| field.name.as_str()),
        Some("user_code")
    );
    Ok(())
}

#[test]
fn router_registers_all_device_authorization_endpoints() -> Result<(), Box<dyn std::error::Error>> {
    let adapter = Arc::new(TestAdapter::default());
    let router = router(adapter, DeviceAuthorizationOptions::default())?;
    let registry = router.endpoint_registry();

    for (method, path) in [
        (Method::POST, "/device/code"),
        (Method::POST, "/device/token"),
        (Method::GET, "/device"),
        (Method::POST, "/device/approve"),
        (Method::POST, "/device/deny"),
    ] {
        assert!(registry
            .iter()
            .any(|endpoint| endpoint.method == method && endpoint.path == path));
    }
    Ok(())
}