diff --git a/crates/pet-conda/tests/ci_test.rs b/crates/pet-conda/tests/ci_test.rs index 3f44703f..1ea75b4d 100644 --- a/crates/pet-conda/tests/ci_test.rs +++ b/crates/pet-conda/tests/ci_test.rs @@ -23,32 +23,33 @@ fn setup() { #[allow(dead_code)] // We should detect the conda install along with the base env fn detect_conda_root() { + use std::sync::Arc; + use pet_conda::Conda; use pet_core::{ manager::EnvManagerType, os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator, }; - use pet_reporter::test::create_reporter; + use pet_reporter::{cache::CacheReporter, collect}; setup(); let env = EnvironmentApi::new(); - let reporter = create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let conda = Conda::from(&env); - conda.find(&reporter); - let result = reporter.get_result(); + conda.find(&CacheReporter::new(reporter.clone())); - assert_eq!(result.managers.len(), 1); + let environments = reporter.environments.lock().unwrap().clone(); + let managers = reporter.managers.lock().unwrap().clone(); let info = get_conda_info(); let conda_dir = PathBuf::from(info.conda_prefix.clone()); - let manager = &result.managers[0]; + let manager = &managers[0]; assert_eq!(manager.executable, conda_dir.join("bin").join("conda")); assert_eq!(manager.tool, EnvManagerType::Conda); assert_eq!(manager.version, info.conda_version.into()); - let env = &result - .environments + let env = &environments .iter() .find(|e| e.name == Some("base".into())) .unwrap(); @@ -107,8 +108,8 @@ fn detect_new_conda_env() { use pet_core::{ os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator, }; - use pet_reporter::test::create_reporter; - use std::path::PathBuf; + use pet_reporter::{cache::CacheReporter, collect}; + use std::{path::PathBuf, sync::Arc}; setup(); let env_name = "env_with_python"; @@ -119,24 +120,23 @@ fn detect_new_conda_env() { let env = EnvironmentApi::new(); let conda = Conda::from(&env); - let reporter = create_reporter(); - conda.find(&reporter); - let result = reporter.get_result(); + let reporter = Arc::new(collect::create_reporter()); + conda.find(&CacheReporter::new(reporter.clone())); - assert_eq!(result.managers.len(), 1); + let environments = reporter.environments.lock().unwrap().clone(); + let managers = reporter.managers.lock().unwrap().clone(); - let manager = &result.managers[0]; + let manager = &managers[0]; let info = get_conda_info(); let conda_dir = PathBuf::from(info.conda_prefix.clone()); - let env = result - .environments + let env = environments .iter() .find(|x| x.name == Some(env_name.into())) .expect( format!( "New Environment not created, detected envs {:?}", - result.environments + environments ) .as_str(), ); @@ -211,8 +211,8 @@ fn detect_new_conda_env_without_python() { use pet_core::{ os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator, }; - use pet_reporter::test::create_reporter; - use std::path::PathBuf; + use pet_reporter::{cache::CacheReporter, collect}; + use std::{path::PathBuf, sync::Arc}; setup(); let env_name = "env_without_python"; @@ -220,24 +220,23 @@ fn detect_new_conda_env_without_python() { let env = EnvironmentApi::new(); let conda = Conda::from(&env); - let reporter = create_reporter(); - conda.find(&reporter); - let result = reporter.get_result(); + let reporter = Arc::new(collect::create_reporter()); + conda.find(&CacheReporter::new(reporter.clone())); - assert_eq!(result.managers.len(), 1); + let environments = reporter.environments.lock().unwrap().clone(); + let managers = reporter.managers.lock().unwrap().clone(); - let manager = &result.managers[0]; + let manager = &managers[0]; let info = get_conda_info(); let conda_dir = PathBuf::from(info.conda_prefix.clone()); - let env = result - .environments + let env = environments .iter() .find(|x| x.name == Some(env_name.into())) .expect( format!( "New Environment not created, detected envs {:?}", - result.environments + environments ) .as_str(), ); @@ -257,12 +256,14 @@ fn detect_new_conda_env_without_python() { #[allow(dead_code)] // Detect envs created without Python in a custom directory using the -p flag fn detect_new_conda_env_created_with_p_flag_without_python() { + use std::sync::Arc; + use common::resolve_test_path; use pet_conda::Conda; use pet_core::{ os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator, }; - use pet_reporter::test::create_reporter; + use pet_reporter::{cache::CacheReporter, collect}; setup(); let env_name = "env_without_python3"; @@ -271,22 +272,21 @@ fn detect_new_conda_env_created_with_p_flag_without_python() { let env = EnvironmentApi::new(); let conda = Conda::from(&env); - let reporter = create_reporter(); - conda.find(&reporter); - let result = reporter.get_result(); + let reporter = Arc::new(collect::create_reporter()); + conda.find(&CacheReporter::new(reporter.clone())); - assert_eq!(result.managers.len(), 1); + let environments = reporter.environments.lock().unwrap().clone(); + let managers = reporter.managers.lock().unwrap().clone(); - let manager = &result.managers[0]; + let manager = &managers[0]; - let env = result - .environments + let env = environments .iter() .find(|x| x.prefix == Some(prefix.clone())) .expect( format!( "New Environment ({:?}) not created, detected envs {:?}", - prefix, result.environments + prefix, environments ) .as_str(), ); @@ -305,12 +305,17 @@ fn detect_new_conda_env_created_with_p_flag_without_python() { #[allow(dead_code)] // Detect envs created Python in a custom directory using the -p flag fn detect_new_conda_env_created_with_p_flag_with_python() { + use std::sync::Arc; + use common::resolve_test_path; use pet_conda::Conda; use pet_core::{ os_environment::EnvironmentApi, python_environment::PythonEnvironmentKind, Locator, }; - use pet_reporter::test::create_reporter; + use pet_reporter::{ + cache::{self, CacheReporter}, + collect, + }; setup(); let env_name = "env_with_python3"; @@ -323,22 +328,21 @@ fn detect_new_conda_env_created_with_p_flag_with_python() { let env = EnvironmentApi::new(); let conda = Conda::from(&env); - let reporter = create_reporter(); - conda.find(&reporter); - let result = reporter.get_result(); + let reporter = Arc::new(collect::create_reporter()); + conda.find(&CacheReporter::new(reporter.clone())); - assert_eq!(result.managers.len(), 1); + let environments = reporter.environments.lock().unwrap().clone(); + let managers = reporter.managers.lock().unwrap().clone(); - let manager = &result.managers[0]; + let manager = &managers[0]; - let env = result - .environments + let env = environments .iter() .find(|x| x.prefix == Some(prefix.clone())) .expect( format!( "New Environment not created, detected envs {:?}", - result.environments + environments ) .as_str(), ); diff --git a/crates/pet-pyenv/tests/pyenv_test.rs b/crates/pet-pyenv/tests/pyenv_test.rs index e03b3937..62ff87a0 100644 --- a/crates/pet-pyenv/tests/pyenv_test.rs +++ b/crates/pet-pyenv/tests/pyenv_test.rs @@ -11,7 +11,7 @@ fn does_not_find_any_pyenv_envs() { use pet_core::{self, Locator}; use pet_pyenv; use pet_pyenv::PyEnv; - use pet_reporter::test::create_reporter; + use pet_reporter::{cache::CacheReporter, collect}; use std::{collections::HashMap, path::PathBuf, sync::Arc}; let environment = create_test_environment( @@ -23,12 +23,14 @@ fn does_not_find_any_pyenv_envs() { let conda = Arc::new(Conda::from(&environment)); let locator = PyEnv::from(&environment, conda); - let reporter = create_reporter(); - locator.find(&reporter); - let result = reporter.get_result(); + let reporter = Arc::new(collect::create_reporter()); + locator.find(&CacheReporter::new(reporter.clone())); - assert_eq!(result.managers.is_empty(), true); - assert_eq!(result.environments.is_empty(), true); + let environments = reporter.environments.lock().unwrap().clone(); + let managers = reporter.managers.lock().unwrap().clone(); + + assert_eq!(managers.is_empty(), true); + assert_eq!(environments.is_empty(), true); } #[test] @@ -44,7 +46,7 @@ fn does_not_find_any_pyenv_envs_even_with_pyenv_installed() { }; use pet_pyenv; use pet_pyenv::PyEnv; - use pet_reporter::test::create_reporter; + use pet_reporter::{cache::CacheReporter, collect}; use serde_json::json; use std::{collections::HashMap, path::PathBuf, sync::Arc}; @@ -67,11 +69,11 @@ fn does_not_find_any_pyenv_envs_even_with_pyenv_installed() { let conda = Arc::new(Conda::from(&environment)); let locator = PyEnv::from(&environment, conda); - let reporter = create_reporter(); - locator.find(&reporter); - let result = reporter.get_result(); + let reporter = Arc::new(collect::create_reporter()); + locator.find(&CacheReporter::new(reporter.clone())); + + let managers = reporter.managers.lock().unwrap().clone(); - let managers = result.clone().managers; assert_eq!(managers.len(), 1); let expected_manager = EnvManager { @@ -79,7 +81,7 @@ fn does_not_find_any_pyenv_envs_even_with_pyenv_installed() { version: None, tool: EnvManagerType::Pyenv, }; - assert_eq!(json!(expected_manager), json!(result.managers[0])); + assert_eq!(json!(expected_manager), json!(managers[0])); } #[test] @@ -97,7 +99,7 @@ fn find_pyenv_envs() { }; use pet_pyenv; use pet_pyenv::PyEnv; - use pet_reporter::test::create_reporter; + use pet_reporter::{cache::CacheReporter, collect}; use serde_json::json; use std::{collections::HashMap, path::PathBuf, sync::Arc}; @@ -123,11 +125,13 @@ fn find_pyenv_envs() { let conda = Arc::new(Conda::from(&environment)); let locator = PyEnv::from(&environment, conda); - let reporter = create_reporter(); - locator.find(&reporter); - let mut result = reporter.get_result(); + let reporter = Arc::new(collect::create_reporter()); + locator.find(&CacheReporter::new(reporter.clone())); + + let mut environments = reporter.environments.lock().unwrap().clone(); + let mut managers = reporter.managers.lock().unwrap().clone(); - assert_eq!(result.managers.len(), 2); + assert_eq!(managers.len(), 2); let expected_pyenv_manager = EnvManager { executable: pyenv_exe.clone(), @@ -144,9 +148,9 @@ fn find_pyenv_envs() { expected_pyenv_manager.clone(), expected_conda_manager.clone(), ]; - result.managers.sort(); + managers.sort(); expected.sort(); - assert_eq!(expected, result.managers); + assert_eq!(expected, managers); let expected_3_9_9 = PythonEnvironment { display_name: None, @@ -356,8 +360,8 @@ fn find_pyenv_envs() { expected_pypy, ]; expected_envs.sort(); - result.environments.sort(); - assert_eq!(json!(expected_envs), json!(result.environments)); + environments.sort(); + assert_eq!(json!(expected_envs), json!(environments)); } #[test] diff --git a/crates/pet-python-utils/src/executable.rs b/crates/pet-python-utils/src/executable.rs index 49c88772..09cc0daf 100644 --- a/crates/pet-python-utils/src/executable.rs +++ b/crates/pet-python-utils/src/executable.rs @@ -184,6 +184,9 @@ pub fn should_search_for_environments_in_path>(path: &P) -> bool // Mostly copied from https://github.com/github/gitignore/blob/main/Python.gitignore let folders_to_ignore = [ "node_modules", + ".cargo", + ".devcontainer", + ".github", ".git", ".tox", ".nox", @@ -195,6 +198,7 @@ pub fn should_search_for_environments_in_path>(path: &P) -> bool ".pyre", ".ptype", ".pytest_cache", + ".vscode", "__pycache__", "__pypackages__", ".mypy_cache", diff --git a/crates/pet-reporter/src/cache.rs b/crates/pet-reporter/src/cache.rs index f822f385..f5ff3844 100644 --- a/crates/pet-reporter/src/cache.rs +++ b/crates/pet-reporter/src/cache.rs @@ -9,6 +9,10 @@ use std::{ sync::{Arc, Mutex}, }; +/// Poorly named, needs to be renamed, +/// The purpose of this reporter was to act as a cache, but since then +/// the requirements of caching have changed and this is no longer a cache. +/// This is merely a decorator class that ensures we do not report the same env/manager more than once. pub struct CacheReporter { reporter: Arc, reported_managers: Arc>>, diff --git a/crates/pet-reporter/src/lib.rs b/crates/pet-reporter/src/lib.rs index 31fb37b4..82280be9 100644 --- a/crates/pet-reporter/src/lib.rs +++ b/crates/pet-reporter/src/lib.rs @@ -6,4 +6,3 @@ pub mod collect; pub mod environment; pub mod jsonrpc; pub mod stdio; -pub mod test; diff --git a/crates/pet-reporter/src/test.rs b/crates/pet-reporter/src/test.rs deleted file mode 100644 index cba3f92c..00000000 --- a/crates/pet-reporter/src/test.rs +++ /dev/null @@ -1,59 +0,0 @@ -// Copyright (c) Microsoft Corporation. -// Licensed under the MIT License. - -use crate::environment::get_environment_key; -use pet_core::LocatorResult; -use pet_core::{manager::EnvManager, python_environment::PythonEnvironment, reporter::Reporter}; -use std::collections::HashMap; -use std::{ - path::PathBuf, - sync::{Arc, Mutex}, -}; - -pub struct TestReporter { - managers: Arc>>, - environments: Arc>>, -} - -impl TestReporter { - pub fn get_result(&self) -> LocatorResult { - LocatorResult { - managers: self.managers.lock().unwrap().values().cloned().collect(), - environments: self - .environments - .lock() - .unwrap() - .values() - .cloned() - .collect(), - } - } -} - -impl Reporter for TestReporter { - fn report_telemetry(&self, _event: &pet_core::telemetry::TelemetryEvent) { - // - } - fn report_manager(&self, manager: &EnvManager) { - let mut reported_managers = self.managers.lock().unwrap(); - reported_managers.insert(manager.executable.clone(), manager.clone()); - } - - fn report_environment(&self, env: &PythonEnvironment) { - if let Some(key) = get_environment_key(env) { - let mut reported_environments = self.environments.lock().unwrap(); - // TODO: Sometimes its possible the exe here is actually some symlink that we have no idea about. - // Hence we'll need to go through the list of reported envs and see if we can find a match. - // If we do find a match, then ensure we update the symlinks - // & if necessary update the other information. - reported_environments.insert(key.clone(), env.clone()); - } - } -} - -pub fn create_reporter() -> TestReporter { - TestReporter { - managers: Arc::new(Mutex::new(HashMap::new())), - environments: Arc::new(Mutex::new(HashMap::new())), - } -} diff --git a/crates/pet/tests/ci_homebrew_container.rs b/crates/pet/tests/ci_homebrew_container.rs index 8eaaa7c3..6e868bf3 100644 --- a/crates/pet/tests/ci_homebrew_container.rs +++ b/crates/pet/tests/ci_homebrew_container.rs @@ -14,24 +14,23 @@ fn verify_python_in_homebrew_contaner() { python_environment::{PythonEnvironment, PythonEnvironmentKind}, }; use pet_poetry::Poetry; - use pet_reporter::test; + use pet_reporter::{cache::CacheReporter, collect}; use std::{path::PathBuf, sync::Arc}; - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); find_and_report_envs( - &reporter, + &CacheReporter::new(reporter.clone()), Default::default(), &create_locators(conda_locator.clone(), poetry_locator.clone(), &environment), &environment, None, ); - let result = reporter.get_result(); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); let python3_12 = PythonEnvironment { kind: Some(PythonEnvironmentKind::Homebrew), diff --git a/crates/pet/tests/ci_jupyter_container.rs b/crates/pet/tests/ci_jupyter_container.rs index 41428dee..4ecdbb18 100644 --- a/crates/pet/tests/ci_jupyter_container.rs +++ b/crates/pet/tests/ci_jupyter_container.rs @@ -30,26 +30,25 @@ fn verify_python_in_jupyter_contaner() { python_environment::{PythonEnvironment, PythonEnvironmentKind}, }; use pet_poetry::Poetry; - use pet_reporter::test; + use pet_reporter::{cache::CacheReporter, collect}; use std::{path::PathBuf, sync::Arc}; setup(); - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); find_and_report_envs( - &reporter, + &CacheReporter::new(reporter.clone()), Default::default(), &create_locators(conda_locator.clone(), poetry_locator.clone(), &environment), &environment, None, ); - let result = reporter.get_result(); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); let conda = PythonEnvironment { kind: Some(PythonEnvironmentKind::Conda), diff --git a/crates/pet/tests/ci_poetry.rs b/crates/pet/tests/ci_poetry.rs index caa62ed7..95bf098f 100644 --- a/crates/pet/tests/ci_poetry.rs +++ b/crates/pet/tests/ci_poetry.rs @@ -2,6 +2,10 @@ // Licensed under the MIT License. use pet_poetry::Poetry; +use pet_reporter::{ + cache::{self, CacheReporter}, + collect, +}; mod common; @@ -17,11 +21,10 @@ fn verify_ci_poetry_global() { python_environment::{PythonEnvironment, PythonEnvironmentKind}, Configuration, }; - use pet_reporter::test; use std::{env, path::PathBuf, sync::Arc}; let workspace_dir = PathBuf::from(env::var("GITHUB_WORKSPACE").unwrap_or_default()); - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); @@ -32,16 +35,23 @@ fn verify_ci_poetry_global() { locator.configure(&config); } - find_and_report_envs(&reporter, Default::default(), &locators, &environment, None); - - let result = reporter.get_result(); + find_and_report_envs( + &CacheReporter::new(reporter.clone()), + Default::default(), + &locators, + &environment, + None, + ); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); // On CI the poetry manager is installed using wsl, and the path isn't available on windows if std::env::consts::OS != "windows" { - result + reporter .managers + .lock() + .unwrap() + .clone() .iter() .find(|m| m.tool == EnvManagerType::Poetry) .expect("Poetry manager not found"); @@ -79,11 +89,10 @@ fn verify_ci_poetry_project() { python_environment::{PythonEnvironment, PythonEnvironmentKind}, Configuration, }; - use pet_reporter::test; use std::{env, path::PathBuf, sync::Arc}; let workspace_dir = PathBuf::from(env::var("GITHUB_WORKSPACE").unwrap_or_default()); - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); @@ -94,16 +103,23 @@ fn verify_ci_poetry_project() { locator.configure(&config); } - find_and_report_envs(&reporter, Default::default(), &locators, &environment, None); - - let result = reporter.get_result(); + find_and_report_envs( + &CacheReporter::new(reporter.clone()), + Default::default(), + &locators, + &environment, + None, + ); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); // On CI the poetry manager is installed using wsl, and the path isn't available on windows if std::env::consts::OS != "windows" { - result + reporter .managers + .lock() + .unwrap() + .clone() .iter() .find(|m| m.tool == EnvManagerType::Poetry) .expect("Poetry manager not found"); diff --git a/crates/pet/tests/ci_test.rs b/crates/pet/tests/ci_test.rs index 154dc464..c4dee52f 100644 --- a/crates/pet/tests/ci_test.rs +++ b/crates/pet/tests/ci_test.rs @@ -17,7 +17,10 @@ use pet_core::{ use pet_env_var_path::get_search_paths_from_env_variables; use pet_poetry::Poetry; use pet_python_utils::env::PythonEnv; -use pet_reporter::{cache::CacheReporter, collect}; +use pet_reporter::{ + cache::{self, CacheReporter}, + collect, +}; use regex::Regex; use serde::Deserialize; @@ -66,13 +69,12 @@ fn verify_validity_of_discovered_envs() { use pet::{find::find_and_report_envs, locators::create_locators}; use pet_conda::Conda; use pet_core::{os_environment::EnvironmentApi, Configuration}; - use pet_reporter::test; use std::{env, sync::Arc, thread}; setup(); let workspace_dir = PathBuf::from(env::var("GITHUB_WORKSPACE").unwrap_or_default()); - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); @@ -84,10 +86,15 @@ fn verify_validity_of_discovered_envs() { } // Find all environments on this machine. - find_and_report_envs(&reporter, Default::default(), &locators, &environment, None); - let result = reporter.get_result(); + find_and_report_envs( + &CacheReporter::new(reporter.clone()), + Default::default(), + &locators, + &environment, + None, + ); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); let mut threads = vec![]; for environment in environments { if environment.executable.is_none() { @@ -134,25 +141,23 @@ fn check_if_virtualenvwrapper_exists() { use pet::{find::find_and_report_envs, locators::create_locators}; use pet_conda::Conda; use pet_core::os_environment::EnvironmentApi; - use pet_reporter::test; use std::sync::Arc; setup(); - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); find_and_report_envs( - &reporter, + &CacheReporter::new(reporter.clone()), Default::default(), &create_locators(conda_locator.clone(), poetry_locator.clone(), &environment), &environment, None, ); - let result = reporter.get_result(); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); assert!( environments.iter().any( @@ -177,25 +182,23 @@ fn check_if_pipenv_exists() { use pet::{find::find_and_report_envs, locators::create_locators}; use pet_conda::Conda; use pet_core::os_environment::EnvironmentApi; - use pet_reporter::test; use std::{env, sync::Arc}; setup(); - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); find_and_report_envs( - &reporter, + &CacheReporter::new(reporter.clone()), Default::default(), &create_locators(conda_locator.clone(), poetry_locator.clone(), &environment), &environment, None, ); - let result = reporter.get_result(); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); let workspace_dir = PathBuf::from(env::var("GITHUB_WORKSPACE").unwrap_or_default()); environments @@ -216,25 +219,23 @@ fn check_if_pyenv_virtualenv_exists() { use pet::{find::find_and_report_envs, locators::create_locators}; use pet_conda::Conda; use pet_core::os_environment::EnvironmentApi; - use pet_reporter::test; use std::sync::Arc; setup(); - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); find_and_report_envs( - &reporter, + &CacheReporter::new(reporter.clone()), Default::default(), &create_locators(conda_locator.clone(), poetry_locator.clone(), &environment), &environment, None, ); - let result = reporter.get_result(); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); assert!( environments.iter().any( @@ -646,25 +647,23 @@ fn verify_bin_usr_bin_user_local_are_separate_python_envs() { use pet::{find::find_and_report_envs, locators::create_locators}; use pet_conda::Conda; use pet_core::os_environment::EnvironmentApi; - use pet_reporter::test; use std::sync::Arc; setup(); - let reporter = test::create_reporter(); + let reporter = Arc::new(collect::create_reporter()); let environment = EnvironmentApi::new(); let conda_locator = Arc::new(Conda::from(&environment)); let poetry_locator = Arc::new(Poetry::from(&environment)); find_and_report_envs( - &reporter, + &CacheReporter::new(reporter.clone()), Default::default(), &create_locators(conda_locator.clone(), poetry_locator.clone(), &environment), &environment, None, ); - let result = reporter.get_result(); - let environments = result.environments; + let environments = reporter.environments.lock().unwrap().clone(); // Python env /bin/python cannot have symlinks in /usr/bin or /usr/local // Python env /usr/bin/python cannot have symlinks /bin or /usr/local