diff --git a/src/render/fixture.rs b/src/render/fixture.rs index b982649..5d52c64 100644 --- a/src/render/fixture.rs +++ b/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::>(); + 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::>(); + 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::>(); diff --git a/src/render/mod.rs b/src/render/mod.rs index 3a92f33..b397929 100644 --- a/src/render/mod.rs +++ b/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, resolver: &impl Resolver, @@ -392,16 +375,6 @@ fn resolve_new_args<'a>( } } -fn resolve_args<'a>( - args: impl Iterator, - 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, ) } } diff --git a/src/render/test.rs b/src/render/test.rs index 4badf11..698bb00 100644 --- a/src/render/test.rs +++ b/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! { diff --git a/tests/fixture/mod.rs b/tests/fixture/mod.rs index 0491f82..e7f4c4f 100644 --- a/tests/fixture/mod.rs +++ b/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] diff --git a/tests/resources/fixture/default_conversion.rs b/tests/resources/fixture/default_conversion.rs new file mode 100644 index 0000000..772521e --- /dev/null +++ b/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()); +}