From b6ed1d9bda76e466a453c01d847850c05789b274 Mon Sep 17 00:00:00 2001 From: Ruben De Smet Date: Thu, 9 Apr 2020 13:52:47 +0200 Subject: [PATCH 1/4] Add async fixture test --- resources/fixture/async_fixture.rs | 18 ++++++++++++++++++ tests/fixture/mod.rs | 13 +++++++++++++ 2 files changed, 31 insertions(+) create mode 100644 resources/fixture/async_fixture.rs diff --git a/resources/fixture/async_fixture.rs b/resources/fixture/async_fixture.rs new file mode 100644 index 0000000..5006d2b --- /dev/null +++ b/resources/fixture/async_fixture.rs @@ -0,0 +1,18 @@ +use std::future::Future; + +use rstest::*; + +#[fixture] +async fn async_u32() -> u32 { + 42 +} + +#[rstest] +async fn default_is_async() { + assert_eq!(42, async_u32::default().await); +} + +#[rstest] +async fn use_async_fixture(async_u32: impl Future) { + assert_eq!(42, async_u32.await); +} diff --git a/tests/fixture/mod.rs b/tests/fixture/mod.rs index 6c24c0e..db38078 100644 --- a/tests/fixture/mod.rs +++ b/tests/fixture/mod.rs @@ -83,6 +83,19 @@ mod should { } } + #[test] + fn resolve_async_fixture() { + let prj = prj("async_fixture.rs"); + prj.add_dependency("async-std", r#"{version="*", features=["attributes"]}"#); + + let output = prj.run_tests().unwrap(); + + TestResults::new() + .ok("default_is_async") + .ok("use_async_fixture") + .assert(output); + } + #[test] fn resolve_fixture_generics_by_fixture_input() { let (output, _) = run_test("resolve.rs"); From 0ce8763540a7d077a2f8a12647a15654645465f7 Mon Sep 17 00:00:00 2001 From: Ruben De Smet Date: Fri, 10 Apr 2020 10:18:20 +0200 Subject: [PATCH 2/4] Carry asyncness over into fixture code --- src/render/fixture.rs | 26 ++++++++++++++++++++++---- 1 file changed, 22 insertions(+), 4 deletions(-) diff --git a/src/render/fixture.rs b/src/render/fixture.rs index 1f6575b..b4d3b64 100644 --- a/src/render/fixture.rs +++ b/src/render/fixture.rs @@ -10,6 +10,7 @@ use crate::utils::{fn_args, fn_args_idents}; pub(crate) fn render<'a>(fixture: ItemFn, info: FixtureInfo) -> TokenStream { let name = &fixture.sig.ident; + let asyncness = &fixture.sig.asyncness.clone(); let vargs = fn_args_idents(&fixture).cloned().collect::>(); let args = &vargs; let orig_args = &fixture.sig.inputs; @@ -29,6 +30,23 @@ pub(crate) fn render<'a>(fixture: ItemFn, info: FixtureInfo) -> TokenStream { let inject = resolve_args(fn_args_idents(&fixture), &resolver); let partials = (1..=orig_args.len()).map(|n| render_partial_impl(&fixture, n, &resolver, &info)); + + let (self_get_default, self_get) = if asyncness.is_none() { + ( + quote! { + Self::get(#(#args),*) + }, + quote! {#name(#(#args),*)}, + ) + } else { + ( + quote! { + Self::get(#(#args),*).await + }, + quote! {#name(#(#args),*).await}, + ) + }; + quote! { #[allow(non_camel_case_types)] #visibility struct #name {} @@ -36,13 +54,13 @@ pub(crate) fn render<'a>(fixture: ItemFn, info: FixtureInfo) -> TokenStream { impl #name { #(#orig_attrs)* #[allow(unused_mut)] - pub fn get #generics (#orig_args) #output #where_clause { - #name(#(#args),*) + pub #asyncness fn get #generics (#orig_args) #output #where_clause { + #self_get } - pub fn default #default_generics () #default_output #default_where_clause { + pub #asyncness fn default #default_generics () #default_output #default_where_clause { #inject - Self::get(#(#args),*) + #self_get_default } #(#partials)* From b716cee5f4fd33f269802c2f0c4a1c65ebbcbba2 Mon Sep 17 00:00:00 2001 From: Ruben De Smet Date: Fri, 10 Apr 2020 10:39:32 +0200 Subject: [PATCH 3/4] Test with impl Trait output --- resources/fixture/async_fixture.rs | 11 +++++++++++ tests/fixture/mod.rs | 1 + 2 files changed, 12 insertions(+) diff --git a/resources/fixture/async_fixture.rs b/resources/fixture/async_fixture.rs index 5006d2b..b1ee3aa 100644 --- a/resources/fixture/async_fixture.rs +++ b/resources/fixture/async_fixture.rs @@ -1,4 +1,5 @@ use std::future::Future; +use std::io::prelude::*; use rstest::*; @@ -16,3 +17,13 @@ async fn default_is_async() { async fn use_async_fixture(async_u32: impl Future) { assert_eq!(42, async_u32.await); } + +#[fixture] +async fn async_impl_output() -> impl Read { + std::io::Cursor::new(vec![1, 2, 3, 4, 5]) +} + +#[rstest] +async fn use_async_impl_output(async_impl_output: impl Future) { + let reader = async_impl_output.await; +} diff --git a/tests/fixture/mod.rs b/tests/fixture/mod.rs index db38078..bd28db6 100644 --- a/tests/fixture/mod.rs +++ b/tests/fixture/mod.rs @@ -93,6 +93,7 @@ mod should { TestResults::new() .ok("default_is_async") .ok("use_async_fixture") + .ok("use_async_impl_output") .assert(output); } From 5f931e2b42cc84aaf81e571782fb6cd97ae21216 Mon Sep 17 00:00:00 2001 From: Ruben De Smet Date: Fri, 10 Apr 2020 10:57:47 +0200 Subject: [PATCH 4/4] Fix generation of async partials --- resources/fixture/async_fixture.rs | 5 +++++ src/render/fixture.rs | 15 +++++++++++++-- 2 files changed, 18 insertions(+), 2 deletions(-) diff --git a/resources/fixture/async_fixture.rs b/resources/fixture/async_fixture.rs index b1ee3aa..5d282b5 100644 --- a/resources/fixture/async_fixture.rs +++ b/resources/fixture/async_fixture.rs @@ -8,6 +8,11 @@ async fn async_u32() -> u32 { 42 } +#[fixture] +async fn nest_fixture(async_u32: impl Future) -> u32 { + async_u32.await +} + #[rstest] async fn default_is_async() { assert_eq!(42, async_u32::default().await); diff --git a/src/render/fixture.rs b/src/render/fixture.rs index b4d3b64..8ee826f 100644 --- a/src/render/fixture.rs +++ b/src/render/fixture.rs @@ -84,6 +84,7 @@ fn render_partial_impl( let generics = generics_clean_up(&fixture.sig.generics, fn_args(fixture).take(n), &output); let where_clause = &generics.where_clause; + let asyncness = &fixture.sig.asyncness; let inject = resolve_args(fn_args_idents(fixture).skip(n), resolver); @@ -91,11 +92,21 @@ fn render_partial_impl( let fixture_args = fn_args_idents(fixture); let name = Ident::new(&format!("partial_{}", n), Span::call_site()); + let self_get = if asyncness.is_none() { + quote! { + Self::get(#(#fixture_args),*) + } + } else { + quote! { + Self::get(#(#fixture_args),*).await + } + }; + quote! { #[allow(unused_mut)] - pub fn #name #generics (#(#sign_args),*) #output #where_clause { + pub #asyncness fn #name #generics (#(#sign_args),*) #output #where_clause { #inject - Self::get(#(#fixture_args),*) + #self_get } } }