refactor: Rename configuration to config profiles

Refs: #1

src-tauri/src/core.rs

@@ -1 +1 @@
-pub mod configuration;
+pub mod profile;

src-tauri/src/core/profile/api.rs

@@ -0,0 +1,6 @@
+use crate::core::profile::domain::{ConfigProfiles};
+use crate::core::profile::error::ConfigProfilesError;
+
+pub trait ConfigProfilesAPI {
+    fn get_config_profiles() -> Result<ConfigProfiles, ConfigProfilesError>;
+}

src-tauri/src/core/configuration/domain.rs → src-tauri/src/core/profile/domain.rs

@@ -4,7 +4,7 @@ use derivative::Derivative;
 use error_stack::{Report, Result};
 use secstr::SecStr;
 
-use crate::core::configuration::error::ConfigurationError;
+use crate::core::profile::error::ConfigProfilesError;
 
 #[derive(Debug, Eq, PartialEq, Clone)]
 pub struct Credentials {
@@ -45,22 +45,22 @@ impl Settings {
 
 #[derive(Derivative)]
 #[derivative(Debug, Eq, PartialEq)]
-pub struct Configuration {
+pub struct ConfigProfiles {
     profiles: HashMap<String, Settings>,
     #[derivative(Debug = "ignore")]
     #[derivative(PartialEq = "ignore")]
-    pub errors: Vec<Report<ConfigurationError>>,
+    pub errors: Vec<Report<ConfigProfilesError>>,
 }
 
-impl Configuration {
+impl ConfigProfiles {
     pub fn new() -> Self {
         Self { profiles: HashMap::new(), errors: Vec::new() }
     }
 
     // changed from String to &str
-    pub fn add_profile(&mut self, name: &str, settings: Settings) -> Result<(), ConfigurationError> {
+    pub fn add_profile(&mut self, name: &str, settings: Settings) -> Result<(), ConfigProfilesError> {
         if name.trim().is_empty() {
-            return Err(Report::new(ConfigurationError::InvalidProfileNameError)
+            return Err(Report::new(ConfigProfilesError::InvalidProfileNameError)
                 .attach_printable("profile name can not be empty or blank"));
         }
         self.profiles.insert(name.to_string(), settings);  // convert to String here as hashmap key is String
@@ -80,13 +80,13 @@ mod tests {
     use spectral::prelude::*;
 
     use crate::common::test::report_utils::messages;
-    use crate::core::configuration::error::ConfigurationError;
+    use crate::core::profile::error::ConfigProfilesError;
 
     use super::*;
 
     #[test]
     fn should_add_profile() {
-        let mut cut: Configuration = Configuration::new();
+        let mut cut: ConfigProfiles = ConfigProfiles::new();
         let input_settings: Settings = Settings { ..Default::default() };
         let input_profile: String = Word().fake();
 
@@ -101,22 +101,22 @@ mod tests {
     #[case("")]
     #[case(" ")]
     fn should_return_error_when_key_is_blank(#[case] input_profile: &str) {
-        let mut cut: Configuration = Configuration::new();
+        let mut cut: ConfigProfiles = ConfigProfiles::new();
         let input_settings: Settings = Settings { ..Default::default() };
 
         let actual = cut.add_profile(input_profile, input_settings);
 
         assert_that(&actual).is_err();
         let report = actual.unwrap_err();
-        assert!(report.contains::<ConfigurationError>());
+        assert!(report.contains::<ConfigProfilesError>());
         let messages = messages(report);
         assert_that(&messages).has_length(1);
         assert_that(&messages).contains(String::from("profile name can not be empty or blank"));
     }
 
     #[test]
     fn should_return_profiles() {
-        let mut cut: Configuration = Configuration::new();
+        let mut cut: ConfigProfiles = ConfigProfiles::new();
         let input_settings: Settings = Settings { ..Default::default() };
         let input_profile = Word().fake();
 

src-tauri/src/core/configuration/error.rs → src-tauri/src/core/profile/error.rs

@@ -2,21 +2,21 @@ use std::fmt::{Debug, Display, Formatter};
 use error_stack::{Context};
 
 #[derive(Debug, Eq, PartialEq)]
-pub enum ConfigurationError {
+pub enum ConfigProfilesError {
     InvalidProfileNameError,
-    ProfileLoadError,
+    ConfigLoadError,
 }
 
-impl Display for ConfigurationError {
+impl Display for ConfigProfilesError {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            ConfigurationError::InvalidProfileNameError => write!(f, "invalid profile name"),
-            ConfigurationError::ProfileLoadError => write!(f, "failed to load profile")
+            ConfigProfilesError::InvalidProfileNameError => write!(f, "invalid profile name"),
+            ConfigProfilesError::ConfigLoadError => write!(f, "failed to load config")
         }
     }
 }
 
-impl Context for ConfigurationError {}
+impl Context for ConfigProfilesError {}
 
 #[cfg(test)]
 mod tests {
@@ -26,13 +26,13 @@ mod tests {
     fn given_invalid_profile_error_should_output_expected_error_message_when_printed() {
         let expected = "invalid profile name";
 
-        assert_eq!(format!("{}", ConfigurationError::InvalidProfileNameError), expected)
+        assert_eq!(format!("{}", ConfigProfilesError::InvalidProfileNameError), expected)
     }
 
     #[test]
     fn given_profile_load_error_should_output_expected_error_message_when_printed() {
-        let expected = "failed to load profile";
+        let expected = "failed to load config";
 
-        assert_eq!(format!("{}", ConfigurationError::ProfileLoadError), expected)
+        assert_eq!(format!("{}", ConfigProfilesError::ConfigLoadError), expected)
     }
 }

src-tauri/src/core/profile/spi.rs

@@ -0,0 +1,9 @@
+use async_trait::async_trait;
+use crate::core::profile::domain::{ConfigProfiles};
+use crate::core::profile::error::ConfigProfilesError;
+use error_stack::{Result};
+
+#[async_trait]
+pub trait ConfigProfilesSPI {
+    async fn load_config_profiles(&self) -> Result<ConfigProfiles, ConfigProfilesError>;
+}

src-tauri/src/infrastructure/aws/sdk_config/configuration_adapter.rs

@@ -3,15 +3,15 @@ use aws_config::profile::Profile;
 use error_stack::Report;
 use secstr::SecStr;
 
-use crate::core::configuration::domain::{Config, Configuration, Credentials, Settings};
-use crate::core::configuration::error::ConfigurationError;
-use crate::core::configuration::spi::ConfigurationSPI;
+use crate::core::profile::domain::{Config, ConfigProfiles, Credentials, Settings};
+use crate::core::profile::error::ConfigProfilesError;
+use crate::core::profile::spi::ConfigProfilesSPI;
 
-pub struct ConfigurationAdapter;
+pub struct ConfigProfilesAdapter;
 
 #[async_trait]
-impl ConfigurationSPI for ConfigurationAdapter {
-    async fn load_configuration(&self) -> error_stack::Result<Configuration, ConfigurationError> {
+impl ConfigProfilesSPI for ConfigProfilesAdapter {
+    async fn load_config_profiles(&self) -> error_stack::Result<ConfigProfiles, ConfigProfilesError> {
         // See https://docs.rs/aws-config/latest/aws_config/profile/index.html
         let result = aws_config::profile::load(
             &Default::default(),
@@ -23,7 +23,7 @@ impl ConfigurationSPI for ConfigurationAdapter {
         match result {
             Ok(profile_set) => {
                 let profile_names = profile_set.profiles();
-                let mut configuration = Configuration::new();
+                let mut configuration = ConfigProfiles::new();
 
                 for profile_name in profile_names {
                     if let Some(profile) = profile_set.get_profile(profile_name) {
@@ -44,7 +44,7 @@ impl ConfigurationSPI for ConfigurationAdapter {
             }
             Err(e) => {
                 Err(Report::from(e)
-                    .change_context(ConfigurationError::ProfileLoadError))
+                    .change_context(ConfigProfilesError::ConfigLoadError))
             }
         }
     }

src-tauri/tests/configuration_adapter_test.rs

@@ -9,10 +9,10 @@ mod tests {
     use tempfile::{TempDir, tempdir};
     use test_context::{AsyncTestContext, test_context};
 
-    use app::core::configuration::domain::{Config, Credentials, Settings};
-    use app::core::configuration::error::ConfigurationError;
-    use app::core::configuration::spi::ConfigurationSPI;
-    use app::infrastructure::aws::sdk_config::configuration_adapter::ConfigurationAdapter;
+    use app::core::profile::domain::{Config, Credentials, Settings};
+    use app::core::profile::error::ConfigProfilesError;
+    use app::core::profile::spi::ConfigProfilesSPI;
+    use app::infrastructure::aws::sdk_config::configuration_adapter::ConfigProfilesAdapter;
 
     struct ValidContext {
         _test_dir: TempDir,
@@ -108,13 +108,13 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn should_load_config_from_environment(_: &mut ValidContext) {
-        let cut: Box<dyn ConfigurationSPI> = Box::new(ConfigurationAdapter);
+        let cut: Box<dyn ConfigProfilesSPI> = Box::new(ConfigProfilesAdapter);
         let dev_settings = Settings::new(
             Credentials::new(Some("devAccessKeyID".to_string()), Some(SecStr::from("devSecretAccessKey"))),
             Config::new(Some("eu-west-1".to_string()), Some("json".to_string())),
         );
 
-        let result = cut.load_configuration().await;
+        let result = cut.load_config_profiles().await;
 
         assert_that(&result).is_ok();
         let actual = result.unwrap();
@@ -127,18 +127,18 @@ mod tests {
     #[tokio::test]
     #[serial]
     async fn should_have_errors_when_loading_config_with_invalid_profile_name(_: &mut InvalidContext) {
-        let cut: Box<dyn ConfigurationSPI> = Box::new(ConfigurationAdapter);
+        let cut: Box<dyn ConfigProfilesSPI> = Box::new(ConfigProfilesAdapter);
 
-        let result = cut.load_configuration().await;
+        let result = cut.load_config_profiles().await;
 
         assert_that(&result).is_ok();
         let config = result.unwrap();
         assert_that(&config.errors).has_length(1);
         let is_invalid_profile_name_error = *&config.errors.get(0).unwrap()
-            .contains::<ConfigurationError>();
+            .contains::<ConfigProfilesError>();
         assert_that(&is_invalid_profile_name_error).is_true();
         let actual = *&config.errors.get(0).unwrap()
-            .downcast_ref::<ConfigurationError>().unwrap();
-        assert_that(&actual).is_equal_to(&ConfigurationError::InvalidProfileNameError);
+            .downcast_ref::<ConfigProfilesError>().unwrap();
+        assert_that(&actual).is_equal_to(&ConfigProfilesError::InvalidProfileNameError);
     }
 }