From 36fb1cff524a378ca97e319df37c57fb434b4738 Mon Sep 17 00:00:00 2001
From: Philippe Loctaux <p@philippeloctaux.com>
Date: Sun, 12 Mar 2023 19:20:00 +0100
Subject: [PATCH] ezidam: on launch: in testing environment, use premade keys,
 else generate them

---
 crates/ezidam/src/database.rs | 88 ++++++++++++++++++++++-------------
 1 file changed, 55 insertions(+), 33 deletions(-)

diff --git a/crates/ezidam/src/database.rs b/crates/ezidam/src/database.rs
index e15eac8..b3d3ffe 100644
--- a/crates/ezidam/src/database.rs
+++ b/crates/ezidam/src/database.rs
@@ -61,48 +61,70 @@ impl Database {
                     );
                 }
                 None => {
-                    info!("No valid keys are present. Starting generation...");
+                    // When running tests, import premade keys to save time
+                    // Otherwise, generate keys
+                    let (key_id, private, public) = if cfg!(test) {
+                        use std::str::FromStr;
 
-                    // Generate key id
-                    let key_id = match task::spawn_blocking(id::KeyID::default).await {
-                        Ok(key_id) => {
-                            info!("Generated KeyID {}", key_id);
-                            key_id
-                        }
-                        Err(e) => {
-                            error!("Failed to run KeyID generation: {}", e);
-                            return Err(rocket);
-                        }
-                    };
+                        info!("Importing testing keys");
 
-                    // Generate keys
-                    info!("Starting key generation. This should not be long.");
-                    let key_id_for_generation = key_id.clone();
-                    let new_keys = match task::spawn_blocking(move || {
-                        jwt::generate(&key_id_for_generation)
-                    })
-                    .await
-                    {
-                        Ok(res) => match res {
-                            Ok(keys) => {
-                                info!("Generated public and private key! Starting to save in database.");
-                                keys
+                        let key_id = id::KeyID::from_str("SgTG8ulMHAp5UsGWuCclw36zWsdEo5").unwrap();
+                        let private_key = jwt::PrivateKey::from_der(
+                            include_bytes!("../../jwt/tests/private_key.der"),
+                            &key_id,
+                        )
+                        .unwrap();
+                        let public_key = jwt::PublicKey::from_der(
+                            include_bytes!("../../jwt/tests/public_key.der"),
+                            &key_id,
+                        )
+                        .unwrap();
+
+                        (key_id, private_key, public_key)
+                    } else {
+                        info!("No valid keys are present. Starting generation...");
+
+                        // Generate key id
+                        let key_id = match task::spawn_blocking(id::KeyID::default).await {
+                            Ok(key_id) => {
+                                info!("Generated KeyID {}", key_id);
+                                key_id
                             }
                             Err(e) => {
-                                error!("Failed to generate keys: {}", e);
+                                error!("Failed to run KeyID generation: {}", e);
                                 return Err(rocket);
                             }
-                        },
-                        Err(e) => {
-                            error!("Failed to run key generation: {}", e);
-                            return Err(rocket);
-                        }
+                        };
+
+                        // Generate keys
+                        info!("Starting key generation. This should not be long.");
+                        let key_id_for_generation = key_id.clone();
+                        let new_keys = match task::spawn_blocking(move || {
+                            jwt::generate(&key_id_for_generation)
+                        })
+                        .await
+                        {
+                            Ok(res) => match res {
+                                Ok(keys) => {
+                                    info!("Generated public and private key! Starting to save in database.");
+                                    keys
+                                }
+                                Err(e) => {
+                                    error!("Failed to generate keys: {}", e);
+                                    return Err(rocket);
+                                }
+                            },
+                            Err(e) => {
+                                error!("Failed to run key generation: {}", e);
+                                return Err(rocket);
+                            }
+                        };
+
+                        (key_id, new_keys.0, new_keys.1)
                     };
 
                     // Insert keys in database
-                    match jwt::database::save_new_keys(&db.0, &key_id, &new_keys.0, &new_keys.1)
-                        .await
-                    {
+                    match jwt::database::save_new_keys(&db.0, &key_id, &private, &public).await {
                         Ok(Some(())) => {
                             info!("Saved keys with id {}", key_id);
                         }