results: add failure reason to build/test failures

Author: pietroalbini

Cargo.lock

@@ -27,6 +27,7 @@ lazy_static = "1.0"
 mime = "0.3.1"
 minifier = { version = "0.0.20", features = ["html"] }
 nix = "0.11.0"
+paste = "0.1.3"
 petgraph = "0.4.11"
 r2d2 = "0.8.2"
 r2d2_sqlite = "0.7.0"

Cargo.toml

@@ -21,6 +21,8 @@ extern crate mime;
 extern crate minifier;
 #[cfg(unix)]
 extern crate nix;
+#[macro_use]
+extern crate paste;
 extern crate petgraph;
 extern crate r2d2;
 extern crate r2d2_sqlite;

src/lib.rs

@@ -1,5 +1,22 @@
+use failure::Context;
 pub use failure::{err_msg, Fail, Fallible, ResultExt};
 
+pub trait FailExt {
+    fn downcast_ctx<T: Fail>(&self) -> Option<&T>;
+}
+
+impl FailExt for dyn Fail {
+    fn downcast_ctx<T: Fail>(&self) -> Option<&T> {
+        if let Some(res) = self.downcast_ref::<T>() {
+            Some(res)
+        } else if let Some(ctx) = self.downcast_ref::<Context<T>>() {
+            Some(ctx.get_context())
+        } else {
+            None
+        }
+    }
+}
+
 macro_rules! to_failure_compat {
     ($($error:path,)*) => {
         pub trait ToFailureCompat<T> {

src/prelude.rs

@@ -100,7 +100,7 @@ mod tests {
     use flate2::read::GzDecoder;
     use mime::Mime;
     use report::DummyWriter;
-    use results::{DatabaseDB, TestResult, WriteResults};
+    use results::{DatabaseDB, FailureReason, TestResult, WriteResults};
     use std::io::Read;
     use tar::Archive;
 
@@ -130,7 +130,7 @@ mod tests {
         results
             .record_result(&ex, &ex.toolchains[1], &crate1, || {
                 info!("tc2 crate1");
-                Ok(TestResult::BuildFail)
+                Ok(TestResult::BuildFail(FailureReason::Unknown))
             }).unwrap();
         results
             .record_result(&ex, &ex.toolchains[0], &crate2, || {

src/report/archives.rs

@@ -4,7 +4,7 @@ use mime;
 use minifier;
 use prelude::*;
 use report::{archives::Archive, Comparison, CrateResult, ReportWriter, TestResults};
-use results::TestResult;
+use results::{FailureReason, TestResult};
 use std::collections::HashMap;
 
 #[derive(Serialize)]
@@ -36,14 +36,41 @@ impl ResultColor for Comparison {
 impl ResultColor for TestResult {
     fn color(&self) -> Color {
         match self {
-            TestResult::BuildFail => Color::Single("#db3026"),
-            TestResult::TestFail => Color::Single("#65461e"),
+            TestResult::BuildFail(_) => Color::Single("#db3026"),
+            TestResult::TestFail(_) => Color::Single("#65461e"),
             TestResult::TestSkipped | TestResult::TestPass => Color::Single("#62a156"),
             TestResult::Error => Color::Single("#d77026"),
         }
     }
 }
 
+trait ResultName {
+    fn name(&self) -> String;
+}
+
+impl ResultName for FailureReason {
+    fn name(&self) -> String {
+        match self {
+            FailureReason::Unknown => "failed".into(),
+            FailureReason::Broken => "broken".into(),
+            FailureReason::Timeout => "timed out".into(),
+            FailureReason::OOM => "OOM".into(),
+        }
+    }
+}
+
+impl ResultName for TestResult {
+    fn name(&self) -> String {
+        match self {
+            TestResult::BuildFail(reason) => format!("build {}", reason.name()),
+            TestResult::TestFail(reason) => format!("test {}", reason.name()),
+            TestResult::TestSkipped => "test skipped".into(),
+            TestResult::TestPass => "test passed".into(),
+            TestResult::Error => "error".into(),
+        }
+    }
+}
+
 #[derive(Serialize)]
 struct NavbarItem {
     label: &'static str,
@@ -90,6 +117,7 @@ struct ResultsContext<'a> {
 
     comparison_colors: HashMap<Comparison, Color>,
     result_colors: HashMap<TestResult, Color>,
+    result_names: HashMap<TestResult, String>,
 }
 
 #[derive(Serialize)]
@@ -110,6 +138,7 @@ fn write_report<W: ReportWriter>(
 ) -> Fallible<()> {
     let mut comparison_colors = HashMap::new();
     let mut result_colors = HashMap::new();
+    let mut result_names = HashMap::new();
 
     let mut categories = HashMap::new();
     for result in &res.crates {
@@ -118,19 +147,25 @@ fn write_report<W: ReportWriter>(
             continue;
         }
 
-        // Add the colors used in this run
+        // Add the colors and names used in this run
         comparison_colors
             .entry(result.res)
             .or_insert_with(|| result.res.color());
         if let Some(ref run) = result.runs[0] {
             result_colors
                 .entry(run.res)
                 .or_insert_with(|| run.res.color());
+            result_names
+                .entry(run.res)
+                .or_insert_with(|| run.res.name());
         }
         if let Some(ref run) = result.runs[1] {
             result_colors
                 .entry(run.res)
                 .or_insert_with(|| run.res.color());
+            result_names
+                .entry(run.res)
+                .or_insert_with(|| run.res.name());
         }
 
         let mut category = categories.entry(result.res).or_insert_with(Vec::new);
@@ -150,6 +185,7 @@ fn write_report<W: ReportWriter>(
 
         comparison_colors,
         result_colors,
+        result_names,
     };
 
     info!("generating {}", to);

src/report/html.rs

@@ -296,22 +296,22 @@ fn compare(
     use results::TestResult::*;
     match (r1, r2) {
         (Some(res1), Some(res2)) => match (res1, res2) {
-            (BuildFail, BuildFail) => Comparison::SameBuildFail,
-            (TestFail, TestFail) => Comparison::SameTestFail,
+            (BuildFail(_), BuildFail(_)) => Comparison::SameBuildFail,
+            (TestFail(_), TestFail(_)) => Comparison::SameTestFail,
             (TestSkipped, TestSkipped) => Comparison::SameTestSkipped,
             (TestPass, TestPass) => Comparison::SameTestPass,
-            (BuildFail, TestFail)
-            | (BuildFail, TestSkipped)
-            | (BuildFail, TestPass)
-            | (TestFail, TestPass) => Comparison::Fixed,
-            (TestPass, TestFail)
-            | (TestPass, BuildFail)
-            | (TestSkipped, BuildFail)
-            | (TestFail, BuildFail) => Comparison::Regressed,
+            (BuildFail(_), TestFail(_))
+            | (BuildFail(_), TestSkipped)
+            | (BuildFail(_), TestPass)
+            | (TestFail(_), TestPass) => Comparison::Fixed,
+            (TestPass, TestFail(_))
+            | (TestPass, BuildFail(_))
+            | (TestSkipped, BuildFail(_))
+            | (TestFail(_), BuildFail(_)) => Comparison::Regressed,
             (Error, _) | (_, Error) => Comparison::Error,
-            (TestFail, TestSkipped)
+            (TestFail(_), TestSkipped)
             | (TestPass, TestSkipped)
-            | (TestSkipped, TestFail)
+            | (TestSkipped, TestFail(_))
             | (TestSkipped, TestPass) => {
                 panic!("can't compare {} and {}", res1, res2);
             }
@@ -426,7 +426,7 @@ mod tests {
     use config::{Config, CrateConfig};
     use crates::{Crate, GitHubRepo, RegistryCrate};
     use experiments::{CapLints, Experiment, Mode, Status};
-    use results::{DummyDB, TestResult};
+    use results::{DummyDB, FailureReason, TestResult};
     use std::collections::HashMap;
     use toolchain::{MAIN_TOOLCHAIN, TEST_TOOLCHAIN};
 
@@ -515,15 +515,17 @@ mod tests {
 
     #[test]
     fn test_compare() {
+        use results::{FailureReason::*, TestResult::*};
+
         macro_rules! test_compare {
-            ($cmp:ident, $config:expr, $reg:expr, [$($a:ident + $b:ident = $c:ident,)*]) => {
+            ($cmp:ident, $config:expr, $reg:expr, [$($a:expr, $b:expr => $c:ident;)*]) => {
                 $(
                     assert_eq!(
                         $cmp(
                             $config,
                             $reg,
-                            Some(TestResult::$a),
-                            Some(TestResult::$b),
+                            Some($a),
+                            Some($b),
                         ),
                         Comparison::$c
                     );
@@ -542,26 +544,26 @@ mod tests {
             &config,
             &reg,
             [
-                BuildFail + BuildFail = SameBuildFail,
-                TestFail + TestFail = SameTestFail,
-                TestSkipped + TestSkipped = SameTestSkipped,
-                TestPass + TestPass = SameTestPass,
-                BuildFail + TestFail = Fixed,
-                BuildFail + TestSkipped = Fixed,
-                BuildFail + TestPass = Fixed,
-                TestFail + TestPass = Fixed,
-                TestPass + TestFail = Regressed,
-                TestPass + BuildFail = Regressed,
-                TestSkipped + BuildFail = Regressed,
-                TestFail + BuildFail = Regressed,
-                Error + TestPass = Error,
-                Error + TestSkipped = Error,
-                Error + TestFail = Error,
-                Error + BuildFail = Error,
-                TestPass + Error = Error,
-                TestSkipped + Error = Error,
-                TestFail + Error = Error,
-                BuildFail + Error = Error,
+                BuildFail(Unknown), BuildFail(Unknown) => SameBuildFail;
+                TestFail(Unknown), TestFail(Unknown) => SameTestFail;
+                TestSkipped, TestSkipped => SameTestSkipped;
+                TestPass, TestPass => SameTestPass;
+                BuildFail(Unknown), TestFail(Unknown) => Fixed;
+                BuildFail(Unknown), TestSkipped => Fixed;
+                BuildFail(Unknown), TestPass => Fixed;
+                TestFail(Unknown), TestPass => Fixed;
+                TestPass, TestFail(Unknown) => Regressed;
+                TestPass, BuildFail(Unknown) => Regressed;
+                TestSkipped, BuildFail(Unknown) => Regressed;
+                TestFail(Unknown), BuildFail(Unknown) => Regressed;
+                Error, TestPass => Error;
+                Error, TestSkipped => Error;
+                Error, TestFail(Unknown) => Error;
+                Error, BuildFail(Unknown) => Error;
+                TestPass, Error => Error;
+                TestSkipped, Error => Error;
+                TestFail(Unknown), Error => Error;
+                BuildFail(Unknown), Error => Error;
             ]
         );
 
@@ -618,7 +620,7 @@ mod tests {
             &ex,
             gh.clone(),
             TEST_TOOLCHAIN.clone(),
-            TestResult::BuildFail,
+            TestResult::BuildFail(FailureReason::Unknown),
         );
         db.add_dummy_log(
             &ex,
@@ -668,7 +670,7 @@ mod tests {
         );
         assert_eq!(
             (&crate_result.runs[1]).as_ref().unwrap().res,
-            TestResult::BuildFail
+            TestResult::BuildFail(FailureReason::Unknown)
         );
         assert_eq!(
             (&crate_result.runs[0]).as_ref().unwrap().log.as_str(),

src/report/mod.rs

@@ -66,7 +66,7 @@ impl<'a> DatabaseDB<'a> {
                 &ex.name,
                 &serde_json::to_string(krate)?,
                 &toolchain.to_string(),
-                &res.to_str(),
+                &res.to_string(),
                 &log,
             ],
         )?;
@@ -211,7 +211,7 @@ mod tests {
     use crates::{Crate, GitHubRepo, RegistryCrate};
     use db::Database;
     use experiments::Experiment;
-    use results::{DeleteResults, ReadResults, TestResult, WriteResults};
+    use results::{DeleteResults, FailureReason, ReadResults, TestResult, WriteResults};
     use toolchain::{MAIN_TOOLCHAIN, TEST_TOOLCHAIN};
 
     #[test]
@@ -345,11 +345,11 @@ mod tests {
         results
             .record_result(&ex, &TEST_TOOLCHAIN, &krate, || {
                 info!("Another log message!");
-                Ok(TestResult::TestFail)
+                Ok(TestResult::TestFail(FailureReason::Unknown))
             }).unwrap();
         assert_eq!(
             results.get_result(&ex, &TEST_TOOLCHAIN, &krate).unwrap(),
-            Some(TestResult::TestFail)
+            Some(TestResult::TestFail(FailureReason::Unknown))
         );
 
         // Test deleting the newly-added result