test: add mamba/micromamba unit and CI tests

- Add is_mamba_executable test for cross-platform binary name detection
- Add find_mamba_binary/find_micromamba_binary PATH discovery tests
- Add CondaManager::from tests for miniforge (conda+mamba) and micromamba-only installs
- Add CI test that installs mamba and verifies both managers are reported
- Add test fixtures: miniforge3-mamba and micromamba-only directories

Author: karthiknadig

crates/pet-conda/src/lib.rs

@@ -349,10 +349,13 @@ impl Locator for Conda {
                         reporter.report_environment(&env);
 
                         // Also check for a mamba/micromamba manager in the same directory and report it.
+                        let is_new_mamba = !self.mamba_managers.contains_key(conda_dir);
                         if let Some(mamba_mgr) = self.mamba_managers.get_or_insert_with(conda_dir.clone(), || {
                             get_mamba_manager(conda_dir)
                         }) {
-                            reporter.report_manager(&mamba_mgr.to_manager());
+                            if is_new_mamba {
+                                reporter.report_manager(&mamba_mgr.to_manager());
+                            }
                         }
                     } else {
                         // We will still return the conda env even though we do not have the manager.

crates/pet-conda/src/manager.rs

@@ -40,9 +40,13 @@ fn get_mamba_executable(path: &Path) -> Option<PathBuf> {
     #[cfg(windows)]
     let relative_paths = vec![
         PathBuf::from("Scripts").join("mamba.exe"),
+        PathBuf::from("Scripts").join("mamba.bat"),
         PathBuf::from("Scripts").join("micromamba.exe"),
+        PathBuf::from("Scripts").join("micromamba.bat"),
         PathBuf::from("bin").join("mamba.exe"),
+        PathBuf::from("bin").join("mamba.bat"),
         PathBuf::from("bin").join("micromamba.exe"),
+        PathBuf::from("bin").join("micromamba.bat"),
     ];
     #[cfg(unix)]
     let relative_paths = vec![
@@ -75,7 +79,7 @@ fn get_conda_bin_names() -> Vec<&'static str> {
 /// Specifically returns the file names that are valid for 'mamba'/'micromamba' on windows
 #[cfg(windows)]
 fn get_mamba_bin_names() -> Vec<&'static str> {
-    vec!["mamba.exe", "micromamba.exe"]
+    vec!["mamba.exe", "mamba.bat", "micromamba.exe", "micromamba.bat"]
 }
 
 /// Specifically returns the file names that are valid for 'mamba'/'micromamba' on linux/Mac

crates/pet-conda/src/telemetry.rs

@@ -11,8 +11,12 @@ use pet_core::{
 };
 
 use crate::{
-    conda_info::CondaInfo, conda_rc::Condarc, env_variables::EnvVariables,
-    environments::get_conda_environment_info, manager::CondaManager, utils::is_conda_install,
+    conda_info::CondaInfo,
+    conda_rc::Condarc,
+    env_variables::EnvVariables,
+    environments::get_conda_environment_info,
+    manager::{is_mamba_executable, CondaManager},
+    utils::is_conda_install,
 };
 
 pub fn report_missing_envs(
@@ -221,11 +225,12 @@ fn log_and_find_missing_envs(
         .collect::<Vec<_>>();
 
     // Oh oh, we have new envs, lets see what they are.
-    let manager = CondaManager::from_info(
-        &conda_info.executable,
-        conda_info,
-        pet_core::manager::EnvManagerType::Conda,
-    )?;
+    let manager_type = if is_mamba_executable(&conda_info.executable) {
+        pet_core::manager::EnvManagerType::Mamba
+    } else {
+        pet_core::manager::EnvManagerType::Conda
+    };
+    let manager = CondaManager::from_info(&conda_info.executable, conda_info, manager_type)?;
     for path in missing_envs
         .clone()
         .iter()

crates/pet-conda/tests/ci_test.rs

@@ -334,6 +334,84 @@ fn detect_new_conda_env_created_with_p_flag_with_python() {
     assert_eq!(env.manager, Some(manager.clone()));
 }
 
+#[cfg(unix)]
+#[cfg_attr(feature = "ci", test)]
+#[allow(dead_code)]
+// Install mamba into the conda base env and verify both Conda and Mamba managers are reported
+fn detect_mamba_manager_alongside_conda() {
+    use std::sync::Arc;
+
+    use pet_conda::Conda;
+    use pet_core::{
+        manager::EnvManagerType, os_environment::EnvironmentApi,
+        python_environment::PythonEnvironmentKind, Locator,
+    };
+    use pet_reporter::{cache::CacheReporter, collect};
+
+    setup();
+
+    // Install mamba into the base conda environment
+    let output = std::process::Command::new(get_conda_exe())
+        .args(["install", "-n", "base", "mamba", "-c", "conda-forge", "-y"])
+        .output()
+        .expect("Failed to install mamba");
+    println!(
+        "Mamba install stdout: {}",
+        String::from_utf8_lossy(&output.stdout)
+    );
+    println!(
+        "Mamba install stderr: {}",
+        String::from_utf8_lossy(&output.stderr)
+    );
+    assert!(
+        output.status.success(),
+        "Failed to install mamba into conda base env"
+    );
+
+    let env = EnvironmentApi::new();
+    let reporter = Arc::new(collect::create_reporter());
+    let conda = Conda::from(&env);
+    conda.find(&CacheReporter::new(reporter.clone()));
+
+    let managers = reporter.managers.lock().unwrap().clone();
+
+    let info = get_conda_info();
+    let conda_dir = PathBuf::from(info.conda_prefix.clone());
+
+    // Verify we have a Conda manager
+    let conda_manager = managers
+        .iter()
+        .find(|m| m.tool == EnvManagerType::Conda)
+        .unwrap_or_else(|| panic!("Conda manager not found in managers: {managers:?}"));
+    assert_eq!(
+        conda_manager.executable,
+        conda_dir.join("bin").join("conda")
+    );
+
+    // Verify we have a Mamba manager
+    let mamba_manager = managers
+        .iter()
+        .find(|m| m.tool == EnvManagerType::Mamba)
+        .unwrap_or_else(|| panic!("Mamba manager not found in managers: {managers:?}"));
+    assert_eq!(
+        mamba_manager.executable,
+        conda_dir.join("bin").join("mamba")
+    );
+
+    // Environments should still be reported as Conda kind
+    let environments = reporter.environments.lock().unwrap().clone();
+    let base_env = environments
+        .iter()
+        .find(|e| e.name == Some("base".into()))
+        .unwrap_or_else(|| panic!("Base env not found in environments: {environments:?}"));
+    assert_eq!(base_env.kind, Some(PythonEnvironmentKind::Conda));
+    // The environment manager should be Conda (not Mamba)
+    assert_eq!(
+        base_env.manager.as_ref().map(|m| m.tool),
+        Some(EnvManagerType::Conda)
+    );
+}
+
 #[derive(Deserialize)]
 struct CondaInfo {
     conda_version: String,

crates/pet-conda/tests/manager_test.rs

@@ -131,3 +131,155 @@ fn does_not_find_conda_binary_when_not_on_path() {
 
     assert!(conda_binary.is_none());
 }
+
+// ==================== Mamba/Micromamba Tests ====================
+
+/// Test is_mamba_executable correctly identifies mamba binaries.
+#[test]
+fn is_mamba_executable_identifies_mamba_binaries() {
+    use pet_conda::manager::is_mamba_executable;
+    use std::path::Path;
+
+    assert!(is_mamba_executable(Path::new("/usr/bin/mamba")));
+    assert!(is_mamba_executable(Path::new("/usr/bin/micromamba")));
+    assert!(is_mamba_executable(Path::new("C:\\Scripts\\mamba.exe")));
+    assert!(is_mamba_executable(Path::new(
+        "C:\\Scripts\\micromamba.exe"
+    )));
+    assert!(is_mamba_executable(Path::new("/opt/miniforge3/bin/mamba")));
+
+    // Should NOT match conda or python
+    assert!(!is_mamba_executable(Path::new("/usr/bin/conda")));
+    assert!(!is_mamba_executable(Path::new("/usr/bin/python")));
+    assert!(!is_mamba_executable(Path::new("C:\\Scripts\\conda.exe")));
+}
+
+/// Test that get_mamba_manager finds a mamba manager from a conda install with mamba.
+#[cfg(unix)]
+#[test]
+fn finds_mamba_manager_from_miniforge_root() {
+    use common::resolve_test_path;
+    use pet_conda::manager::CondaManager;
+    use pet_core::manager::EnvManagerType;
+
+    let path = resolve_test_path(&["unix", "miniforge3-mamba"]);
+    let manager = CondaManager::from(&path).unwrap();
+
+    // Should find conda first (conda takes precedence)
+    assert_eq!(manager.executable, path.join("bin").join("conda"));
+    assert_eq!(manager.version, Some("24.1.0".into()));
+    assert_eq!(manager.manager_type, EnvManagerType::Conda);
+}
+
+/// Test that CondaManager::from falls back to mamba when only micromamba is available.
+#[cfg(unix)]
+#[test]
+fn finds_mamba_manager_when_only_micromamba_available() {
+    use common::resolve_test_path;
+    use pet_conda::manager::CondaManager;
+    use pet_core::manager::EnvManagerType;
+
+    let path = resolve_test_path(&["unix", "micromamba-only"]);
+    let manager = CondaManager::from(&path).unwrap();
+
+    // No conda binary, should fall back to micromamba
+    assert_eq!(manager.executable, path.join("bin").join("micromamba"));
+    assert_eq!(manager.version, None); // version is unknown for mamba
+    assert_eq!(manager.manager_type, EnvManagerType::Mamba);
+}
+
+/// Test that find_mamba_binary finds mamba from the PATH environment variable.
+#[cfg(unix)]
+#[test]
+fn finds_mamba_binary_from_path() {
+    use common::{create_test_environment, resolve_test_path};
+    use pet_conda::env_variables::EnvVariables;
+    use pet_conda::manager::find_mamba_binary;
+    use std::collections::HashMap;
+
+    let miniforge_bin = resolve_test_path(&["unix", "miniforge3-mamba", "bin"]);
+    let path_value = miniforge_bin.to_string_lossy().to_string();
+
+    let mut vars = HashMap::new();
+    vars.insert("PATH".to_string(), path_value);
+
+    let env = create_test_environment(vars, None, vec![], None);
+    let env_vars = EnvVariables::from(&env);
+
+    let mamba_binary = find_mamba_binary(&env_vars);
+
+    assert!(mamba_binary.is_some());
+    assert_eq!(
+        mamba_binary.unwrap(),
+        resolve_test_path(&["unix", "miniforge3-mamba", "bin", "mamba"])
+    );
+}
+
+/// Test that find_mamba_binary finds micromamba when mamba is not available.
+#[cfg(unix)]
+#[test]
+fn finds_micromamba_binary_from_path() {
+    use common::{create_test_environment, resolve_test_path};
+    use pet_conda::env_variables::EnvVariables;
+    use pet_conda::manager::find_mamba_binary;
+    use std::collections::HashMap;
+
+    let micromamba_bin = resolve_test_path(&["unix", "micromamba-only", "bin"]);
+    let path_value = micromamba_bin.to_string_lossy().to_string();
+
+    let mut vars = HashMap::new();
+    vars.insert("PATH".to_string(), path_value);
+
+    let env = create_test_environment(vars, None, vec![], None);
+    let env_vars = EnvVariables::from(&env);
+
+    let mamba_binary = find_mamba_binary(&env_vars);
+
+    assert!(mamba_binary.is_some());
+    assert_eq!(
+        mamba_binary.unwrap(),
+        resolve_test_path(&["unix", "micromamba-only", "bin", "micromamba"])
+    );
+}
+
+/// Test that find_mamba_binary returns None when mamba is not on PATH.
+#[cfg(unix)]
+#[test]
+fn does_not_find_mamba_binary_when_not_on_path() {
+    use common::{create_test_environment, resolve_test_path};
+    use pet_conda::env_variables::EnvVariables;
+    use pet_conda::manager::find_mamba_binary;
+    use std::collections::HashMap;
+
+    // Use the anaconda path which has conda but no mamba
+    let anaconda_bin = resolve_test_path(&["unix", "anaconda3-2023.03", "bin"]);
+    let path_value = anaconda_bin.to_string_lossy().to_string();
+
+    let mut vars = HashMap::new();
+    vars.insert("PATH".to_string(), path_value);
+
+    let env = create_test_environment(vars, None, vec![], None);
+    let env_vars = EnvVariables::from(&env);
+
+    let mamba_binary = find_mamba_binary(&env_vars);
+
+    assert!(mamba_binary.is_none());
+}
+
+/// Test that CondaManager::from finds mamba manager from a child env
+/// in a micromamba-only installation (no conda binary).
+#[cfg(unix)]
+#[test]
+fn finds_mamba_manager_from_child_env_in_miniforge() {
+    use common::resolve_test_path;
+    use pet_conda::manager::CondaManager;
+    use pet_core::manager::EnvManagerType;
+
+    let path = resolve_test_path(&["unix", "miniforge3-mamba", "envs", "myenv"]);
+    let manager = CondaManager::from(&path).unwrap();
+
+    // Should find the conda manager from the parent install dir
+    let conda_dir = resolve_test_path(&["unix", "miniforge3-mamba"]);
+    assert_eq!(manager.executable, conda_dir.join("bin").join("conda"));
+    assert_eq!(manager.manager_type, EnvManagerType::Conda);
+}

crates/pet-conda/tests/unix/micromamba-only/bin/micromamba

@@ -0,0 +1,2 @@
+==> 2024-01-01 00:00:00 <==
+# cmd: micromamba install python=3.11.0

crates/pet-conda/tests/unix/micromamba-only/bin/python

@@ -0,0 +1,5 @@
+{
+  "build": "h1234567_0",
+  "name": "python",
+  "version": "3.11.0"
+}