add tests

Author: zeegomo

src/report/analyzer.rs

@@ -7,12 +7,12 @@ use crate::results::{
 use std::collections::BTreeSet;
 use std::collections::HashMap;
 
-#[derive(PartialEq)]
 pub enum ReportConfig {
     Simple,
     Complete { toolchain: usize },
 }
 
+#[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Clone)]
 pub enum ReportCrates {
     Plain(Vec<CrateResult>),
@@ -22,6 +22,7 @@ pub enum ReportCrates {
     },
 }
 
+#[cfg_attr(test, derive(Debug, PartialEq))]
 pub struct TestResults {
     pub categories: HashMap<Comparison, ReportCrates>,
     pub info: HashMap<Comparison, u32>,
@@ -93,3 +94,161 @@ pub fn analyze_report(test: RawTestResults) -> TestResults {
 
     TestResults { categories, info }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::config::Config;
+    use crate::crates::{Crate, RegistryCrate};
+    use crate::experiments::{CapLints, Experiment, Mode, Status};
+    use crate::report::{generate_report, Comparison};
+    use crate::results::{DummyDB, FailureReason::*};
+    use crate::toolchain::{MAIN_TOOLCHAIN, TEST_TOOLCHAIN};
+    use failure::Fallible;
+
+    #[test]
+    fn test_report_analysis() -> Fallible<()> {
+        macro_rules! reg {
+            ($name:expr) => {
+                Crate::Registry(RegistryCrate {
+                    name: $name.into(),
+                    version: "0.0.1".into(),
+                })
+            };
+        }
+
+        macro_rules! record_crates {
+            ($db:expr, $ex:expr, $($name:expr => ($tc1:expr, $tc2:expr)),*) => {
+                {
+                    let mut crates = Vec::new();
+                    $(
+                        let krate = reg!($name);
+                        $db.add_dummy_result(
+                            &$ex,
+                            krate.clone(),
+                            MAIN_TOOLCHAIN.clone(),
+                            $tc1,
+                        );
+                        $db.add_dummy_result(
+                            &$ex,
+                            krate.clone(),
+                            TEST_TOOLCHAIN.clone(),
+                            $tc2,
+                        );
+                        crates.push(krate);
+                    )*
+                    crates
+                }
+            };
+        }
+
+        let config = Config::default();
+        let mut db = DummyDB::default();
+        let ex = Experiment {
+            name: "foo".to_string(),
+            toolchains: [MAIN_TOOLCHAIN.clone(), TEST_TOOLCHAIN.clone()],
+            mode: Mode::BuildAndTest,
+            cap_lints: CapLints::Forbid,
+            priority: 0,
+            created_at: ::chrono::Utc::now(),
+            started_at: None,
+            completed_at: None,
+            github_issue: None,
+            status: Status::GeneratingReport,
+            assigned_to: None,
+            report_url: None,
+            ignore_blacklist: false,
+            requirement: None,
+        };
+
+        let crates = record_crates! {db, ex,
+            "test-pass" => (TestResult::TestPass, TestResult::TestPass),
+            "ce-1" => (TestResult::TestPass, TestResult::BuildFail(CompilerError(btreeset!["001".parse()?, "002".parse()?]))),
+            "ce-2" => (TestResult::TestPass, TestResult::BuildFail(CompilerError(btreeset!["002".parse()?]))),
+            "unknown" => (TestResult::TestPass, TestResult::BuildFail(Unknown)),
+            "dep-1" => (TestResult::TestPass, TestResult::BuildFail(DependsOn(btreeset![reg!("ce-1"), reg!("unknown")]))),
+            "dep-2" => (TestResult::TestPass, TestResult::BuildFail(DependsOn(btreeset![reg!("ce-1"), reg!("ce-2")]))),
+            "fix-1" => (TestResult::BuildFail(DependsOn(btreeset![reg!("ce-1"), reg!("ce-2")])), TestResult::TestPass),
+            "fix-2" => (TestResult::BuildFail(Unknown), TestResult::TestPass)
+        };
+
+        let raw = generate_report(&db, &config, &ex, &crates)?;
+        let mut crates = raw
+            .crates
+            .clone()
+            .into_iter()
+            .map(|krate| {
+                if let Crate::Registry(ref registry_krate) = krate.krate {
+                    (registry_krate.name.clone(), krate)
+                } else {
+                    panic!("invalid crate type")
+                }
+            })
+            .collect::<HashMap<_, _>>();
+        let analyzed = analyze_report(raw);
+
+        let mut info = HashMap::new();
+        info.insert(Comparison::Regressed, 5);
+        info.insert(Comparison::Fixed, 2);
+        info.insert(Comparison::SameTestPass, 1);
+
+        macro_rules! create_results {
+            ($src:expr, $($key:expr => ($($krate:expr),*)),*) => {
+                {
+                    let mut map = HashMap::new();
+                    $(
+                        let mut crates = Vec::new();
+                        $(
+                            crates.push($src.get($krate).unwrap().clone());
+                        )*
+                        map.insert($key, crates);
+                    )*
+                    map
+                }
+            }
+        }
+
+        let regr_tree = create_results! {crates,
+            reg!("ce-1") => ("dep-1", "dep-2"),
+            reg!("ce-2") => ("dep-2"),
+            reg!("unknown") => ("dep-1")
+        };
+
+        let regr_root = create_results! {crates,
+            TestResult::BuildFail(CompilerError(btreeset!["001".parse()?])) => ("ce-1"),
+            TestResult::BuildFail(CompilerError(btreeset!["002".parse()?])) => ("ce-1", "ce-2"),
+            TestResult::BuildFail(Unknown) => ("unknown")
+        };
+
+        let regressed = ReportCrates::Complete {
+            tree: regr_tree,
+            results: regr_root,
+        };
+
+        let fix_tree = create_results! {crates,
+            reg!("ce-1") => ("fix-1"),
+            reg!("ce-2") => ("fix-1")
+        };
+
+        let fix_root = create_results! {crates,
+            TestResult::BuildFail(Unknown) => ("fix-2")
+        };
+
+        let fixed = ReportCrates::Complete {
+            tree: fix_tree,
+            results: fix_root,
+        };
+
+        let test_pass = ReportCrates::Plain(vec![crates.remove("test-pass").unwrap()]);
+
+        let mut categories = HashMap::new();
+        categories.insert(Comparison::Regressed, regressed);
+        categories.insert(Comparison::Fixed, fixed);
+        categories.insert(Comparison::SameTestPass, test_pass);
+
+        let expected = TestResults { categories, info };
+        assert_eq!(expected, analyzed);
+
+        Ok(())
+    }
+}

src/report/mod.rs

@@ -46,6 +46,7 @@ pub struct RawTestResults {
     pub crates: Vec<CrateResult>,
 }
 
+#[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Serialize, Deserialize, Clone)]
 pub struct CrateResult {
     name: String,
@@ -106,6 +107,7 @@ impl Comparison {
     }
 }
 
+#[cfg_attr(test, derive(Debug, PartialEq))]
 #[derive(Serialize, Deserialize, Clone)]
 struct BuildTestResult {
     res: TestResult,