Add Native tests for the native locator

Author: DonJayamanne

.github/workflows/pr-check.yml

@@ -188,6 +188,9 @@ jobs:
       - name: Install test requirements
         run: python -m pip install --upgrade -r build/test-requirements.txt
 
+      - name: Native Locator (Rust) tests
+        run: nox --session native_test
+
       - name: Install functional test requirements
         run: python -m pip install --upgrade -r ./build/functional-test-requirements.txt
         if: matrix.test-suite == 'functional'
@@ -311,6 +314,30 @@ jobs:
         run: npm run test:functional
         if: matrix.test-suite == 'functional'
 
+  native-tests:
+    name: Native Tests
+    # The value of runs-on is the OS of the current job (specified in the strategy matrix below) instead of being hardcoded.
+    runs-on: ${{ matrix.os }}
+    defaults:
+      run:
+        working-directory: ${{ env.special-working-directory }}
+    strategy:
+      fail-fast: false
+      matrix:
+        # We're not running CI on macOS for now because it's one less matrix entry to lower the number of runners used,
+        # macOS runners are expensive, and we assume that Ubuntu is enough to cover the Unix case.
+        os: [ubuntu-latest, windows-latest]
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          path: ${{ env.special-working-directory-relative }}
+
+      - name: Native Locator tests
+        run: cargo test
+        working-directory: ${{ env.special-working-directory }}/native_locator
+
   smoke-tests:
     name: Smoke tests
     # The value of runs-on is the OS of the current job (specified in the strategy matrix below) instead of being hardcoded.

native_locator/Cargo.toml

@@ -7,7 +7,13 @@ edition = "2021"
 winreg = "0.52.0"
 
 [dependencies]
-serde = {version ="1.0.152", features = ["derive"]}
+serde = { version = "1.0.152", features = ["derive"] }
 serde_json = "1.0.93"
 serde_repr = "0.1.10"
 regex = "1.10.4"
+
+[features]
+test = []
+
+[lib]
+doctest = false

native_locator/src/common_python.rs

@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation. All rights reserved.
 // Licensed under the MIT License.
 
+use crate::known;
 use crate::messaging;
 use crate::utils;
 use std::env;
@@ -20,10 +21,10 @@ fn get_env_path(path: &str) -> Option<String> {
     }
 }
 
-fn report_path_python(path: &str) {
+fn report_path_python(dispatcher: &mut impl messaging::MessageDispatcher, path: &str) {
     let version = utils::get_version(path);
     let env_path = get_env_path(path);
-    messaging::send_message(messaging::PythonEnvironment::new(
+    dispatcher.send_message(messaging::PythonEnvironment::new(
         "Python".to_string(),
         vec![path.to_string()],
         "System".to_string(),
@@ -33,30 +34,26 @@ fn report_path_python(path: &str) {
     ));
 }
 
-fn report_python_on_path() {
-    let paths = env::var("PATH");
-    let bin = if cfg!(windows) {
-        "python.exe"
-    } else {
-        "python"
-    };
-    match paths {
-        Ok(paths) => {
-            let paths = env::split_paths(&paths);
-            for path in paths {
-                let full_path = path.join(bin);
-                if full_path.exists() {
-                    match full_path.to_str() {
-                        Some(full_path) => report_path_python(full_path),
-                        None => (),
-                    }
-                }
-            }
-        }
-        Err(_) => (),
+fn report_python_on_path(
+    dispatcher: &mut impl messaging::MessageDispatcher,
+    known_paths: &impl known::KnownPaths,
+) {
+    if let Some(paths) = known_paths.get_env_var("PATH".to_string()) {
+        let bin = if cfg!(windows) {
+            "python.exe"
+        } else {
+            "python"
+        };
+        env::split_paths(&paths)
+            .map(|p| p.join(bin))
+            .filter(|p| p.exists())
+            .for_each(|full_path| report_path_python(dispatcher, full_path.to_str().unwrap()));
     }
 }
 
-pub fn find_and_report() {
-    report_python_on_path();
+pub fn find_and_report(
+    dispatcher: &mut impl messaging::MessageDispatcher,
+    known_paths: &impl known::KnownPaths,
+) {
+    report_python_on_path(dispatcher, known_paths);
 }

native_locator/src/conda.rs

@@ -84,7 +84,6 @@ fn get_version_from_meta_json(json_file: &Path) -> Option<String> {
 fn get_conda_package_json_path(any_path: &Path, package: &str) -> Option<PathBuf> {
     let package_name = format!("{}-", package);
     let conda_meta_path = get_conda_meta_path(any_path)?;
-
     std::fs::read_dir(conda_meta_path).ok()?.find_map(|entry| {
         let path = entry.ok()?.path();
         let file_name = path.file_name()?.to_string_lossy();
@@ -97,6 +96,7 @@ fn get_conda_package_json_path(any_path: &Path, package: &str) -> Option<PathBuf
 }
 
 /// Checks if the `python` package is installed in the conda environment
+#[allow(dead_code)]
 pub fn is_python_conda_env(any_path: &Path) -> bool {
     let conda_python_json_path = get_conda_package_json_path(any_path, "python");
     match conda_python_json_path {
@@ -127,11 +127,9 @@ fn get_conda_bin_names() -> Vec<&'static str> {
 }
 
 /// Find the conda binary on the PATH environment variable
-fn find_conda_binary_on_path() -> Option<PathBuf> {
-    let paths = env::var("PATH").ok()?;
-    let paths = env::split_paths(&paths);
-    for path in paths {
-        let path = Path::new(&path);
+fn find_conda_binary_on_path(known_paths: &impl known::KnownPaths) -> Option<PathBuf> {
+    let paths = known_paths.get_env_var("PATH".to_string())?;
+    for path in env::split_paths(&paths) {
         for bin in get_conda_bin_names() {
             let conda_path = path.join(bin);
             match std::fs::metadata(&conda_path) {
@@ -161,11 +159,11 @@ fn find_python_binary_path(env_path: &Path) -> Option<PathBuf> {
 }
 
 #[cfg(windows)]
-fn get_known_conda_locations() -> Vec<PathBuf> {
-    let user_profile = env::var("USERPROFILE").unwrap();
-    let program_data = env::var("PROGRAMDATA").unwrap();
-    let all_user_profile = env::var("ALLUSERSPROFILE").unwrap();
-    let home_drive = env::var("HOMEDRIVE").unwrap();
+fn get_known_conda_locations(known_paths_provider: &impl known::KnownPaths) -> Vec<PathBuf> {
+    let user_profile = known_paths_provider.get_env_var("USERPROFILE".to_string()).unwrap();
+    let program_data = known_paths_provider.get_env_var("PROGRAMDATA".to_string()).unwrap();
+    let all_user_profile = known_paths_provider.get_env_var("ALLUSERSPROFILE".to_string()).unwrap();
+    let home_drive = known_paths_provider.get_env_var("HOMEDRIVE".to_string()).unwrap();
     let mut known_paths = vec![
         Path::new(&user_profile).join("Anaconda3\\Scripts"),
         Path::new(&program_data).join("Anaconda3\\Scripts"),
@@ -176,40 +174,42 @@ fn get_known_conda_locations() -> Vec<PathBuf> {
         Path::new(&all_user_profile).join("Miniconda3\\Scripts"),
         Path::new(&home_drive).join("Miniconda3\\Scripts"),
     ];
-    known_paths.append(&mut known::get_know_global_search_locations());
+    known_paths.append(&mut known_paths_provider.get_know_global_search_locations());
     known_paths
 }
 
 #[cfg(unix)]
-fn get_known_conda_locations() -> Vec<PathBuf> {
+fn get_known_conda_locations(known_paths_provider: &impl known::KnownPaths) -> Vec<PathBuf> {
     let mut known_paths = vec![
-        Path::new("/opt/anaconda3/bin").to_path_buf(),
-        Path::new("/opt/miniconda3/bin").to_path_buf(),
-        Path::new("/usr/local/anaconda3/bin").to_path_buf(),
-        Path::new("/usr/local/miniconda3/bin").to_path_buf(),
-        Path::new("/usr/anaconda3/bin").to_path_buf(),
-        Path::new("/usr/miniconda3/bin").to_path_buf(),
-        Path::new("/home/anaconda3/bin").to_path_buf(),
-        Path::new("/home/miniconda3/bin").to_path_buf(),
-        Path::new("/anaconda3/bin").to_path_buf(),
-        Path::new("/miniconda3/bin").to_path_buf(),
-        Path::new("/usr/local/anaconda3/bin").to_path_buf(),
-        Path::new("/usr/local/miniconda3/bin").to_path_buf(),
-        Path::new("/usr/anaconda3/bin").to_path_buf(),
-        Path::new("/usr/miniconda3/bin").to_path_buf(),
-        Path::new("/home/anaconda3/bin").to_path_buf(),
-        Path::new("/home/miniconda3/bin").to_path_buf(),
-        Path::new("/anaconda3/bin").to_path_buf(),
-        Path::new("/miniconda3/bin").to_path_buf(),
+        PathBuf::from("/opt/anaconda3/bin"),
+        PathBuf::from("/opt/miniconda3/bin"),
+        PathBuf::from("/usr/local/anaconda3/bin"),
+        PathBuf::from("/usr/local/miniconda3/bin"),
+        PathBuf::from("/usr/anaconda3/bin"),
+        PathBuf::from("/usr/miniconda3/bin"),
+        PathBuf::from("/home/anaconda3/bin"),
+        PathBuf::from("/home/miniconda3/bin"),
+        PathBuf::from("/anaconda3/bin"),
+        PathBuf::from("/miniconda3/bin"),
+        PathBuf::from("/usr/local/anaconda3/bin"),
+        PathBuf::from("/usr/local/miniconda3/bin"),
+        PathBuf::from("/usr/anaconda3/bin"),
+        PathBuf::from("/usr/miniconda3/bin"),
+        PathBuf::from("/home/anaconda3/bin"),
+        PathBuf::from("/home/miniconda3/bin"),
+        PathBuf::from("/anaconda3/bin"),
+        PathBuf::from("/miniconda3/bin"),
     ];
-    known_paths.append(&mut known::get_know_global_search_locations());
+    known_paths.append(&mut known_paths_provider.get_know_global_search_locations());
     known_paths
 }
 
 /// Find conda binary in known locations
-fn find_conda_binary_in_known_locations() -> Option<PathBuf> {
+fn find_conda_binary_in_known_locations(
+    known_paths_provider: &impl known::KnownPaths,
+) -> Option<PathBuf> {
     let conda_bin_names = get_conda_bin_names();
-    let known_locations = get_known_conda_locations();
+    let known_locations = get_known_conda_locations(known_paths_provider);
     for location in known_locations {
         for bin in &conda_bin_names {
             let conda_path = location.join(bin);
@@ -223,17 +223,19 @@ fn find_conda_binary_in_known_locations() -> Option<PathBuf> {
 }
 
 /// Find the conda binary on the system
-pub fn find_conda_binary() -> Option<PathBuf> {
-    let conda_binary_on_path = find_conda_binary_on_path();
+pub fn find_conda_binary(known_paths_provider: &impl known::KnownPaths) -> Option<PathBuf> {
+    let conda_binary_on_path = find_conda_binary_on_path(known_paths_provider);
     match conda_binary_on_path {
         Some(conda_binary_on_path) => Some(conda_binary_on_path),
-        None => find_conda_binary_in_known_locations(),
+        None => find_conda_binary_in_known_locations(known_paths_provider),
     }
 }
 
-fn get_conda_envs_from_environment_txt() -> Vec<String> {
+fn get_conda_envs_from_environment_txt(
+    known_paths_provider: &impl known::KnownPaths,
+) -> Vec<String> {
     let mut envs = vec![];
-    let home = known::get_user_home();
+    let home = known_paths_provider.get_user_home();
     match home {
         Some(home) => {
             let home = Path::new(&home);
@@ -252,9 +254,12 @@ fn get_conda_envs_from_environment_txt() -> Vec<String> {
     envs
 }
 
-fn get_known_env_locations(conda_bin: PathBuf) -> Vec<String> {
+fn get_known_env_locations(
+    conda_bin: PathBuf,
+    known_paths_provider: &impl known::KnownPaths,
+) -> Vec<String> {
     let mut paths = vec![];
-    let home = known::get_user_home();
+    let home = known_paths_provider.get_user_home();
     match home {
         Some(home) => {
             let home = Path::new(&home);
@@ -284,9 +289,12 @@ fn get_known_env_locations(conda_bin: PathBuf) -> Vec<String> {
     paths
 }
 
-fn get_conda_envs_from_known_env_locations(conda_bin: PathBuf) -> Vec<String> {
+fn get_conda_envs_from_known_env_locations(
+    conda_bin: PathBuf,
+    known_paths_provider: &impl known::KnownPaths,
+) -> Vec<String> {
     let mut envs = vec![];
-    for location in get_known_env_locations(conda_bin) {
+    for location in get_known_env_locations(conda_bin, known_paths_provider) {
         if is_conda_environment(&Path::new(&location)) {
             envs.push(location.to_string());
         }
@@ -324,16 +332,20 @@ struct CondaEnv {
     path: PathBuf,
 }
 
-fn get_distinct_conda_envs(conda_bin: PathBuf) -> Vec<CondaEnv> {
-    let mut envs = get_conda_envs_from_environment_txt();
-    let mut known_envs = get_conda_envs_from_known_env_locations(conda_bin.to_path_buf());
+fn get_distinct_conda_envs(
+    conda_bin: PathBuf,
+    known_paths_provider: &impl known::KnownPaths,
+) -> Vec<CondaEnv> {
+    let mut envs = get_conda_envs_from_environment_txt(known_paths_provider);
+    let mut known_envs =
+        get_conda_envs_from_known_env_locations(conda_bin.to_path_buf(), known_paths_provider);
     envs.append(&mut known_envs);
     envs.sort();
     envs.dedup();
 
-    let locations = get_known_env_locations(conda_bin);
+    let locations = get_known_env_locations(conda_bin, known_paths_provider);
     let mut conda_envs = vec![];
-    for env in envs.clone() {
+    for env in envs {
         let env = Path::new(&env);
         let mut named = false;
         let mut name = "".to_string();
@@ -367,16 +379,19 @@ fn get_distinct_conda_envs(conda_bin: PathBuf) -> Vec<CondaEnv> {
     conda_envs
 }
 
-pub fn find_and_report() {
-    let conda_binary = find_conda_binary();
+pub fn find_and_report(
+    dispatcher: &mut impl messaging::MessageDispatcher,
+    known_paths_provider: &impl known::KnownPaths,
+) {
+    let conda_binary = find_conda_binary(known_paths_provider);
     match conda_binary {
         Some(conda_binary) => {
             let params =
                 messaging::EnvManager::new(vec![conda_binary.to_string_lossy().to_string()], None);
             let message = messaging::EnvManagerMessage::new(params);
-            messaging::send_message(message);
+            dispatcher.send_message(message);
 
-            let envs = get_distinct_conda_envs(conda_binary.to_path_buf());
+            let envs = get_distinct_conda_envs(conda_binary.to_path_buf(), known_paths_provider);
             for env in envs {
                 let executable = find_python_binary_path(Path::new(&env.path));
                 let params = messaging::PythonEnvironment::new(
@@ -407,7 +422,7 @@ pub fn find_and_report() {
                     Some(env.path.to_string_lossy().to_string()),
                 );
                 let message = messaging::PythonEnvironmentMessage::new(params);
-                messaging::send_message(message);
+                dispatcher.send_message(message);
             }
         }
         None => (),