feat+chore: factories to create forge adapters

.woodpecker.yml

@@ -8,6 +8,7 @@ steps:
     commands:
       #      - curl -fsSL https://deb.nodesource.com/setup_16.x | bash - &&\
       #      - apt update && apt-get -y --no-install-recommends install nodejs tar gpg curl wget
+      - rustup toolchain install nightly
       - rustup component add rustfmt
       - rustup component add clippy
       - make db.migrate

src/auth/adapter/input/web/login/adapter.rs

@@ -46,8 +46,6 @@ impl RequestAuthorizationInterface for RequestAuthorizationHandler {
             self.generate_random_string.clone(),
         );
 
-        log::info!("service found");
-
         let cmd = RequestAuthorizationCommand::new_command(forge_name)?;
         let auth_page = service.request_authorization(cmd).await?;
         Ok(HttpResponse::Found()

src/auth/adapter/input/web/login/handler.rs

@@ -1,105 +0,0 @@
-use std::sync::Arc;
-
-use actix_web::http::header::ContentType;
-use actix_web::{get, post, web, HttpResponse};
-use url::Url;
-
-use crate::auth::adapter::input::web::routes::RoutesRepository;
-use crate::auth::adapter::out::forge::SupportedForges;
-use crate::auth::application::port::input::ui::{errors::*, login::RequestAuthorizationInterface};
-use crate::auth::application::port::out::db::save_oauth_state::SaveOAuthState;
-use crate::utils::random_string::GenerateRandomStringInterface;
-use crate::ForgeRepository;
-
-use super::template::{LoginCtxFactory, LoginPageInterface};
-
-#[get("/login")]
-#[tracing::instrument(name = "login page handler", skip(forges, routes, template))]
-async fn login_page(
-    forges: web::Data<Arc<ForgeRepository>>,
-    routes: web::Data<Arc<RoutesRepository>>,
-    template: web::Data<Arc<dyn LoginPageInterface>>,
-) -> InUIResult<HttpResponse> {
-    let template_ctx = LoginCtxFactory::get_ctx(forges.get_supported_forges(), &routes);
-    let page = template.get_login_page(template_ctx).unwrap();
-    Ok(HttpResponse::Ok()
-        .insert_header(ContentType::html())
-        .body(page))
-}
-
-#[post("/oauth/forgejo/login")]
-async fn request_oauth_authorization_forgejo(
-    forges: web::Data<Arc<ForgeRepository>>,
-    save_oauth_state_adapter: web::Data<Arc<dyn SaveOAuthState>>,
-    routes: web::Data<Arc<RoutesRepository>>,
-    generate_random_string: web::Data<Arc<dyn GenerateRandomStringInterface>>,
-    settings: web::Data<crate::settings::Settings>,
-) -> InUIResult<HttpResponse> {
-    let oauth_auth_req_uri_adapter = &forges
-        .get_forge(&SupportedForges::Forgejo)
-        .unwrap()
-        .oauth_auth_req_uri_adapter;
-
-    let process_authorization_response_redirect_uri = Url::parse(&format!(
-        "{}://{}{}",
-        "http",
-        &settings.server.domain,
-        &routes.process_oauth_authorization_response(&SupportedForges::Forgejo)
-    ))
-    .map_err(|_| InUIError::InternalServerError)?;
-
-    let web_adapter = super::adapter::RequestAuthorizationHandler::new(
-        save_oauth_state_adapter.as_ref().to_owned(),
-        oauth_auth_req_uri_adapter.clone(),
-        generate_random_string.as_ref().clone(),
-        process_authorization_response_redirect_uri,
-    );
-
-    web_adapter
-        .request_oauth_authorization(SupportedForges::Forgejo.to_string())
-        .await
-}
-
-pub fn services(cfg: &mut web::ServiceConfig) {
-    cfg.service(login_page);
-    cfg.service(request_oauth_authorization_forgejo);
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use actix_web::{http::header::ContentType, test, App};
-
-    use crate::auth::adapter::input::web::login::template::load_templates;
-    use crate::auth::adapter::out::forge::forgejo::Forgejo;
-
-    #[actix_web::test]
-    async fn test_get_login_page() {
-        let settings = crate::settings::Settings::new().unwrap();
-
-        let forgejo = Forgejo::new(
-            settings.forges.forgejo.url.clone(),
-            settings.forges.forgejo.client_id.clone(),
-            settings.forges.forgejo.client_secret.clone(),
-        );
-        let forges = ForgeRepository::new(forgejo);
-        let routes = RoutesRepository::default();
-
-        let app = test::init_service(
-            App::new()
-                .app_data(web::Data::new(Arc::new(forges.clone())))
-                .app_data(web::Data::new(Arc::new(routes.clone())))
-                .configure(load_templates)
-                .service(login_page),
-        )
-        .await;
-
-        let req = test::TestRequest::get()
-            .uri("/login")
-            .insert_header(ContentType::html())
-            .to_request();
-        let resp = test::call_service(&app, req).await;
-        println!("{}", resp.status());
-        assert!(resp.status().is_success());
-    }
-}

src/auth/adapter/input/web/login/handlers/login_page.rs

@@ -0,0 +1,66 @@
+use actix_web::http::header::ContentType;
+use actix_web::{get, web, HttpResponse};
+
+use crate::auth::application::port::input::ui::errors::*;
+
+use super::template::LoginCtxFactory;
+use super::types;
+
+#[get("/login")]
+#[tracing::instrument(name = "login page handler", skip(forges, routes, template))]
+async fn handler(
+    forges: types::WebForgeRepositoryInterface,
+    routes: types::WebRouteRepository,
+    template: super::WebLoginPageInterface,
+) -> InUIResult<HttpResponse> {
+    let template_ctx = LoginCtxFactory::get_ctx(forges.get_supported_forges(), &routes);
+    let page = template.get_login_page(template_ctx).unwrap();
+    Ok(HttpResponse::Ok()
+        .insert_header(ContentType::html())
+        .body(page))
+}
+
+pub fn services(cfg: &mut web::ServiceConfig) {
+    cfg.service(handler);
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use actix_web::{http::header::ContentType, test, App};
+    use std::sync::Arc;
+
+    use crate::auth::adapter::input::web::login::template::load_templates;
+    use crate::auth::adapter::input::web::routes::RoutesRepository;
+    use crate::auth::adapter::out::forge::forge_repository::MockForgeRepositoryInterface;
+    use crate::auth::adapter::out::forge::SupportedForges;
+
+    #[actix_web::test]
+    async fn test_login_page_handler() {
+        let mut mock_forges = MockForgeRepositoryInterface::default();
+        mock_forges
+            .expect_get_supported_forges()
+            .return_const(vec![SupportedForges::Forgejo])
+            .times(1);
+        let mock_forges = types::WebForgeRepositoryInterface::new(Arc::new(mock_forges));
+
+        let routes = types::WebRouteRepository::new(Arc::new(RoutesRepository::default()));
+
+        let app = test::init_service(
+            App::new()
+                .app_data(mock_forges)
+                .app_data(routes)
+                .configure(load_templates)
+                .service(handler),
+        )
+        .await;
+
+        let req = test::TestRequest::get()
+            .uri("/login")
+            .insert_header(ContentType::html())
+            .to_request();
+        let resp = test::call_service(&app, req).await;
+        println!("{}", resp.status());
+        assert!(resp.status().is_success());
+    }
+}

src/auth/adapter/input/web/login/handlers/mod.rs

@@ -0,0 +1,14 @@
+mod login_page;
+mod request_oauth_authorization_forgejo;
+
+use actix_web::web;
+
+use super::adapter;
+use super::template;
+use super::types;
+use super::WebLoginPageInterface;
+
+pub fn services(cfg: &mut web::ServiceConfig) {
+    login_page::services(cfg);
+    request_oauth_authorization_forgejo::services(cfg);
+}

src/auth/adapter/input/web/login/handlers/request_oauth_authorization_forgejo.rs

@@ -0,0 +1,161 @@
+use actix_web::{post, web, HttpResponse};
+use url::Url;
+
+use super::types;
+use crate::auth::adapter::out::forge::SupportedForges;
+use crate::auth::application::port::input::ui::{errors::*, login::RequestAuthorizationInterface};
+
+pub fn services(cfg: &mut web::ServiceConfig) {
+    cfg.service(handler);
+}
+
+#[post("/oauth/forgejo/login")]
+#[tracing::instrument(
+    name = "login page handler",
+    skip(
+        forges,
+        save_oauth_state_adapter,
+        generate_random_string,
+        routes,
+        settings
+    )
+)]
+async fn handler(
+    forges: types::WebForgeRepositoryInterface,
+    save_oauth_state_adapter: types::WebSaveOauthState,
+    generate_random_string: types::WebGenerateRandomStringInterface,
+    routes: types::WebRouteRepository,
+    settings: types::WebSettings,
+) -> InUIResult<HttpResponse> {
+    let oauth_auth_req_uri_adapter = &forges
+        .get_forge_factory(&SupportedForges::Forgejo)
+        .unwrap()
+        .get_oauth_auth_req_uri_adapter();
+
+    let process_authorization_response_redirect_uri = Url::parse(&format!(
+        "{}://{}{}",
+        "http",
+        &settings.server.domain,
+        &routes.process_oauth_authorization_response(&SupportedForges::Forgejo)
+    ))
+    .map_err(|_| InUIError::InternalServerError)?;
+
+    let web_adapter = super::adapter::RequestAuthorizationHandler::new(
+        save_oauth_state_adapter.as_ref().to_owned(),
+        oauth_auth_req_uri_adapter.clone(),
+        generate_random_string.as_ref().clone(),
+        process_authorization_response_redirect_uri,
+    );
+
+    web_adapter
+        .request_oauth_authorization(SupportedForges::Forgejo.to_string())
+        .await
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use super::*;
+    use actix_web::http::{header, StatusCode};
+    use actix_web::{http::header::ContentType, test, App};
+
+    use crate::auth::adapter::input::web::routes::RoutesRepository;
+    use crate::auth::adapter::out::forge::forge_factory::{
+        ForgeAdapterFactoryInterface, MockForgeAdapterFactoryInterface,
+    };
+    use crate::auth::adapter::out::forge::forge_repository::MockForgeRepositoryInterface;
+
+    use crate::auth::application::port::out::forge::oauth_auth_req_uri::OAuthAuthReqUri;
+    use crate::auth::application::port::out::{
+        db::save_oauth_state::MockSaveOAuthState, forge::oauth_auth_req_uri::MockOAuthAuthReqUri,
+    };
+    use crate::utils::random_string::*;
+
+    #[actix_web::test]
+    async fn test_ui_handler_request_oauth_authorization_forgejo() {
+        let random_string = "foorand";
+        let settings = crate::settings::Settings::new().unwrap();
+
+        let url = Url::parse("http://test_ui_handler_request_oauth_authorization_forgejo").unwrap();
+        let mut redirect_uri = url.clone();
+        redirect_uri.set_query(Some(&format!("state={random_string}")));
+
+        let mock_random_generate_string = {
+            let mut mock_random_generate_string = MockGenerateRandomStringInterface::new();
+            mock_random_generate_string
+                .expect_get_random()
+                .times(1)
+                .return_const(random_string.to_string());
+            WebGenerateRandomStringInterface::new(Arc::new(mock_random_generate_string))
+        };
+
+        let mock_save_oauth_state = {
+            let mut mock_save_oauth_state = MockSaveOAuthState::new();
+            mock_save_oauth_state
+                .expect_save_oauth_state()
+                .times(1)
+                .returning(|_, _, _| Ok(()));
+            types::WebSaveOauthState::new(Arc::new(mock_save_oauth_state))
+        };
+
+        let mock_forges = {
+            let mock_oauth_req_uri: Arc<dyn OAuthAuthReqUri> = {
+                let r = redirect_uri.clone();
+                let mut mock_oauth_req_uri = MockOAuthAuthReqUri::new();
+                mock_oauth_req_uri
+                    .expect_oauth_auth_req_uri()
+                    .times(1)
+                    .returning(move |_, _| Ok(r.clone()));
+                Arc::new(mock_oauth_req_uri)
+            };
+
+            let mut mock_forge_factory = MockForgeAdapterFactoryInterface::default();
+            let a = mock_oauth_req_uri.clone();
+            mock_forge_factory
+                .expect_get_oauth_auth_req_uri_adapter()
+                .times(1)
+                .returning(move || a.clone());
+            let mock_forge_factory: Arc<dyn ForgeAdapterFactoryInterface> =
+                Arc::new(mock_forge_factory);
+
+            let mut mock_forges = MockForgeRepositoryInterface::default();
+            mock_forges
+                .expect_get_forge_factory()
+                .times(1)
+                .returning(move |_| Some(mock_forge_factory.clone()));
+
+            types::WebForgeRepositoryInterface::new(Arc::new(mock_forges))
+        };
+
+        let routes = RoutesRepository::default();
+
+        let app = test::init_service(
+            App::new()
+                .app_data(mock_save_oauth_state)
+                .wrap(tracing_actix_web::TracingLogger::default())
+                .app_data(mock_random_generate_string)
+                .app_data(mock_forges)
+                .app_data(web::Data::new(Arc::new(routes.clone())))
+                .app_data(web::Data::new(settings.clone()))
+                .service(handler),
+        )
+        .await;
+
+        let req = test::TestRequest::post()
+            .uri("/oauth/forgejo/login")
+            .insert_header(ContentType::html())
+            .to_request();
+        let resp = test::call_service(&app, req).await;
+        let status = resp.status();
+        assert_eq!(status, StatusCode::FOUND);
+        assert_eq!(
+            resp.headers()
+                .get(header::LOCATION)
+                .unwrap()
+                .to_str()
+                .unwrap(),
+            redirect_uri.as_str()
+        );
+    }
+}

src/auth/adapter/input/web/login/mod.rs

@@ -1,12 +1,18 @@
 use actix_web::web;
+use std::sync::Arc;
 
 mod adapter;
-mod handler;
+mod handlers;
 mod template;
 
+use super::types;
+use template::LoginPageInterface;
+
 pub use template::register_templates;
 
 pub fn services(cfg: &mut web::ServiceConfig) {
     template::load_templates(cfg);
-    handler::services(cfg);
+    handlers::services(cfg);
 }
+
+pub type WebLoginPageInterface = web::Data<Arc<dyn LoginPageInterface>>;

src/auth/adapter/input/web/login/template.rs

@@ -20,8 +20,8 @@ pub fn register_templates(t: &mut tera::Tera) {
 }
 
 pub fn load_templates(cfg: &mut web::ServiceConfig) {
-    let t: Arc<dyn LoginPageInterface> = Arc::new(LoginPageTemplate);
-    cfg.app_data(web::Data::new(t));
+    let t = super::WebLoginPageInterface::new(Arc::new(LoginPageTemplate));
+    cfg.app_data(t);
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]

src/auth/adapter/input/web/mod.rs

@@ -5,11 +5,12 @@ use actix_web::web;
 pub mod login;
 mod routes;
 mod template;
+pub mod types;
 
 use routes::RoutesRepository;
 
 pub fn load_ctx() -> impl FnOnce(&mut web::ServiceConfig) {
-    let routes = web::Data::new(Arc::new(RoutesRepository::default()));
+    let routes = types::WebRouteRepository::new(Arc::new(RoutesRepository::default()));
 
     let f = move |cfg: &mut web::ServiceConfig| {
         cfg.app_data(routes);

src/auth/adapter/input/web/types.rs

@@ -0,0 +1,14 @@
+use std::sync::Arc;
+
+use actix_web::web;
+
+use crate::auth::adapter::out::forge::forge_repository::ForgeRepositoryInterface;
+use crate::auth::application::port::out::db::save_oauth_state::SaveOAuthState;
+pub(super) use crate::utils::random_string::WebGenerateRandomStringInterface;
+
+use super::RoutesRepository;
+
+pub type WebForgeRepositoryInterface = web::Data<Arc<dyn ForgeRepositoryInterface>>;
+pub type WebSaveOauthState = web::Data<Arc<dyn SaveOAuthState>>;
+pub type WebRouteRepository = web::Data<Arc<RoutesRepository>>;
+pub type WebSettings = web::Data<crate::settings::Settings>;

src/auth/adapter/mod.rs

@@ -7,8 +7,10 @@ pub mod input;
 pub mod out;
 
 use crate::settings;
-use out::db::DBAdapter;
-use out::forge::{forgejo::Forgejo, ForgeRepository};
+use out::db::postgres::DBOutPostgresAdapter;
+use out::forge::{forge_repository::ForgeRepository, forgejo::Forgejo};
+
+use input::web::types;
 
 pub fn load_adapters(
     pool: PgPool,
@@ -19,11 +21,19 @@ pub fn load_adapters(
         settings.forges.forgejo.client_id.clone(),
         settings.forges.forgejo.client_secret.clone(),
     );
-    let forges = ForgeRepository::new(forgejo);
+
+    let forge_repository_interface =
+        types::WebForgeRepositoryInterface::new(Arc::new(ForgeRepository::new(forgejo)));
+    let db = DBOutPostgresAdapter::new(pool);
+    let save_oauth_state_adapter: types::WebSaveOauthState =
+        types::WebSaveOauthState::new(Arc::new(db.clone()));
+
+    let s = types::WebSettings::new(settings.clone());
 
     let f = move |cfg: &mut web::ServiceConfig| {
-        cfg.app_data(web::Data::new(Arc::new(DBAdapter::new(pool))));
-        cfg.app_data(web::Data::new(Arc::new(forges.clone())));
+        cfg.app_data(save_oauth_state_adapter);
+        cfg.app_data(forge_repository_interface);
+        cfg.app_data(s);
         cfg.configure(input::web::load_ctx());
     };
 

src/auth/adapter/out/db/mod.rs

@@ -1,28 +1 @@
-use std::sync::Arc;
-
-use sqlx::PgPool;
-
-use crate::auth::application::port::out::db::save_oauth_state::SaveOAuthState;
-use crate::db::migrate::RunMigrations;
-
 pub mod postgres;
-
-#[derive(Clone)]
-pub struct DBAdapter {
-    pub save_oauth_state_adapter: Arc<dyn SaveOAuthState>,
-    pg_adapter: postgres::DBOutPostgresAdapter,
-}
-
-impl DBAdapter {
-    pub fn new(pool: PgPool) -> Self {
-        let pg_adapter = postgres::DBOutPostgresAdapter::new(pool);
-        Self {
-            save_oauth_state_adapter: Arc::new(pg_adapter.clone()),
-            pg_adapter,
-        }
-    }
-
-    pub fn migratable(&self) -> Arc<dyn RunMigrations> {
-        self.pg_adapter.migratable()
-    }
-}

src/auth/adapter/out/forge/forge_factory.rs

@@ -0,0 +1,31 @@
+use std::sync::Arc;
+
+use mockall::predicate::*;
+use mockall::*;
+
+use super::forgejo::Forgejo;
+use crate::auth::application::port::out::forge::oauth_auth_req_uri::OAuthAuthReqUri;
+
+#[automock]
+pub trait ForgeAdapterFactoryInterface: Send + Sync {
+    fn get_oauth_auth_req_uri_adapter(&self) -> Arc<dyn OAuthAuthReqUri>;
+}
+
+#[derive(Clone)]
+pub struct ForgeAdapterFactory {
+    forgejo: Arc<Forgejo>,
+}
+
+impl ForgeAdapterFactoryInterface for ForgeAdapterFactory {
+    fn get_oauth_auth_req_uri_adapter(&self) -> Arc<dyn OAuthAuthReqUri> {
+        self.forgejo.clone()
+    }
+}
+
+impl ForgeAdapterFactory {
+    pub fn new(forgejo: Forgejo) -> Self {
+        Self {
+            forgejo: Arc::new(forgejo),
+        }
+    }
+}

src/auth/adapter/out/forge/forge_repository.rs

@@ -0,0 +1,71 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use mockall::predicate::*;
+use mockall::*;
+
+use super::{
+    forge_factory::ForgeAdapterFactory, forge_factory::ForgeAdapterFactoryInterface,
+    forgejo::Forgejo, SupportedForges,
+};
+
+#[automock]
+pub trait ForgeRepositoryInterface: Send + Sync {
+    fn add_forge(
+        &mut self,
+        name: SupportedForges,
+        forge_factory: Arc<dyn ForgeAdapterFactoryInterface>,
+    );
+
+    fn get_supported_forge_str(&self) -> Vec<String>;
+
+    fn get_supported_forges(&self) -> Vec<SupportedForges>;
+
+    fn get_forge_factory(
+        &self,
+        name: &SupportedForges,
+    ) -> Option<Arc<dyn ForgeAdapterFactoryInterface>>;
+}
+
+#[derive(Clone, Default)]
+pub struct ForgeRepository {
+    forges: HashMap<SupportedForges, Arc<dyn ForgeAdapterFactoryInterface>>,
+}
+
+impl ForgeRepositoryInterface for ForgeRepository {
+    fn add_forge(
+        &mut self,
+        name: SupportedForges,
+        forge_factory: Arc<dyn ForgeAdapterFactoryInterface>,
+    ) {
+        self.forges.insert(name, forge_factory);
+    }
+
+    fn get_supported_forge_str(&self) -> Vec<String> {
+        self.forges
+            .clone()
+            .into_keys()
+            .map(|v| v.to_string())
+            .collect()
+    }
+
+    fn get_supported_forges(&self) -> Vec<SupportedForges> {
+        self.forges.clone().into_keys().collect()
+    }
+
+    fn get_forge_factory(
+        &self,
+        name: &SupportedForges,
+    ) -> Option<Arc<dyn ForgeAdapterFactoryInterface>> {
+        self.forges.get(name).cloned()
+    }
+}
+
+impl ForgeRepository {
+    pub fn new(forgejo: Forgejo) -> Self {
+        let forgejo_adapter = ForgeAdapterFactory::new(forgejo);
+        let mut s = Self::default();
+        s.add_forge(SupportedForges::Forgejo, Arc::new(forgejo_adapter));
+        s
+    }
+}

src/auth/adapter/out/forge/mod.rs

@@ -1,57 +1,12 @@
-use std::collections::HashMap;
 use std::str::FromStr;
-use std::sync::Arc;
 
 use derive_more::Display;
 use serde::{Deserialize, Serialize};
 
-use crate::auth::application::port::out::forge::oauth_auth_req_uri::OAuthAuthReqUri;
-
-use self::forgejo::Forgejo;
-
+pub mod forge_factory;
+pub mod forge_repository;
 pub mod forgejo;
 
-#[derive(Clone)]
-pub struct ForgeAdapter {
-    pub oauth_auth_req_uri_adapter: Arc<dyn OAuthAuthReqUri>,
-}
-
-#[derive(Clone, Default)]
-pub struct ForgeRepository {
-    forges: HashMap<SupportedForges, ForgeAdapter>,
-}
-
-impl ForgeRepository {
-    fn add_forge(&mut self, name: SupportedForges, forge_factory: ForgeAdapter) {
-        self.forges.insert(name, forge_factory);
-    }
-
-    pub fn get_supported_forge_str(&self) -> Vec<String> {
-        self.forges
-            .clone()
-            .into_keys()
-            .map(|v| v.to_string())
-            .collect()
-    }
-
-    pub fn get_supported_forges(&self) -> Vec<SupportedForges> {
-        self.forges.clone().into_keys().collect()
-    }
-
-    pub fn get_forge(&self, name: &SupportedForges) -> Option<&ForgeAdapter> {
-        self.forges.get(name)
-    }
-
-    pub fn new(forgejo: Forgejo) -> Self {
-        let forgejo_adapter = ForgeAdapter {
-            oauth_auth_req_uri_adapter: Arc::new(forgejo),
-        };
-        let mut s = Self::default();
-        s.add_forge(SupportedForges::Forgejo, forgejo_adapter);
-        s
-    }
-}
-
 #[derive(Debug, Display, Clone, Hash, Serialize, Deserialize, PartialEq, Eq, PartialOrd, Ord)]
 #[serde(rename_all = "lowercase")]
 pub enum SupportedForges {

src/main.rs

@@ -8,11 +8,6 @@ mod db;
 mod settings;
 mod utils;
 
-pub use crate::auth::adapter::out::{
-    db::DBAdapter,
-    forge::{forgejo::Forgejo, ForgeRepository},
-};
-
 #[actix_web::main]
 async fn main() {
     let settings = settings::Settings::new().unwrap();
@@ -36,11 +31,11 @@ async fn main() {
             .wrap(tracing_actix_web::TracingLogger::default())
             .wrap(middleware::Compress::default())
             .app_data(actix_web::web::Data::new(settings.clone()))
-            .app_data(utils::random_string::GenerateRandomString::inject())
             .wrap(
                 middleware::DefaultHeaders::new().add(("Permissions-Policy", "interest-cohort=()")),
             )
             .configure(auth::adapter::load_adapters(db.pool.clone(), &settings))
+            .configure(utils::random_string::GenerateRandomString::inject())
     })
     .bind(&socket_addr)
     .unwrap()

src/utils/random_string.rs

@@ -4,6 +4,8 @@ use actix_web::web;
 use mockall::predicate::*;
 use mockall::*;
 
+pub type WebGenerateRandomStringInterface = web::Data<Arc<dyn GenerateRandomStringInterface>>;
+
 #[automock]
 pub trait GenerateRandomStringInterface: Send + Sync {
     fn get_random(&self, len: usize) -> String;
@@ -28,9 +30,9 @@ impl GenerateRandomStringInterface for GenerateRandomString {
 
 impl GenerateRandomString {
     pub fn inject() -> impl FnOnce(&mut web::ServiceConfig) {
-        let g: Arc<dyn GenerateRandomStringInterface> = Arc::new(GenerateRandomString);
+        let g = WebGenerateRandomStringInterface::new(Arc::new(GenerateRandomString));
         let f = move |cfg: &mut web::ServiceConfig| {
-            cfg.app_data(web::Data::new(g));
+            cfg.app_data(g);
         };
 
         Box::new(f)