#136 Implemetation and tests

CHANGELOG.md

@@ -4,8 +4,11 @@
 
 ### Add
 
+- `#[timeout(duration)]` test implementation for both sync and async tests (See #136)
+
 ### Changed
 
+- Split rstest in separated crates for macro and libs (See #32)
 ### Fixed
 
 ## [0.12.0] 2021/12/12

playground/Cargo.toml

@@ -1,20 +1,20 @@
 [package]
-name = "playground"
-version = "0.1.0"
 authors = ["michele <michele.damico@gmail.com>"]
 edition = "2018"
+name = "playground"
+version = "0.1.0"
 
 [features]
 default = []
 # Depends on nightly
 trace_all = []
 
 [dependencies]
+async-std = {version = "1.5", features = ["attributes"]}
 lazy_static = "*"
-async-std = { version="1.5", features = ["attributes"] }
 
 [dependencies.rstest]
-path = "../"
+path = "../rstest"
 version = "*"
 
 [dependencies.rstest_reuse]

rstest/Cargo.toml

@@ -17,6 +17,7 @@ version = "0.13.0"
 [lib]
 
 [dependencies]
+async-std = {version = "1.9.0", features = ["attributes"]}
 futures = "0.3.15"
 futures-timer = "3.0.2"
 rstest_macros = {version = "0.13.0", path = "../rstest_macros"}

rstest/tests/resources/rstest/errors.rs

@@ -92,3 +92,15 @@ async fn error_future_on_impl_type(#[case] #[future] s: impl AsRef<str>) {}
 #[rstest]
 #[case(async { 42 } )]
 async fn error_future_on_impl_type(#[case] #[future] #[future] a: i32) {}
+
+#[rstest]
+#[timeout]
+fn error_timeout_without_arg() {}
+
+#[rstest]
+#[timeout(some -> strange -> invalid -> expression)]
+fn error_timeout_without_expression_arg() {}
+
+#[rstest]
+#[timeout(42)]
+fn error_timeout_without_duration() {}

rstest/tests/resources/rstest/timeout.rs

@@ -2,7 +2,7 @@ use rstest::*;
 use std::time::Duration;
 
 fn ms(ms: u32) -> Duration {
-    Duration::from_millis(ms)
+    Duration::from_millis(ms.into())
 }
 
 mod thread {
@@ -13,6 +13,24 @@ mod thread {
         a + b
     }
 
+    #[rstest]
+    #[timeout(ms(80))]
+    fn single_pass() {
+        assert_eq!(4, delayed_sum(2, 2, ms(10)));
+    }
+
+    #[rstest]
+    #[timeout(ms(100))]
+    fn single_fail_value() {
+        assert_eq!(5, delayed_sum(2, 2, ms(1)));
+    }
+
+    #[rstest]
+    #[timeout(ms(10))]
+    fn single_fail_timeout() {
+        assert_eq!(4, delayed_sum(2, 2, ms(80)));
+    }
+
     #[rstest]
     #[timeout(ms(80))]
     #[case(ms(10))]
@@ -39,7 +57,7 @@ mod thread {
     #[case::fail_timeout(ms(80), 4)]
     #[case::fail_value(ms(1), 5)]
     #[timeout(ms(40))]
-    fn group_same_timeout(#[case] delay: Duration, expected: u32) {
+    fn group_same_timeout(#[case] delay: Duration,#[case] expected: u32) {
         assert_eq!(expected, delayed_sum(2, 2, delay));
     }
 
@@ -50,7 +68,7 @@ mod thread {
     #[case::fail_timeout(ms(70), 4)]
     #[timeout(ms(100))]
     #[case::fail_value(ms(1), 5)]
-    fn group_single_timeout(#[case] delay: Duration, expected: u32) {
+    fn group_single_timeout(#[case] delay: Duration,#[case] expected: u32) {
         assert_eq!(expected, delayed_sum(2, 2, delay));
     }
 
@@ -60,71 +78,85 @@ mod thread {
     #[case::fail_timeout(ms(60), 4)]
     #[case::fail_value(ms(1), 5)]
     #[timeout(ms(100))]
-    fn group_one_timeout_override(#[case] delay: Duration, expected: u32) {
+    fn group_one_timeout_override(#[case] delay: Duration,#[case] expected: u32) {
         assert_eq!(expected, delayed_sum(2, 2, delay));
     }
 }
 
-mod async_cases {
+mod async_std_cases {
     use super::*;
 
-    mod async_std {
-        use super::*;
-
-        async fn delayed_sum(a: u32, b: u32, delay: Duration) -> u32 {
-            async_std::task::sleep(delay).await;
-            a + b
-        }
-
-        #[rstest]
-        #[timeout(ms(80))]
-        #[case(ms(10))]
-        async fn one_pass(#[case] delay: Duration) {
-            assert_eq!(4, delayed_sum(2, 2, delay).await);
-        }
-
-        #[rstest]
-        #[timeout(ms(10))]
-        #[case(ms(80))]
-        async fn one_fail_timeout(#[case] delay: Duration) {
-            assert_eq!(4, delayed_sum(2, 2, delay).await);
-        }
-
-        #[rstest]
-        #[timeout(ms(100))]
-        #[case(ms(1))]
-        async fn one_fail_value(#[case] delay: Duration) {
-            assert_eq!(5, delayed_sum(2, 2, delay).await);
-        }
-
-        #[rstest]
-        #[case::pass(ms(1), 4)]
-        #[case::fail_timeout(ms(80), 4)]
-        #[case::fail_value(ms(1), 5)]
-        #[timeout(ms(40))]
-        async fn group_same_timeout(#[case] delay: Duration, expected: u32) {
-            assert_eq!(expected, delayed_sum(2, 2, delay).await);
-        }
-
-        #[rstest]
-        #[timeout(ms(100))]
-        #[case::pass(ms(1), 4)]
-        #[timeout(ms(30))]
-        #[case::fail_timeout(ms(70), 4)]
-        #[timeout(ms(100))]
-        #[case::fail_value(ms(1), 5)]
-        async fn group_single_timeout(#[case] delay: Duration, expected: u32) {
-            assert_eq!(expected, delayed_sum(2, 2, delay).await);
-        }
-
-        #[rstest]
-        #[case::pass(ms(1), 4)]
-        #[timeout(ms(10))]
-        #[case::fail_timeout(ms(60), 4)]
-        #[case::fail_value(ms(1), 5)]
-        #[timeout(ms(100))]
-        async fn group_one_timeout_override(#[case] delay: Duration, expected: u32) {
-            assert_eq!(expected, delayed_sum(2, 2, delay).await);
-        }
+    async fn delayed_sum(a: u32, b: u32,delay: Duration) -> u32 {
+        async_std::task::sleep(delay).await;
+        a + b
     }
-}
+
+    #[rstest]
+    #[timeout(ms(80))]
+    async fn single_pass() {
+        assert_eq!(4, delayed_sum(2, 2, ms(10)).await);
+    }
+
+    #[rstest]
+    #[timeout(ms(10))]
+    async fn single_fail_timeout() {
+        assert_eq!(4, delayed_sum(2, 2, ms(80)).await);
+    }
+
+    #[rstest]
+    #[timeout(ms(100))]
+    async fn single_fail_value() {
+        assert_eq!(5, delayed_sum(2, 2, ms(1)).await);
+    }
+
+    #[rstest]
+    #[timeout(ms(80))]
+    #[case(ms(10))]
+    async fn one_pass(#[case] delay: Duration) {
+        assert_eq!(4, delayed_sum(2, 2, delay).await);
+    }
+
+    #[rstest]
+    #[timeout(ms(10))]
+    #[case(ms(80))]
+    async fn one_fail_timeout(#[case] delay: Duration) {
+        assert_eq!(4, delayed_sum(2, 2, delay).await);
+    }
+
+    #[rstest]
+    #[timeout(ms(100))]
+    #[case(ms(1))]
+    async fn one_fail_value(#[case] delay: Duration) {
+        assert_eq!(5, delayed_sum(2, 2, delay).await);
+    }
+
+    #[rstest]
+    #[case::pass(ms(1), 4)]
+    #[case::fail_timeout(ms(80), 4)]
+    #[case::fail_value(ms(1), 5)]
+    #[timeout(ms(40))]
+    async fn group_same_timeout(#[case] delay: Duration, #[case] expected: u32) {
+        assert_eq!(expected, delayed_sum(2, 2, delay).await);
+    }
+
+    #[rstest]
+    #[timeout(ms(100))]
+    #[case::pass(ms(1), 4)]
+    #[timeout(ms(30))]
+    #[case::fail_timeout(ms(70), 4)]
+    #[timeout(ms(100))]
+    #[case::fail_value(ms(1), 5)]
+    async fn group_single_timeout(#[case] delay: Duration, #[case] expected: u32) {
+        assert_eq!(expected, delayed_sum(2, 2, delay).await);
+    }
+
+    #[rstest]
+    #[case::pass(ms(1), 4)]
+    #[timeout(ms(10))]
+    #[case::fail_timeout(ms(60), 4)]
+    #[case::fail_value(ms(1), 5)]
+    #[timeout(ms(100))]
+    async fn group_one_timeout_override(#[case] delay: Duration, #[case] expected: u32) {
+        assert_eq!(expected, delayed_sum(2, 2, delay).await);
+    }
+}

rstest/tests/rstest/mod.rs

@@ -893,6 +893,46 @@ fn ignore_underscore_args() {
         .assert(output);
 }
 
+#[test]
+fn timeout() {
+    let prj = prj("timeout.rs");
+    prj.add_dependency("async-std", r#"{version="*", features=["attributes"]}"#);
+    let output = prj.run_tests().unwrap();
+
+    TestResults::new()
+        .ok("thread::single_pass")
+        .fail("thread::single_fail_value")
+        .fail("thread::single_fail_timeout")
+        .ok("thread::one_pass::case_1")
+        .fail("thread::one_fail_value::case_1")
+        .fail("thread::one_fail_timeout::case_1")
+        .ok("thread::group_same_timeout::case_1_pass")
+        .fail("thread::group_same_timeout::case_2_fail_timeout")
+        .fail("thread::group_same_timeout::case_3_fail_value")
+        .ok("thread::group_single_timeout::case_1_pass")
+        .fail("thread::group_single_timeout::case_2_fail_timeout")
+        .fail("thread::group_single_timeout::case_3_fail_value")
+        .ok("thread::group_one_timeout_override::case_1_pass")
+        .fail("thread::group_one_timeout_override::case_2_fail_timeout")
+        .fail("thread::group_one_timeout_override::case_3_fail_value")
+        .ok("async_std_cases::single_pass")
+        .fail("async_std_cases::single_fail_value")
+        .fail("async_std_cases::single_fail_timeout")
+        .ok("async_std_cases::one_pass::case_1")
+        .fail("async_std_cases::one_fail_value::case_1")
+        .fail("async_std_cases::one_fail_timeout::case_1")
+        .ok("async_std_cases::group_same_timeout::case_1_pass")
+        .fail("async_std_cases::group_same_timeout::case_2_fail_timeout")
+        .fail("async_std_cases::group_same_timeout::case_3_fail_value")
+        .ok("async_std_cases::group_single_timeout::case_1_pass")
+        .fail("async_std_cases::group_single_timeout::case_2_fail_timeout")
+        .fail("async_std_cases::group_single_timeout::case_3_fail_value")
+        .ok("async_std_cases::group_one_timeout_override::case_1_pass")
+        .fail("async_std_cases::group_one_timeout_override::case_2_fail_timeout")
+        .fail("async_std_cases::group_one_timeout_override::case_3_fail_value")
+        .assert(output);
+}
+
 mod should_show_correct_errors {
     use std::process::Output;
 
@@ -1326,4 +1366,64 @@ mod should_show_correct_errors {
             .unindent()
         );
     }
+
+    #[test]
+    fn if_use_timeout_without_arg() {
+        let (output, name) = execute();
+
+        assert_in!(
+            output.stderr.str(),
+            format!(
+                "
+                error: expected attribute arguments in parentheses: #[timeout(...)]
+                  --> {}/src/lib.rs:97:1
+                   |
+                97 | #[timeout]
+                   | ^^^^^^^^^^
+                ",
+                name
+            )
+            .unindent()
+        );
+    }
+
+    #[test]
+    fn if_timeout_is_not_an_expression() {
+        let (output, name) = execute();
+
+        assert_in!(
+            output.stderr.str(),
+            format!(
+                "
+                error: expected expression
+                   --> {}/src/lib.rs:101:16
+                    |
+                101 | #[timeout(some -> strange -> invalid -> expression)]
+                    |                ^^
+                ",
+                name
+            )
+            .unindent()
+        );
+    }
+
+    #[test]
+    fn if_timeout_is_not_a_duration() {
+        let (output, name) = execute();
+
+        assert_in!(
+            output.stderr.str(),
+            format!(
+                "
+                error[E0308]: mismatched types
+                   --> {}/src/lib.rs:105:11
+                    |
+                105 | #[timeout(42)]
+                    |           ^^ expected struct `Duration`, found integer
+                ",
+                name
+            )
+            .unindent()
+        );
+    }
 }