Add more tests for prek cache gc (#1425)

j178 · web-flow · commit 0f6134430601 · 2026-01-20T22:23:48.000+08:00
diff --git a/crates/prek/src/cli/cache_gc.rs b/crates/prek/src/cli/cache_gc.rs
@@ -11,7 +11,7 @@ use tracing::{debug, trace, warn};
 
 use crate::cli::ExitStatus;
 use crate::cli::cache_size::{dir_size_bytes, human_readable_bytes};
-use crate::config::{self, Error as ConfigError, Language, Repo as ConfigRepo, load_config};
+use crate::config::{self, Error as ConfigError, Repo as ConfigRepo, load_config};
 use crate::hook::{HOOK_MARKER, HookEnvKey, HookSpec, InstallInfo, Repo as HookRepo};
 use crate::printer::Printer;
 use crate::store::{CacheBucket, REPO_MARKER, Store, ToolBucket};
@@ -193,7 +193,8 @@ pub(crate) async fn cache_gc(
 
     // Mark tools/caches from hook languages.
     for key in &used_env_keys {
-        mark_tools_and_cache_for_language(key.language, &mut used_tools, &mut used_cache);
+        used_tools.extend(key.language.tool_buckets());
+        used_cache.extend(key.language.cache_buckets());
     }
 
     // Mark hook environments by matching already-installed env metadata.
@@ -400,36 +401,6 @@ fn hook_env_keys_from_config(store: &Store, config: &config::Config) -> Vec<Hook
     keys
 }
 
-fn mark_tools_and_cache_for_language(
-    language: Language,
-    used_tools: &mut FxHashSet<ToolBucket>,
-    used_cache: &mut FxHashSet<CacheBucket>,
-) {
-    match language {
-        Language::Python | Language::Pygrep => {
-            used_tools.insert(ToolBucket::Uv);
-            used_tools.insert(ToolBucket::Python);
-            used_cache.insert(CacheBucket::Uv);
-            used_cache.insert(CacheBucket::Python);
-        }
-        Language::Node => {
-            used_tools.insert(ToolBucket::Node);
-        }
-        Language::Golang => {
-            used_tools.insert(ToolBucket::Go);
-            used_cache.insert(CacheBucket::Go);
-        }
-        Language::Ruby => {
-            used_tools.insert(ToolBucket::Ruby);
-        }
-        Language::Rust => {
-            used_tools.insert(ToolBucket::Rustup);
-            used_cache.insert(CacheBucket::Cargo);
-        }
-        _ => {}
-    }
-}
-
 fn mark_tool_versions_from_install_info(
     store: &Store,
     info: &InstallInfo,
@@ -438,16 +409,7 @@ fn mark_tool_versions_from_install_info(
     // NOTE: `InstallInfo.toolchain` is typically the executable path (e.g.
     // tools/go/1.24.0/bin/go). We keep the first path component under the tool bucket.
     // If we can't recognize it, we do nothing (and GC will keep all versions).
-    let buckets: &[ToolBucket] = match info.language {
-        Language::Python | Language::Pygrep => &[ToolBucket::Python, ToolBucket::Uv],
-        Language::Node => &[ToolBucket::Node],
-        Language::Golang => &[ToolBucket::Go],
-        Language::Ruby => &[ToolBucket::Ruby],
-        Language::Rust => &[ToolBucket::Rustup],
-        _ => &[],
-    };
-
-    for bucket in buckets {
+    for bucket in info.language.tool_buckets() {
         let bucket_root = store.tools_path(*bucket);
         if let Some(version) = tool_version_dir_name(&bucket_root, &info.toolchain) {
             used_tool_versions
@@ -516,6 +478,7 @@ fn sweep_tool_bucket_versions(
             }
         };
         let path = entry.path();
+        // Don't remove files (uv, and rustup are files inside tools/).
         if !path.is_dir() {
             continue;
         }
@@ -768,3 +731,66 @@ fn format_dependency_list(deps: &[String], max_items: usize, max_chars: usize) -
     }
     truncate_end(&rendered, max_chars)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn truncate_end_returns_input_when_short_enough() {
+        assert_eq!(truncate_end("abc", 3), "abc");
+        assert_eq!(truncate_end("abc", 10), "abc");
+    }
+
+    #[test]
+    fn truncate_end_truncates_and_appends_ellipsis() {
+        assert_eq!(truncate_end("abcd", 3), "ab…");
+        assert_eq!(truncate_end("abcdef", 5), "abcd…");
+    }
+
+    #[test]
+    fn truncate_end_counts_chars_not_bytes() {
+        // 3 unicode scalar values.
+        assert_eq!(truncate_end("ééé", 3), "ééé");
+        assert_eq!(truncate_end("ééé", 2), "é…");
+    }
+
+    #[test]
+    fn split_repo_dependency_prefers_url_like_repo_at_rev() {
+        let mut deps = FxHashSet::default();
+        deps.insert("requests==2.32.0".to_string());
+        deps.insert("black==24.1.0".to_string());
+        deps.insert("https://github.com/pre-commit/pre-commit-hooks@v1.0.0".to_string());
+
+        let (repo_dep, rest) = split_repo_dependency(&deps);
+
+        assert_eq!(
+            repo_dep.as_deref(),
+            Some("https://github.com/pre-commit/pre-commit-hooks@v1.0.0")
+        );
+        assert_eq!(rest, vec!["black==24.1.0", "requests==2.32.0"]);
+    }
+
+    #[test]
+    fn split_repo_dependency_returns_none_when_no_repo_like_dep() {
+        let mut deps = FxHashSet::default();
+        deps.insert("requests==2.32.0".to_string());
+        deps.insert("black==24.1.0".to_string());
+
+        let (repo_dep, rest) = split_repo_dependency(&deps);
+        assert!(repo_dep.is_none());
+        assert_eq!(rest, vec!["black==24.1.0", "requests==2.32.0"]);
+    }
+
+    #[test]
+    fn format_dependency_list_includes_more_suffix() {
+        let deps = vec!["a".to_string(), "b".to_string(), "c".to_string()];
+        assert_eq!(format_dependency_list(&deps, 2, 200), "a, b, … (+1 more)");
+    }
+
+    #[test]
+    fn format_dependency_list_truncates_rendered_string() {
+        let deps = vec!["abcdef".to_string()];
+        assert_eq!(format_dependency_list(&deps, 6, 5), "abcd…");
+    }
+}
diff --git a/crates/prek/src/languages/mod.rs b/crates/prek/src/languages/mod.rs
@@ -15,7 +15,7 @@ use crate::config::Language;
 use crate::fs::{CWD, Simplified};
 use crate::hook::{Hook, InstallInfo, InstalledHook, Repo};
 use crate::identify::parse_shebang;
-use crate::store::Store;
+use crate::store::{CacheBucket, Store, ToolBucket};
 use crate::{archive, hooks, warn_user_once};
 
 mod bun;
@@ -144,10 +144,31 @@ impl Language {
     pub fn supports_install_env(self) -> bool {
         !matches!(
             self,
-            Self::DockerImage | Self::Fail | Self::Pygrep | Self::Script | Self::System
+            Self::DockerImage | Self::Fail | Self::Script | Self::System
         )
     }
 
+    pub fn tool_buckets(self) -> &'static [ToolBucket] {
+        match self {
+            Self::Bun => &[ToolBucket::Bun],
+            Self::Golang => &[ToolBucket::Go],
+            Self::Node => &[ToolBucket::Node],
+            Self::Python | Self::Pygrep => &[ToolBucket::Uv, ToolBucket::Python],
+            Self::Ruby => &[ToolBucket::Ruby],
+            Self::Rust => &[ToolBucket::Rustup],
+            _ => &[],
+        }
+    }
+
+    pub fn cache_buckets(self) -> &'static [CacheBucket] {
+        match self {
+            Self::Golang => &[CacheBucket::Go],
+            Self::Python | Self::Pygrep => &[CacheBucket::Uv, CacheBucket::Python],
+            Self::Rust => &[CacheBucket::Cargo],
+            _ => &[],
+        }
+    }
+
     /// Return whether the language allows specifying the version, e.g. we can install a specific
     /// requested language version.
     /// See <https://pre-commit.com/#overriding-language-version>
diff --git a/crates/prek/tests/cache.rs b/crates/prek/tests/cache.rs
@@ -46,6 +46,32 @@ fn cache_gc_verbose_shows_removed_entries() {
     home.child("hooks/hook-env-dead")
         .create_dir_all()
         .expect("create hook env dir");
+    home.child("hooks/hook-env-dead/.prek-hook.json")
+        .write_str(
+            &serde_json::to_string_pretty(&json!({
+                "language": "python",
+                "language_version": "3.12.0",
+                "dependencies": [
+                    "https://example.com/repo@v1.0.0",
+                    "dep1",
+                    "dep2",
+                    "dep3",
+                    "dep4",
+                    "dep5",
+                    "dep6",
+                    "dep7",
+                ],
+                "env_path": home.child("hooks/hook-env-dead").path(),
+                "toolchain": "/usr/bin/python3",
+                "extra": {},
+            }))
+            .expect("serialize hook marker"),
+        )
+        .expect("write hook marker");
+
+    home.child("cache/go")
+        .create_dir_all()
+        .expect("create cache dir");
 
     // Have a tracked config that exists but references nothing (so everything above is unreferenced).
     let config_path = context.work_dir().child(CONFIG_FILE);
@@ -55,15 +81,22 @@ fn cache_gc_verbose_shows_removed_entries() {
     success: true
     exit_code: 0
     ----- stdout -----
-    Removed 1 repo, 1 hook env ([SIZE])
+    Removed 1 repo, 1 hook env, 1 cache entry ([SIZE])
 
     Removed 1 repo:
     - https://github.com/pre-commit/pre-commit-hooks@v1.0.0
       path: [HOME]/repos/deadbeef
 
     Removed 1 hook env:
-    - hook-env-dead
+    - python env
       path: [HOME]/hooks/hook-env-dead
+      language: python (3.12.0)
+      repo: https://example.com/repo@v1.0.0
+      deps: dep1, dep2, dep3, dep4, dep5, dep6, … (+1 more)
+
+    Removed 1 cache entry:
+    - go
+      path: [HOME]/cache/go
 
     ----- stderr -----
     ");
@@ -220,10 +253,30 @@ fn cache_gc_prunes_unused_tool_versions() -> anyhow::Result<()> {
         repos:
           - repo: local
             hooks:
-            - id: local-python
-              name: Local Python Hook
-              entry: "python -c \"print(1)\""
-              language: python
+              - id: local-python
+                name: Local Python Hook
+                entry: "python -c \"print(1)\""
+                language: python
+              - id: local-pygrep
+                name: Local Pygrep Hook
+                entry: "python -c \"print(1)\""
+                language: pygrep
+              - id: local-node
+                name: Local Node Hook
+                entry: "node -e \"console.log(1)\""
+                language: node
+              - id: local-go
+                name: Local Go Hook
+                entry: "go version"
+                language: golang
+              - id: local-ruby
+                name: Local Ruby Hook
+                entry: "ruby -e 'puts 1'"
+                language: ruby
+              - id: local-rust
+                name: Local Rust Hook
+                entry: "rustc --version"
+                language: rust
     "#});
 
     let home = context.home_dir();
@@ -232,36 +285,88 @@ fn cache_gc_prunes_unused_tool_versions() -> anyhow::Result<()> {
     let config_path = context.work_dir().child(CONFIG_FILE);
     write_config_tracking_file(home, &[config_path.path()])?;
 
-    // Seed a "used" python hook env marker so GC can read `.prek-hook.json` and retain the
-    // corresponding Python tool version.
-    let env_dir = home.child("hooks/python-keep");
-    env_dir.create_dir_all()?;
-
-    let py_312 = home.child("tools/python/3.12.0");
-    let py_311 = home.child("tools/python/3.11.0");
-    py_312.create_dir_all()?;
-    py_311.create_dir_all()?;
+    // Seed "used" hook env markers so GC can read `.prek-hook.json` and retain the
+    // corresponding tool versions per language.
+    let env_py = home.child("hooks/python-keep");
+    let env_node = home.child("hooks/node-keep");
+    let env_go = home.child("hooks/go-keep");
+    let env_ruby = home.child("hooks/ruby-remove");
+    let env_rust = home.child("hooks/rust-remove");
+    env_py.create_dir_all()?;
+    env_node.create_dir_all()?;
+    env_go.create_dir_all()?;
+    env_ruby.create_dir_all()?;
+    env_rust.create_dir_all()?;
+
+    let py_keep = home.child("tools/python/3.12.0");
+    let py_remove = home.child("tools/python/3.11.0");
+    py_keep.create_dir_all()?;
+    py_remove.create_dir_all()?;
+
+    let node_keep = home.child("tools/node/22.0.0");
+    let node_remove = home.child("tools/node/21.0.0");
+    node_keep.create_dir_all()?;
+    node_remove.create_dir_all()?;
+
+    let go_keep = home.child("tools/go/1.24.0");
+    let go_remove = home.child("tools/go/1.23.0");
+    go_keep.create_dir_all()?;
+    go_remove.create_dir_all()?;
 
     // Match logic for local hooks: empty deps + language request is `Any` by default.
-    let marker = json!({
+    let marker_py = json!({
         "language": "python",
         "language_version": "3.12.0",
         "dependencies": [],
-        "env_path": env_dir.path(),
-        "toolchain": py_312.child("bin/python").path(),
+        "env_path": env_py.path(),
+        "toolchain": py_keep.child("bin/python").path(),
         "extra": {},
     });
-    env_dir
+    env_py
         .child(".prek-hook.json")
-        .write_str(&serde_json::to_string_pretty(&marker)?)?;
+        .write_str(&serde_json::to_string_pretty(&marker_py)?)?;
+
+    let marker_node = json!({
+        "language": "node",
+        "language_version": "22.0.0",
+        "dependencies": [],
+        "env_path": env_node.path(),
+        "toolchain": node_keep.child("bin/node").path(),
+        "extra": {},
+    });
+    env_node
+        .child(".prek-hook.json")
+        .write_str(&serde_json::to_string_pretty(&marker_node)?)?;
+
+    let marker_go = json!({
+        "language": "golang",
+        "language_version": "1.24.0",
+        "dependencies": [],
+        "env_path": env_go.path(),
+        "toolchain": go_keep.child("bin/go").path(),
+        "extra": {},
+    });
+    env_go
+        .child(".prek-hook.json")
+        .write_str(&serde_json::to_string_pretty(&marker_go)?)?;
 
     cmd_snapshot!(context.filters(), context.command().args(["cache", "gc", "--dry-run", "-v"]), @r"
     success: true
     exit_code: 0
     ----- stdout -----
-    Would remove 1 tool ([SIZE])
-
-    Would remove 1 tool:
+    Would remove 2 hook envs, 3 tools ([SIZE])
+
+    Would remove 2 hook envs:
+    - ruby-remove
+      path: [HOME]/hooks/ruby-remove
+    - rust-remove
+      path: [HOME]/hooks/rust-remove
+
+    Would remove 3 tools:
+    - go/1.23.0
+      path: [HOME]/tools/go/1.23.0
+    - node/21.0.0
+      path: [HOME]/tools/node/21.0.0
     - python/3.11.0
       path: [HOME]/tools/python/3.11.0
 
