Redirect stdin and stdout and capture for tests

type: testing

src/assert_matches.rs

@@ -0,0 +1,12 @@
+macro_rules! assert_matches {
+  ($expression:expr, $( $pattern:pat )|+ $( if $guard:expr )?) => {
+    match $expression {
+      $( $pattern )|+ $( if $guard )? => {}
+      left => panic!(
+        "assertion failed: (left ~= right)\n  left: `{:?}`\n right: `{}`",
+        left,
+        stringify!($($pattern)|+ $(if $guard)?)
+      ),
+    }
+  }
+}

src/capture.rs

@@ -0,0 +1,30 @@
+use crate::common::*;
+
+#[derive(Clone)]
+pub(crate) struct Capture {
+  cursor: Rc<RefCell<Cursor<Vec<u8>>>>,
+}
+
+impl Capture {
+  pub(crate) fn new() -> Self {
+    Self {
+      cursor: Rc::new(RefCell::new(Cursor::new(Vec::new()))),
+    }
+  }
+
+  pub(crate) fn string(&self) -> String {
+    str::from_utf8(&self.cursor.borrow().get_ref())
+      .unwrap()
+      .to_owned()
+  }
+}
+
+impl Write for Capture {
+  fn write(&mut self, buffer: &[u8]) -> std::result::Result<usize, std::io::Error> {
+    self.cursor.borrow_mut().write(buffer)
+  }
+
+  fn flush(&mut self) -> std::result::Result<(), std::io::Error> {
+    self.cursor.borrow_mut().flush()
+  }
+}

src/common.rs

@@ -44,3 +44,17 @@ pub(crate) use crate::{
 // test modules
 #[cfg(test)]
 pub(crate) use crate::testing;
+
+// test stdlib types
+#[cfg(test)]
+pub(crate) use std::{
+  cell::RefCell,
+  io::Cursor,
+  iter,
+  ops::{Deref, DerefMut},
+  rc::Rc,
+};
+
+// test structs and enums
+#[cfg(test)]
+pub(crate) use crate::{capture::Capture, test_env::TestEnv};

src/consts.rs

@@ -11,3 +11,13 @@ pub(crate) const CREATED_BY_DEFAULT: &str = concat!(
 
 /// Value for `encoding` torrent metainfo field.
 pub(crate) const ENCODING_UTF8: &str = "UTF-8";
+
+pub(crate) const ABOUT: &str = concat!(
+  env!("CARGO_PKG_DESCRIPTION"),
+  " - ",
+  env!("CARGO_PKG_HOMEPAGE")
+);
+
+pub(crate) const VERSION: &str = concat!("v", env!("CARGO_PKG_VERSION"));
+
+pub(crate) const AUTHOR: &str = env!("CARGO_PKG_AUTHORS");

src/env.rs

@@ -4,6 +4,7 @@ pub(crate) struct Env {
   args: Vec<String>,
   dir: Box<dyn AsRef<Path>>,
   pub(crate) err: Box<dyn Write>,
+  pub(crate) _out: Box<dyn Write>,
 }
 
 impl Env {
@@ -13,16 +14,17 @@ impl Env {
       Err(error) => panic!("Failed to get current directory: {}", error),
     };
 
-    Self::new(dir, io::stderr(), env::args())
+    Self::new(dir, io::stdout(), io::stderr(), env::args())
   }
 
   pub(crate) fn run(&mut self) -> Result<(), Error> {
     Opt::from_iter_safe(&self.args)?.run(self)
   }
 
-  pub(crate) fn new<D, E, S, I>(dir: D, err: E, args: I) -> Self
+  pub(crate) fn new<D, O, E, S, I>(dir: D, out: O, err: E, args: I) -> Self
   where
     D: AsRef<Path> + 'static,
+    O: Write + 'static,
     E: Write + 'static,
     S: Into<String>,
     I: IntoIterator<Item = S>,
@@ -31,13 +33,23 @@ impl Env {
       args: args.into_iter().map(Into::into).collect(),
       dir: Box::new(dir),
       err: Box::new(err),
+      _out: Box::new(out),
     }
   }
 
   pub(crate) fn status(&mut self) -> Result<(), i32> {
+    use structopt::clap::ErrorKind;
     if let Err(error) = self.run() {
-      write!(&mut self.err, "error: {}", error).ok();
-      Err(EXIT_FAILURE)
+      if let Error::Clap { source } = error {
+        write!(&mut self.err, "{}", source).ok();
+        match source.kind {
+          ErrorKind::VersionDisplayed | ErrorKind::HelpDisplayed => Ok(()),
+          _ => Err(EXIT_FAILURE),
+        }
+      } else {
+        write!(&mut self.err, "error: {}", error).ok();
+        Err(EXIT_FAILURE)
+      }
     } else {
       Ok(())
     }
@@ -47,3 +59,25 @@ impl Env {
     self.dir.as_ref().as_ref().join(path).clean()
   }
 }
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn error_message_on_stdout() {
+    let mut env = testing::env(
+      ["torrent", "create", "--input", "foo", "--announce", "bar"]
+        .iter()
+        .cloned(),
+    );
+    fs::write(env.resolve("foo"), "").unwrap();
+    env.status().ok();
+    let err = env.err();
+    if !err.starts_with("error: Failed to parse announce URL:") {
+      panic!("Unexpected standard error output: {}", err);
+    }
+
+    assert_eq!(env.out(), "");
+  }
+}

src/error.rs

@@ -9,8 +9,10 @@ pub(crate) enum Error {
   Clap { source: clap::Error },
   #[snafu(display("I/O error at `{}`: {}", path.display(), source))]
   Filesystem { source: io::Error, path: PathBuf },
-  #[snafu(display("Failed to write to standard error stream: {}", source))]
+  #[snafu(display("Failed to write to standard error: {}", source))]
   Stderr { source: io::Error },
+  #[snafu(display("Failed to write to standard output: {}", source))]
+  Stdout { source: io::Error },
   #[snafu(display("Serialization failed: {}", source))]
   Serialize { source: serde_bencode::Error },
   #[snafu(display("Filename was not valid unicode: {}", filename.to_string_lossy()))]

src/main.rs

@@ -9,7 +9,8 @@
   clippy::option_map_unwrap_or_else,
   clippy::option_unwrap_used,
   clippy::result_expect_used,
-  clippy::result_unwrap_used
+  clippy::result_unwrap_used,
+  clippy::wildcard_enum_match_arm
 )]
 
 use crate::common::*;
@@ -18,6 +19,10 @@ use crate::common::*;
 #[macro_use]
 mod matches;
 
+#[cfg(test)]
+#[macro_use]
+mod assert_matches;
+
 #[macro_use]
 mod errln;
 
@@ -27,6 +32,12 @@ mod err;
 #[cfg(test)]
 mod testing;
 
+#[cfg(test)]
+mod test_env;
+
+#[cfg(test)]
+mod capture;
+
 mod bencode;
 mod common;
 mod consts;

src/opt.rs

@@ -1,6 +1,15 @@
 use crate::common::*;
 
+use structopt::clap::AppSettings;
+
 #[derive(StructOpt)]
+#[structopt(
+  about(consts::ABOUT),
+  version(consts::VERSION),
+  author(consts::AUTHOR),
+  setting(AppSettings::ColoredHelp),
+  setting(AppSettings::ColorAuto)
+)]
 pub(crate) struct Opt {
   #[structopt(long = "unstable", short = "u")]
   unstable: bool,