diff --git a/.github/workflows/pr-check.yml b/.github/workflows/pr-check.yml
index f462e508..032123b8 100644
--- a/.github/workflows/pr-check.yml
+++ b/.github/workflows/pr-check.yml
@@ -132,14 +132,14 @@ jobs:
         shell: bash
 
       - name: Run Tests
-        run: cargo test --frozen --all-features
+        run: cargo test --frozen --all-features -- --nocapture
         shell: bash
 
       - name: Find Environments
         if: matrix.run_cli == 'yes'
         run: cargo run --release --target ${{ matrix.target }}
         shell: bash
-        
+
   builds:
     name: Builds
     runs-on: ${{ matrix.os }}
@@ -183,7 +183,9 @@ jobs:
         shell: bash
 
       - name: Run Tests
-        run: cargo test --frozen --all-features
+        # We do not want to run all features, CI is only for tests with Python
+        # Thats a separate job.
+        run: cargo test --frozen
         shell: bash
 
       - name: Build
diff --git a/crates/pet-conda/Cargo.toml b/crates/pet-conda/Cargo.toml
index aefc3235..69ae0395 100644
--- a/crates/pet-conda/Cargo.toml
+++ b/crates/pet-conda/Cargo.toml
@@ -11,3 +11,6 @@ pet-core = { path = "../pet-core" }
 pet-utils = { path = "../pet-utils" }
 log = "0.4.21"
 regex = "1.10.4"
+
+[features]
+ci = []
\ No newline at end of file
diff --git a/crates/pet-conda/src/environment_locations.rs b/crates/pet-conda/src/environment_locations.rs
index 48f093ca..6d26a29e 100644
--- a/crates/pet-conda/src/environment_locations.rs
+++ b/crates/pet-conda/src/environment_locations.rs
@@ -182,10 +182,7 @@ pub fn get_known_conda_install_locations(env_vars: &EnvVariables) -> Vec<PathBuf
         known_paths.push(PathBuf::from(conda_prefix.clone()));
     }
     if let Some(ref conda) = env_vars.conda {
-        let conda = PathBuf::from(conda);
-        if let Some(parent) = conda.parent() {
-            known_paths.push(parent.to_path_buf());
-        }
+        known_paths.push(PathBuf::from(conda));
     }
     if let Some(home) = env_vars.clone().home {
         known_paths.push(home.clone().join("anaconda3"));
@@ -233,10 +230,7 @@ pub fn get_known_conda_install_locations(env_vars: &EnvVariables) -> Vec<PathBuf
         known_paths.push(PathBuf::from(conda_prefix.clone()));
     }
     if let Some(ref conda) = env_vars.conda {
-        let conda = PathBuf::from(conda);
-        if let Some(parent) = conda.parent() {
-            known_paths.push(parent.to_path_buf());
-        }
+        known_paths.push(PathBuf::from(conda));
     }
     if let Some(ref home) = env_vars.home {
         known_paths.push(home.clone().join("anaconda"));
diff --git a/crates/pet-conda/src/environments.rs b/crates/pet-conda/src/environments.rs
index 303a80da..7b9d0c19 100644
--- a/crates/pet-conda/src/environments.rs
+++ b/crates/pet-conda/src/environments.rs
@@ -235,6 +235,7 @@ pub fn get_activation_command(
 
 #[cfg(test)]
 mod tests {
+    #[cfg(windows)]
     use super::*;
 
     #[test]
diff --git a/crates/pet-conda/tests/ci_test.rs b/crates/pet-conda/tests/ci_test.rs
index a0623878..c8a7c7e2 100644
--- a/crates/pet-conda/tests/ci_test.rs
+++ b/crates/pet-conda/tests/ci_test.rs
@@ -1,18 +1,393 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+use std::path::PathBuf;
+
+use serde::Deserialize;
+
 mod common;
 
 #[cfg(unix)]
-#[test]
-fn conda_ci() {
+#[cfg_attr(feature = "ci_conda", test)]
+#[allow(dead_code)]
+// We should detect the conda install along with the base env
+fn detect_conda_root() {
+    use pet_conda::Conda;
+    use pet_core::{
+        manager::EnvManagerType, os_environment::EnvironmentApi,
+        python_environment::PythonEnvironmentCategory, Locator,
+    };
+    use std::path::PathBuf;
+
+    let env = EnvironmentApi::new();
+
+    let conda = Conda::from(&env);
+    let result = conda.find().unwrap();
+
+    assert_eq!(result.managers.len(), 1);
+
+    let info = get_conda_info();
+    let conda_dir = PathBuf::from(info.conda_prefix.clone());
+    let manager = &result.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
+        .iter()
+        .find(|e| e.name == Some("base".into()))
+        .unwrap();
+    assert_eq!(env.prefix, conda_dir.clone().into());
+    assert_eq!(env.name, Some("base".into()));
+    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.executable, Some(conda_dir.join("bin").join("python")));
+    assert_eq!(env.version, Some(get_version(&info.python_version)));
+
+    assert_eq!(env.manager, Some(manager.clone()));
+}
+
+#[cfg(unix)]
+#[cfg_attr(feature = "ci_conda", test)]
+#[allow(dead_code)]
+// Given the path to the root directory, detect the manager and base env
+fn detect_conda_root_from_path() {
+    use pet_conda::Conda;
+    use pet_core::{
+        manager::EnvManagerType, os_environment::EnvironmentApi,
+        python_environment::PythonEnvironmentCategory, Locator,
+    };
+    use pet_utils::env::PythonEnv;
+    use std::path::PathBuf;
+
+    let env = EnvironmentApi::new();
+    let info = get_conda_info();
+    let conda_dir = PathBuf::from(info.conda_prefix.clone());
+    let exe = conda_dir.join("bin").join("python");
+    let conda = Conda::from(&env);
+
+    let python_env = PythonEnv::new(exe, Some(conda_dir.clone()), None);
+    let env = conda.from(&python_env).unwrap();
+
+    assert_eq!(env.manager.is_some(), true);
+
+    let manager = env.manager.unwrap();
+    assert_eq!(manager.executable, conda_dir.join("bin").join("conda"));
+    assert_eq!(manager.tool, EnvManagerType::Conda);
+    assert_eq!(manager.version, info.conda_version.into());
+
+    assert_eq!(env.prefix, conda_dir.clone().into());
+    assert_eq!(env.name, Some("base".into()));
+    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.executable, Some(conda_dir.join("bin").join("python")));
+    assert_eq!(env.version, Some(get_version(&info.python_version)));
+}
+
+#[cfg(unix)]
+#[cfg_attr(feature = "ci_conda", test)]
+#[allow(dead_code)]
+// When a new env is created detect that too
+fn detect_new_conda_env() {
+    use pet_conda::Conda;
+    use pet_core::{
+        os_environment::EnvironmentApi, python_environment::PythonEnvironmentCategory, Locator,
+    };
+    use std::path::PathBuf;
+
+    let env_name = "env_with_python";
+    create_conda_env(
+        &CondaCreateEnvNameOrPath::Name(env_name.into()),
+        Some("3.10".into()),
+    );
+    let env = EnvironmentApi::new();
+
+    let conda = Conda::from(&env);
+    let result = conda.find().unwrap();
+
+    assert_eq!(result.managers.len(), 1);
+
+    let manager = &result.managers[0];
+
+    let info = get_conda_info();
+    let conda_dir = PathBuf::from(info.conda_prefix.clone());
+    let env = result
+        .environments
+        .iter()
+        .find(|x| x.name == Some(env_name.into()))
+        .expect(
+            format!(
+                "New Environment not created, detected envs {:?}",
+                result.environments
+            )
+            .as_str(),
+        );
+
+    let prefix = conda_dir.clone().join("envs").join(env_name);
+    assert_eq!(env.prefix, prefix.clone().into());
+    assert_eq!(env.name, Some(env_name.into()));
+    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.executable, prefix.join("bin").join("python").into());
+    assert!(
+        env.version.clone().unwrap_or_default().starts_with("3.10"),
+        "Expected 3.10, but got Version: {:?}",
+        env.version
+    );
+
+    assert_eq!(env.manager, Some(manager.clone()));
+}
+
+#[cfg(unix)]
+#[cfg_attr(feature = "ci_conda", test)]
+#[allow(dead_code)]
+// Identify the manager and conda env given the path to a conda env inside the `envs` directory
+fn detect_conda_env_from_path() {
+    use pet_conda::Conda;
+    use pet_core::{
+        manager::EnvManagerType, os_environment::EnvironmentApi,
+        python_environment::PythonEnvironmentCategory, Locator,
+    };
+    use pet_utils::env::PythonEnv;
+    use std::path::PathBuf;
+
+    let env = EnvironmentApi::new();
+    let info = get_conda_info();
+    let env_name = "env_with_python2";
+    create_conda_env(
+        &CondaCreateEnvNameOrPath::Name(env_name.into()),
+        Some("3.10".into()),
+    );
+    let conda_dir = PathBuf::from(info.conda_prefix.clone());
+    let prefix = conda_dir.join("envs").join(env_name);
+    let exe = prefix.join("bin").join("python");
+    let conda = Conda::from(&env);
+
+    let python_env = PythonEnv::new(exe.clone(), Some(prefix.clone()), None);
+    let env = conda.from(&python_env).unwrap();
+
+    assert_eq!(env.manager.is_some(), true);
+
+    let manager = env.manager.unwrap();
+    assert_eq!(manager.executable, conda_dir.join("bin").join("conda"));
+    assert_eq!(manager.tool, EnvManagerType::Conda);
+    assert_eq!(manager.version, info.conda_version.into());
+
+    assert_eq!(env.prefix, prefix.clone().into());
+    assert_eq!(env.name, Some(env_name.into()));
+    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.executable, exe.clone().into());
+    assert!(
+        env.version.clone().unwrap_or_default().starts_with("3.10"),
+        "Expected 3.10, but got Version: {:?}",
+        env.version
+    );
+}
+
+#[cfg(unix)]
+#[cfg_attr(feature = "ci_conda", test)]
+#[allow(dead_code)]
+// Detect envs created without Python
+fn detect_new_conda_env_without_python() {
+    use pet_conda::Conda;
+    use pet_core::{
+        os_environment::EnvironmentApi, python_environment::PythonEnvironmentCategory, Locator,
+    };
+    use std::path::PathBuf;
+
+    let env_name = "env_without_python";
+    create_conda_env(&CondaCreateEnvNameOrPath::Name(env_name.into()), None);
+    let env = EnvironmentApi::new();
+
+    let conda = Conda::from(&env);
+    let result = conda.find().unwrap();
+
+    assert_eq!(result.managers.len(), 1);
+
+    let manager = &result.managers[0];
+
+    let info = get_conda_info();
+    let conda_dir = PathBuf::from(info.conda_prefix.clone());
+    let env = result
+        .environments
+        .iter()
+        .find(|x| x.name == Some(env_name.into()))
+        .expect(
+            format!(
+                "New Environment not created, detected envs {:?}",
+                result.environments
+            )
+            .as_str(),
+        );
+
+    let prefix = conda_dir.clone().join("envs").join(env_name);
+    assert_eq!(env.prefix, prefix.clone().into());
+    assert_eq!(env.name, Some(env_name.into()));
+    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.executable.is_none(), true);
+    assert_eq!(env.version.is_none(), true);
+
+    assert_eq!(env.manager, Some(manager.clone()));
+}
+
+#[cfg(unix)]
+#[cfg_attr(feature = "ci_conda", test)]
+#[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 common::resolve_test_path;
+    use pet_conda::Conda;
+    use pet_core::{
+        os_environment::EnvironmentApi, python_environment::PythonEnvironmentCategory, Locator,
+    };
+    use std::path::PathBuf;
+
+    let env_name = "env_without_python3";
+    let prefix = resolve_test_path(&["unix", env_name]);
+    create_conda_env(&CondaCreateEnvNameOrPath::Path(prefix.clone()), None);
+    let env = EnvironmentApi::new();
+
+    let conda = Conda::from(&env);
+    let result = conda.find().unwrap();
+
+    assert_eq!(result.managers.len(), 1);
+
+    let manager = &result.managers[0];
+
+    let info = get_conda_info();
+    let conda_dir = PathBuf::from(info.conda_prefix.clone());
+    let env = result
+        .environments
+        .iter()
+        .find(|x| x.prefix == Some(prefix.clone()))
+        .expect(
+            format!(
+                "New Environment not created, detected envs {:?}",
+                result.environments
+            )
+            .as_str(),
+        );
+
+    let prefix = conda_dir.clone().join("envs").join(env_name);
+    assert_eq!(env.prefix, prefix.clone().into());
+    assert_eq!(env.name, None);
+    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.executable.is_none(), true);
+    assert_eq!(env.version.is_none(), true);
+
+    assert_eq!(env.manager, Some(manager.clone()));
+}
+
+#[cfg(unix)]
+#[cfg_attr(feature = "ci_conda", test)]
+#[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 common::resolve_test_path;
     use pet_conda::Conda;
-    use pet_core::{os_environment::EnvironmentApi, Locator};
+    use pet_core::{
+        os_environment::EnvironmentApi, python_environment::PythonEnvironmentCategory, Locator,
+    };
+    use std::path::PathBuf;
 
+    let env_name = "env_with_python3";
+    let prefix = resolve_test_path(&["unix", env_name]);
+    let exe = prefix.join("bin").join("python");
+    create_conda_env(
+        &CondaCreateEnvNameOrPath::Path(prefix.clone()),
+        Some("3.10".into()),
+    );
     let env = EnvironmentApi::new();
 
     let conda = Conda::from(&env);
-    let result = conda.find();
-    println!("SERVER CI Started");
-    println!("SERVER CI REsults{:?}", result);
+    let result = conda.find().unwrap();
+
+    assert_eq!(result.managers.len(), 1);
+
+    let manager = &result.managers[0];
+
+    let info = get_conda_info();
+    let conda_dir = PathBuf::from(info.conda_prefix.clone());
+    let env = result
+        .environments
+        .iter()
+        .find(|x| x.prefix == Some(prefix.clone()))
+        .expect(
+            format!(
+                "New Environment not created, detected envs {:?}",
+                result.environments
+            )
+            .as_str(),
+        );
+
+    let prefix = conda_dir.clone().join("envs").join(env_name);
+    assert_eq!(env.prefix, prefix.clone().into());
+    assert_eq!(env.name, None);
+    assert_eq!(env.category, PythonEnvironmentCategory::Conda);
+    assert_eq!(env.executable, exe.into());
+    assert!(
+        env.version.clone().unwrap_or_default().starts_with("3.10"),
+        "Expected 3.10, but got Version: {:?}",
+        env.version
+    );
+
+    assert_eq!(env.manager, Some(manager.clone()));
+}
+
+#[derive(Deserialize)]
+struct CondaInfo {
+    conda_version: String,
+    conda_prefix: String,
+    python_version: String,
+    #[allow(dead_code)]
+    envs: Vec<String>,
+}
+
+fn get_conda_exe() -> &'static str {
+    // On CI we expect conda to be in the current path.
+    "conda"
+}
+
+fn get_conda_info() -> CondaInfo {
+    // Spawn `conda --version` to get the version of conda as a string
+    let output = std::process::Command::new(get_conda_exe())
+        .args(["info", "--json"])
+        .output()
+        .expect("Failed to execute command");
+    let output = String::from_utf8(output.stdout).unwrap();
+    let conda_info: CondaInfo = serde_json::from_str(&output).unwrap();
+    conda_info
+}
+
+enum CondaCreateEnvNameOrPath {
+    Name(String),
+    Path(PathBuf),
+}
+
+fn create_conda_env(mode: &CondaCreateEnvNameOrPath, python_version: Option<String>) {
+    let mut cli: Vec<String> = vec!["create".to_string()];
+    match mode {
+        CondaCreateEnvNameOrPath::Name(name) => {
+            cli.push("-n".to_string());
+            cli.push(name.to_string());
+        }
+        CondaCreateEnvNameOrPath::Path(path) => {
+            cli.push("-p".to_string());
+            cli.push(path.to_str().unwrap().to_string());
+        }
+    }
+    if let Some(ref python_version) = python_version {
+        cli.push(format!("python={}", python_version.as_str()));
+    }
+    cli.push("-y".to_string());
+    // Spawn `conda --version` to get the version of conda as a string
+    let _ = std::process::Command::new(get_conda_exe())
+        .args(cli)
+        .output()
+        .expect("Failed to execute command");
+}
+
+fn get_version(value: &String) -> String {
+    // Regex to extract just the d.d.d version from the full version string
+    let re = regex::Regex::new(r"\d+\.\d+\.\d+").unwrap();
+    let captures = re.captures(value).unwrap();
+    captures.get(0).unwrap().as_str().to_string()
 }
diff --git a/crates/pet-conda/tests/environment_locations_test.rs b/crates/pet-conda/tests/environment_locations_test.rs
index a20dff80..bf3c738d 100644
--- a/crates/pet-conda/tests/environment_locations_test.rs
+++ b/crates/pet-conda/tests/environment_locations_test.rs
@@ -117,25 +117,3 @@ fn list_conda_envs_in_install_location() {
         ]
     );
 }
-
-// #[test]
-// fn get_conda_environment_paths_test() {
-//     let now = SystemTime::now();
-//     let env = EnvironmentApi {};
-//     let envs = get_conda_environment_paths(&env);
-//     println!("{:?}", envs);
-//     println!("{:?}", envs);
-//     println!("{:?}", envs);
-//     println!("{:?}", envs);
-//     println!("{:?}", envs);
-//     match now.elapsed() {
-//         Ok(elapsed) => {
-//             println!("Native Locator took {} milliseconds.", elapsed.as_millis());
-//             println!("Native Locator took {} milliseconds.", elapsed.as_millis());
-//             println!("Native Locator took {} milliseconds.", elapsed.as_millis());
-//         }
-//         Err(e) => {
-//             log::error!("Error getting elapsed time: {:?}", e);
-//         }
-//     }
-// }
diff --git a/crates/pet/src/main.rs b/crates/pet/src/main.rs
index c2952ebf..f94bf3e2 100644
--- a/crates/pet/src/main.rs
+++ b/crates/pet/src/main.rs
@@ -21,7 +21,6 @@ enum Commands {
 
 fn main() {
     let cli = Cli::parse();
-    println!("{:?}", cli);
 
     match cli.command {
         Some(Commands::Server) => find_and_report_envs_jsonrpc(),