Config tests

crates/e2e/macro/src/config.rs

@@ -12,12 +12,17 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-use ink_ir::{ast, format_err_spanned, utils::duplicate_config_err};
+use ink_ir::{
+    ast,
+    format_err_spanned,
+    utils::duplicate_config_err,
+};
 
 /// The type of the architecture that should be used to run test.
 #[derive(Copy, Clone, Eq, PartialEq, Debug, Default)]
 enum Backend {
-    /// The standard approach with running dedicated single-node blockchain in a background process.
+    /// The standard approach with running dedicated single-node blockchain in a
+    /// background process.
     #[default]
     Full,
     /// The lightweight approach skipping node layer.
@@ -30,12 +35,14 @@ impl TryFrom<syn::LitStr> for Backend {
     fn try_from(value: syn::LitStr) -> Result<Self, Self::Error> {
         match value.value().as_str() {
             "full" => Ok(Self::Full),
-            "runtime_only" => Ok(Self::RuntimeOnly),
-            _ => Err(format_err_spanned!(
-                value,
-                "unknown backend `{}` for ink! E2E test configuration argument",
-                value.value()
-            )),
+            "runtime_only" | "runtime-only" => Ok(Self::RuntimeOnly),
+            _ => {
+                Err(format_err_spanned!(
+                    value,
+                    "unknown backend `{}` for ink! E2E test configuration argument",
+                    value.value()
+                ))
+            }
         }
     }
 }
@@ -84,12 +91,7 @@ impl TryFrom<ast::AttributeArgs> for E2EConfig {
                 }
             } else if arg.name.is_ident("environment") {
                 if let Some((_, ast)) = environment {
-                    return Err(duplicate_config_err(
-                        ast,
-                        arg,
-                        "environment",
-                        "E2E test",
-                    ));
+                    return Err(duplicate_config_err(ast, arg, "environment", "E2E test"))
                 }
                 if let ast::MetaValue::Path(path) = &arg.value {
                     environment = Some((path.clone(), arg))
@@ -101,7 +103,7 @@ impl TryFrom<ast::AttributeArgs> for E2EConfig {
                 }
             } else if arg.name.is_ident("backend") {
                 if let Some((_, ast)) = backend {
-                    return Err(duplicate_config_err(ast, arg, "backend", "E2E test"));
+                    return Err(duplicate_config_err(ast, arg, "backend", "E2E test"))
                 }
                 if let ast::MetaValue::Lit(syn::Lit::Str(lit_str)) = &arg.value {
                     backend = Some((lit_str.clone(), arg))
@@ -115,14 +117,17 @@ impl TryFrom<ast::AttributeArgs> for E2EConfig {
                 return Err(format_err_spanned!(
                     arg,
                     "encountered unknown or unsupported ink! configuration argument",
-                ));
+                ))
             }
         }
         let additional_contracts = additional_contracts
             .map(|(value, _)| value.value().split(' ').map(String::from).collect())
             .unwrap_or_else(Vec::new);
         let environment = environment.map(|(path, _)| path);
-        let backend = backend.map(|(b, _)| Backend::try_from(b)).transpose()?.unwrap_or_default();
+        let backend = backend
+            .map(|(b, _)| Backend::try_from(b))
+            .transpose()?
+            .unwrap_or_default();
 
         Ok(E2EConfig {
             additional_contracts,
@@ -224,19 +229,51 @@ mod tests {
         );
     }
 
+    #[test]
+    fn backend_must_be_literal() {
+        assert_try_from(
+            syn::parse_quote! { backend = full },
+            Err("expected a string literal for `backend` ink! E2E test configuration argument"),
+        );
+    }
+
+    #[test]
+    fn duplicate_backend_fails() {
+        assert_try_from(
+            syn::parse_quote! {
+                backend = "full",
+                backend = "runtime-only",
+            },
+            Err("encountered duplicate ink! E2E test `backend` configuration argument"),
+        );
+    }
+
+    #[test]
+    fn specifying_backend_works() {
+        assert_try_from(
+            syn::parse_quote! { backend = "runtime-only" },
+            Ok(E2EConfig {
+                backend: Backend::RuntimeOnly,
+                ..Default::default()
+            }),
+        );
+    }
+
     #[test]
     fn full_config_works() {
         assert_try_from(
             syn::parse_quote! {
                 additional_contracts = "adder/Cargo.toml flipper/Cargo.toml",
                 environment = crate::CustomEnvironment,
+                backend = "full",
             },
             Ok(E2EConfig {
                 additional_contracts: vec![
                     "adder/Cargo.toml".into(),
                     "flipper/Cargo.toml".into(),
                 ],
                 environment: Some(syn::parse_quote! { crate::CustomEnvironment }),
+                backend: Backend::Full,
             }),
         );
     }