#111 Implemented for default fixture args

src/render/fixture.rs

@@ -3,7 +3,7 @@ use syn::{parse_quote, Ident, ItemFn};
 
 use quote::quote;
 
-use super::{generics_clean_up, render_exec_call, resolve_args};
+use super::{generics_clean_up, render_exec_call, resolve_new_args};
 use crate::parse::fixture::FixtureInfo;
 use crate::resolver::{self, Resolver};
 use crate::utils::{fn_args, fn_args_idents};
@@ -30,7 +30,12 @@ pub(crate) fn render<'a>(fixture: ItemFn, info: FixtureInfo) -> TokenStream {
         resolver::fixtures::get(info.data.fixtures()),
         resolver::values::get(info.data.values()),
     );
-    let inject = resolve_args(fn_args_idents(&fixture), &resolver);
+    let generics_idents = generics
+        .type_params()
+        .map(|tp| &tp.ident)
+        .cloned()
+        .collect::<Vec<_>>();
+    let inject = resolve_new_args(fixture.sig.inputs.iter(), &resolver, &generics_idents);
     let partials =
         (1..=orig_args.len()).map(|n| render_partial_impl(&fixture, n, &resolver, &info));
 
@@ -76,7 +81,12 @@ fn render_partial_impl(
     let where_clause = &generics.where_clause;
     let asyncness = &fixture.sig.asyncness;
 
-    let inject = resolve_args(fn_args_idents(fixture).skip(n), resolver);
+    let genercs_idents = generics
+        .type_params()
+        .map(|tp| &tp.ident)
+        .cloned()
+        .collect::<Vec<_>>();
+    let inject = resolve_new_args(fixture.sig.inputs.iter().skip(n), resolver, &genercs_idents);
 
     let sign_args = fn_args(fixture).take(n);
     let fixture_args = fn_args_idents(fixture).cloned().collect::<Vec<_>>();

src/render/mod.rs

@@ -364,23 +364,6 @@ fn fnarg_2_fixture(arg: &FnArg, resolver: &impl Resolver, generic_types: &[Ident
     })
 }
 
-fn arg_2_fixture(ident: &Ident, resolver: &impl Resolver) -> Stmt {
-    let id_str = ident.to_string();
-    let fixture_name = if id_str.starts_with("_") && !id_str.starts_with("__") {
-        Cow::Owned(Ident::new(&id_str[1..], ident.span()))
-    } else {
-        Cow::Borrowed(ident)
-    };
-
-    let fixture = resolver
-        .resolve(&fixture_name)
-        .map(|e| e.clone())
-        .unwrap_or_else(|| default_fixture_resolve(&fixture_name));
-    parse_quote! {
-        let #ident = #fixture;
-    }
-}
-
 fn resolve_new_args<'a>(
     args: impl Iterator<Item = &'a FnArg>,
     resolver: &impl Resolver,
@@ -392,16 +375,6 @@ fn resolve_new_args<'a>(
     }
 }
 
-fn resolve_args<'a>(
-    args: impl Iterator<Item = &'a Ident>,
-    resolver: &impl Resolver,
-) -> TokenStream {
-    let define_vars = args.map(|arg| arg_2_fixture(arg, resolver));
-    quote! {
-        #(#define_vars)*
-    }
-}
-
 fn where_predicate_bounded_type(wp: &WherePredicate) -> Option<&Type> {
     match wp {
         syn::WherePredicate::Type(pt) => Some(&pt.bounded_ty),
@@ -492,7 +465,7 @@ impl<'a> TestCaseRender<'a> {
             None,
             self.resolver,
             &attributes,
-            &generic_types
+            &generic_types,
         )
     }
 }

src/render/test.rs

@@ -26,83 +26,6 @@ impl SetAsync for ItemFn {
     }
 }
 
-mod arg_2_fixture_should {
-    use super::{assert_eq, *};
-
-    mod call_fixture {
-        use super::{assert_eq, *};
-
-        fn test(function: &str, expected: &str) {
-            let ast = function.ast();
-            let arg = first_arg_ident(&ast);
-
-            let line = arg_2_fixture(arg, &EmptyResolver);
-
-            assert_eq!(line, expected.ast());
-        }
-
-        #[test]
-        fn as_is() {
-            test("fn foo(fix: String) {}", "let fix = fix::default();");
-        }
-
-        #[test]
-        fn by_remove_underscore_if_any() {
-            test("fn foo(_fix: String) {}", "let _fix = fix::default();");
-        }
-
-        #[test]
-        fn do_not_remove_more_underscores() {
-            test("fn foo(f_i_x: String) {}", "let f_i_x = f_i_x::default();");
-        }
-
-        #[test]
-        fn do_not_remove_two_underscores() {
-            test("fn foo(__fix: String) {}", "let __fix = __fix::default();");
-        }
-
-        #[test]
-        fn without_add_mut() {
-            test("fn foo(mut fix: String) {}", "let fix = fix::default();");
-        }
-    }
-
-    mod call_given_fixture {
-        use super::{assert_eq, *};
-
-        fn test(function: &str, fixture: &str, call: Expr, expected: &str) {
-            let ast = function.ast();
-            let arg = first_arg_ident(&ast);
-            let mut resolver = HashMap::new();
-            resolver.insert(fixture.to_owned(), &call);
-
-            let line = arg_2_fixture(arg, &resolver);
-
-            assert_eq!(line, expected.ast());
-        }
-
-        #[test]
-        fn as_is() {
-            test(
-                "fn foo(mut fix: String) {}",
-                "fix",
-                expr("bar()"),
-                "let fix = bar();",
-            );
-        }
-
-        #[test]
-        fn by_remove_underscore() {
-            test(
-                "fn foo(_fix: String) {}",
-                "fix",
-                expr("bar()"),
-                "let _fix = bar();",
-            );
-        }
-    }
-}
-
 fn trace_argument_code_string(arg_name: &str) -> String {
     let arg_name = ident(arg_name);
     let statment: Stmt = parse_quote! {

tests/fixture/mod.rs

@@ -2,6 +2,7 @@ use std::path::Path;
 pub use unindent::Unindent;
 
 use super::resources;
+use rstest::*;
 use rstest_test::{assert_in, assert_not_in, Project, Stringable, TestResults};
 
 fn prj(res: &str) -> Project {
@@ -159,9 +160,11 @@ mod should {
             .assert(output);
     }
 
-    #[test]
-    fn use_input_values_if_any() {
-        let (output, _) = run_test("default.rs");
+    #[rstest]
+    #[case::compact_form("default.rs")]
+    #[case::attrs_form("default_in_attrs.rs")]
+    fn use_input_values_if_any(#[case] file: &str) {
+        let (output, _) = run_test(file);
 
         TestResults::new()
             .ok("test_simple")
@@ -173,16 +176,10 @@ mod should {
     }
 
     #[test]
-    fn use_default_arguments_values_values_if_any() {
-        let (output, _) = run_test("default_in_attrs.rs");
+    fn convert_literal_string_for_default_values() {
+        let (output, _) = run_test("default_conversion.rs");
 
-        TestResults::new()
-            .ok("test_simple")
-            .ok("test_simple_changed")
-            .ok("test_double")
-            .ok("test_double_changed")
-            .ok("test_mixed")
-            .assert(output);
+        TestResults::new().ok("test_base").assert(output);
     }
 
     #[test]

tests/resources/fixture/default_conversion.rs

@@ -0,0 +1,12 @@
+use rstest::{fixture, rstest};
+use std::net::{Ipv4Addr, SocketAddr};
+
+#[fixture]
+fn base(#[default = "1.2.3.4"] ip: Ipv4Addr, #[default = r#"8080"#] port: u16) -> SocketAddr {
+    SocketAddr::new(ip.into(), port)
+}
+
+#[rstest]
+fn test_base(base: SocketAddr) {
+    assert_eq!(base, "1.2.3.4:8080".parse().unwrap());
+}