Use differnt test dir

crates/distribution-types/src/lib.rs

@@ -371,7 +371,6 @@ impl Dist {
             return Err(Error::NotFound(url.to_url()));
         }
 
-
         // Determine whether the path represents a built or source distribution.
         match ext {
             DistExtension::Wheel => {

crates/uv-fs/src/path.rs

@@ -7,19 +7,12 @@ use path_slash::PathExt;
 
 /// The current working directory.
 pub static CWD: LazyLock<PathBuf> =
-    LazyLock::new(|| {
-        std::env::var("UV_CWD")
-            .ok()
-            .map(PathBuf::from)
-            .unwrap_or_else(|| std::env::current_dir().expect("The current directory must exist"))
-    });
+    LazyLock::new(|| std::env::current_dir().expect("The current directory must exist"));
 
 /// The current working directory, canonicalized.
 pub static CANONICAL_CWD: LazyLock<PathBuf> = LazyLock::new(|| {
-    std::env::var("UV_CWD")
-        .ok()
-        .map(PathBuf::from)
-        .unwrap_or_else(|| std::env::current_dir().expect("The current directory must exist"))
+    std::env::current_dir()
+        .expect("The current directory must exist")
         .canonicalize()
         .expect("The current directory must be canonicalized")
 });

crates/uv-installer/src/plan.rs

@@ -278,7 +278,6 @@ impl<'a> Planner<'a> {
                         return Err(Error::NotFound(url.to_url()).into());
                     }
 
-
                     let sdist = DirectorySourceDist {
                         name: requirement.name.clone(),
                         url: url.clone(),

crates/uv-resolver/src/lock.rs

@@ -1928,9 +1928,6 @@ impl Source {
     }
 
     fn from_path_source_dist(path_dist: &PathSourceDist, root: &Path) -> Result<Source, LockError> {
-
-
-
         let path = relative_to(&path_dist.install_path, root)
             .map_err(LockErrorKind::DistributionRelativePath)?;
 

crates/uv-workspace/src/workspace.rs

@@ -169,8 +169,6 @@ impl Workspace {
                 pyproject_toml,
             });
 
-
-
         Self::collect_members(
             workspace_root.clone(),
             workspace_definition,

crates/uv/Cargo.toml

@@ -86,6 +86,7 @@ assert_cmd = { version = "2.0.14" }
 assert_fs = { version = "1.1.0" }
 base64 = { version = "0.22.0" }
 byteorder = { version = "1.5.0" }
+etcetera =  { workspace = true }
 filetime = { version = "0.2.23" }
 ignore = { version = "0.4.22" }
 indoc = { version = "2.0.4" }
@@ -94,6 +95,7 @@ predicates = { version = "3.0.4" }
 regex = { workspace = true }
 reqwest = { workspace = true, features = ["blocking"], default-features = false }
 similar = { version = "2.6.0" }
+tempfile = { workspace = true }
 zip = { workspace = true }
 
 [package.metadata.cargo-shear]

crates/uv/tests/common/mod.rs

@@ -13,6 +13,7 @@ use assert_cmd::assert::{Assert, OutputAssertExt};
 use assert_fs::assert::PathAssert;
 use assert_fs::fixture::{ChildPath, PathChild, PathCopy, PathCreateDir, SymlinkToFile};
 use base64::{prelude::BASE64_STANDARD as base64, Engine};
+use etcetera::BaseStrategy;
 use indoc::formatdoc;
 use itertools::Itertools;
 use predicates::prelude::predicate;
@@ -72,10 +73,10 @@ pub const INSTA_FILTERS: &[(&str, &str)] = &[
 /// * Set a cutoff for versions used in the resolution so the snapshots don't change after a new release.
 /// * Set the venv to a fresh `.venv` in `temp_dir`
 pub struct TestContext {
-    pub temp_dir: assert_fs::TempDir,
-    pub cache_dir: assert_fs::TempDir,
-    pub python_dir: assert_fs::TempDir,
-    pub home_dir: assert_fs::TempDir,
+    pub temp_dir: ChildPath,
+    pub cache_dir: ChildPath,
+    pub python_dir: ChildPath,
+    pub home_dir: ChildPath,
     pub venv: ChildPath,
     pub workspace_root: PathBuf,
 
@@ -87,6 +88,9 @@ pub struct TestContext {
 
     /// Standard filters for this test context.
     filters: Vec<(String, String)>,
+
+    #[allow(dead_code)]
+    _root: tempfile::TempDir,
 }
 
 impl TestContext {
@@ -168,18 +172,29 @@ impl TestContext {
     ///
     /// See [`TestContext::new`] if only a single version is desired.
     pub fn new_with_versions(python_versions: &[&str]) -> Self {
-        let temp_dir = assert_fs::TempDir::new().expect("Failed to create test working directory");
-        let cache_dir = assert_fs::TempDir::new().expect("Failed to create test cache directory");
-        let python_dir = assert_fs::TempDir::new().expect("Failed to create test Python directory");
-        let home_dir = assert_fs::TempDir::new().expect("Failed to create test home directory");
+        let state =
+            etcetera::base_strategy::choose_base_strategy().expect("Failed to find base strategy");
+        let bucket = state.data_dir().join("uv").join("tests");
+        fs_err::create_dir_all(&bucket).expect("Failed to create test bucket");
+
+        let root = tempfile::TempDir::new_in(bucket).expect("Failed to create temp dir");
+
+        let temp_dir = ChildPath::new(root.path()).child("temp");
+        fs_err::create_dir_all(&temp_dir).expect("Failed to create temp dir");
+
+        let cache_dir = ChildPath::new(root.path()).child("cache");
+        fs_err::create_dir_all(&cache_dir).expect("Failed to create cache dir");
+
+        let python_dir = ChildPath::new(root.path()).child("python");
+        fs_err::create_dir_all(&python_dir).expect("Failed to create python dir");
+
+        let home_dir = ChildPath::new(root.path()).child("home");
+        fs_err::create_dir_all(&home_dir).expect("Failed to create home dir");
 
         // Canonicalize the temp dir for consistent snapshot behavior
         let canonical_temp_dir = temp_dir.canonicalize().unwrap();
         let venv = ChildPath::new(canonical_temp_dir.join(".venv"));
 
-        println!("temp_dir: {:?}", temp_dir.path());
-        println!("canonical_temp_dir: {:?}", canonical_temp_dir);
-
         let python_version = python_versions
             .first()
             .map(|version| PythonVersion::from_str(version).unwrap());
@@ -334,6 +349,7 @@ impl TestContext {
             python_version,
             python_versions,
             filters,
+            _root: root,
         }
     }
 
@@ -366,7 +382,6 @@ impl TestContext {
             .env("UV_EXCLUDE_NEWER", EXCLUDE_NEWER)
             .env("UV_CWD", self.temp_dir.path())
             .current_dir(self.temp_dir.path());
-        println!("current_dir: {:?}", self.temp_dir.path());
 
         if cfg!(all(windows, debug_assertions)) {
             // TODO(konstin): Reduce stack usage in debug mode enough that the tests pass with the
@@ -857,7 +872,7 @@ pub fn get_python(version: &PythonVersion) -> PathBuf {
 /// Create a virtual environment at the given path.
 pub fn create_venv_from_executable<P: AsRef<std::path::Path>>(
     path: P,
-    cache_dir: &assert_fs::TempDir,
+    cache_dir: &ChildPath,
     python: &Path,
 ) {
     assert_cmd::Command::new(get_bin())
@@ -884,7 +899,7 @@ pub fn get_bin() -> PathBuf {
 ///
 /// Generally this should be used with `UV_TEST_PYTHON_PATH`.
 pub fn python_path_with_versions(
-    temp_dir: &assert_fs::TempDir,
+    temp_dir: &ChildPath,
     python_versions: &[&str],
 ) -> anyhow::Result<OsString> {
     Ok(std::env::join_paths(
@@ -898,7 +913,7 @@ pub fn python_path_with_versions(
 ///
 /// Generally this should be used with `UV_TEST_PYTHON_PATH`.
 pub fn python_installations_for_versions(
-    temp_dir: &assert_fs::TempDir,
+    temp_dir: &ChildPath,
     python_versions: &[&str],
 ) -> anyhow::Result<Vec<PathBuf>> {
     let cache = Cache::from_path(temp_dir.child("cache").to_path_buf()).init()?;

crates/uv/tests/lock.rs

@@ -7106,8 +7106,6 @@ fn lock_sources_archive() -> Result<()> {
     let mut workspace_archive_file = fs_err::File::create(&*workspace_archive)?;
     std::io::copy(&mut response.bytes()?.as_ref(), &mut workspace_archive_file)?;
 
-
-
     let pyproject_toml = context.temp_dir.child("pyproject.toml");
     pyproject_toml.write_str(&formatdoc! {
         r#"
@@ -7134,8 +7132,8 @@ fn lock_sources_archive() -> Result<()> {
     // insta::with_settings!({
     //     filters => context.filters(),
     // }, {
-        assert_snapshot!(
-            lock, @r###"
+    assert_snapshot!(
+        lock, @r###"
         version = 1
         requires-python = ">=3.12"
 
@@ -7195,7 +7193,7 @@ fn lock_sources_archive() -> Result<()> {
         [package.metadata]
         requires-dist = [{ name = "anyio" }]
         "###
-        );
+    );
     // });
 
     // Re-run with `--locked`.