fix(cli): panic on empty commit or empty type

src/git.rs

@@ -228,4 +228,20 @@ Name: Keke";
             Some(("feat".to_string(), None, "add dummy option".to_string()))
         );
     }
+    #[test]
+    fn test_parse_subject_without_message() {
+        let input = "";
+        assert_eq!(
+            parse_subject(input),
+            None
+        );
+    }
+      #[test]
+    fn test_parse_subject_with_error_message() {
+        let input = "test";
+        assert_eq!(
+            parse_subject(input),
+            None
+        );
+    }
 }

src/main.rs

@@ -24,7 +24,7 @@
     };
 
     if args.print_config {
         println!("{}", config.to_string());
     }
 
     let messages = match args.read() {
@@ -39,7 +39,6 @@
         .into_iter()
         .map(|message| {
             let config = config.clone();
-
             tokio::spawn(async move { validate(&message, &config).await })
         })
         .collect::<Vec<_>>();

src/rule/scope.rs

@@ -25,7 +25,7 @@ impl Rule for Scope {
     fn message(&self, message: &Message) -> String {
         format!(
             "scope {} is not allowed. Only {:?} are allowed",
-            message.scope.as_ref().unwrap(),
+            message.scope.as_ref().unwrap_or(&"".to_string()),
             self.options
         )
     }
@@ -122,4 +122,27 @@ mod tests {
             "scope invalid is not allowed. Only [] are allowed".to_string()
         );
     }
+
+    #[test]
+    fn test_without_scope() {
+        let rule = Scope::default();
+
+        let message = Message {
+            body: None,
+            description: None,
+            footers: None,
+            r#type: None,
+            raw: "".to_string(),
+            scope: None,
+            subject: None,
+        };
+
+        let violation = rule.validate(&message);
+        assert!(violation.is_some());
+        assert_eq!(violation.clone().unwrap().level, Level::Error);
+        assert_eq!(
+            violation.unwrap().message,
+            "scope  is not allowed. Only [] are allowed"
+        );
+    }
 }

src/rule/type.rs

@@ -21,11 +21,10 @@ pub struct Type {
 impl Rule for Type {
     const NAME: &'static str = "type";
     const LEVEL: Level = Level::Error;
-
     fn message(&self, message: &Message) -> String {
         format!(
             "type {} is not allowed. Only {:?} are allowed",
-            message.r#type.as_ref().unwrap(),
+            message.r#type.as_ref().unwrap_or(&"".to_string()),
             self.options
         )
     }
@@ -122,4 +121,43 @@ mod tests {
             "type invalid is not allowed. Only [] are allowed".to_string()
         );
     }
+
+    #[test]
+    fn test_empty_message() {
+        let rule = Type::default();
+
+        let message = Message {
+            body: None,
+            description: None,
+            footers: None,
+            r#type: None,
+            raw: "".to_string(),
+            scope: None,
+            subject: None,
+        };
+        assert_eq!(rule.validate(&message).unwrap().level, Level::Error);
+        assert_eq!(
+            rule.validate(&message).unwrap().message,
+            "type  is not allowed. Only [] are allowed".to_string());
+    }
+
+    #[test]
+    fn test_missing_type() {
+        let rule = Type::default();
+        let input = "test".to_string();
+
+        let message = Message {
+            body: None,
+            description: None,
+            footers: None,
+            r#type: None,
+            raw: input.clone(),
+            scope: None,
+            subject: None,
+        };
+        assert_eq!(rule.validate(&message).unwrap().level, Level::Error);
+        assert_eq!(
+            rule.validate(&message).unwrap().message,
+            "type  is not allowed. Only [] are allowed");
+    }
 }