new laptop setup

src/auth/jwt.rs

@@ -0,0 +1,104 @@
+extern crate hmac;
+extern crate jwt;
+extern crate sha2;
+
+use std::collections::BTreeMap;
+
+use actix_web::HttpRequest;
+use hmac::{Hmac, Mac};
+use jwt::{Header, SignWithKey, Token, VerifyWithKey};
+use sha2::Sha256;
+
+pub struct JwtToken {
+    pub user_id: i32,
+    pub body: String,
+}
+
+type HmacSha256 = Hmac<Sha256>;
+
+impl JwtToken {
+    pub fn encode(user_id: i32) -> String {
+        let key: HmacSha256 = HmacSha256::new_from_slice(b"secret").unwrap();
+        let mut claims = BTreeMap::new();
+        claims.insert("user_id", user_id);
+        claims.sign_with_key(&key).unwrap()
+    }
+
+    pub fn decode(encoded_token: String) -> Result<JwtToken, &'static str> {
+        let key: HmacSha256 = HmacSha256::new_from_slice(b"secret").unwrap();
+        let token_str: &str = encoded_token.as_str();
+        let token: Result<Token<Header, BTreeMap<String, i32>, jwt::Verified>, jwt::Error> =
+            VerifyWithKey::verify_with_key(token_str, &key);
+
+        match token {
+            Ok(token) => {
+                let _header = token.header();
+                let claims = token.claims();
+                Ok(JwtToken {
+                    user_id: claims["user_id"],
+                    body: encoded_token,
+                })
+            }
+            Err(_err) => Err("could not decode token"),
+        }
+    }
+
+    pub fn decode_from_request(request: HttpRequest) -> Result<JwtToken, &'static str> {
+        match request.headers().get("user-token") {
+            Some(token) => JwtToken::decode(String::from(token.to_str().unwrap())),
+            None => Err("There is no token"),
+        }
+    }
+}
+
+#[cfg(test)]
+mod jwt_test {
+    use actix_web::{http::header, test};
+
+    use super::JwtToken;
+
+    #[test]
+    async fn encode_decode() {
+        let encoded_token: String = JwtToken::encode(32);
+        let decoded_token: JwtToken = JwtToken::decode(encoded_token).unwrap();
+        assert_eq!(32, decoded_token.user_id);
+    }
+
+    #[test]
+    async fn decode_incorrect_token() {
+        let encoded_token: String = String::from("test");
+
+        match JwtToken::decode(encoded_token) {
+            Err(message) => assert_eq!(message, "could not decode token"),
+            _ => panic!("Incorrect token should not be able to decode."),
+        }
+    }
+
+    #[actix_web::test]
+    async fn decode_from_request_with_correct_token() {
+        let encoded_token: String = JwtToken::encode(32);
+        let request = test::TestRequest::default()
+            .insert_header(header::ContentType::json())
+            .insert_header(("user-token", encoded_token))
+            .to_http_request();
+        let out_come = JwtToken::decode_from_request(request);
+
+        match out_come {
+            Ok(token) => assert_eq!(32, token.user_id),
+            _ => panic!("Token is not returned with it should be."),
+        }
+    }
+
+    #[actix_web::test]
+    async fn decode_from_request_with_no_token() {
+        let request = test::TestRequest::default()
+            .insert_header(("test", "test"))
+            .to_http_request();
+        let out_come = JwtToken::decode_from_request(request);
+
+        match out_come {
+            Err(message) => assert_eq!("There is no token", message),
+            _ => panic!("Token should not be returned when it is not present in the header."),
+        }
+    }
+}