openid-client 0.2.7

OpenID client for Rust
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

use serde_json::{json, Value};

use crate::issuer::Issuer;
use crate::types::IssuerMetadata;
use std::collections::HashMap;

#[test]
fn accepts_the_recognized_metadata() {
    let authorization_endpoint = || "https://accounts.google.com/o/oauth2/v2/auth".to_string();
    let token_endpoint = || "https://www.googleapis.com/oauth2/v4/token".to_string();
    let userinfo_endpoint = || "https://www.googleapis.com/oauth2/v3/userinfo".to_string();
    let jwks_uri = || "https://www.googleapis.com/oauth2/v3/certs".to_string();

    let metadata = IssuerMetadata {
        issuer: "https://accounts.google.com".to_string(),
        authorization_endpoint: Some(authorization_endpoint()),
        token_endpoint: Some(token_endpoint()),
        userinfo_endpoint: Some(userinfo_endpoint()),
        jwks_uri: Some(jwks_uri()),
        ..IssuerMetadata::default()
    };

    let issuer = Issuer::new(metadata);

    assert_eq!(
        authorization_endpoint(),
        issuer.authorization_endpoint.unwrap()
    );
    assert_eq!(token_endpoint(), issuer.token_endpoint.unwrap());
    assert_eq!(userinfo_endpoint(), issuer.userinfo_endpoint.unwrap());
    assert_eq!(jwks_uri(), issuer.jwks_uri.unwrap());
}

#[test]
fn does_not_assign_discovery_1_0_defaults_when_instantiating_manually() {
    let issuer = Issuer::new(IssuerMetadata::default());

    assert!(issuer.claims_parameter_supported.is_none());
    assert!(issuer.grant_types_supported.is_none());
    assert!(issuer.request_parameter_supported.is_none());
    assert!(issuer.request_uri_parameter_supported.is_none());
    assert!(issuer.require_request_uri_registration.is_none());
    assert!(issuer.response_modes_supported.is_none());
    assert!(issuer.token_endpoint_auth_methods_supported.is_none());
}

#[test]
fn assigns_introspection_and_revocation_auth_method_meta_from_token_if_both_are_not_defined() {
    let token_endpoint = || "https://op.example.com/token".to_string();
    let token_endpoint_auth_methods_supported = || {
        vec![
            "client_secret_basic".to_string(),
            "client_secret_post".to_string(),
            "client_secret_jwt".to_string(),
        ]
    };

    let token_endpoint_auth_signing_alg_values_supported =
        || vec!["RS256".to_string(), "HS256".to_string()];

    let metadata = IssuerMetadata {
        token_endpoint: Some(token_endpoint()),
        token_endpoint_auth_methods_supported: Some(token_endpoint_auth_methods_supported()),
        token_endpoint_auth_signing_alg_values_supported: Some(
            token_endpoint_auth_signing_alg_values_supported(),
        ),
        ..IssuerMetadata::default()
    };

    let issuer = Issuer::new(metadata);

    assert_eq!(
        token_endpoint_auth_methods_supported(),
        issuer
            .introspection_endpoint_auth_methods_supported
            .unwrap(),
    );
    assert_eq!(
        token_endpoint_auth_methods_supported(),
        issuer.revocation_endpoint_auth_methods_supported.unwrap(),
    );

    assert_eq!(
        token_endpoint_auth_signing_alg_values_supported(),
        issuer
            .revocation_endpoint_auth_signing_alg_values_supported
            .unwrap(),
    );
    assert_eq!(
        token_endpoint_auth_signing_alg_values_supported(),
        issuer
            .introspection_endpoint_auth_signing_alg_values_supported
            .unwrap(),
    );
}

#[test]
fn is_able_to_discover_custom_or_non_recognized_properties() {
    let mut other_fields: HashMap<String, Value> = HashMap::new();
    other_fields.insert("foo".to_string(), json!("bar"));

    let metadata = IssuerMetadata {
        issuer: "https://op.example.com".to_string(),
        other_fields,
        ..IssuerMetadata::default()
    };

    let issuer = Issuer::new(metadata);

    assert_eq!("https://op.example.com".to_string(), issuer.issuer);
    assert!(issuer.other_fields.contains_key("foo"));
    assert_eq!(
        "bar",
        issuer.other_fields.get("foo").unwrap().as_str().unwrap()
    );
}