1 
/// Get the version of the program from the environment variables
2
218 
pub fn get_version_digits() -> String {
3
218 
  let semver = option_env!("CARGO_PKG_VERSION").unwrap_or("unknown");
4
218 
  match option_env!("MK_BUILD_GIT_HASH") {
5 
    None => semver.to_string(),
6
218 
    Some(hash) => format!("{} (rev {})", semver, hash),
7 
  }
8
218 
}
9 

            

        

            

                10
            

            

                
            

            

                
#[cfg(test)]

            

        

            

                11
            

            

                
            

            

                
mod tests {

            

        

            

                12
            

            

                
            

            

                
  use super::*;

            

        

            

                13
            

            

                
            

            

                
  use regex::Regex;

            

        

            

                14
            

            

                
            

            

                

            

        

            

                15
            

            

                
            

            

                
  #[test]

            

        

            

                16
            

            

                2
            

            

                
  fn test_get_version_digits_no_hash() -> anyhow::Result<()> {

            

        

            

                17
            

            

                
            

            

                
    // Since CARGO_PKG_VERSION is set at compile time and

            

        

            

                18
            

            

                
            

            

                
    // MK_BUILD_GIT_HASH is not set in test environment

            

        

            

                19
            

            

                2
            

            

                
    let version = get_version_digits();

            

        

            

                20
            

            

                2
            

            

                
    let re = Regex::new(r"^\d+\.\d+\.\d+ \(rev [a-f0-9]+\)$")?;

            

        

            

                21
            

            

                2
            

            

                
    assert!(version == "unknown" || re.find(&version).is_some());

            

        

            

                22
            

            

                2
            

            

                
    Ok(())

            

        

            

                23
            

            

                2
            

            

                
  }

            

        

            

                24
            

            

                
            

            

                

            

        

            

                25
            

            

                
            

            

                
  #[test]

            

        

            

                26
            

            

                2
            

            

                
  fn test_get_version_digits_format() -> anyhow::Result<()> {

            

        

            

                27
            

            

                
            

            

                
    // Test version string format when hash is present

            

        

            

                28
            

            

                
            

            

                
    // We can't directly set env vars for option_env! macro

            

        

            

                29
            

            

                
            

            

                
    // but we can verify the function returns expected format

            

        

            

                30
            

            

                2
            

            

                
    let version: &str = &get_version_digits();

            

        

            

                31
            

            

                2
            

            

                
    let re_1 = Regex::new(r"^\d+\.\d+\.\d+$")?;

            

        

            

                32
            

            

                2
            

            

                
    let re_2 = Regex::new(r"^\d+\.\d+\.\d+ \(rev [a-f0-9]+\)$")?;

            

        

            

                33
            

            

                2
            

            

                
    assert!(version == "unknown" || re_1.find(version).is_some() || re_2.find(version).is_some());

            

        

            

                34
            

            

                
            

            

                

            

        

            

                35
            

            

                2
            

            

                
    Ok(())

            

        

            

                36
            

            

                2
            

            

                
  }

            

        

            

                37
            

            

                
            

            

                
}