feat: added tests for shared types and refactored

crates/configuration/src/shared/errors.rs

@@ -78,14 +78,11 @@ pub enum FieldError<E> {
     LimitCpu(E),
 }
 
-#[derive(thiserror::Error, Debug)]
+#[derive(thiserror::Error, Debug, Clone)]
 pub enum ConversionError {
     #[error("'{0}' shouldn't contains whitespace")]
     ContainsWhitespaces(String),
 
     #[error("'{}' doesn't match regex '{}'", .value, .regex)]
     DoesntMatchRegex { value: String, regex: String },
-
-    #[error("unable to convert '{0}' into url::Url or path::PathBuf")]
-    InvalidUrlOrPathBuf(String),
 }

crates/configuration/src/shared/types.rs

@@ -107,37 +107,15 @@ impl From<PathBuf> for AssetLocation {
     }
 }
 
-impl TryFrom<&str> for AssetLocation {
-    type Error = ConversionError;
-
-    fn try_from(value: &str) -> Result<Self, Self::Error> {
+impl From<&str> for AssetLocation {
+    fn from(value: &str) -> Self {
         if let Ok(parsed_url) = Url::parse(value) {
-            return Ok(Self::Url(parsed_url));
-        }
-
-        if let Ok(parsed_path) = PathBuf::from_str(value) {
-            return Ok(Self::FilePath(parsed_path));
-        }
-
-        Err(ConversionError::InvalidUrlOrPathBuf(value.to_string()))
-    }
-}
-
-impl AssetLocation {
-    pub fn as_url(&self) -> Option<&Url> {
-        if let Self::Url(url) = self {
-            Some(url)
-        } else {
-            None
+            return Self::Url(parsed_url);
         }
-    }
 
-    pub fn as_path_buf(&self) -> Option<&PathBuf> {
-        if let Self::FilePath(path) = self {
-            Some(path)
-        } else {
-            None
-        }
+        Self::FilePath(
+            PathBuf::from_str(value).expect("infaillible. this is a bug, please report it"),
+        )
     }
 }
 
@@ -160,3 +138,189 @@ impl From<(&str, &str)> for Arg {
         Self::Option(option.to_owned(), value.to_owned())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_without_whitespaces_into_a_chain() {
+        let got: Result<Chain, ConversionError> = "mychain".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "mychain");
+    }
+
+    #[test]
+    fn we_shouldnt_be_able_to_convert_a_str_with_whitespaces_into_a_chain() {
+        let got: Result<Chain, ConversionError> = "my chain".try_into();
+
+        assert!(matches!(
+            got.clone().unwrap_err(),
+            ConversionError::ContainsWhitespaces(_)
+        ));
+        assert_eq!(
+            got.unwrap_err().to_string(),
+            "'my chain' shouldn't contains whitespace"
+        );
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_containing_tag_name_into_an_image() {
+        let got: Result<Image, ConversionError> = "myimage".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "myimage");
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_containing_tag_name_and_tag_version_into_an_image() {
+        let got: Result<Image, ConversionError> = "myimage:version".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "myimage:version");
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_containing_hostname_and_tag_name_into_an_image() {
+        let got: Result<Image, ConversionError> = "myrepository.com/myimage".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "myrepository.com/myimage");
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_containing_hostname_tag_name_and_tag_version_into_an_image(
+    ) {
+        let got: Result<Image, ConversionError> = "myrepository.com/myimage:version".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "myrepository.com/myimage:version");
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_containing_ip_and_tag_name_into_an_image() {
+        let got: Result<Image, ConversionError> = "myrepository.com/myimage".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "myrepository.com/myimage");
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_containing_ip_tag_name_and_tag_version_into_an_image() {
+        let got: Result<Image, ConversionError> = "127.0.0.1/myimage:version".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "127.0.0.1/myimage:version");
+    }
+
+    #[test]
+    fn we_shouldnt_be_able_to_convert_a_str_containing_only_ip_into_an_image() {
+        let got: Result<Image, ConversionError> = "127.0.0.1".try_into();
+
+        assert!(matches!(
+            got.clone().unwrap_err(),
+            ConversionError::DoesntMatchRegex { value: _, regex: _ }
+        ));
+        assert_eq!(
+            got.unwrap_err().to_string(),
+            "'127.0.0.1' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'"
+        );
+    }
+
+    #[test]
+    fn we_shouldnt_be_able_to_convert_a_str_containing_only_ip_and_tag_version_into_an_image() {
+        let got: Result<Image, ConversionError> = "127.0.0.1:version".try_into();
+
+        assert!(matches!(
+            got.clone().unwrap_err(),
+            ConversionError::DoesntMatchRegex { value: _, regex: _ }
+        ));
+        assert_eq!(got.unwrap_err().to_string(), "'127.0.0.1:version' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'");
+    }
+    #[test]
+    fn we_shouldnt_be_able_to_convert_a_str_containing_only_hostname_into_an_image() {
+        let got: Result<Image, ConversionError> = "myrepository.com".try_into();
+
+        assert!(matches!(
+            got.clone().unwrap_err(),
+            ConversionError::DoesntMatchRegex { value: _, regex: _ }
+        ));
+        assert_eq!(got.unwrap_err().to_string(), "'myrepository.com' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'");
+    }
+
+    #[test]
+    fn we_shouldnt_be_able_to_convert_a_str_containing_only_hostname_and_tag_version_into_an_image()
+    {
+        let got: Result<Image, ConversionError> = "myrepository.com:version".try_into();
+
+        assert!(matches!(
+            got.clone().unwrap_err(),
+            ConversionError::DoesntMatchRegex { value: _, regex: _ }
+        ));
+        assert_eq!(got.unwrap_err().to_string(), "'myrepository.com:version' doesn't match regex '^([ip]|[hostname]/)?[tag_name]:[tag_version]?$'");
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_without_whitespaces_into_a_command() {
+        let got: Result<Command, ConversionError> = "mycommand".try_into();
+
+        assert_eq!(got.unwrap().as_str(), "mycommand");
+    }
+
+    #[test]
+    fn we_shouldnt_be_able_to_convert_a_str_with_whitespaces_into_a_command() {
+        let got: Result<Command, ConversionError> = "my command".try_into();
+
+        assert!(matches!(
+            got.clone().unwrap_err(),
+            ConversionError::ContainsWhitespaces(_)
+        ));
+        assert_eq!(
+            got.unwrap_err().to_string(),
+            "'my command' shouldn't contains whitespace"
+        );
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_an_url_into_an_asset_location() {
+        let url = Url::from_str("https://mycloudstorage.com/path/to/my/file.tgz").unwrap();
+        let got: AssetLocation = url.clone().into();
+
+        assert!(matches!(got, AssetLocation::Url(value) if value == url));
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_pathbuf_into_an_asset_location() {
+        let pathbuf = PathBuf::from_str("/tmp/path/to/my/file").unwrap();
+        let got: AssetLocation = pathbuf.clone().into();
+
+        assert!(matches!(got, AssetLocation::FilePath(value) if value == pathbuf));
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_into_an_url_asset_location() {
+        let url = "https://mycloudstorage.com/path/to/my/file.tgz";
+        let got: AssetLocation = url.into();
+
+        assert!(matches!(got, AssetLocation::Url(value) if value == Url::from_str(url).unwrap()));
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_into_an_filepath_asset_location() {
+        let filepath = "/tmp/path/to/my/file";
+        let got: AssetLocation = filepath.into();
+
+        assert!(matches!(
+            got,
+            AssetLocation::FilePath(value) if value == PathBuf::from_str(filepath).unwrap()
+        ));
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_into_an_flag_arg() {
+        let got: Arg = "myflag".into();
+
+        assert!(matches!(got, Arg::Flag(flag) if flag == "myflag"));
+    }
+
+    #[test]
+    fn we_should_be_able_to_convert_a_str_tuple_into_an_option_arg() {
+        let got: Arg = ("name", "value").into();
+
+        assert!(matches!(got, Arg::Option(name, value) if name == "name" && value == "value"));
+    }
+}