add test

Author: Mr-Leshiy

rust/catalyst-voting/src/crypto/zk_unit_vector/decoding.rs

@@ -149,7 +149,7 @@ mod tests {
 
     #[proptest]
     fn proof_to_bytes_from_bytes_test(
-        #[strategy(0..20usize)] _size: usize, #[any(#_size)] p1: UnitVectorProof,
+        #[strategy(0..5usize)] _size: usize, #[any(#_size)] p1: UnitVectorProof,
     ) {
         let bytes = p1.to_bytes();
         let p2 = UnitVectorProof::from_bytes(&bytes, p1.size()).unwrap();

rust/catalyst-voting/src/txs/v1/decoding.rs

@@ -152,3 +152,63 @@ impl Tx {
         })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use proptest::prelude::{any, any_with, Arbitrary, BoxedStrategy, ProptestConfig, Strategy};
+    use test_strategy::proptest;
+
+    use super::*;
+    use crate::SecretKey;
+
+    impl Arbitrary for Tx {
+        type Parameters = ();
+        type Strategy = BoxedStrategy<Self>;
+
+        fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
+            any::<([u8; 32], u8, Vote, SecretKey)>()
+                .prop_map(|(vote_plan_id, proposal_index, vote, s)| {
+                    Tx {
+                        vote_plan_id,
+                        proposal_index,
+                        vote,
+                        public_key: s.public_key(),
+                    }
+                })
+                .boxed()
+        }
+    }
+
+    impl Arbitrary for Vote {
+        type Parameters = ();
+        type Strategy = BoxedStrategy<Self>;
+
+        fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
+            any::<bool>()
+                .prop_flat_map(|b| {
+                    if b {
+                        any::<u8>().prop_map(Vote::Public).boxed()
+                    } else {
+                        any::<(u8, u8)>()
+                            .prop_flat_map(|(s1, s2)| {
+                                any_with::<(EncryptedVote, VoterProof)>((s1.into(), s2.into()))
+                                    .prop_map(|(v, p)| Vote::Private(v, p))
+                            })
+                            .boxed()
+                    }
+                })
+                .boxed()
+        }
+    }
+
+    #[proptest(ProptestConfig::with_cases(1))]
+    #[allow(clippy::indexing_slicing)]
+    fn tx_to_bytes_from_bytes_test(t1: Tx) {
+        let bytes = t1.to_bytes();
+        // verify correctness serializing tx size field
+        let size = u32::from_be_bytes(bytes[0..4].try_into().unwrap());
+        assert_eq!(size as usize, bytes.len() - 4);
+        let t2 = Tx::from_bytes(&bytes).unwrap();
+        assert_eq!(t1, t2);
+    }
+}

rust/catalyst-voting/src/txs/v1/mod.rs

@@ -10,6 +10,7 @@ use crate::{
 };
 
 /// A v1 (Jörmungandr) transaction struct
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub struct Tx {
     /// Vote plan id
     vote_plan_id: [u8; 32],
@@ -22,25 +23,10 @@ pub struct Tx {
 }
 
 /// Vote struct
+#[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Vote {
     /// Public voting choice
     Public(u8),
     /// Private (encrypted) voting choice
     Private(EncryptedVote, VoterProof),
 }
-
-// #[cfg(test)]
-// mod tests {
-//     use proptest::prelude::{Arbitrary, BoxedStrategy};
-
-//     use super::*;
-
-//     impl Arbitrary for Tx {
-//         type Parameters = ();
-//         type Strategy = BoxedStrategy<Self>;
-
-//         fn arbitrary_with((): Self::Parameters) -> Self::Strategy {
-
-//         }
-//     }
-// }

rust/catalyst-voting/src/vote_protocol/voter/decoding.rs

@@ -89,9 +89,8 @@ mod tests {
 
     #[proptest]
     fn encrypted_vote_to_bytes_from_bytes_test(
-        #[strategy(0..20usize)] _size: usize, #[any(#_size)] vote1: EncryptedVote,
+        #[strategy(0..5usize)] _size: usize, #[any(#_size)] vote1: EncryptedVote,
     ) {
-        println!("{}", vote1.size());
         let bytes = vote1.to_bytes();
         assert_eq!(bytes.len(), vote1.bytes_size());
         let vote2 = EncryptedVote::from_bytes(&bytes, vote1.size()).unwrap();