tests/utils.rs

   1 use std::{env, io::Write, path::PathBuf};
   2
   3 use assert_cmd::Command;
   4 use fs_err as fs;
   5 use rand::{Rng, RngCore};
   6
   7 #[macro_export]
   8 macro_rules! ouch {
   9     ($($e:expr),*) => {
  10         $crate::utils::cargo_bin()
  11             $(.arg($e))*
  12             .arg("--yes")
  13             .unwrap();
  14     }
  15 }
  16
  17 pub fn cargo_bin() -> Command {
  18     env::vars()
  19         .find_map(|(k, v)| {
  20             (k.starts_with("CARGO_TARGET_") && k.ends_with("_RUNNER")).then(|| {
  21                 let mut runner = v.split_whitespace();
  22                 let mut cmd = Command::new(runner.next().unwrap());
  23                 cmd.args(runner).arg(assert_cmd::cargo::cargo_bin("ouch"));
  24                 cmd
  25             })
  26         })
  27         .unwrap_or_else(|| Command::cargo_bin("ouch").expect("Failed to find ouch executable"))
  28 }
  29
  30 // write random content to a file
  31 pub fn write_random_content(file: &mut impl Write, rng: &mut impl RngCore) {
  32     let mut data = Vec::new();
  33     data.resize(rng.gen_range(0..8192), 0);
  34     rng.fill_bytes(&mut data);
  35     file.write_all(&data).unwrap();
  36 }
  37
  38 // check that two directories have the exact same content recursively
  39 // checks equility of file types if preserve_permissions is true, ignored on non-unix
  40 pub fn assert_same_directory(x: impl Into<PathBuf>, y: impl Into<PathBuf>, preserve_permissions: bool) {
  41     fn read_dir(dir: impl Into<PathBuf>) -> impl Iterator<Item = fs::DirEntry> {
  42         let mut dir: Vec<_> = fs::read_dir(dir).unwrap().map(|entry| entry.unwrap()).collect();
  43         dir.sort_by_key(|x| x.file_name());
  44         dir.into_iter()
  45     }
  46
  47     let mut x = read_dir(x);
  48     let mut y = read_dir(y);
  49
  50     loop {
  51         match (x.next(), y.next()) {
  52             (Some(x), Some(y)) => {
  53                 assert_eq!(x.file_name(), y.file_name());
  54
  55                 let meta_x = x.metadata().unwrap();
  56                 let meta_y = y.metadata().unwrap();
  57                 let ft_x = meta_x.file_type();
  58                 let ft_y = meta_y.file_type();
  59
  60                 #[cfg(unix)]
  61                 if preserve_permissions {
  62                     assert_eq!(ft_x, ft_y);
  63                 }
  64
  65                 if ft_x.is_dir() && ft_y.is_dir() {
  66                     assert_same_directory(x.path(), y.path(), preserve_permissions);
  67                 } else if ft_x.is_file() && ft_y.is_file() {
  68                     assert_eq!(meta_x.len(), meta_y.len());
  69                     assert_eq!(fs::read(x.path()).unwrap(), fs::read(y.path()).unwrap());
  70                 } else {
  71                     panic!(
  72                         "entries should be both directories or both files\n  left: `{:?}`,\n right: `{:?}`",
  73                         x.path(),
  74                         y.path()
  75                     );
  76                 }
  77             }
  78
  79             (None, None) => break,
  80
  81             (x, y) => {
  82                 panic!(
  83                     "directories don't have the same number of entries\n  left: `{:?}`,\n right: `{:?}`",
  84                     x.map(|x| x.path()),
  85                     y.map(|y| y.path()),
  86                 )
  87             }
  88         }
  89     }
  90 }
  91
  92 #[test]
  93 fn src_is_src() {
  94     assert_same_directory("src", "src", true);
  95 }
  96
  97 #[test]
  98 #[should_panic]
  99 fn src_is_not_tests() {
 100     assert_same_directory("src", "tests", false);
 101 }