test: simplify unit tests

src/app.rs

@@ -178,16 +178,13 @@ mod tests {
         let arg_vec = vec!["lowcharts", "--verbose", "hist", "foo"];
         let m = get_app().get_matches_from(arg_vec);
         assert!(m.is_present("verbose"));
-        if let Some(sub_m) = m.subcommand_matches("hist") {
-            assert_eq!("foo", sub_m.value_of("input").unwrap());
-            assert!(sub_m.value_of("max").is_none());
-            assert!(sub_m.value_of("min").is_none());
-            assert!(sub_m.value_of("regex").is_none());
-            assert_eq!("110", sub_m.value_of("width").unwrap());
-            assert_eq!("20", sub_m.value_of("intervals").unwrap());
-        } else {
-            assert!(false, "Subcommand `hist` not detected");
-        }
+        let sub_m = m.subcommand_matches("hist").unwrap();
+        assert_eq!("foo", sub_m.value_of("input").unwrap());
+        assert!(sub_m.value_of("max").is_none());
+        assert!(sub_m.value_of("min").is_none());
+        assert!(sub_m.value_of("regex").is_none());
+        assert_eq!("110", sub_m.value_of("width").unwrap());
+        assert_eq!("20", sub_m.value_of("intervals").unwrap());
     }
 
     #[test]
@@ -204,41 +201,32 @@ mod tests {
         ];
         let m = get_app().get_matches_from(arg_vec);
         assert!(!m.is_present("verbose"));
-        if let Some(sub_m) = m.subcommand_matches("plot") {
-            assert_eq!("-", sub_m.value_of("input").unwrap());
-            assert_eq!("1.1", sub_m.value_of("max").unwrap());
-            assert_eq!("0.9", sub_m.value_of("min").unwrap());
-            assert_eq!("11", sub_m.value_of("height").unwrap());
-        } else {
-            assert!(false, "Subcommand `plot` not detected");
-        }
+        let sub_m = m.subcommand_matches("plot").unwrap();
+        assert_eq!("-", sub_m.value_of("input").unwrap());
+        assert_eq!("1.1", sub_m.value_of("max").unwrap());
+        assert_eq!("0.9", sub_m.value_of("min").unwrap());
+        assert_eq!("11", sub_m.value_of("height").unwrap());
     }
 
     #[test]
     fn matches_subcommand_arg_parsing() {
         let arg_vec = vec!["lowcharts", "matches", "-", "A", "B", "C"];
         let m = get_app().get_matches_from(arg_vec);
-        if let Some(sub_m) = m.subcommand_matches("matches") {
-            assert_eq!("-", sub_m.value_of("input").unwrap());
-            assert_eq!(
-                // vec![String::from("A"), String::from("B"), String::from("C")],
-                vec!["A", "B", "C"],
-                sub_m.values_of("match").unwrap().collect::<Vec<&str>>()
-            );
-        } else {
-            assert!(false, "Subcommand `matches` not detected");
-        }
+        let sub_m = m.subcommand_matches("matches").unwrap();
+        assert_eq!("-", sub_m.value_of("input").unwrap());
+        assert_eq!(
+            // vec![String::from("A"), String::from("B"), String::from("C")],
+            vec!["A", "B", "C"],
+            sub_m.values_of("match").unwrap().collect::<Vec<&str>>()
+        );
     }
 
     #[test]
     fn timehist_subcommand_arg_parsing() {
         let arg_vec = vec!["lowcharts", "timehist", "--regex", "foo", "some"];
         let m = get_app().get_matches_from(arg_vec);
-        if let Some(sub_m) = m.subcommand_matches("timehist") {
-            assert_eq!("some", sub_m.value_of("input").unwrap());
-            assert_eq!("foo", sub_m.value_of("regex").unwrap());
-        } else {
-            assert!(false, "Subcommand `timehist` not detected");
-        }
+        let sub_m = m.subcommand_matches("timehist").unwrap();
+        assert_eq!("some", sub_m.value_of("input").unwrap());
+        assert_eq!("foo", sub_m.value_of("regex").unwrap());
     }
 }

src/read/buckets.rs

@@ -98,67 +98,51 @@ mod tests {
     #[test]
     fn basic_reader_test() {
         let reader = DataReader::default();
-        match NamedTempFile::new() {
-            Ok(ref mut file) => {
-                writeln!(file, "1.3").unwrap();
-                writeln!(file, "foobar").unwrap();
-                writeln!(file, "2").unwrap();
-                writeln!(file, "-2.7").unwrap();
-                let vec = reader.read(file.path().to_str().unwrap());
-                assert_eq!(vec, [1.3, 2.0, -2.7]);
-            }
-            Err(_) => assert!(false, "Could not create temp file"),
-        }
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "1.3").unwrap();
+        writeln!(file, "foobar").unwrap();
+        writeln!(file, "2").unwrap();
+        writeln!(file, "-2.7").unwrap();
+        let vec = reader.read(file.path().to_str().unwrap());
+        assert_eq!(vec, [1.3, 2.0, -2.7]);
     }
 
     #[test]
     fn regex_first_match() {
         let re = Regex::new("^foo ([0-9.-]+) ([0-9.-]+)").unwrap();
         let reader = DataReaderBuilder::default().regex(re).build().unwrap();
-        match NamedTempFile::new() {
-            Ok(ref mut file) => {
-                writeln!(file, "foo 1.3 1.6").unwrap();
-                writeln!(file, "nothing").unwrap();
-                writeln!(file, "1.1").unwrap();
-                writeln!(file, "1.1 1.2").unwrap();
-                writeln!(file, "foo -2 3").unwrap();
-                writeln!(file, "foo 5").unwrap();
-                let vec = reader.read(file.path().to_str().unwrap());
-                assert_eq!(vec, [1.3, -2.0]);
-            }
-            Err(_) => assert!(false, "Could not create temp file"),
-        }
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "foo 1.3 1.6").unwrap();
+        writeln!(file, "nothing").unwrap();
+        writeln!(file, "1.1").unwrap();
+        writeln!(file, "1.1 1.2").unwrap();
+        writeln!(file, "foo -2 3").unwrap();
+        writeln!(file, "foo 5").unwrap();
+        let vec = reader.read(file.path().to_str().unwrap());
+        assert_eq!(vec, [1.3, -2.0]);
     }
 
     #[test]
     fn regex_named_match() {
         let re = Regex::new("^foo ([0-9.-]+) (?P<value>[0-9.-]+)").unwrap();
         let reader = DataReaderBuilder::default().regex(re).build().unwrap();
-        match NamedTempFile::new() {
-            Ok(ref mut file) => {
-                writeln!(file, "foo 1.3 1.6").unwrap();
-                writeln!(file, "nothing").unwrap();
-                writeln!(file, "1.1").unwrap();
-                writeln!(file, "1.1 1.2").unwrap();
-                writeln!(file, "foo -2 3").unwrap();
-                writeln!(file, "foo 5").unwrap();
-                let vec = reader.read(file.path().to_str().unwrap());
-                assert_eq!(vec, [1.6, 3.0]);
-            }
-            Err(_) => assert!(false, "Could not create temp file"),
-        }
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "foo 1.3 1.6").unwrap();
+        writeln!(file, "nothing").unwrap();
+        writeln!(file, "1.1").unwrap();
+        writeln!(file, "1.1 1.2").unwrap();
+        writeln!(file, "foo -2 3").unwrap();
+        writeln!(file, "foo 5").unwrap();
+        let vec = reader.read(file.path().to_str().unwrap());
+        assert_eq!(vec, [1.6, 3.0]);
     }
 
     #[test]
     fn regex_empty_file() {
         let reader = DataReader::default();
-        match NamedTempFile::new() {
-            Ok(ref mut file) => {
-                let vec = reader.read(file.path().to_str().unwrap());
-                assert_eq!(vec, []);
-            }
-            Err(_) => assert!(false, "Could not create temp file"),
-        }
+        let file = NamedTempFile::new().unwrap();
+        let vec = reader.read(file.path().to_str().unwrap());
+        assert_eq!(vec, []);
     }
 
     #[test]
@@ -167,41 +151,33 @@ mod tests {
             .range(-1.0..1.0)
             .build()
             .unwrap();
-        match NamedTempFile::new() {
-            Ok(ref mut file) => {
-                writeln!(file, "1.3").unwrap();
-                writeln!(file, "2").unwrap();
-                writeln!(file, "-0.5").unwrap();
-                writeln!(file, "0.5").unwrap();
-                let vec = reader.read(file.path().to_str().unwrap());
-                assert_eq!(vec, [-0.5, 0.5]);
-            }
-            Err(_) => assert!(false, "Could not create temp file"),
-        }
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "1.3").unwrap();
+        writeln!(file, "2").unwrap();
+        writeln!(file, "-0.5").unwrap();
+        writeln!(file, "0.5").unwrap();
+        let vec = reader.read(file.path().to_str().unwrap());
+        assert_eq!(vec, [-0.5, 0.5]);
     }
 
     #[test]
     fn basic_match_reader() {
         let reader = DataReader::default();
-        match NamedTempFile::new() {
-            Ok(ref mut file) => {
-                writeln!(file, "foobar").unwrap();
-                writeln!(file, "data data foobar").unwrap();
-                writeln!(file, "data data").unwrap();
-                writeln!(file, "foobar").unwrap();
-                writeln!(file, "none").unwrap();
-                let mb = reader.read_matches(
-                    file.path().to_str().unwrap(),
-                    vec!["random", "foobar", "data"],
-                );
-                assert_eq!(mb.vec[0].label, "random");
-                assert_eq!(mb.vec[0].count, 0);
-                assert_eq!(mb.vec[1].label, "foobar");
-                assert_eq!(mb.vec[1].count, 3);
-                assert_eq!(mb.vec[2].label, "data");
-                assert_eq!(mb.vec[2].count, 2);
-            }
-            Err(_) => assert!(false, "Could not create temp file"),
-        }
+        let mut file = NamedTempFile::new().unwrap();
+        writeln!(file, "foobar").unwrap();
+        writeln!(file, "data data foobar").unwrap();
+        writeln!(file, "data data").unwrap();
+        writeln!(file, "foobar").unwrap();
+        writeln!(file, "none").unwrap();
+        let mb = reader.read_matches(
+            file.path().to_str().unwrap(),
+            vec!["random", "foobar", "data"],
+        );
+        assert_eq!(mb.vec[0].label, "random");
+        assert_eq!(mb.vec[0].count, 0);
+        assert_eq!(mb.vec[1].label, "foobar");
+        assert_eq!(mb.vec[1].count, 3);
+        assert_eq!(mb.vec[2].label, "data");
+        assert_eq!(mb.vec[2].count, 2);
     }
 }

src/read/mod.rs

@@ -17,8 +17,20 @@ fn open_file(path: &str) -> Box<dyn io::BufRead> {
             Ok(fd) => Box::new(io::BufReader::new(fd)),
             Err(error) => {
                 error!("Could not open {}: {}", path, error);
-                std::process::exit(1);
+                panic!("{}", error);
             }
         },
     }
 }
+
+#[cfg(test)]
+mod tests {
+
+    use super::*;
+
+    #[test]
+    #[should_panic]
+    fn test_bad_file() {
+        open_file("/no/good");
+    }
+}