mock.rs - source
Description: Source of the Rust file `src/mock.rs`.
Keywords: rust, rustlang, rust-lang

      1
      2
      3
      4
      5
      6
      7
      8
      9
     10
     11
     12
     13
     14
     15
     16
     17
     18
     19
     20
     21
     22
     23
     24
     25
     26
     27
     28
     29
     30
     31
     32
     33
     34
     35
     36
     37
     38
     39
     40
     41
     42
     43
     44
     45
     46
     47
     48
     49
     50
     51
     52
     53
     54
     55
     56
     57
     58
     59
     60
     61
     62
     63
     64
     65
     66
     67
     68
     69
     70
     71
     72
     73
     74
     75
     76
     77
     78
     79
     80
     81
     82
     83
     84
     85
     86
     87
     88
     89
     90
     91
     92
     93
     94
     95
     96
     97
     98
     99
    100
    101
    102
    103
    104
    105
    106
    107
    108
    109
    110
    111
    112
    113
    114
    115
    116
    117

    //! # mock
    //!
    //! Enables to mock a specific CI vendor by setting the relevant environment variables.
    //!

    use crate::config;
    use crate::types::{CiInfo, EnvValue, VendorConfig};
    use envmnt;

    fn get_env_keys(env_info: &Option<EnvValue>) -> Vec<String> {
        match env_info {
            Some(info) => match info {
                EnvValue::Exists(ref key) => vec![key.to_string()],
                EnvValue::AllExists(ref keys) => keys.clone(),
                EnvValue::AnyExists(ref keys) => keys.clone(),
                EnvValue::Value(ref key, ref _value) => vec![key.to_string()],
                EnvValue::NotEqual(ref key, ref _value) => vec![key.to_string()],
                EnvValue::Contains(ref key, ref _value) => vec![key.to_string()],
                EnvValue::NotEmpty(ref key) => vec![key.to_string()],
            },
            None => vec![],
        }
    }

    pub(crate) fn clear_env(vendor_config_list: &Vec<VendorConfig>) {
        for vendor_config in vendor_config_list.iter() {
            let mut keys = get_env_keys(&Some(vendor_config.ci_env.clone()));
            envmnt::remove_all(&keys);

            keys = get_env_keys(&vendor_config.pr_env);
            envmnt::remove_all(&keys);

            match vendor_config.branch_name_env {
                Some(ref key) => envmnt::remove(key),
                None => (),
            };
        }
    }

    fn set_mock_env_key_value_pairs(env_info: &Option<EnvValue>, test_value: &str) {
        let key_value_pairs = match env_info {
            Some(info) => match info {
                EnvValue::Exists(ref key) => vec![(key.to_string(), test_value.to_string())],
                EnvValue::AllExists(ref keys) => {
                    let mut key_values = vec![];

                    for key in keys {
                        key_values.push((key.to_string(), test_value.to_string()))
                    }

                    key_values
                }
                EnvValue::AnyExists(ref keys) => vec![(keys[0].to_string(), test_value.to_string())],
                EnvValue::Value(ref key, ref value) => vec![(key.to_string(), value.to_string())],
                EnvValue::NotEqual(ref key, ref _value) => {
                    vec![(key.to_string(), test_value.to_string())]
                }
                EnvValue::Contains(ref key, ref value) => vec![(key.to_string(), value.to_string())],
                EnvValue::NotEmpty(ref key) => vec![(key.to_string(), test_value.to_string())],
            },
            None => vec![],
        };

        for key_value_pair in key_value_pairs {
            envmnt::set(key_value_pair.0, key_value_pair.1);
        }
    }

    pub(crate) fn set_env_for_config(vendor_config: &VendorConfig, branch_name: Option<String>) {
        set_mock_env_key_value_pairs(&Some(vendor_config.ci_env.clone()), "mock_ci");
        set_mock_env_key_value_pairs(&vendor_config.pr_env, "mock_pr");
        match vendor_config.branch_name_env {
            Some(ref key) => envmnt::set(key, branch_name.unwrap_or("mock_branch".to_string())),
            None => (),
        };
    }

    fn set_env_for_info(info: &CiInfo, vendor_config_list: Vec<VendorConfig>) {
        if info.ci {
            match info.vendor {
                Some(ref vendor) => {
                    for vendor_config in vendor_config_list.iter() {
                        if vendor_config.vendor == *vendor {
                            let mut mock_vendor_config = vendor_config.clone();

                            match info.pr {
                                Some(value) => {
                                    if !value {
                                        mock_vendor_config.pr_env = None;
                                    }
                                }
                                None => mock_vendor_config.pr_env = None,
                            }

                            if info.branch_name.is_none() {
                                mock_vendor_config.branch_name_env = None;
                            }

                            set_env_for_config(&mock_vendor_config, info.branch_name.clone());

                            break;
                        }
                    }
                }
                None => (),
            }
        }
    }

    pub(crate) fn mock_ci_info(info: &CiInfo) {
        let vendor_config_list = config::create();

        // clear current env
        clear_env(&vendor_config_list);

        set_env_for_info(info, vendor_config_list);
    }