Proptest for define functions

clar2wasm/tests/wasm-generation/functions.rs

@@ -0,0 +1,331 @@
+use clar2wasm::tools::crosscheck;
+use clarity::vm::types::{ResponseData, TupleData, TypeSignature};
+use clarity::vm::{ClarityName, Value};
+use proptest::prelude::*;
+use proptest::proptest;
+use proptest::strategy::Strategy;
+
+use crate::{prop_signature, response, type_string, PropValue};
+
+fn strategies_for_function_siganture() -> impl Strategy<Value = (Vec<TypeSignature>, Vec<PropValue>)>
+{
+    prop::collection::vec(
+        prop_signature().prop_ind_flat_map2(|ty| PropValue::from_type(ty.clone())),
+        1..=20,
+    )
+    .prop_map(|arg_ty| arg_ty.into_iter().unzip::<_, _, Vec<_>, Vec<_>>())
+    .no_shrink()
+}
+
+fn strategies_for_response() -> impl Strategy<Value = PropValue> {
+    (prop_signature(), prop_signature())
+        .prop_flat_map(|(ok, err)| response(ok, err))
+        .prop_map(PropValue::from)
+        .no_shrink()
+}
+
+/// Given a list of type signatures, join them together with some generated arguments names
+/// and return both the formatted signature `(arg-0 type-0) ...` and the list of
+/// generated arguments names
+fn format_args_signature(tys: &Vec<TypeSignature>) -> (String, Vec<String>) {
+    let args: Vec<String> = (0..tys.len()).map(|i| format!("arg-{i}")).collect();
+    let sig = args
+        .iter()
+        .zip(tys)
+        .map(|(arg, ty)| format!("({arg} {})", type_string(ty)))
+        .collect::<Vec<_>>()
+        .join(" ");
+    (sig, args)
+}
+
+fn join_stringified(values: &[PropValue]) -> String {
+    values
+        .iter()
+        .map(|v| v.to_string())
+        .collect::<Vec<_>>()
+        .join(" ")
+}
+
+proptest! {
+    #![proptest_config(super::runtime_config())]
+
+    #[test]
+    fn crossprop_define_private_accepts_any_args(
+        (tys, values) in strategies_for_function_siganture(),
+        result in PropValue::any().no_shrink()
+    ) {
+        let (args_signature, _) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+        crosscheck(
+            &format!(
+                r#"
+                    (define-private (some-fn {args_signature})
+                        {result}
+                    )
+                    (some-fn {call_args})
+                "#,
+            ),
+            Ok(Some(result.into())),
+        )
+    }
+
+    #[test]
+    fn crossprop_define_private_returns_any_argument(
+        ((tys, values), return_index) in strategies_for_function_siganture().prop_ind_flat_map2(|(tys, _)| 0..tys.len()),
+    ) {
+        let (args_signature, args_name) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+        crosscheck(
+            &format!(
+                r#"
+                    (define-private (some-fn {args_signature})
+                        {}
+                    )
+                    (some-fn {call_args})
+                "#, args_name[return_index]
+            ),
+            Ok(Some(values[return_index].clone().into())),
+        )
+    }
+
+    #[test]
+    fn crossprop_define_private_can_use_all_arguments((tys, values) in strategies_for_function_siganture()) {
+        let (args_signature, args_name) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+
+        let return_exp = args_name.iter().map(|arg| format!("ret-{arg}: {arg}")).collect::<Vec<_>>().join(", ");
+        let expected = TupleData::from_data(
+            args_name.iter()
+                .map(|arg| ClarityName::try_from(format!("ret-{arg}")).unwrap())
+                .zip(values.into_iter().map(Value::from))
+                .collect(),
+        )
+        .unwrap()
+        .into();
+
+        crosscheck(
+            &format!(
+                r#"
+                    (define-private (some-fn {args_signature})
+                        {{ {return_exp} }}
+                    )
+                    (some-fn {call_args})
+                "#,
+            ),
+            Ok(Some(expected)),
+        )
+    }
+
+    #[test]
+    fn crossprop_define_private_side_effects(
+        (tys, values) in strategies_for_function_siganture(),
+        response in strategies_for_response())
+    {
+        let (args_signature, _) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+
+        let expected = TupleData::from_data(vec![
+            (ClarityName::from("fn"), response.clone().into()),
+            // Response does not affect private functions
+            (ClarityName::from("side"), Value::Bool(true)),
+        ]).unwrap().into();
+
+        crosscheck(
+            &format!(
+                r#"
+                    (define-data-var side bool false)
+                    (define-private (some-fn {args_signature})
+                        (begin 
+                            (var-set side true)
+                            {response}
+                        )
+                    )
+                    {{ fn: (some-fn {call_args}), side: (var-get side) }}
+                "#,
+            ),
+            Ok(Some(expected)),
+        )
+    }
+
+
+    #[test]
+    fn crossprop_define_public_accepts_any_args(
+        (tys, values) in strategies_for_function_siganture(),
+        response in strategies_for_response())
+    {
+        let (args_signature, _) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+        crosscheck(
+            &format!(
+                r#"
+                    (define-public (some-fn {args_signature})
+                        {response}
+                    )
+                    (some-fn {call_args})
+                "#,
+            ),
+            Ok(Some(response.into())),
+        )
+    }
+
+    #[test]
+    fn crossprop_define_public_returns_any_argument(
+        ((tys, values), return_index) in strategies_for_function_siganture().prop_ind_flat_map2(|(tys, _)| 0..tys.len()),
+        response_ok in any::<bool>()
+    ) {
+        let (args_signature, args_name) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+        let expected = Value::Response(ResponseData {
+            committed: response_ok,
+            data: Box::new(values[return_index].clone().into()),
+        });
+        crosscheck(
+            &format!(
+                r#"
+                    (define-public (some-fn {args_signature})
+                        ({} {})
+                    )
+                    (some-fn {call_args})
+                "#, if response_ok { "ok" } else { "err" }, args_name[return_index]
+            ),
+            Ok(Some(expected)),
+        )
+    }
+
+    #[test]
+    fn crossprop_define_public_can_use_all_arguments(
+        (tys, values) in strategies_for_function_siganture(),
+        response_ok in any::<bool>()
+    ) {
+        let (args_signature, args_name) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+
+        let return_exp = args_name.iter().map(|arg| format!("ret-{arg}: {arg}")).collect::<Vec<_>>().join(", ");
+        let expected = TupleData::from_data(
+            args_name.iter()
+                .map(|arg| ClarityName::try_from(format!("ret-{arg}")).unwrap())
+                .zip(values.into_iter().map(Value::from))
+                .collect(),
+        ).unwrap();
+        let expected = Value::Response(ResponseData {
+            committed: response_ok,
+            data: Box::new(expected.into()),
+        });
+
+        crosscheck(
+            &format!(
+                r#"
+                    (define-public (some-fn {args_signature})
+                        ({} {{ {return_exp} }})
+                    )
+                    (some-fn {call_args})
+                "#, if response_ok { "ok" } else { "err" }
+            ),
+            Ok(Some(expected)),
+        )
+    }
+
+    #[test]
+    fn crossprop_define_public_side_effects(
+        (tys, values) in strategies_for_function_siganture(),
+        response in strategies_for_response())
+    {
+        let (args_signature, _) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+
+        let expected = TupleData::from_data(vec![
+            (ClarityName::from("fn"), response.clone().into()),
+            // Err responses revert changes (`(var-set side true)`)
+            (ClarityName::from("side"), Value::Bool(
+                match response {
+                    PropValue(Value::Response(ResponseData{ committed, ..})) => committed,
+                    _ => unreachable!("Expected a response")
+                }
+            )),
+        ]).unwrap().into();
+
+        crosscheck(
+            &format!(
+                r#"
+                    (define-data-var side bool false)
+                    (define-public (some-fn {args_signature})
+                        (begin 
+                            (var-set side true)
+                            {response}
+                        )
+                    )
+                    {{ fn: (some-fn {call_args}), side: (var-get side) }}
+                "#,
+            ),
+            Ok(Some(expected)),
+        )
+    }
+
+
+    #[test]
+    fn crossprop_define_readonly_accepts_any_args(
+        (tys, values) in strategies_for_function_siganture(),
+        result in PropValue::any().no_shrink()
+    ) {
+        let (args_signature, _) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+        crosscheck(
+            &format!(
+                r#"
+                    (define-read-only (some-fn {args_signature})
+                        {result}
+                    )
+                    (some-fn {call_args})
+                "#,
+            ),
+            Ok(Some(result.into())),
+        )
+    }
+
+    #[test]
+    fn crossprop_define_readonly_returns_any_argument(
+        ((tys, values), return_index) in strategies_for_function_siganture().prop_ind_flat_map2(|(tys, _)| 0..tys.len()),
+    ) {
+        let (args_signature, args_name) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+        crosscheck(
+            &format!(
+                r#"
+                    (define-read-only (some-fn {args_signature})
+                        {}
+                    )
+                    (some-fn {call_args})
+                "#, args_name[return_index]
+            ),
+            Ok(Some(values[return_index].clone().into())),
+        )
+    }
+
+    #[test]
+    fn crossprop_define_readonly_can_use_all_arguments((tys, values) in strategies_for_function_siganture()) {
+        let (args_signature, args_name) = format_args_signature(&tys);
+        let call_args = join_stringified(&values);
+
+        let return_exp = args_name.iter().map(|arg| format!("ret-{arg}: {arg}")).collect::<Vec<_>>().join(", ");
+        let expected = TupleData::from_data(
+            args_name.iter()
+                .map(|arg| ClarityName::try_from(format!("ret-{arg}")).unwrap())
+                .zip(values.into_iter().map(Value::from))
+                .collect(),
+        )
+        .unwrap()
+        .into();
+
+        crosscheck(
+            &format!(
+                r#"
+                    (define-read-only (some-fn {args_signature})
+                        {{ {return_exp} }}
+                    )
+                    (some-fn {call_args})
+                "#,
+            ),
+            Ok(Some(expected)),
+        )
+    }
+}

clar2wasm/tests/wasm-generation/main.rs

@@ -10,6 +10,7 @@ pub mod contracts;
 pub mod control_flow;
 pub mod default_to;
 pub mod equal;
+pub mod functions;
 pub mod hashing;
 pub mod maps;
 pub mod noop;