tendermint_testgen/
validator_set.rs

1use gumdrop::Options;
2use serde::{Deserialize, Serialize};
3use simple_error::*;
4use tendermint::validator;
5
6use crate::{
7    helpers::*,
8    validator::{generate_validators, Validator},
9    Generator,
10};
11
12#[derive(Debug, Options, Serialize, Deserialize, Clone)]
13pub struct ValidatorSet {
14    #[options(
15        parse(try_from_str = "parse_as::<Vec<Validator>>"),
16        help = "validators (required)"
17    )]
18    pub validators: Option<Vec<Validator>>,
19}
20
21impl ValidatorSet {
22    pub fn new(ids: Vec<&str>) -> Self {
23        let validators = ids
24            .iter()
25            .map(|v| Validator::new(v).voting_power(50))
26            .collect::<Vec<Validator>>();
27        Self {
28            validators: Some(validators),
29        }
30    }
31}
32
33impl std::str::FromStr for ValidatorSet {
34    type Err = SimpleError;
35    fn from_str(s: &str) -> Result<Self, Self::Err> {
36        let validator_set = match parse_as::<ValidatorSet>(s) {
37            Ok(input) => input,
38            Err(_) => ValidatorSet::new(vec![s]),
39        };
40        Ok(validator_set)
41    }
42}
43
44impl Generator<validator::Set> for ValidatorSet {
45    fn merge_with_default(self, default: Self) -> Self {
46        ValidatorSet {
47            validators: self.validators.or(default.validators),
48        }
49    }
50
51    fn generate(&self) -> Result<validator::Set, SimpleError> {
52        let vals = generate_validators(self.validators.as_ref().unwrap())?;
53        Ok(validator::Set::without_proposer(vals))
54    }
55}
56
57#[cfg(test)]
58mod tests {
59    use super::*;
60
61    #[test]
62    fn test_validator_set() {
63        let valset1 = ValidatorSet::new(vec!["a", "b", "c"]).generate().unwrap();
64        let vals1 = vec![
65            Validator::new("a").voting_power(50),
66            Validator::new("b").voting_power(50),
67            Validator::new("c").voting_power(50),
68        ];
69        let valset2 = validator::Set::without_proposer(generate_validators(&vals1).unwrap());
70
71        assert_eq!(valset1.hash(), valset2.hash());
72
73        let valset3 = ValidatorSet::new(vec!["b", "c", "a"]).generate().unwrap();
74
75        assert_eq!(valset1.hash(), valset3.hash());
76
77        let valset4 = ValidatorSet::new(vec!["c", "a"]).generate().unwrap();
78
79        assert_ne!(valset4.hash(), valset3.hash());
80
81        let vals2 = vec![
82            Validator::new("a").voting_power(100),
83            Validator::new("b"),
84            Validator::new("c"),
85        ];
86        let valset5 = validator::Set::without_proposer(generate_validators(&vals2).unwrap());
87        assert_ne!(valset2.hash(), valset5.hash());
88    }
89}