Merge pull request #31 from teloxide/actual-tests

Actually tests that macros work

Cargo.toml

@@ -7,11 +7,15 @@ edition = "2018"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[lib]
+proc-macro = true
+
 [dependencies]
 quote = "1.0.7"
 proc-macro2 = "1.0.19"
 syn = { version = "1.0.13",  features = ["full"] }
 heck = "0.4.0"
 
-[lib]
-proc-macro = true
+[dev-dependencies]
+# XXX: Do not enable `macros` feature
+teloxide = { git = "https://github.com/teloxide/teloxide.git", rev = "4246455" }

tests/command.rs

@@ -0,0 +1,296 @@
+//! Test for `teloxide-macros`
+
+use teloxide_macros::BotCommands;
+
+// Import only trait _methods_, such that we can call `parse`, but we also test
+// that proc macros work without the trait being imported.
+use teloxide::utils::command::BotCommands as _;
+
+#[test]
+fn parse_command_with_args() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    enum DefaultCommands {
+        Start(String),
+        Help,
+    }
+
+    let data = "/start arg1 arg2";
+    let expected = DefaultCommands::Start("arg1 arg2".to_string());
+    let actual = DefaultCommands::parse(data, "").unwrap();
+    assert_eq!(actual, expected)
+}
+
+#[test]
+fn parse_command_with_non_string_arg() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    enum DefaultCommands {
+        Start(i32),
+        Help,
+    }
+
+    let data = "/start -50";
+    let expected = DefaultCommands::Start("-50".parse().unwrap());
+    let actual = DefaultCommands::parse(data, "").unwrap();
+    assert_eq!(actual, expected)
+}
+
+#[test]
+fn attribute_prefix() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    enum DefaultCommands {
+        #[command(prefix = "!")]
+        Start(String),
+        Help,
+    }
+
+    let data = "!start arg1 arg2";
+    let expected = DefaultCommands::Start("arg1 arg2".to_string());
+    let actual = DefaultCommands::parse(data, "").unwrap();
+    assert_eq!(actual, expected)
+}
+
+#[test]
+fn many_attributes() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    enum DefaultCommands {
+        #[command(prefix = "!", description = "desc")]
+        Start,
+        Help,
+    }
+
+    assert_eq!(
+        DefaultCommands::Start,
+        DefaultCommands::parse("!start", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::descriptions().to_string(),
+        "!start — desc\n/help"
+    );
+}
+
+#[test]
+fn global_attributes() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(prefix = "!", rename = "lowercase", description = "Bot commands")]
+    enum DefaultCommands {
+        #[command(prefix = "/")]
+        Start,
+        Help,
+    }
+
+    assert_eq!(
+        DefaultCommands::Start,
+        DefaultCommands::parse("/start", "MyNameBot").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::Help,
+        DefaultCommands::parse("!help", "MyNameBot").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::descriptions().to_string(),
+        "Bot commands\n\n/start\n!help"
+    );
+}
+
+#[test]
+fn parse_command_with_bot_name() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    enum DefaultCommands {
+        #[command(prefix = "/")]
+        Start,
+        Help,
+    }
+
+    assert_eq!(
+        DefaultCommands::Start,
+        DefaultCommands::parse("/start@MyNameBot", "MyNameBot").unwrap()
+    );
+}
+
+#[test]
+fn parse_with_split() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    #[command(parse_with = "split")]
+    enum DefaultCommands {
+        Start(u8, String),
+        Help,
+    }
+
+    assert_eq!(
+        DefaultCommands::Start(10, "hello".to_string()),
+        DefaultCommands::parse("/start 10 hello", "").unwrap()
+    );
+}
+
+#[test]
+fn parse_with_split2() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    #[command(parse_with = "split", separator = "|")]
+    enum DefaultCommands {
+        Start(u8, String),
+        Help,
+    }
+
+    assert_eq!(
+        DefaultCommands::Start(10, "hello".to_string()),
+        DefaultCommands::parse("/start 10|hello", "").unwrap()
+    );
+}
+
+#[test]
+fn parse_custom_parser() {
+    mod parser {
+        use teloxide::utils::command::ParseError;
+
+        pub fn custom_parse_function(
+            s: String,
+        ) -> Result<(u8, String), ParseError> {
+            let vec = s.split_whitespace().collect::<Vec<_>>();
+            let (left, right) = match vec.as_slice() {
+                [l, r] => (l, r),
+                _ => {
+                    return Err(ParseError::IncorrectFormat(
+                        "might be 2 arguments!".into(),
+                    ))
+                }
+            };
+            left.parse::<u8>().map(|res| (res, (*right).to_string())).map_err(
+                |_| {
+                    ParseError::Custom(
+                        "First argument must be a integer!".to_owned().into(),
+                    )
+                },
+            )
+        }
+    }
+
+    use parser::custom_parse_function;
+
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    enum DefaultCommands {
+        #[command(parse_with = "custom_parse_function")]
+        Start(u8, String),
+
+        // Test <https://github.com/teloxide/teloxide/issues/668>.
+        #[command(parse_with = "parser::custom_parse_function")]
+        TestPath(u8, String),
+
+        Help,
+    }
+
+    assert_eq!(
+        DefaultCommands::Start(10, "hello".to_string()),
+        DefaultCommands::parse("/start 10 hello", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::TestPath(10, "hello".to_string()),
+        DefaultCommands::parse("/testpath 10 hello", "").unwrap()
+    );
+}
+
+#[test]
+fn parse_named_fields() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    #[command(parse_with = "split")]
+    enum DefaultCommands {
+        Start { num: u8, data: String },
+        Help,
+    }
+
+    assert_eq!(
+        DefaultCommands::Start { num: 10, data: "hello".to_string() },
+        DefaultCommands::parse("/start 10 hello", "").unwrap()
+    );
+}
+
+#[test]
+fn descriptions_off() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    #[command(rename = "lowercase")]
+    enum DefaultCommands {
+        #[command(description = "off")]
+        Start,
+        Help,
+    }
+
+    assert_eq!(DefaultCommands::descriptions().to_string(), "/help".to_owned());
+}
+
+#[test]
+fn rename_rules() {
+    #[derive(BotCommands, Debug, PartialEq)]
+    enum DefaultCommands {
+        #[command(rename = "lowercase")]
+        AaaAaa,
+        #[command(rename = "UPPERCASE")]
+        BbbBbb,
+        #[command(rename = "PascalCase")]
+        CccCcc,
+        #[command(rename = "camelCase")]
+        DddDdd,
+        #[command(rename = "snake_case")]
+        EeeEee,
+        #[command(rename = "SCREAMING_SNAKE_CASE")]
+        FffFff,
+        #[command(rename = "kebab-case")]
+        GggGgg,
+        #[command(rename = "SCREAMING-KEBAB-CASE")]
+        HhhHhh,
+        //#[command(rename = "Bar")]
+        //Foo,
+    }
+
+    assert_eq!(
+        DefaultCommands::AaaAaa,
+        DefaultCommands::parse("/aaaaaa", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::BbbBbb,
+        DefaultCommands::parse("/BBBBBB", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::CccCcc,
+        DefaultCommands::parse("/CccCcc", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::DddDdd,
+        DefaultCommands::parse("/dddDdd", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::EeeEee,
+        DefaultCommands::parse("/eee_eee", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::FffFff,
+        DefaultCommands::parse("/FFF_FFF", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::GggGgg,
+        DefaultCommands::parse("/ggg-ggg", "").unwrap()
+    );
+    assert_eq!(
+        DefaultCommands::HhhHhh,
+        DefaultCommands::parse("/HHH-HHH", "").unwrap()
+    );
+    //assert_eq!(DefaultCommands::Foo, DefaultCommands::parse("/Bar",
+    // "").unwrap());
+
+    // assert_eq!(
+    //     "/aaaaaa\n/BBBBBB\n/CccCcc\n/dddDdd\n/eee_eee\n/FFF_FFF\n/ggg-ggg\n/
+    // HHH-HHH\n/Bar",     DefaultCommands::descriptions().to_string()
+    // );
+    assert_eq!(
+        "/aaaaaa\n/BBBBBB\n/CccCcc\n/dddDdd\n/eee_eee\n/FFF_FFF\n/ggg-ggg\n/\
+         HHH-HHH",
+        DefaultCommands::descriptions().to_string()
+    );
+}