test: Introduce mocking framework (#168)

Author: giomf

Cargo.lock

@@ -26,6 +26,7 @@ thiserror = "1.0.41"
 diesel = { version = "2.1.0", features = ["sqlite", "r2d2", "returning_clauses_for_sqlite_3_35"] }
 reqwest = {version = "0.11.18", features = ["json"] }
 nanoid = "0.4.0"
+faux = "0.1.9"
 
 
 

server/Cargo.toml

@@ -7,14 +7,13 @@ mod project;
 
 use crate::service::auth::AuthService;
 use crate::service::function::FunctionService;
-use crate::service::{project::ProjectService, user::UserService};
+use crate::service::project::ProjectService;
 use crate::wasmstore::WasmStore;
 use axum::{extract::FromRef, middleware, Router};
 
 #[derive(Debug, Clone)]
 pub struct AppState {
     auth: AuthService,
-    users: UserService,
     projects: ProjectService,
     functions: FunctionService,
     wasmstore: WasmStore,
@@ -23,14 +22,12 @@ pub struct AppState {
 impl AppState {
     pub fn new(
         auth: AuthService,
-        users: UserService,
         projects: ProjectService,
         functions: FunctionService,
         wasmstore: WasmStore,
     ) -> Self {
         Self {
             auth,
-            users,
             projects,
             functions,
             wasmstore,
@@ -50,12 +47,6 @@ impl FromRef<AppState> for AuthService {
     }
 }
 
-impl FromRef<AppState> for UserService {
-    fn from_ref(app_state: &AppState) -> UserService {
-        app_state.users.clone()
-    }
-}
-
 impl FromRef<AppState> for ProjectService {
     fn from_ref(app_state: &AppState) -> ProjectService {
         app_state.projects.clone()

server/src/controller/mod.rs

@@ -8,6 +8,7 @@ use serde::Deserialize;
 const GITHUB_API_USER: &str = "https://api.github.com/user";
 const GITHUB_API_EMAIL: &str = "https://api.github.com/user/emails";
 
+#[derive(Debug, Clone)]
 pub struct GithubUser {
     pub id: i32,
     pub email: String,
@@ -25,51 +26,67 @@ struct Email {
     primary: bool,
 }
 
-pub async fn get_user(access_token: String) -> anyhow::Result<GithubUser> {
-    let client = reqwest::Client::new();
-    let headers = create_headers(&access_token)?;
+#[cfg_attr(test, faux::create)]
+#[derive(Debug, Clone)]
+pub struct GithubClient {
+    client: Client,
+}
 
-    let user_infos = get_user_infos(&client, headers.clone()).await?;
-    let email = get_primary_email(&client, headers).await?;
+#[cfg_attr(test, faux::methods)]
+impl GithubClient {
+    pub fn new() -> Self {
+        Self {
+            client: reqwest::Client::new(),
+        }
+    }
 
-    Ok(GithubUser {
-        id: user_infos.id,
-        email: email.email,
-        access_token,
-    })
-}
+    pub async fn get_user(&self, access_token: String) -> anyhow::Result<GithubUser> {
+        let headers = self.create_headers(&access_token)?;
 
-async fn get_user_infos(client: &Client, headers: HeaderMap) -> anyhow::Result<User> {
-    let user = client
-        .get(GITHUB_API_USER)
-        .headers(headers)
-        .send()
-        .await?
-        .json()
-        .await?;
+        let user_infos = self.get_user_infos(headers.clone()).await?;
+        let email = self.get_primary_email(headers).await?;
 
-    Ok(user)
-}
+        Ok(GithubUser {
+            id: user_infos.id,
+            email: email.email,
+            access_token,
+        })
+    }
 
-async fn get_primary_email(client: &Client, headers: HeaderMap) -> anyhow::Result<Email> {
-    let emails: Vec<Email> = client
-        .get(GITHUB_API_EMAIL)
-        .headers(headers)
-        .send()
-        .await?
-        .json()
-        .await?;
-
-    let email = emails.into_iter().find(|email| email.primary).unwrap();
-    Ok(email)
-}
+    async fn get_user_infos(&self, headers: HeaderMap) -> anyhow::Result<User> {
+        let user = self
+            .client
+            .get(GITHUB_API_USER)
+            .headers(headers)
+            .send()
+            .await?
+            .json()
+            .await?;
+
+        Ok(user)
+    }
+
+    async fn get_primary_email(&self, headers: HeaderMap) -> anyhow::Result<Email> {
+        let emails: Vec<Email> = self
+            .client
+            .get(GITHUB_API_EMAIL)
+            .headers(headers)
+            .send()
+            .await?
+            .json()
+            .await?;
+
+        let email = emails.into_iter().find(|email| email.primary).unwrap();
+        Ok(email)
+    }
 
-fn create_headers(access_token: &str) -> anyhow::Result<HeaderMap> {
-    let mut headers = HeaderMap::new();
-    headers.insert(USER_AGENT, "noops-server".parse()?);
-    headers.insert(AUTHORIZATION, format!("Bearer {}", access_token).parse()?);
-    headers.insert(ACCEPT, "application/vnd.github+json".parse()?);
-    headers.insert("X-GitHub-Api-Version", "2022-11-28".parse()?);
+    fn create_headers(&self, access_token: &str) -> anyhow::Result<HeaderMap> {
+        let mut headers = HeaderMap::new();
+        headers.insert(USER_AGENT, "noops-server".parse()?);
+        headers.insert(AUTHORIZATION, format!("Bearer {}", access_token).parse()?);
+        headers.insert(ACCEPT, "application/vnd.github+json".parse()?);
+        headers.insert("X-GitHub-Api-Version", "2022-11-28".parse()?);
 
-    Ok(headers)
+        Ok(headers)
+    }
 }

server/src/github.rs

@@ -9,9 +9,8 @@ mod service;
 mod wasmstore;
 
 use axum::Server;
-use service::{
-    auth::AuthService, function::FunctionService, project::ProjectService, user::UserService,
-};
+use github::GithubClient;
+use service::{auth::AuthService, function::FunctionService, project::ProjectService};
 use std::{net::SocketAddr, path::Path};
 use tower_http::trace::TraceLayer;
 use tracing_subscriber::{self, layer::SubscriberExt, util::SubscriberInitExt};
@@ -47,18 +46,11 @@ fn create_app_state(database_path: &Path, wasmstore_path: &Path) -> anyhow::Resu
     let (users, projects, functions) = repository::new(database_path);
     let wasmstore = wasmstore::WasmStore::new(wasmstore_path)?;
 
-    let auth_service = AuthService::new(users);
-    let user_service = UserService::new();
+    let auth_service = AuthService::new(GithubClient::new(), users);
     let project_service = ProjectService::new(projects.clone(), functions.clone());
     let function_service = FunctionService::new(projects, functions, wasmstore.clone());
 
-    let state = AppState::new(
-        auth_service,
-        user_service,
-        project_service,
-        function_service,
-        wasmstore,
-    );
+    let state = AppState::new(auth_service, project_service, function_service, wasmstore);
 
     Ok(state)
 }

server/src/main.rs

@@ -39,11 +39,13 @@ impl From<Function> for GetFunctionDTO {
     }
 }
 
+#[cfg_attr(test, faux::create)]
 #[derive(Debug, Clone)]
 pub struct FunctionRepository {
     pool: Pool<ConnectionManager<SqliteConnection>>,
 }
 
+#[cfg_attr(test, faux::methods)]
 impl Repository<Function> for FunctionRepository {
     fn new(pool: Pool<ConnectionManager<SqliteConnection>>) -> Self {
         Self { pool }
@@ -81,10 +83,10 @@ impl Repository<Function> for FunctionRepository {
     }
 }
 
+#[cfg_attr(test, faux::methods)]
 impl FunctionRepository {
     pub fn belonging_to(&self, project: &Project) -> anyhow::Result<Vec<Function>> {
         let mut connection = self.pool.get()?;
-
         let functions = Function::belonging_to(project).load::<Function>(&mut connection)?;
         Ok(functions)
     }
@@ -133,9 +135,9 @@ mod tests {
     fn setup() -> anyhow::Result<(TempDir, FunctionRepository)> {
         let temp_dir = tempdir()?;
         let pool = create_pool(&temp_dir.path().join(DATABASE_NAME));
+        let mut connection = pool.get()?;
         let projects = FunctionRepository::new(pool);
         let migrations = FileBasedMigrations::find_migrations_directory_in_path("./server")?;
-        let mut connection = projects.pool.get()?;
         connection.run_pending_migrations(migrations).unwrap();
         Ok((temp_dir, projects))
     }

server/src/repository/function.rs

@@ -31,11 +31,13 @@ impl Project {
     }
 }
 
+#[cfg_attr(test, faux::create)]
 #[derive(Debug, Clone)]
 pub struct ProjectRepository {
     pool: Pool<ConnectionManager<SqliteConnection>>,
 }
 
+#[cfg_attr(test, faux::methods)]
 impl Repository<Project> for ProjectRepository {
     fn new(pool: Pool<ConnectionManager<SqliteConnection>>) -> Self {
         Self { pool }
@@ -71,6 +73,7 @@ impl Repository<Project> for ProjectRepository {
     }
 }
 
+#[cfg_attr(test, faux::methods)]
 impl ProjectRepository {
     pub fn belonging_to_by_name(
         &self,
@@ -112,9 +115,9 @@ mod tests {
     fn setup() -> anyhow::Result<(TempDir, ProjectRepository)> {
         let temp_dir = tempdir()?;
         let pool = create_pool(&temp_dir.path().join(DATABASE_NAME));
+        let mut connection = pool.get()?;
         let projects = ProjectRepository::new(pool);
         let migrations = FileBasedMigrations::find_migrations_directory_in_path("./server")?;
-        let mut connection = projects.pool.get()?;
         connection.run_pending_migrations(migrations).unwrap();
         Ok((temp_dir, projects))
     }