Merge pull request #46 from Coduck-Team/43-replace-with-rstest

Refactor some unit test code with 'rstest'

Author: utilForever

Cargo.toml

@@ -21,3 +21,4 @@ tokio = { version = "1.45.1", features = ["full"] }
 uuid = { version = "1.17.0", features = ["v4"] }
 
 [dev-dependencies]
+rstest = "0.25.0"

src/file_manager/models.rs

@@ -77,83 +77,59 @@ impl Language {
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    #[test]
-    fn can_parse_language_from_valid_filename() {
-        assert_eq!(
-            Language::from_filename("solution.py").unwrap(),
-            Language::Python
-        );
-        assert_eq!(
-            Language::from_filename("test.PY").unwrap(),
-            Language::Python
-        );
-
-        assert_eq!(
-            Language::from_filename("Solution.java").unwrap(),
-            Language::Java
-        );
-
-        assert_eq!(Language::from_filename("code.cpp").unwrap(), Language::Cpp);
-
-        assert_eq!(
-            Language::from_filename("input.in").unwrap(),
-            Language::Input
-        );
-
-        assert_eq!(
-            Language::from_filename("output.out").unwrap(),
-            Language::Output
-        );
+    use rstest::rstest;
+
+    #[rstest]
+    #[case("solution.py", Language::Python)]
+    #[case("test.PY", Language::Python)]
+    #[case("Solution.java", Language::Java)]
+    #[case("code.cpp", Language::Cpp)]
+    #[case("input.in", Language::Input)]
+    #[case("output.out", Language::Output)]
+    fn can_parse_language_from_valid_filename(#[case] filename: &str, #[case] expected: Language) {
+        assert_eq!(Language::from_filename(filename).unwrap(), expected);
     }
 
-    #[test]
-    fn fails_to_parse_language_from_invalid_filename() {
+    #[rstest]
+    #[case(".java", LanguageError::InvalidFilename)]
+    #[case("py", LanguageError::InvalidFilename)]
+    #[case("file.", LanguageError::InvalidFilename)]
+    #[case("run.exe", LanguageError::UnsupportedExtension("exe".to_string()))]
+    #[case("", LanguageError::InvalidFilename)]
+    fn fail_to_parse_language_from_invalid_filename(
+        #[case] filename: &str,
+        #[case] expected_error: LanguageError,
+    ) {
         assert_eq!(
-            Language::from_filename(".java").unwrap_err(),
-            LanguageError::InvalidFilename
-        );
-
-        assert_eq!(
-            Language::from_filename("py").unwrap_err(),
-            LanguageError::InvalidFilename
-        );
-
-        assert_eq!(
-            Language::from_filename("file.").unwrap_err(),
-            LanguageError::InvalidFilename
-        );
-
-        assert_eq!(
-            Language::from_filename("run.exe").unwrap_err(),
-            LanguageError::UnsupportedExtension("exe".to_string())
-        );
-
-        assert_eq!(
-            Language::from_filename("").unwrap_err(),
-            LanguageError::InvalidFilename
+            Language::from_filename(filename).unwrap_err(),
+            expected_error
         );
     }
 
-    #[test]
-    fn can_parse_language_from_valid_extension() {
-        assert_eq!(Language::from_extension("py").unwrap(), Language::Python);
-        assert_eq!(Language::from_extension("java").unwrap(), Language::Java);
-        assert_eq!(Language::from_extension("cpp").unwrap(), Language::Cpp);
-        assert_eq!(Language::from_extension("txt").unwrap(), Language::Text);
-        assert_eq!(Language::from_extension("in").unwrap(), Language::Input);
-        assert_eq!(Language::from_extension("out").unwrap(), Language::Output);
+    #[rstest]
+    #[case("py", Language::Python)]
+    #[case("java", Language::Java)]
+    #[case("cpp", Language::Cpp)]
+    #[case("txt", Language::Text)]
+    #[case("in", Language::Input)]
+    #[case("out", Language::Output)]
+    fn can_parse_language_from_valid_extension(
+        #[case] extension: &str,
+        #[case] expected: Language,
+    ) {
+        assert_eq!(Language::from_extension(extension).unwrap(), expected);
     }
 
-    #[test]
-    fn fails_to_parse_language_from_invalid_extension() {
-        assert_eq!(
-            Language::from_extension("").unwrap_err(),
-            LanguageError::UnsupportedExtension("".to_string())
-        );
+    #[rstest]
+    #[case("", LanguageError::UnsupportedExtension("".to_string()))]
+    #[case("no", LanguageError::UnsupportedExtension("no".to_string()))]
+    fn fail_to_parse_language_from_invalid_extension(
+        #[case] extension: &str,
+        #[case] expected_error: LanguageError,
+    ) {
         assert_eq!(
-            Language::from_extension("no").unwrap_err(),
-            LanguageError::UnsupportedExtension("no".to_string())
+            Language::from_extension(extension).unwrap_err(),
+            expected_error
         );
     }
 }