Add unit tests to vrf_sortition

Author: HoOngEe

Cargo.lock

@@ -46,6 +46,7 @@ vrf = { git = "https://github.com/HoOngEe/vrf-rs.git" }
 
 [dev-dependencies]
 rand_xorshift = "0.1.0"
+hex = "0.4.0"
 
 [features]
 nightly = []

core/Cargo.toml

@@ -53,6 +53,7 @@ impl VRFSortition {
         let vrf_proof = vrf_inst.prove(&*priv_key, &*seed)?;
         let vrf_hash = vrf_inst.proof_to_hash(&vrf_proof)?;
         let j = lot(voting_power, self.total_power, self.expectation, &vrf_hash);
+        println!("{:?}, {}", vrf_hash, j);
 
         Ok((0..j)
             .map(|sub_user_idx| {
@@ -105,3 +106,114 @@ impl PriorityInfo {
         expected_priority == self.priority
     }
 }
+
+#[cfg(test)]
+mod vrf_tests {
+    extern crate hex;
+
+    use ccrypto::sha256;
+    use ckey::KeyPair;
+    use vrf::openssl::CipherSuite;
+
+    use super::*;
+    #[test]
+    fn test_create_highest_priority_info() {
+        let priv_key = sha256("secret_key");
+        let seed = sha256("seed");
+        let ec_vrf = ECVRF::from_suite(CipherSuite::SECP256K1_SHA256_SVDW).unwrap();
+        let ec_vrf = Arc::new(RwLock::new(ec_vrf));
+        let sortition_scheme = VRFSortition {
+            total_power: 100,
+            expectation: 50.0,
+            vrf_inst: ec_vrf,
+        };
+        // maximized when sha256(vrf_result || byte expression of 1u64), the testing oracle is generated from python sha256.
+        let expected_priority =
+            H256::from_slice(&hex::decode("ddc2ca3bd180e1af8fdec721ea863f79ad33279da2148dd58953b44420a0abca").unwrap());
+        let expected_sub_user_idx = 1;
+        let actual_priority_info =
+            sortition_scheme.create_highest_priority_info(seed, priv_key.into(), 10).unwrap().unwrap();
+        assert_eq!(expected_priority, actual_priority_info.priority());
+        assert_eq!(expected_sub_user_idx, actual_priority_info.sub_user_idx());
+    }
+
+    #[test]
+    fn test_create_highest_priority_info2() {
+        let priv_key = sha256("secret_key");
+        let seed = sha256("seed");
+        let ec_vrf = ECVRF::from_suite(CipherSuite::SECP256K1_SHA256_SVDW).unwrap();
+        let ec_vrf = Arc::new(RwLock::new(ec_vrf));
+        let sortition_scheme = VRFSortition {
+            total_power: 100,
+            expectation: 1.2,
+            vrf_inst: ec_vrf,
+        };
+        let actual_priority_info = sortition_scheme.create_highest_priority_info(seed, priv_key.into(), 10).unwrap();
+        assert!(actual_priority_info.is_none());
+    }
+
+    #[test]
+    fn test_verify_vrf_hash() {
+        let priv_key = sha256("secret_key2");
+        let pub_key = *KeyPair::from_private(priv_key.into()).expect("Valid private key").public();
+        let wrong_priv_key = sha256("wrong_secret_key");
+        let wrong_pub_key = *KeyPair::from_private(wrong_priv_key.into()).expect("Valid private key").public();
+
+        // sha256("seed2")
+        let seed = sha256("seed2");
+        let ec_vrf = ECVRF::from_suite(CipherSuite::SECP256K1_SHA256_SVDW).unwrap();
+        let ec_vrf = Arc::new(RwLock::new(ec_vrf));
+        let sortition_scheme = VRFSortition {
+            total_power: 100,
+            expectation: 60.7,
+            vrf_inst: ec_vrf,
+        };
+        let voting_power = 100;
+        let priority_info =
+            sortition_scheme.create_highest_priority_info(seed, priv_key.into(), voting_power).unwrap().unwrap();
+        assert!(priority_info.verify_vrf_hash(&pub_key, &seed, Arc::clone(&sortition_scheme.vrf_inst)).unwrap());
+        match priority_info.verify_vrf_hash(&wrong_pub_key, &seed, Arc::clone(&sortition_scheme.vrf_inst)) {
+            Err(VrfError::InvalidProof) => assert!(true),
+            _ => assert!(false),
+        }
+    }
+
+    #[test]
+    fn test_verify_sub_user_idx() {
+        let priv_key = sha256("secret_key3");
+        let seed = sha256("seed3");
+        let ec_vrf = ECVRF::from_suite(CipherSuite::SECP256K1_SHA256_SVDW).unwrap();
+        let ec_vrf = Arc::new(RwLock::new(ec_vrf));
+        let sortition_scheme = VRFSortition {
+            total_power: 100,
+            expectation: 60.7,
+            vrf_inst: ec_vrf,
+        };
+        let voting_power = 100;
+        let priority_info =
+            sortition_scheme.create_highest_priority_info(seed, priv_key.into(), voting_power).unwrap().unwrap();
+        assert!(priority_info.verify_sub_user_idx(
+            voting_power,
+            sortition_scheme.total_power,
+            sortition_scheme.expectation
+        ));
+    }
+
+
+    #[test]
+    fn test_priority() {
+        let priv_key = sha256("secret_key4");
+        let seed = sha256("seed4");
+        let ec_vrf = ECVRF::from_suite(CipherSuite::SECP256K1_SHA256_SVDW).unwrap();
+        let ec_vrf = Arc::new(RwLock::new(ec_vrf));
+        let sortition_scheme = VRFSortition {
+            total_power: 100,
+            expectation: 41.85,
+            vrf_inst: ec_vrf,
+        };
+        let voting_power = 50;
+        let priority_info =
+            sortition_scheme.create_highest_priority_info(seed, priv_key.into(), voting_power).unwrap().unwrap();
+        assert!(priority_info.verify_priority());
+    }
+}