src/test.rs

   1 // TODO: remove tests of CompressionFormat::try_from since that's no longer used anywhere
   2
   3 #[cfg(test)]
   4 mod cli {
   5     use std::{convert::TryFrom, fs, path::Path};
   6
   7     use crate::{
   8         cli::{clap_app, Command, CommandKind::*},
   9         extension::{CompressionFormat::*, Extension},
  10         file::File,
  11     };
  12
  13     // ouch's command-line logic uses fs::canonicalize on its inputs so we cannot
  14     // use made-up files for testing.
  15     // make_dummy_file therefores creates a small temporary file to bypass fs::canonicalize errors
  16     fn make_dummy_file<'a, P>(path: P) -> crate::Result<()>
  17     where
  18         P: AsRef<Path> + 'a,
  19     {
  20         fs::write(path.as_ref(), &[2, 3, 4, 5, 6, 7, 8, 9, 10])?;
  21         Ok(())
  22     }
  23
  24     #[test]
  25     fn decompress_files_into_folder() -> crate::Result<()> {
  26         make_dummy_file("file.zip")?;
  27         let matches = clap_app().get_matches_from(vec!["ouch", "-i", "file.zip", "-o", "folder/"]);
  28         let command_from_matches = Command::try_from(matches)?;
  29
  30         assert_eq!(
  31             command_from_matches,
  32             Command {
  33                 kind: Decompression(vec![File {
  34                     path: fs::canonicalize("file.zip")?,
  35                     contents_in_memory: None,
  36                     extension: Some(Extension::from(Zip))
  37                 }]),
  38                 output: Some(File {
  39                     path: "folder".into(),
  40                     contents_in_memory: None,
  41                     extension: None
  42                 }),
  43             }
  44         );
  45
  46         fs::remove_file("file.zip")?;
  47
  48         Ok(())
  49     }
  50
  51     #[test]
  52     fn decompress_files() -> crate::Result<()> {
  53         make_dummy_file("my-cool-file.zip")?;
  54         make_dummy_file("file.tar")?;
  55         let matches =
  56             clap_app().get_matches_from(vec!["ouch", "-i", "my-cool-file.zip", "file.tar"]);
  57         let command_from_matches = Command::try_from(matches)?;
  58
  59         assert_eq!(
  60             command_from_matches,
  61             Command {
  62                 kind: Decompression(vec![
  63                     File {
  64                         path: fs::canonicalize("my-cool-file.zip")?,
  65                         contents_in_memory: None,
  66                         extension: Some(Extension::from(Zip))
  67                     },
  68                     File {
  69                         path: fs::canonicalize("file.tar")?,
  70                         contents_in_memory: None,
  71                         extension: Some(Extension::from(Tar))
  72                     }
  73                 ],),
  74                 output: None,
  75             }
  76         );
  77
  78         fs::remove_file("my-cool-file.zip")?;
  79         fs::remove_file("file.tar")?;
  80
  81         Ok(())
  82     }
  83
  84     #[test]
  85     fn compress_files() -> crate::Result<()> {
  86         make_dummy_file("file")?;
  87         make_dummy_file("file2.jpeg")?;
  88         make_dummy_file("file3.ok")?;
  89
  90         let matches = clap_app().get_matches_from(vec![
  91             "ouch",
  92             "-i",
  93             "file",
  94             "file2.jpeg",
  95             "file3.ok",
  96             "-o",
  97             "file.tar",
  98         ]);
  99         let command_from_matches = Command::try_from(matches)?;
 100
 101         assert_eq!(
 102             command_from_matches,
 103             Command {
 104                 kind: Compression(vec![
 105                     fs::canonicalize("file")?,
 106                     fs::canonicalize("file2.jpeg")?,
 107                     fs::canonicalize("file3.ok")?
 108                 ]),
 109                 output: Some(File {
 110                     path: "file.tar".into(),
 111                     contents_in_memory: None,
 112                     extension: Some(Extension::from(Tar))
 113                 }),
 114             }
 115         );
 116
 117         fs::remove_file("file")?;
 118         fs::remove_file("file2.jpeg")?;
 119         fs::remove_file("file3.ok")?;
 120
 121         Ok(())
 122     }
 123 }
 124
 125 #[cfg(test)]
 126 mod cli_errors {
 127
 128     use std::convert::TryFrom;
 129
 130     use crate::{
 131         cli::{clap_app, Command},
 132     };
 133
 134     #[test]
 135     fn compress_files() -> crate::Result<()> {
 136         let matches =
 137             clap_app().get_matches_from(vec!["ouch", "-i", "a_file", "file2.jpeg", "file3.ok"]);
 138         let res = Command::try_from(matches);
 139
 140         assert_eq!(
 141             res,
 142             Err(crate::Error::InputsMustHaveBeenDecompressible(
 143                 "a_file".into()
 144             ))
 145         );
 146
 147         Ok(())
 148     }
 149 }
 150
 151 #[cfg(test)]
 152 mod extension_extraction {
 153     use std::{convert::TryFrom, path::PathBuf, str::FromStr};
 154
 155     use crate::{
 156         extension::{CompressionFormat, Extension},
 157     };
 158
 159     #[test]
 160     fn zip() -> crate::Result<()> {
 161         let path = PathBuf::from_str("filename.tar.zip").unwrap();
 162         assert_eq!(CompressionFormat::try_from(&path)?, CompressionFormat::Zip);
 163
 164         Ok(())
 165     }
 166
 167     #[test]
 168     fn tar_gz() -> crate::Result<()> {
 169         let extension = Extension::new("folder.tar.gz")?;
 170
 171         assert_eq!(
 172             extension,
 173             Extension {
 174                 first_ext: Some(CompressionFormat::Tar),
 175                 second_ext: CompressionFormat::Gzip
 176             }
 177         );
 178
 179         Ok(())
 180     }
 181
 182     #[test]
 183     fn tar() -> crate::Result<()> {
 184         let path = PathBuf::from_str("pictures.tar").unwrap();
 185         assert_eq!(CompressionFormat::try_from(&path)?, CompressionFormat::Tar);
 186
 187         Ok(())
 188     }
 189
 190     #[test]
 191     fn gz() -> crate::Result<()> {
 192         let path = PathBuf::from_str("passwords.tar.gz").unwrap();
 193         assert_eq!(CompressionFormat::try_from(&path)?, CompressionFormat::Gzip);
 194
 195         Ok(())
 196     }
 197
 198     #[test]
 199     fn lzma() -> crate::Result<()> {
 200         let path = PathBuf::from_str("mygame.tar.lzma").unwrap();
 201         assert_eq!(CompressionFormat::try_from(&path)?, CompressionFormat::Lzma);
 202
 203         Ok(())
 204     }
 205
 206     #[test]
 207     fn bz() -> crate::Result<()> {
 208         let path = PathBuf::from_str("songs.tar.bz").unwrap();
 209         assert_eq!(CompressionFormat::try_from(&path)?, CompressionFormat::Bzip);
 210
 211         Ok(())
 212     }
 213 }