feat: unit test external call mock

crates/motsu-proc/src/test.rs

@@ -15,57 +15,45 @@ pub(crate) fn test(_attr: &TokenStream, input: TokenStream) -> TokenStream {
     let fn_block = &item_fn.block;
     let fn_args = &sig.inputs;
 
-    // Currently, more than one contract per unit test is not supported.
-    if fn_args.len() > 1 {
-        error!(fn_args, "expected at most one contract in test signature");
-    }
-
     // Whether 1 or none contracts will be declared.
     let arg_binding_and_ty = match fn_args
         .into_iter()
         .map(|arg| {
             let FnArg::Typed(arg) = arg else {
                 error!(@arg, "unexpected receiver argument in test signature");
             };
-            let contract_arg_binding = &arg.pat;
-            let contract_ty = &arg.ty;
-            Ok((contract_arg_binding, contract_ty))
+            let arg_binding = &arg.pat;
+            let arg_ty = &arg.ty;
+            Ok((arg_binding, arg_ty))
         })
         .collect::<Result<Vec<_>, _>>()
     {
         Ok(res) => res,
         Err(err) => return err.to_compile_error().into(),
     };
 
-    let contract_arg_defs =
-        arg_binding_and_ty.iter().map(|(arg_binding, contract_ty)| {
-            // Test case assumes, that contract's variable has `&mut` reference
-            // to contract's type.
-            quote! {
-                #arg_binding: &mut #contract_ty
-            }
-        });
+    // Collect argument definitions.
+    let arg_defs = arg_binding_and_ty.iter().map(|(arg_binding, arg_ty)| {
+        quote! {
+            #arg_binding: #arg_ty
+        }
+    });
 
-    let contract_args =
-        arg_binding_and_ty.iter().map(|(_arg_binding, contract_ty)| {
-            // Pass mutable reference to the contract.
-            quote! {
-                &mut <#contract_ty>::default()
-            }
-        });
+    // Collect argument initializations.
+    let arg_inits = arg_binding_and_ty.iter().map(|(_arg_binding, arg_ty)| {
+        quote! {
+            <#arg_ty>::random()
+        }
+    });
 
     // Declare test case closure.
-    // Pass mut ref to the test closure and call it.
-    // Reset storage for the test context and return test's output.
+    // Pass arguments to the test closure and call it.
     quote! {
         #( #attrs )*
         #[test]
         fn #fn_name() #fn_return_type {
-            use ::motsu::prelude::DefaultStorage;
-            let test = | #( #contract_arg_defs ),* | #fn_block;
-            let res = test( #( #contract_args ),* );
-            ::motsu::prelude::Context::current().reset_storage();
-            res
+            let test = | #( #arg_defs ),* | #fn_block;
+            test( #( #arg_inits ),* )
         }
     }
     .into()

crates/motsu/Cargo.toml

@@ -15,6 +15,8 @@ tiny-keccak.workspace = true
 stylus-sdk.workspace = true
 motsu-proc.workspace = true
 dashmap.workspace = true
+alloy-primitives = { workspace = true, features = ["arbitrary", "rand"] }
+alloy-sol-types.workspace = true
 
 [lints]
 workspace = true