test(derive): Allow specializing tests for unstable-v4

Author: epage

tests/derive/main.rs

@@ -1,5 +1,8 @@
 #![cfg(feature = "derive")]
 
+mod legacy;
+mod next;
+
 mod app_name;
 mod arguments;
 mod author_version_about;
@@ -15,7 +18,6 @@ mod flatten;
 mod generic;
 mod help;
 mod issues;
-mod legacy;
 mod macros;
 mod naming;
 mod nested_subcommands;

tests/derive/next/app_name.rs

@@ -0,0 +1,97 @@
+use clap::CommandFactory;
+use clap::Parser;
+#[test]
+fn app_name_in_short_help_from_struct() {
+    #[derive(Parser)]
+    #[clap(name = "my-cmd")]
+    struct MyApp {}
+
+    let mut help = Vec::new();
+    MyApp::command().write_help(&mut help).unwrap();
+    let help = String::from_utf8(help).unwrap();
+
+    assert!(help.contains("my-cmd"));
+}
+
+#[test]
+fn app_name_in_long_help_from_struct() {
+    #[derive(Parser)]
+    #[clap(name = "my-cmd")]
+    struct MyApp {}
+
+    let mut help = Vec::new();
+    MyApp::command().write_long_help(&mut help).unwrap();
+    let help = String::from_utf8(help).unwrap();
+
+    assert!(help.contains("my-cmd"));
+}
+
+#[test]
+fn app_name_in_short_help_from_enum() {
+    #[derive(Parser)]
+    #[clap(name = "my-cmd")]
+    enum MyApp {}
+
+    let mut help = Vec::new();
+    MyApp::command().write_help(&mut help).unwrap();
+    let help = String::from_utf8(help).unwrap();
+
+    assert!(help.contains("my-cmd"));
+}
+
+#[test]
+fn app_name_in_long_help_from_enum() {
+    #[derive(Parser)]
+    #[clap(name = "my-cmd")]
+    enum MyApp {}
+
+    let mut help = Vec::new();
+    MyApp::command().write_long_help(&mut help).unwrap();
+    let help = String::from_utf8(help).unwrap();
+
+    assert!(help.contains("my-cmd"));
+}
+
+#[test]
+fn app_name_in_short_version_from_struct() {
+    #[derive(Parser)]
+    #[clap(name = "my-cmd")]
+    struct MyApp {}
+
+    let version = MyApp::command().render_version();
+
+    assert!(version.contains("my-cmd"));
+}
+
+#[test]
+fn app_name_in_long_version_from_struct() {
+    #[derive(Parser)]
+    #[clap(name = "my-cmd")]
+    struct MyApp {}
+
+    let version = MyApp::command().render_long_version();
+
+    assert!(version.contains("my-cmd"));
+}
+
+#[test]
+fn app_name_in_short_version_from_enum() {
+    #[derive(Parser)]
+    #[clap(name = "my-cmd")]
+    enum MyApp {}
+
+    let version = MyApp::command().render_version();
+
+    assert!(version.contains("my-cmd"));
+}
+
+#[test]
+fn app_name_in_long_version_from_enum() {
+    #[derive(Parser)]
+    #[clap(name = "my-cmd")]
+    enum MyApp {}
+
+    let version = MyApp::command().render_long_version();
+
+    assert!(version.contains("my-cmd"));
+}

tests/derive/next/arguments.rs

@@ -0,0 +1,124 @@
+// Copyright 2018 Guillaume Pinot (@TeXitoi) <[email protected]>,
+// Kevin Knapp (@kbknapp) <[email protected]>, and
+// Ana Hobden (@hoverbear) <[email protected]>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+//
+// This work was derived from Structopt (https://github.com/TeXitoi/structopt)
+// commit#ea76fa1b1b273e65e3b0b1046643715b49bec51f which is licensed under the
+// MIT/Apache 2.0 license.
+
+use clap::CommandFactory;
+use clap::Parser;
+
+#[test]
+fn required_argument() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(value_parser)]
+        arg: i32,
+    }
+    assert_eq!(
+        Opt { arg: 42 },
+        Opt::try_parse_from(&["test", "42"]).unwrap()
+    );
+    assert!(Opt::try_parse_from(&["test"]).is_err());
+    assert!(Opt::try_parse_from(&["test", "42", "24"]).is_err());
+}
+
+#[test]
+fn argument_with_default() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(value_parser, default_value = "42")]
+        arg: i32,
+    }
+    assert_eq!(
+        Opt { arg: 24 },
+        Opt::try_parse_from(&["test", "24"]).unwrap()
+    );
+    assert_eq!(Opt { arg: 42 }, Opt::try_parse_from(&["test"]).unwrap());
+    assert!(Opt::try_parse_from(&["test", "42", "24"]).is_err());
+}
+
+#[test]
+fn auto_value_name() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(value_parser)]
+        my_special_arg: i32,
+    }
+
+    let mut help = Vec::new();
+    Opt::command().write_help(&mut help).unwrap();
+    let help = String::from_utf8(help).unwrap();
+
+    assert!(help.contains("MY_SPECIAL_ARG"));
+    // Ensure the implicit `num_vals` is just 1
+    assert_eq!(
+        Opt { my_special_arg: 10 },
+        Opt::try_parse_from(&["test", "10"]).unwrap()
+    );
+}
+
+#[test]
+fn explicit_value_name() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(value_parser, value_name = "BROWNIE_POINTS")]
+        my_special_arg: i32,
+    }
+
+    let mut help = Vec::new();
+    Opt::command().write_help(&mut help).unwrap();
+    let help = String::from_utf8(help).unwrap();
+
+    assert!(help.contains("BROWNIE_POINTS"));
+    assert!(!help.contains("MY_SPECIAL_ARG"));
+    // Ensure the implicit `num_vals` is just 1
+    assert_eq!(
+        Opt { my_special_arg: 10 },
+        Opt::try_parse_from(&["test", "10"]).unwrap()
+    );
+}
+
+#[test]
+fn option_type_is_optional() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(value_parser)]
+        arg: Option<i32>,
+    }
+    assert_eq!(
+        Opt { arg: Some(42) },
+        Opt::try_parse_from(&["test", "42"]).unwrap()
+    );
+    assert_eq!(Opt { arg: None }, Opt::try_parse_from(&["test"]).unwrap());
+    assert!(Opt::try_parse_from(&["test", "42", "24"]).is_err());
+}
+
+#[test]
+fn vec_type_is_multiple_values() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(value_parser)]
+        arg: Vec<i32>,
+    }
+    assert_eq!(
+        Opt { arg: vec![24] },
+        Opt::try_parse_from(&["test", "24"]).unwrap()
+    );
+    assert_eq!(Opt { arg: vec![] }, Opt::try_parse_from(&["test"]).unwrap());
+    assert_eq!(
+        Opt { arg: vec![24, 42] },
+        Opt::try_parse_from(&["test", "24", "42"]).unwrap()
+    );
+    assert_eq!(
+        clap::ErrorKind::ValueValidation,
+        Opt::try_parse_from(&["test", "NOPE"]).err().unwrap().kind()
+    );
+}

tests/derive/next/author_version_about.rs

@@ -0,0 +1,51 @@
+// Copyright 2018 Guillaume Pinot (@TeXitoi) <[email protected]>,
+// Kevin Knapp (@kbknapp) <[email protected]>, and
+// Ana Hobden (@hoverbear) <[email protected]>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+//
+// This work was derived from Structopt (https://github.com/TeXitoi/structopt)
+// commit#ea76fa1b1b273e65e3b0b1046643715b49bec51f which is licensed under the
+// MIT/Apache 2.0 license.
+
+use crate::utils;
+
+use clap::Parser;
+
+#[test]
+fn no_author_version_about() {
+    #[derive(Parser, PartialEq, Debug)]
+    #[clap(name = "foo")]
+    struct Opt {}
+
+    let output = utils::get_long_help::<Opt>();
+    assert!(output.starts_with("foo \n\nUSAGE:"));
+}
+
+#[test]
+fn use_env() {
+    #[derive(Parser, PartialEq, Debug)]
+    #[clap(author, about, version)]
+    struct Opt {}
+
+    let output = utils::get_long_help::<Opt>();
+    assert!(output.starts_with("clap"));
+    assert!(output
+        .contains("A simple to use, efficient, and full-featured Command Line Argument Parser"));
+}
+
+#[test]
+fn explicit_version_not_str_lit() {
+    const VERSION: &str = "custom version";
+
+    #[derive(Parser)]
+    #[clap(version = VERSION)]
+    pub struct Opt {}
+
+    let output = utils::get_long_help::<Opt>();
+    assert!(output.contains("custom version"));
+}

tests/derive/next/basic.rs

@@ -0,0 +1,51 @@
+// Copyright 2018 Guillaume Pinot (@TeXitoi) <[email protected]>,
+// Kevin Knapp (@kbknapp) <[email protected]>, and
+// Ana Hobden (@hoverbear) <[email protected]>
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+//
+// This work was derived from Structopt (https://github.com/TeXitoi/structopt)
+// commit#ea76fa1b1b273e65e3b0b1046643715b49bec51f which is licensed under the
+// MIT/Apache 2.0 license.
+
+use clap::Parser;
+
+#[test]
+fn basic() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(short = 'a', long = "arg", value_parser)]
+        arg: i32,
+    }
+    assert_eq!(
+        Opt { arg: 24 },
+        Opt::try_parse_from(&["test", "-a24"]).unwrap()
+    );
+}
+
+#[test]
+fn update_basic() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt {
+        #[clap(short = 'a', long = "arg", value_parser)]
+        single_value: i32,
+    }
+
+    let mut opt = Opt::try_parse_from(&["test", "-a0"]).unwrap();
+
+    opt.update_from(&["test", "-a42"]);
+
+    assert_eq!(Opt { single_value: 42 }, opt);
+}
+
+#[test]
+fn unit_struct() {
+    #[derive(Parser, PartialEq, Debug)]
+    struct Opt;
+
+    assert_eq!(Opt {}, Opt::try_parse_from(&["test"]).unwrap());
+}

tests/derive/next/boxed.rs

@@ -0,0 +1,49 @@
+use clap::{Args, Parser, Subcommand};
+
+#[derive(Parser, PartialEq, Debug)]
+struct Opt {
+    #[clap(subcommand)]
+    sub: Box<Sub>,
+}
+
+#[derive(Subcommand, PartialEq, Debug)]
+enum Sub {
+    Flame {
+        #[clap(flatten)]
+        arg: Box<Ext>,
+    },
+}
+
+#[derive(Args, PartialEq, Debug)]
+struct Ext {
+    #[clap(value_parser)]
+    arg: u32,
+}
+
+#[test]
+fn boxed_flatten_subcommand() {
+    assert_eq!(
+        Opt {
+            sub: Box::new(Sub::Flame {
+                arg: Box::new(Ext { arg: 1 })
+            })
+        },
+        Opt::try_parse_from(&["test", "flame", "1"]).unwrap()
+    );
+}
+
+#[test]
+fn update_boxed_flatten_subcommand() {
+    let mut opt = Opt::try_parse_from(&["test", "flame", "1"]).unwrap();
+
+    opt.update_from(&["test", "flame", "42"]);
+
+    assert_eq!(
+        Opt {
+            sub: Box::new(Sub::Flame {
+                arg: Box::new(Ext { arg: 42 })
+            })
+        },
+        opt
+    );
+}