Add support for async tests

Author: robgjansen

README.md

@@ -123,8 +123,14 @@ Multiple attributes can optionally be applied to each test, for example:
 test_each_file! { #[ignore, cfg(target_os = "linux")] in "./resources" => test }
 ```
 
+You can specify that each test is async, for example:
+
+```rust
+test_each_file! { #[tokio::test] async in "./resources" => test }
+```
+
 All the options above can be combined, for example:
 
 ```rust
-test_each_file! { #[ignore, cfg(target_os = "linux")] for ["in", "out"] in "./resources" as example => |[a, b]: [&str; 2]| assert_eq!(a, b) }
+test_each_file! { #[tokio::test, ignore, cfg(target_os = "linux")] async for ["in", "out"] in "./resources" as example => |[a, b]: [&str; 2]| assert_eq!(a, b) }
 ```

src/lib.rs

@@ -1,6 +1,7 @@
 #![doc = include_str!("../README.md")]
 use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote};
+use syn::token::Async;
 use std::collections::{HashMap, HashSet};
 use std::ffi::OsString;
 use std::path::{Path, PathBuf};
@@ -15,6 +16,7 @@ struct TestEachArgs {
     function: Expr,
     extensions: Vec<String>,
     attributes: Vec<Meta>,
+    async_fn: Option<Async>,
 }
 
 macro_rules! abort {
@@ -32,7 +34,7 @@ macro_rules! abort_token_stream {
 impl Parse for TestEachArgs {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         // Optionally parse attributes if `#` is used. Aborts if none are given.
-        let attributes = input
+        let attributes: Vec<Meta> = input
             .parse::<Token![#]>()
             .and_then(|_| {
                 let content;
@@ -45,6 +47,19 @@ impl Parse for TestEachArgs {
             })
             .unwrap_or_default();
 
+        // Optionally mark as async.
+        // The async keyword is the error span if we did not specify an attribute.
+        let async_span = input.span();
+        let async_fn = match input.parse::<Token![async]>() {
+            Ok(token) => {
+                if attributes.is_empty() {
+                    abort!(async_span, "Expected at least one attribute (e.g., `#[tokio::test]`) when `async` is given.");
+                }
+                Some(token)
+            },
+            Err(_) => None,
+        };
+
         // Optionally parse extensions if the keyword `for` is used. Aborts if none are given.
         let extensions = input
             .parse::<Token![for]>()
@@ -97,6 +112,7 @@ impl Parse for TestEachArgs {
             function,
             extensions,
             attributes,
+            async_fn,
         })
     }
 }
@@ -248,12 +264,23 @@ fn generate_from_tree(
             });
         }
 
-        stream.extend(quote! {
-            #[test]
-            fn #file_name() {
-                (#function)(#arguments)
-            }
-        });
+        if let Some(async_keyword) = &parsed.async_fn {
+            // For async functions, we'd need something like `#[tokio::test]` instead of `#[test]`.
+            // Here we assume the user will have already provided that in the list of attributes.
+            stream.extend(quote! {
+                #async_keyword fn #file_name() {
+                    (#function)(#arguments).await
+                }
+            });
+        } else {
+            // Default, non-async test.
+            stream.extend(quote! {
+                #[test]
+                fn #file_name() {
+                    (#function)(#arguments)
+                }
+            });
+        }
     }
 
     Ok(())