refactor: simpler e2e runtime tests style

Author: Daanvdplas

Cargo.toml

@@ -81,7 +81,7 @@ tracing-subscriber = { version = "0.3.20" }
 trybuild = { version = "1.0.110" }
 which = { version = "8.0.0" }
 xxhash-rust = { version = "0.8" }
-const_env = { version = "0.1" }
+const_env = { version = "0.1.4" }
 const-hex = { version = "1.17.0", default-features = false }
 
 # Substrate dependencies

crates/e2e/macro/src/config.rs

@@ -12,6 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+use darling::{
+    FromMeta,
+    ast::NestedMeta,
+};
+use proc_macro2::TokenStream as TokenStream2;
+use syn::{
+    Meta,
+    punctuated::Punctuated,
+    spanned::Spanned,
+};
+
 /// The type of the architecture that should be used to run test.
 #[derive(Clone, Eq, PartialEq, Debug, darling::FromMeta)]
 #[darling(rename_all = "snake_case")]
@@ -129,25 +140,123 @@ impl E2EConfig {
     pub fn replace_test_attr(&self) -> Option<String> {
         self.replace_test_attr.clone()
     }
+
+    /// Parses the attribute arguments passed to `ink_e2e::test`.
+    pub fn from_attr_tokens(attr: TokenStream2) -> Result<Self, syn::Error> {
+        let nested_meta = NestedMeta::parse_meta_list(attr)?;
+        Self::from_nested_meta(nested_meta)
+    }
+
+    /// Builds the configuration from already parsed meta items.
+    pub fn from_nested_meta(nested_meta: Vec<NestedMeta>) -> Result<Self, syn::Error> {
+        let normalized = normalize_runtime_meta(nested_meta)?;
+        Self::from_list(&normalized).map_err(syn::Error::from)
+    }
+}
+
+fn normalize_runtime_meta(
+    nested_meta: Vec<NestedMeta>,
+) -> Result<Vec<NestedMeta>, syn::Error> {
+    let mut args = Vec::with_capacity(nested_meta.len());
+    let mut runtime = None;
+
+    for meta in nested_meta {
+        if let Some(found) = RuntimeBackendArg::from_nested_meta(&meta)? {
+            if runtime.replace(found).is_some() {
+                return Err(syn::Error::new(
+                    meta.span(),
+                    "only a single `runtime` attribute is allowed",
+                ));
+            }
+            continue;
+        }
+        args.push(meta);
+    }
+
+    if let Some(runtime) = runtime {
+        args.push(runtime.into_backend_meta());
+    }
+
+    Ok(args)
+}
+
+struct RuntimeBackendArg {
+    runtime: Option<syn::Path>,
+}
+
+impl RuntimeBackendArg {
+    fn from_nested_meta(meta: &NestedMeta) -> Result<Option<Self>, syn::Error> {
+        let meta = match meta {
+            NestedMeta::Meta(meta) if meta.path().is_ident("runtime") => meta,
+            _ => return Ok(None),
+        };
+
+        match meta {
+            Meta::Path(_) => Ok(Some(Self { runtime: None })),
+            Meta::List(list) => {
+                let nested: Punctuated<NestedMeta, syn::Token![,]> =
+                    list.parse_args_with(Punctuated::parse_terminated)?;
+                if nested.len() != 1 {
+                    return Err(syn::Error::new(
+                        list.span(),
+                        "`runtime` expects zero or one runtime type",
+                    ));
+                }
+                match nested.first().unwrap() {
+                    NestedMeta::Meta(Meta::Path(path)) => {
+                        Ok(Some(Self {
+                            runtime: Some(path.clone()),
+                        }))
+                    }
+                    other => {
+                        Err(syn::Error::new(
+                            other.span(),
+                            "`runtime` expects a runtime type path",
+                        ))
+                    }
+                }
+            }
+            Meta::NameValue(name_value) => {
+                Err(syn::Error::new(
+                    name_value.span(),
+                    "`runtime` does not support name-value pairs",
+                ))
+            }
+        }
+    }
+
+    fn runtime(&self) -> syn::Path {
+        self.runtime
+            .clone()
+            .unwrap_or_else(|| syn::parse_quote! { ::ink_runtime::DefaultRuntime })
+    }
+
+    fn into_backend_meta(self) -> NestedMeta {
+        let runtime = self.runtime();
+        syn::parse_quote! {
+            backend(runtime_only(sandbox = #runtime, client = ::ink_runtime::RuntimeClient))
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use darling::{
-        FromMeta,
-        ast::NestedMeta,
-    };
+    use darling::ast::NestedMeta;
     use quote::quote;
 
+    fn parse_config(input: TokenStream2) -> E2EConfig {
+        let nested = NestedMeta::parse_meta_list(input).unwrap();
+        E2EConfig::from_nested_meta(nested).unwrap()
+    }
+
     #[test]
     fn config_works_backend_runtime_only() {
         let input = quote! {
             environment = crate::CustomEnvironment,
             backend(runtime_only(sandbox = ::ink_runtime::DefaultRuntime, client = ::ink_runtime::RuntimeClient)),
         };
-        let config =
-            E2EConfig::from_list(&NestedMeta::parse_meta_list(input).unwrap()).unwrap();
+        let config = parse_config(input);
 
         assert_eq!(
             config.environment(),
@@ -169,8 +278,7 @@ mod tests {
         let input = quote! {
             backend(runtime_only(default)),
         };
-        let config =
-            E2EConfig::from_list(&NestedMeta::parse_meta_list(input).unwrap()).unwrap();
+        let config = parse_config(input);
 
         assert_eq!(
             config.backend(),
@@ -186,8 +294,7 @@ mod tests {
         let input = quote! {
             backend(runtime_only(sandbox = ::ink_runtime::DefaultRuntime, client = ::ink_runtime::RuntimeClient)),
         };
-        let config =
-            E2EConfig::from_list(&NestedMeta::parse_meta_list(input).unwrap()).unwrap();
+        let config = parse_config(input);
 
         assert_eq!(
             config.backend(),
@@ -198,13 +305,40 @@ mod tests {
         );
     }
 
+    #[test]
+    fn runtime_keyword_defaults() {
+        let input = quote! { runtime };
+        let config = parse_config(input);
+
+        assert_eq!(
+            config.backend(),
+            Backend::RuntimeOnly(RuntimeOnly {
+                sandbox: syn::parse_quote! { ::ink_runtime::DefaultRuntime },
+                client: syn::parse_quote! { ::ink_runtime::RuntimeClient },
+            })
+        );
+    }
+
+    #[test]
+    fn runtime_keyword_custom_runtime() {
+        let input = quote! { runtime(crate::CustomRuntime) };
+        let config = parse_config(input);
+
+        assert_eq!(
+            config.backend(),
+            Backend::RuntimeOnly(RuntimeOnly {
+                sandbox: syn::parse_quote! { crate::CustomRuntime },
+                client: syn::parse_quote! { ::ink_runtime::RuntimeClient },
+            })
+        );
+    }
+
     #[test]
     fn config_works_backend_node() {
         let input = quote! {
             backend(node),
         };
-        let config =
-            E2EConfig::from_list(&NestedMeta::parse_meta_list(input).unwrap()).unwrap();
+        let config = parse_config(input);
 
         assert_eq!(config.backend(), Backend::Node(Node::Auto));
 
@@ -236,8 +370,7 @@ mod tests {
         let input = quote! {
             backend(node(auto)),
         };
-        let config =
-            E2EConfig::from_list(&NestedMeta::parse_meta_list(input).unwrap()).unwrap();
+        let config = parse_config(input);
 
         assert_eq!(config.backend(), Backend::Node(Node::Auto));
     }
@@ -247,8 +380,7 @@ mod tests {
         let input = quote! {
             backend(node(url = "ws://0.0.0.0:9999")),
         };
-        let config =
-            E2EConfig::from_list(&NestedMeta::parse_meta_list(input).unwrap()).unwrap();
+        let config = parse_config(input);
 
         match config.backend() {
             Backend::Node(node_config) => {
@@ -277,8 +409,7 @@ mod tests {
         let input = quote! {
             replace_test_attr = "#[quickcheck]"
         };
-        let config =
-            E2EConfig::from_list(&NestedMeta::parse_meta_list(input).unwrap()).unwrap();
+        let config = parse_config(input);
 
         assert_eq!(config.replace_test_attr(), Some("#[quickcheck]".to_owned()));
     }

crates/e2e/macro/src/ir.rs

@@ -13,10 +13,6 @@
 // limitations under the License.
 
 use crate::config::E2EConfig;
-use darling::{
-    FromMeta,
-    ast::NestedMeta,
-};
 use proc_macro2::TokenStream as TokenStream2;
 
 /// The End-to-End test with all required information.
@@ -38,7 +34,7 @@ impl InkE2ETest {
     /// Returns `Ok` if the test matches all requirements for an
     /// ink! E2E test definition.
     pub fn new(attrs: TokenStream2, input: TokenStream2) -> Result<Self, syn::Error> {
-        let e2e_config = E2EConfig::from_list(&NestedMeta::parse_meta_list(attrs)?)?;
+        let e2e_config = E2EConfig::from_attr_tokens(attrs)?;
         let item_fn = syn::parse2::<syn::ItemFn>(input)?;
         let e2e_fn = E2EFn::from(item_fn);
         Ok(Self {

crates/e2e/macro/src/lib.rs

@@ -60,12 +60,15 @@ use syn::Result;
 /// ```
 /// type E2EResult<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 ///
-/// #[ink_runtime::test(backend(runtime_only(sandbox = ink_runtime::DefaultRuntime, client = ink_runtime::RuntimeClient)))]
-/// async fn runtime_call_works() -> E2EResult<()> {
+/// #[ink_e2e::test(runtime)]
+/// async fn runtime_call_works(mut client: Client) -> E2EResult<()> {
 ///     // ...
 /// }
 /// ```
 ///
+/// This defaults to `ink_runtime::DefaultRuntime` together with the built-in
+/// `ink_runtime::RuntimeClient`.
+///
 /// In this configuration the test will not run against a node that is running in the
 /// background, but against an in-process slimmed down `pallet-revive` execution
 /// environment.
@@ -74,6 +77,15 @@ use syn::Result;
 /// in our documentation for more details.
 /// For a full example [see here](https://github.com/use-ink/ink-examples/tree/v5.x.x/e2e-runtime-only-backend).
 ///
+/// You can also provide a custom runtime:
+///
+/// ```
+/// #[ink_e2e::test(runtime(crate::CustomRuntime))]
+/// async fn runtime_call_works(mut client: Client) -> E2EResult<()> {
+///     // ...
+/// }
+/// ```
+///
 /// # Example
 ///
 /// ```

crates/runtime/src/client.rs

@@ -853,7 +853,7 @@ pub mod preset {
         /// with a mock network of relay chain and parachains.
         ///
         /// ```no_compile
-        /// #[ink_e2e::test(backend(runtime_only(sandbox = MockNetworkRuntime, client = ink_runtime::RuntimeClient)))]
+        /// #[ink_e2e::test(runtime(MockNetworkRuntime))]
         /// async fn my_test<Client: E2EBackend>(mut client: Client) -> E2EResult<()> {
         ///   // ...
         /// }

integration-tests/internal/e2e-runtime-only-backend/lib.rs

@@ -56,11 +56,8 @@ pub mod flipper {
         /// - flip the flipper
         /// - get the flipper's value
         /// - assert that the value is `true`
-        #[ink_runtime::test(backend(runtime_only(
-            sandbox = ink_runtime::DefaultRuntime,
-            client  = ink_runtime::RuntimeClient
-        )))]
-        async fn it_works<Client: E2EBackend>(mut client: Client) -> E2EResult<()> {
+        #[ink_e2e::test(runtime)]
+        async fn it_works(mut client: Client) -> E2EResult<()> {
             // given
             const INITIAL_VALUE: bool = false;
             let mut constructor = FlipperRef::new(INITIAL_VALUE);
@@ -98,10 +95,7 @@ pub mod flipper {
         /// - transfer some funds to the contract using runtime call
         /// - get the contract's balance again
         /// - assert that the contract's balance increased by the transferred amount
-        #[ink_runtime::test(backend(runtime_only(
-            sandbox = ink_runtime::DefaultRuntime,
-            client  = ink_runtime::RuntimeClient
-        )))]
+        #[ink_e2e::test(runtime)]
         async fn runtime_call_works() -> E2EResult<()> {
             // given
             let mut constructor = FlipperRef::new(false);
@@ -155,11 +149,8 @@ pub mod flipper {
         }
 
         /// Just instantiate a contract using non-default runtime.
-        #[ink_runtime::test(backend(runtime_only(
-            sandbox = ink_runtime::DefaultRuntime,
-            client  = ink_runtime::RuntimeClient
-        )))]
-        async fn custom_runtime<Client: E2EBackend>(mut client: Client) -> E2EResult<()> {
+        #[ink_e2e::test(runtime)]
+        async fn custom_runtime(mut client: Client) -> E2EResult<()> {
             client
                 .instantiate(
                     "e2e-runtime-only-backend",