Add tempfile as a dev-dependency and implement tests for architecture and virtual environment functionality (#309)

Author: karthiknadig

Cargo.lock

@@ -15,3 +15,6 @@ lazy_static = "1.4.0"
 regex = "1.10.4"
 log = "0.4.21"
 serde_json = "1.0.93"
+
+[dev-dependencies]
+tempfile = "3.10"

crates/pet-core/Cargo.toml

@@ -36,3 +36,81 @@ impl std::fmt::Display for Architecture {
         Ok(())
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_architecture_display_x64() {
+        let arch = Architecture::X64;
+        assert_eq!(format!("{}", arch), "x64");
+    }
+
+    #[test]
+    fn test_architecture_display_x86() {
+        let arch = Architecture::X86;
+        assert_eq!(format!("{}", arch), "x86");
+    }
+
+    #[test]
+    fn test_architecture_ordering() {
+        let x64 = Architecture::X64;
+        let x86 = Architecture::X86;
+        // X64 < X86 alphabetically
+        assert!(x64 < x86);
+        assert!(x86 > x64);
+        assert_eq!(x64.cmp(&x64), std::cmp::Ordering::Equal);
+    }
+
+    #[test]
+    fn test_architecture_partial_ordering() {
+        let x64 = Architecture::X64;
+        let x86 = Architecture::X86;
+        assert_eq!(x64.partial_cmp(&x86), Some(std::cmp::Ordering::Less));
+        assert_eq!(x86.partial_cmp(&x64), Some(std::cmp::Ordering::Greater));
+        assert_eq!(x64.partial_cmp(&x64), Some(std::cmp::Ordering::Equal));
+    }
+
+    #[test]
+    fn test_architecture_equality() {
+        assert_eq!(Architecture::X64, Architecture::X64);
+        assert_eq!(Architecture::X86, Architecture::X86);
+        assert_ne!(Architecture::X64, Architecture::X86);
+    }
+
+    #[test]
+    fn test_architecture_clone() {
+        let arch = Architecture::X64;
+        let cloned = arch.clone();
+        assert_eq!(arch, cloned);
+    }
+
+    #[test]
+    fn test_architecture_debug() {
+        let arch = Architecture::X64;
+        assert_eq!(format!("{:?}", arch), "X64");
+        let arch = Architecture::X86;
+        assert_eq!(format!("{:?}", arch), "X86");
+    }
+
+    #[test]
+    fn test_architecture_serialize() {
+        let arch = Architecture::X64;
+        let json = serde_json::to_string(&arch).unwrap();
+        assert_eq!(json, "\"x64\"");
+
+        let arch = Architecture::X86;
+        let json = serde_json::to_string(&arch).unwrap();
+        assert_eq!(json, "\"x86\"");
+    }
+
+    #[test]
+    fn test_architecture_deserialize() {
+        let arch: Architecture = serde_json::from_str("\"x64\"").unwrap();
+        assert_eq!(arch, Architecture::X64);
+
+        let arch: Architecture = serde_json::from_str("\"x86\"").unwrap();
+        assert_eq!(arch, Architecture::X86);
+    }
+}

crates/pet-core/src/arch.rs

@@ -186,3 +186,150 @@ fn parse_prompt(line: &str) -> Option<String> {
     }
     None
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::io::Write;
+    use tempfile::tempdir;
+
+    #[test]
+    fn test_parse_version_standard() {
+        let line = "version = 3.11.4";
+        let result = parse_version(line, &VERSION);
+        assert!(result.is_some());
+        let (ver, major, minor) = result.unwrap();
+        assert_eq!(ver, "3.11.4");
+        assert_eq!(major, 3);
+        assert_eq!(minor, 11);
+    }
+
+    #[test]
+    fn test_parse_version_info() {
+        let line = "version_info = 3.12.0.final";
+        let result = parse_version(line, &VERSION_INFO);
+        assert!(result.is_some());
+        let (ver, major, minor) = result.unwrap();
+        assert_eq!(ver, "3.12.0.final");
+        assert_eq!(major, 3);
+        assert_eq!(minor, 12);
+    }
+
+    #[test]
+    fn test_parse_version_no_match() {
+        let line = "home = /usr/bin/python";
+        let result = parse_version(line, &VERSION);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_parse_prompt_double_quotes() {
+        let line = r#"prompt = "my-env""#;
+        let result = parse_prompt(line);
+        assert_eq!(result, Some("my-env".to_string()));
+    }
+
+    #[test]
+    fn test_parse_prompt_single_quotes() {
+        let line = "prompt = 'my-env'";
+        let result = parse_prompt(line);
+        assert_eq!(result, Some("my-env".to_string()));
+    }
+
+    #[test]
+    fn test_parse_prompt_no_quotes() {
+        let line = "prompt = my-venv";
+        let result = parse_prompt(line);
+        assert_eq!(result, Some("my-venv".to_string()));
+    }
+
+    #[test]
+    fn test_parse_prompt_with_spaces() {
+        let line = "prompt   =   my-venv  ";
+        let result = parse_prompt(line);
+        assert_eq!(result, Some("my-venv".to_string()));
+    }
+
+    #[test]
+    fn test_parse_prompt_empty_value() {
+        let line = "prompt = ";
+        let result = parse_prompt(line);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_parse_prompt_not_prompt_line() {
+        let line = "home = /usr/bin/python";
+        let result = parse_prompt(line);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_pyvenv_cfg_find_in_directory() {
+        let dir = tempdir().unwrap();
+        let cfg_path = dir.path().join("pyvenv.cfg");
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "version = 3.11.4").unwrap();
+        writeln!(file, "prompt = test-env").unwrap();
+
+        let result = PyVenvCfg::find(dir.path());
+        assert!(result.is_some());
+        let cfg = result.unwrap();
+        assert_eq!(cfg.version, "3.11.4");
+        assert_eq!(cfg.version_major, 3);
+        assert_eq!(cfg.version_minor, 11);
+        assert_eq!(cfg.prompt, Some("test-env".to_string()));
+    }
+
+    #[test]
+    fn test_pyvenv_cfg_find_from_bin() {
+        let dir = tempdir().unwrap();
+        let bin_dir = dir.path().join("bin");
+        fs::create_dir_all(&bin_dir).unwrap();
+
+        let cfg_path = dir.path().join("pyvenv.cfg");
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "version = 3.10.0").unwrap();
+
+        let result = PyVenvCfg::find(&bin_dir);
+        assert!(result.is_some());
+        let cfg = result.unwrap();
+        assert_eq!(cfg.version, "3.10.0");
+        assert_eq!(cfg.version_major, 3);
+        assert_eq!(cfg.version_minor, 10);
+    }
+
+    #[test]
+    fn test_pyvenv_cfg_not_found() {
+        let dir = tempdir().unwrap();
+        let result = PyVenvCfg::find(dir.path());
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn test_pyvenv_cfg_missing_version() {
+        let dir = tempdir().unwrap();
+        let cfg_path = dir.path().join("pyvenv.cfg");
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "home = /usr/bin/python").unwrap();
+        writeln!(file, "prompt = my-env").unwrap();
+
+        let result = PyVenvCfg::find(dir.path());
+        assert!(result.is_none()); // Version is required
+    }
+
+    #[test]
+    fn test_pyvenv_cfg_version_info_format() {
+        let dir = tempdir().unwrap();
+        let cfg_path = dir.path().join("pyvenv.cfg");
+        let mut file = fs::File::create(&cfg_path).unwrap();
+        writeln!(file, "version_info = 3.12.1.final.0").unwrap();
+
+        let result = PyVenvCfg::find(dir.path());
+        assert!(result.is_some());
+        let cfg = result.unwrap();
+        assert_eq!(cfg.version, "3.12.1.final.0");
+        assert_eq!(cfg.version_major, 3);
+        assert_eq!(cfg.version_minor, 12);
+    }
+}

crates/pet-core/src/pyvenv_cfg.rs

@@ -12,3 +12,6 @@ pet-core = { path = "../pet-core" }
 pet-virtualenv = { path = "../pet-virtualenv" }
 pet-python-utils = { path = "../pet-python-utils" }
 log = "0.4.21"
+
+[dev-dependencies]
+tempfile = "3.10"