#42 All integration tests now are in rstest too. rstest now handle all

errors like parametrize

Author: la10736

resources/rstest/case_with_wrong_args.rs

@@ -0,0 +1,10 @@
+use rstest::rstest;
+
+#[cfg(test)]
+#[rstest(a, b, case(42), case(1, 2), case(43))]
+fn error_less_arguments(a: u32, b: u32) {}
+
+#[cfg(test)]
+#[rstest(a, case(42, 43), case(12), case(24, 34))]
+fn error_too_much_arguments(a: u32) {}
+

resources/rstest/description.rs

@@ -0,0 +1,11 @@
+use rstest::rstest;
+
+#[rstest(
+    expected,
+    case::user_test_description(true),
+    case(true),
+    case::user_test_description_fail(false)
+)]
+fn description(expected: bool) {
+    assert!(expected);
+}

resources/rstest/dump_debug.rs

@@ -0,0 +1,10 @@
+use rstest::rstest;
+
+#[rstest(u, s, t,
+    case(42, "str", ("ss", -12)),
+    case(24, "trs", ("tt", -24))
+    ::trace
+)]
+fn should_fail(u: u32, s: &str, t: (&str, i32)) {
+    assert!(false);
+}

resources/rstest/dump_exclude_some_fixtures.rs

@@ -0,0 +1,13 @@
+use rstest::rstest;
+
+struct A;
+#[derive(Debug)]
+struct D;
+
+#[rstest(u,a,d,
+    case(42, A{}, D{})
+    ::trace::notrace(a))
+]
+fn should_fail(u: u32, a: A, d: D) {
+    assert!(false);
+}

resources/rstest/dump_not_debug.rs

@@ -0,0 +1,9 @@
+use rstest::rstest;
+
+struct S;
+
+#[rstest(s,
+    case(Unwrap("S{}"))
+    ::trace
+)]
+fn test_function(s: S) {}

resources/rstest/errors.rs

@@ -0,0 +1,50 @@
+use rstest::*;
+#[fixture]
+pub fn fixture() -> u32 { 42 }
+
+#[rstest(f, case(42))]
+fn error_inner(f: i32) {
+    let a: u32 = "";
+}
+
+#[rstest(f, case(42))]
+fn error_cannot_resolve_fixture(no_fixture: u32, f: u32) {}
+
+#[rstest(f, case(42))]
+fn error_fixture_wrong_type(fixture: String, f: u32) {}
+
+#[rstest(f, case(42))]
+fn error_param_wrong_type(f: &str) {}
+
+#[rstest(condition,
+    case(vec![1,2,3].contains(2)))
+]
+fn error_in_arbitrary_rust_code(condition: bool) {
+    assert!(condition)
+}
+
+#[rstest(f, case(42), not_a_fixture(24))]
+fn error_inject_an_invalid_fixture(f: u32) {
+}
+
+#[fixture]
+fn n() -> u32 {
+    24
+}
+
+#[fixture]
+fn f(n: u32) -> u32 {
+    2*n
+}
+
+#[rstest(f, f(42), case(12))]
+fn error_inject_a_fixture_that_is_already_a_case(f: u32) {
+}
+
+#[rstest(f(42), f, case(12))]
+fn error_define_case_that_is_already_an_injected_fixture(f: u32) {
+}
+
+#[rstest(v, f(42), f(42), case(12))]
+fn error_inject_a_fixture_more_than_once(v: u32, f: u32) {
+}

resources/rstest/generic.rs

@@ -0,0 +1,10 @@
+use rstest::rstest;
+
+#[rstest(
+    expected, input,
+    case(4, String::from("ciao")),
+    case(3, "Foo")
+)]
+fn strlen_test<S: AsRef<str>>(expected: usize, input: S) {
+    assert_eq!(expected, input.as_ref().len());
+}

resources/rstest/impl_param.rs

@@ -0,0 +1,10 @@
+use rstest::rstest;
+
+#[rstest(
+    expected, input,
+    case(4, String::from("ciao")),
+    case(3, "Foo")
+)]
+fn strlen_test(expected: usize, input: impl AsRef<str>) {
+    assert_eq!(expected, input.as_ref().len());
+}

resources/rstest/missed_argument.rs

@@ -0,0 +1,5 @@
+use rstest::rstest;
+
+#[cfg(test)]
+#[rstest(f, case(42), case(24))]
+fn error_param_not_exist() {}

resources/rstest/missed_some_arguments.rs

@@ -0,0 +1,5 @@
+use rstest::rstest;
+
+#[cfg(test)]
+#[rstest(a,b,c, case(1,2,3), case(3,2,1))]
+fn error_param_not_exist(b: u32) {}

resources/rstest/mut.rs

@@ -0,0 +1,12 @@
+use rstest::rstest;
+
+#[rstest(
+    expected, val,
+    case(4, 3),
+    case(3, 2)
+)]
+fn add_test(expected: u32, mut val: u32) {
+    val += 1;
+
+    assert_eq!(expected, val);
+}

resources/rstest/panic.rs

@@ -0,0 +1,12 @@
+use rstest::rstest;
+
+#[rstest(
+    expected, input,
+    case(4, 5),
+    case(3, 2),
+    case(3, 3)
+)]
+#[should_panic]
+fn fail(expected: i32, input: i32) {
+    assert_eq!(expected, input);
+}

resources/rstest/partial.rs

@@ -0,0 +1,31 @@
+use rstest::*;
+
+#[fixture]
+fn f1() -> u32 { 0 }
+#[fixture]
+fn f2() -> u32 { 0 }
+#[fixture]
+fn f3() -> u32 { 0 }
+
+#[fixture]
+fn fixture(f1: u32, f2: u32, f3: u32) -> u32 { f1 + 10 * f2 + 100 * f3 }
+
+#[rstest(expected, case(0),  case(1000))]
+fn default(fixture: u32, expected: u32) {
+    assert_eq!(fixture, expected);
+}
+
+#[rstest(fixture(7), expected, case(7),  case(1000))]
+fn partial_1(fixture: u32, expected: u32) {
+    assert_eq!(fixture, expected);
+}
+
+#[rstest(fixture(2, 4), expected, case(42),  case(1000))]
+fn partial_2(fixture: u32, expected: u32) {
+    assert_eq!(fixture, expected);
+}
+
+#[rstest(fixture(2, 4, 5), expected, case(542),  case(1000))]
+fn complete(fixture: u32, expected: u32) {
+    assert_eq!(fixture, expected);
+}

resources/rstest/return_result.rs

@@ -0,0 +1,9 @@
+use rstest::rstest;
+
+#[rstest(ret,
+    case::should_success(Ok(())),
+    case::should_fail(Err("Return Error"))
+)]
+fn return_type(ret: Result<(), &'static str>) -> Result<(), &'static str> {
+    ret
+}

resources/rstest/simple.rs

@@ -0,0 +1,10 @@
+use rstest::rstest;
+
+#[rstest(
+    expected, input,
+    case(4, "ciao"),
+    case(3, "Foo")
+)]
+fn strlen_test(expected: usize, input: &str) {
+    assert_eq!(expected, input.len());
+}

src/lib.rs

@@ -660,6 +660,7 @@ fn errors_in_matrix(test: &ItemFn, info: &parse::matrix::MatrixInfo) -> TokenStr
 fn errors_in_rstest(test: &ItemFn, info: &parse::rstest::RsTestInfo) -> TokenStream{
     missed_arguments_errors(test, info.data.items.iter())
         .chain(duplicate_arguments_errors(info.data.items.iter()))
+        .chain(invalid_case_errors(&info.data))
         .map(|e| e.to_compile_error())
         .collect()
 }

src/parse/testcase.rs

@@ -67,7 +67,7 @@ mod should {
     }
 
     #[test]
-    fn raw_code() {
+    fn accept_arbitrary_rust_code() {
         let test_case = parse_test_case(r#"case(vec![1,2,3])"#);
         let args = test_case.args();
 
@@ -76,12 +76,12 @@ mod should {
 
     #[test]
     #[should_panic]
-    fn raw_code_with_parsing_error() {
+    fn raise_error_on_invalid_rust_code() {
         parse_test_case(r#"case(some:<>(1,2,3))"#);
     }
 
     #[test]
-    fn should_read_test_description_if_any() {
+    fn get_description_if_any() {
         let test_case = parse_test_case(r#"case::this_test_description(42)"#);
         let args = test_case.args();
 
@@ -90,7 +90,7 @@ mod should {
     }
 
     #[test]
-    fn should_read_test_description_also_with_more_args() {
+    fn get_description_also_with_more_args() {
         let test_case = parse_test_case(r#"case :: this_test_description (42, 24)"#);
         let args = test_case.args();
 
@@ -99,7 +99,7 @@ mod should {
     }
 
     #[test]
-    fn should_parse_arbitrary_rust_code_as_expression() {
+    fn parse_arbitrary_rust_code_as_expression() {
         let test_case = parse_test_case(r##"
             case(42, -42,
             pippo("pluto"),

tests/integration.rs

@@ -8,32 +8,8 @@ mod framework;
 /// Single's integration tests
 mod single;
 
-/// Single's integration tests
-mod rstest {
-    use std::path::Path;
-    use crate::utils::*;
-
-    fn prj(res: &str) -> crate::prj::Project {
-        let path = Path::new("rstest").join(res);
-        crate::prj().set_code_file(resources(path))
-    }
-
-    fn run_test(res: &str) -> (std::process::Output, String) {
-        let prj = prj(res);
-        (prj.run_tests().unwrap(), prj.get_name().to_owned().to_string())
-    }
-
-
-    #[test]
-    fn happy_path_cases() {
-        let (output, _) = run_test("happy_path_cases.rs");
-
-        TestResults::new()
-            .ok("strlen_test::case_1")
-            .ok("strlen_test::case_2")
-            .assert(output);
-    }
-}
+/// Rstest integration tests
+mod rstest;
 
 /// Parametrize's integration tests
 mod parametrize;