volga 0.9.2

Easy & Fast Web Framework 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

//! JWT signing/verifying algorithm identifiers.

/// A JWT signing/verifying algorithm.
///
/// Mirrors the algorithms defined in [RFC 7518](https://www.rfc-editor.org/rfc/rfc7518).
/// Use this type with [`BearerAuthConfig::with_alg`](super::bearer::BearerAuthConfig::with_alg).
#[derive(Debug, Clone, Copy, Eq, PartialEq, Hash)]
#[non_exhaustive]
pub enum Algorithm {
    /// HMAC using SHA-256.
    HS256,
    /// HMAC using SHA-384.
    HS384,
    /// HMAC using SHA-512.
    HS512,
    /// ECDSA using P-256 and SHA-256.
    ES256,
    /// ECDSA using P-384 and SHA-384.
    ES384,
    /// RSASSA-PKCS1-v1_5 using SHA-256.
    RS256,
    /// RSASSA-PKCS1-v1_5 using SHA-384.
    RS384,
    /// RSASSA-PKCS1-v1_5 using SHA-512.
    RS512,
    /// RSASSA-PSS using SHA-256.
    PS256,
    /// RSASSA-PSS using SHA-384.
    PS384,
    /// RSASSA-PSS using SHA-512.
    PS512,
    /// Edwards-curve Digital Signature Algorithm (EdDSA).
    EdDSA,
}

impl Default for Algorithm {
    #[inline]
    fn default() -> Self {
        Algorithm::HS256
    }
}

impl Algorithm {
    /// Converts this algorithm to the underlying `jsonwebtoken::Algorithm`.
    ///
    /// Crate-private to keep `jsonwebtoken` out of volga's public API surface.
    #[inline]
    pub(crate) fn to_jwt(self) -> jsonwebtoken::Algorithm {
        match self {
            Self::HS256 => jsonwebtoken::Algorithm::HS256,
            Self::HS384 => jsonwebtoken::Algorithm::HS384,
            Self::HS512 => jsonwebtoken::Algorithm::HS512,
            Self::ES256 => jsonwebtoken::Algorithm::ES256,
            Self::ES384 => jsonwebtoken::Algorithm::ES384,
            Self::RS256 => jsonwebtoken::Algorithm::RS256,
            Self::RS384 => jsonwebtoken::Algorithm::RS384,
            Self::RS512 => jsonwebtoken::Algorithm::RS512,
            Self::PS256 => jsonwebtoken::Algorithm::PS256,
            Self::PS384 => jsonwebtoken::Algorithm::PS384,
            Self::PS512 => jsonwebtoken::Algorithm::PS512,
            Self::EdDSA => jsonwebtoken::Algorithm::EdDSA,
        }
    }
}

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

    #[test]
    fn it_defaults_to_hs256() {
        assert_eq!(Algorithm::default(), Algorithm::HS256);
    }

    #[test]
    fn it_converts_every_variant_to_jsonwebtoken() {
        let pairs: [(Algorithm, jsonwebtoken::Algorithm); 12] = [
            (Algorithm::HS256, jsonwebtoken::Algorithm::HS256),
            (Algorithm::HS384, jsonwebtoken::Algorithm::HS384),
            (Algorithm::HS512, jsonwebtoken::Algorithm::HS512),
            (Algorithm::ES256, jsonwebtoken::Algorithm::ES256),
            (Algorithm::ES384, jsonwebtoken::Algorithm::ES384),
            (Algorithm::RS256, jsonwebtoken::Algorithm::RS256),
            (Algorithm::RS384, jsonwebtoken::Algorithm::RS384),
            (Algorithm::RS512, jsonwebtoken::Algorithm::RS512),
            (Algorithm::PS256, jsonwebtoken::Algorithm::PS256),
            (Algorithm::PS384, jsonwebtoken::Algorithm::PS384),
            (Algorithm::PS512, jsonwebtoken::Algorithm::PS512),
            (Algorithm::EdDSA, jsonwebtoken::Algorithm::EdDSA),
        ];
        for (volga, jwt) in pairs {
            assert_eq!(volga.to_jwt(), jwt);
        }
    }

    #[test]
    fn it_debugs_hs256() {
        assert_eq!(format!("{:?}", Algorithm::HS256), "HS256");
    }

    #[test]
    fn it_compares_for_equality() {
        assert_eq!(Algorithm::RS256, Algorithm::RS256);
        assert_ne!(Algorithm::RS256, Algorithm::HS256);
    }
}