added double_vote test

Author: Mr-Leshiy

rust/catalyst-contest/src/tally/tests/double_vote.rs

@@ -0,0 +1,86 @@
+use std::collections::HashMap;
+
+use catalyst_signed_doc::{
+    DocumentRef,
+    catalyst_id::{CatalystId, role_index::RoleId},
+    tests_utils::{create_dummy_key_pair, create_key_pair_and_publish},
+};
+use catalyst_voting::vote_protocol::committee::ElectionSecretKey;
+use proptest::{
+    prelude::{ProptestConfig, prop::array},
+    property_test,
+};
+
+use crate::tally::{
+    contest_tally,
+    provider::tests::TestTallyProvider,
+    tests::{
+        PROPOSALS_AMOUNT, VOTING_OPTIONS, Voter, assert_contest_tally_result, expected_tally,
+        prepare_contest, publish_ballot,
+    },
+};
+
+#[property_test(config = ProptestConfig::with_cases(1))]
+fn double_vote_test(
+    voting_power: u32,
+    #[strategy = array::uniform(0..VOTING_OPTIONS)] first_choices: [usize; PROPOSALS_AMOUNT],
+    #[strategy = array::uniform(0..VOTING_OPTIONS)] second_choices: [usize; PROPOSALS_AMOUNT],
+    anonymous: bool,
+    options: [String; VOTING_OPTIONS],
+) {
+    let election_secret_key = ElectionSecretKey::random_with_default_rng();
+    let mut p = TestTallyProvider::default();
+
+    let (contest_parameters, proposals_refs) = prepare_contest(
+        &options,
+        PROPOSALS_AMOUNT,
+        &election_secret_key.public_key(),
+        &mut p.p,
+    )
+    .unwrap();
+    assert_eq!(proposals_refs.len(), PROPOSALS_AMOUNT);
+
+    let (sk, kid) = create_key_pair_and_publish(&mut p.p, || create_dummy_key_pair(RoleId::Role0));
+    let voter = Voter {
+        voting_power,
+        anonymous,
+        choices: first_choices,
+    };
+    let sk = sk.into();
+    publish_ballot(
+        (&voter, kid.clone(), &sk),
+        &contest_parameters,
+        &proposals_refs,
+        &mut p,
+    )
+    .unwrap();
+    // double vote, which must superceed the previous one
+    std::thread::sleep(std::time::Duration::from_secs(1));
+    let voter = Voter {
+        voting_power,
+        anonymous,
+        choices: second_choices,
+    };
+    let ballot = publish_ballot(
+        (&voter, kid.clone(), &sk),
+        &contest_parameters,
+        &proposals_refs,
+        &mut p,
+    )
+    .unwrap();
+
+    let exp_tally = expected_tally(&contest_parameters, &proposals_refs, &[voter]);
+    let exp_participants: HashMap<CatalystId, (u64, DocumentRef)> =
+        [(kid, (voting_power.into(), ballot.doc_ref().unwrap()))]
+            .into_iter()
+            .collect();
+
+    let res_tally = contest_tally(&contest_parameters, Some(&election_secret_key), &p).unwrap();
+    assert_contest_tally_result(
+        &election_secret_key.public_key(),
+        res_tally,
+        &contest_parameters,
+        exp_tally,
+        exp_participants,
+    );
+}

rust/catalyst-contest/src/tally/tests.rs …/catalyst-contest/src/tally/tests/mod.rsrust/catalyst-contest/src/tally/tests.rs renamed to rust/catalyst-contest/src/tally/tests/mod.rs rust/catalyst-contest/src/tally/tests.rs renamed to rust/catalyst-contest/src/tally/tests/mod.rs

@@ -1,7 +1,10 @@
+mod double_vote;
+
 use std::collections::HashMap;
 
 use catalyst_signed_doc::{
-    CatalystSignedDocument, DocumentRef, builder,
+    CatalystSignedDocument, DocumentRef,
+    builder::{self, ed25519::Ed25519SigningKey},
     catalyst_id::{CatalystId, role_index::RoleId},
     providers::tests::TestCatalystProvider,
     tests_utils::{
@@ -27,7 +30,7 @@ use crate::{
         payload::{Choices, ContestBallotPayload},
     },
     contest_parameters::ContestParameters,
-    tally::{contest_tally, provider::tests::TestTallyProvider},
+    tally::{ContestResult, contest_tally, provider::tests::TestTallyProvider},
 };
 
 const VOTING_OPTIONS: usize = 3;
@@ -43,6 +46,11 @@ struct Voter {
     anonymous: bool,
 }
 
+type EncryptedTotalResult = u64;
+type ClearTotalResult = u64;
+type Participants = HashMap<CatalystId, (u64, DocumentRef)>;
+type TallyRes = HashMap<DocumentRef, Vec<(ClearTotalResult, EncryptedTotalResult, String)>>;
+
 #[property_test(config = ProptestConfig::with_cases(1))]
 fn tally_test(
     voters: [Voter; VOTERS_NUMBER],
@@ -62,10 +70,11 @@ fn tally_test(
 
     let exp_tally = expected_tally(&contest_parameters, &proposals_refs, &voters);
 
-    let exp_participant: HashMap<CatalystId, (u64, DocumentRef)> = voters
+    let exp_participants: Participants = voters
         .iter()
         .map(|v| {
-            let ballot = publish_ballot(v, &contest_parameters, &proposals_refs, &mut p).unwrap();
+            let ballot =
+                publish_ballot_with_keys(v, &contest_parameters, &proposals_refs, &mut p).unwrap();
             let voter = ballot.authors().first().unwrap().clone();
             let ballot_ref = ballot.doc_ref().unwrap();
 
@@ -74,8 +83,24 @@ fn tally_test(
         .collect();
 
     let res_tally = contest_tally(&contest_parameters, Some(&election_secret_key), &p).unwrap();
+    assert_contest_tally_result(
+        &election_secret_key.public_key(),
+        res_tally,
+        &contest_parameters,
+        exp_tally,
+        exp_participants,
+    );
+}
+
+fn assert_contest_tally_result(
+    election_public_key: &ElectionPublicKey,
+    res_tally: ContestResult,
+    contest_parameters: &ContestParameters,
+    exp_tally: TallyRes,
+    exp_participants: Participants,
+) {
     assert_eq!(&res_tally.options, contest_parameters.options());
-    assert_eq!(&res_tally.participants, &exp_participant);
+    assert_eq!(&res_tally.participants, &exp_participants);
 
     for (p_ref, exp_tally_per_proposal) in exp_tally {
         let res_tally_per_proposal = res_tally
@@ -100,7 +125,7 @@ fn tally_test(
             assert!(verify_tally_proof(
                 &res_tally_per_proposal[i].encrypted_tally,
                 decrypted_tally.tally,
-                &election_secret_key.public_key(),
+                &election_public_key,
                 &decrypted_tally.proof
             ));
         }
@@ -141,22 +166,32 @@ fn prepare_contest(
     Ok((ContestParameters::new(&parameters, p)?, proposals_refs))
 }
 
-fn publish_ballot(
+fn publish_ballot_with_keys(
     voter: &Voter,
     parameters: &ContestParameters,
     proposals_refs: &[DocumentRef],
     p: &mut TestTallyProvider,
 ) -> anyhow::Result<CatalystSignedDocument> {
     let (sk, kid) = create_key_pair_and_publish(&mut p.p, || create_dummy_key_pair(RoleId::Role0));
+    publish_ballot((voter, kid, &sk.into()), parameters, proposals_refs, p)
+}
 
+fn publish_ballot(
+    voter: (&Voter, CatalystId, &Ed25519SigningKey),
+    parameters: &ContestParameters,
+    proposals_refs: &[DocumentRef],
+    p: &mut TestTallyProvider,
+) -> anyhow::Result<CatalystSignedDocument> {
     // Filling the `TestTallyProvider` with the voter's voting power information
-    p.voters.insert(kid.clone(), voter.voting_power.into());
+    p.voters
+        .insert(voter.1.clone(), voter.0.voting_power.into());
 
     let choices = voter
+        .0
         .choices
         .iter()
         .map(|choice| {
-            if voter.anonymous {
+            if voter.0.anonymous {
                 let commitment = commitment_key(parameters.doc_ref())?;
                 Choices::new_encrypted_single(
                     *choice,
@@ -176,21 +211,18 @@ fn publish_ballot(
             proposals_refs,
             parameters.doc_ref(),
             &payload,
-            &sk.into(),
-            kid,
+            voter.2,
+            voter.1,
             None,
         )
     })
 }
 
-type EncryptedTotalResult = u64;
-type ClearTotalResult = u64;
-
 fn expected_tally(
     contest_parameters: &ContestParameters,
     proposals_refs: &[DocumentRef],
     voters: &[Voter],
-) -> HashMap<DocumentRef, Vec<(ClearTotalResult, EncryptedTotalResult, String)>> {
+) -> TallyRes {
     let options = contest_parameters.options().clone();
 
     proposals_refs