1 files changed, 122 insertions, 3 deletions

diff --git a/src/log/parser.rs b/src/log/parser.rs
index f83bdfb..c2328f8 100644
--- a/src/log/parser.rs
+++ b/src/log/parser.rs
@@ -38,6 +38,26 @@ where
 
 pub struct ParsedLog(Vec<LogItem>);
 
+impl std::fmt::Debug for ParsedLog {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        writeln!(f, "ParsedLog [")?;
+        for (i, line) in self.0.iter().enumerate() {
+            match line {
+                LogItem::Line(l)         => {
+                    let s = std::str::from_utf8(l).unwrap_or("ERROR UTF8 ENCODING");
+                    writeln!(f, "[{}] Line('{}')", i, s)?
+                },
+                LogItem::Progress(u)     => writeln!(f, "[{}] Progress({})", i, u)?,
+                LogItem::CurrentPhase(s) => writeln!(f, "[{}] Phase({})", i, s)?,
+                LogItem::State(Ok(_))    => writeln!(f, "[{}] State::OK", i)?,
+                LogItem::State(Err(_))   => writeln!(f, "[{}] State::Err", i)?,
+            }
+        }
+
+        writeln!(f, "]")
+    }
+}
+
 impl FromStr for ParsedLog {
     type Err = anyhow::Error;
 
@@ -50,17 +70,35 @@ impl FromStr for ParsedLog {
     }
 }
 
+#[derive(Debug, Eq, PartialEq)]
+pub enum JobResult {
+    Success,
+    Errored,
+    Unknown
+}
+
+impl JobResult {
+    pub fn to_bool(&self) -> Option<bool> {
+        match self {
+            JobResult::Success => Some(true),
+            JobResult::Errored => Some(false),
+            JobResult::Unknown => None,
+        }
+    }
+}
+
 impl ParsedLog {
-    pub fn is_successfull(&self) -> Option<bool> {
+    pub fn is_successfull(&self) -> JobResult {
         self.0
             .iter()
             .rev()
             .filter_map(|line| match line {
-                LogItem::State(Ok(_)) => Some(true),
-                LogItem::State(Err(_)) => Some(false),
+                LogItem::State(Ok(_))  => Some(JobResult::Success),
+                LogItem::State(Err(_)) => Some(JobResult::Errored),
                 _ => None,
             })
             .next()
+            .unwrap_or(JobResult::Unknown)
     }
 
     pub fn into_iter(self) -> impl Iterator<Item = LogItem> {
@@ -345,4 +383,85 @@ mod tests {
             assert!(i.next().is_none());
         }
     }
+
+    #[test]
+    fn test_is_successfull_1() {
+        let buffer: &'static str = indoc::indoc! {"
+            foo bar
+        "};
+
+        let log = ParsedLog::from_str(buffer).unwrap();
+        assert_eq!(log.is_successfull(), JobResult::Unknown);
+    }
+
+    #[test]
+    fn test_is_successfull_2() {
+        let buffer: &'static str = indoc::indoc! {"
+            #BUTIDO:PROGRESS:1
+        "};
+
+        let log = ParsedLog::from_str(buffer).unwrap();
+        assert_eq!(log.is_successfull(), JobResult::Unknown);
+    }
+
+    #[test]
+    fn test_is_successfull_3() {
+        let buffer: &'static str = indoc::indoc! {"
+            #BUTIDO:PHASE:a
+        "};
+
+        let log = ParsedLog::from_str(buffer).unwrap();
+        assert_eq!(log.is_successfull(), JobResult::Unknown);
+    }
+
+    #[test]
+    fn test_successfull_4() {
+        let buffer: &'static str = indoc::indoc! {"
+            #BUTIDO:STATE:OK
+        "};
+
+        let log = ParsedLog::from_str(buffer).unwrap();
+        assert_eq!(log.is_successfull(), JobResult::Success);
+    }
+
+    #[test]
+    fn test_successfull_5() {
+        let buffer: &'static str = indoc::indoc! {"
+            #BUTIDO:STATE:ERR:FOO
+        "};
+
+        let log = ParsedLog::from_str(buffer).unwrap();
+        assert_eq!(log.is_successfull(), JobResult::Errored);
+    }
+
+    #[test]
+    fn test_successfull_6() {
+        let buffer: &'static str = indoc::indoc! {"
+            #BUTIDO:PROGRESS:0
+            Some log line
+            #BUTIDO:PHASE:configure
+            Some log line
+            Some log line
+            Some log line
+            #BUTIDO:PHASE:Build
+            Some other log line
+            Some other log line
+            Some other log line
+            #BUTIDO:STATE:OK
+        "};
+
+        let log = ParsedLog::from_str(buffer).unwrap();
+        assert_eq!(log.is_successfull(), JobResult::Success);
+    }
+
+    #[test]
+    fn test_successfull_7() {
+        let buffer: &'static str = indoc::indoc! {"
+            make: *** No targets specified and no makefile found.  Stop.
+            #BUTIDO:STATE:ERR:make failed
+        "};
+
+        let log = ParsedLog::from_str(buffer).unwrap();
+        assert_eq!(log.is_successfull(), JobResult::Errored);
+    }
 }