test: let integration tests handle it

Author: snus-kin

crates/prek/src/languages/dotnet/dotnet.rs

@@ -11,7 +11,6 @@ use crate::cli::reporter::{HookInstallReporter, HookRunReporter};
 use crate::hook::{Hook, InstallInfo, InstalledHook};
 use crate::languages::LanguageImpl;
 use crate::languages::dotnet::installer::{installer_from_store, query_dotnet_version};
-use crate::languages::version::LanguageRequest;
 use crate::process::Cmd;
 use crate::run::run_by_batch;
 use crate::store::Store;

crates/prek/src/languages/dotnet/installer.rs

@@ -484,123 +484,18 @@ mod tests {
         assert!(display_str.contains("8.0.100"));
     }
 
-    #[tokio::test]
-    async fn test_dotnet_installer_new() {
-        let root = std::path::PathBuf::from("/test/root");
-        let installer = DotnetInstaller::new(root.clone());
-        assert_eq!(installer.root, root);
-    }
-
-    #[tokio::test]
-    async fn test_dotnet_installer_system_only_no_download_allowed() -> anyhow::Result<()> {
-        let temp_dir = tempfile::tempdir()?;
-        let installer = DotnetInstaller::new(temp_dir.path().join("dotnet"));
-
-        // Test system_only: true - this might find system dotnet or not
-        let request = LanguageRequest::Any { system_only: true };
-        let result = installer.install(&request, false).await;
-
-        // If system dotnet is available, it should succeed
-        // If not, it should fail with the expected error message
-        if let Err(err) = result {
-            assert!(
-                err.to_string()
-                    .contains("No system dotnet installation found")
-            );
-        }
-        // If it succeeds, that's also fine - system dotnet was found
-
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn test_dotnet_installer_no_download_allowed() -> anyhow::Result<()> {
-        let temp_dir = tempfile::tempdir()?;
-        let installer = DotnetInstaller::new(temp_dir.path().join("dotnet"));
-
-        // Test with allows_download = false
-        let request = LanguageRequest::Dotnet(DotnetRequest::Major(999)); // Non-existent version
-        let result = installer.install(&request, false).await;
-
-        // Should fail because downloads are disabled
-        assert!(result.is_err());
-        assert!(
-            result
-                .unwrap_err()
-                .to_string()
-                .contains("No suitable dotnet version found and downloads are disabled")
-        );
-
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn test_dotnet_installer_find_existing() -> anyhow::Result<()> {
-        let temp_dir = tempfile::tempdir()?;
-        let installer = DotnetInstaller::new(temp_dir.path().join("dotnet"));
-
-        // Create a fake installed dotnet
-        let version_dir = installer.root.join("8.0.100");
-        fs_err::tokio::create_dir_all(&version_dir).await?;
-
-        let fake_dotnet = dotnet_executable(&version_dir);
-        fs_err::tokio::write(&fake_dotnet, "#!/bin/sh\necho '8.0.100'\n").await?;
-
-        #[cfg(unix)]
-        {
-            use std::os::unix::fs::PermissionsExt;
-            let perms = std::fs::Permissions::from_mode(0o755);
-            std::fs::set_permissions(&fake_dotnet, perms)?;
-        }
-
-        // Mock the query to return our fake version
-        // Since we can't easily mock the actual query_dotnet_version function,
-        // we'll test the find_installed method indirectly by testing scenarios
-        // where it would be called
-
-        Ok(())
-    }
-
-    #[tokio::test]
-    async fn test_dotnet_installer_remove_existing_dir() -> anyhow::Result<()> {
-        let temp_dir = tempfile::tempdir()?;
-        let installer = DotnetInstaller::new(temp_dir.path().join("dotnet"));
-
-        // Create the installer root
-        fs_err::tokio::create_dir_all(&installer.root).await?;
-
-        // Create a directory that would be the target install dir
-        let install_dir = installer.root.join("8.0");
-        fs_err::tokio::create_dir_all(&install_dir).await?;
-        fs_err::tokio::write(install_dir.join("dummy.txt"), "test").await?;
-
-        // Verify the directory exists
-        assert!(install_dir.exists());
-
-        // The installer should clean up existing partial installations
-        // We can't easily test the full download scenario, but we can verify
-        // the cleanup logic works by checking that our test directory structure
-        // is properly set up for testing
-
-        Ok(())
-    }
-
     #[test]
     fn test_display_format_error() {
         let path = std::path::PathBuf::from("/usr/bin/dotnet");
         let version = Version::new(8, 0, 100);
         let result = DotnetResult::new(path, version);
 
-        // Test the Display implementation more thoroughly
+        // Test the Display implementation
         let display_str = format!("{result}");
         assert!(display_str.contains("/usr/bin/dotnet@8.0.100"));
 
-        // Test that the write! operation in fmt could potentially fail
-        // by using a custom formatter that simulates failure
         use std::fmt::{self, Write};
-
         struct FailingFormatter;
-
         impl Write for FailingFormatter {
             fn write_str(&mut self, _s: &str) -> fmt::Result {
                 Err(fmt::Error)
@@ -616,39 +511,31 @@ mod tests {
     #[test]
     fn test_add_channel_args_unix_coverage() {
         let mut cmd = Cmd::new("test", "test");
-
-        // Test with full version
         add_channel_args_unix(&mut cmd, Some("8.0.100"));
-        // This would add --version 8.0.100
+        assert!(format!("{cmd}").contains("--version 8.0.100"));
 
         let mut cmd = Cmd::new("test", "test");
-        // Test with channel
         add_channel_args_unix(&mut cmd, Some("8.0"));
-        // This would add --channel 8.0
+        assert!(format!("{cmd}").contains("--channel 8.0"));
 
         let mut cmd = Cmd::new("test", "test");
-        // Test with None
         add_channel_args_unix(&mut cmd, None);
-        // This would add --channel LTS
+        assert!(format!("{cmd}").contains("--channel LTS"));
     }
 
     #[cfg(windows)]
     #[test]
     fn test_add_channel_args_windows_coverage() {
         let mut cmd = Cmd::new("test", "test");
-
-        // Test with full version
         add_channel_args_windows(&mut cmd, Some("8.0.100"));
-        // This would add -Version 8.0.100
+        assert!(format!("{cmd}").contains("-Version 8.0.100"));
 
         let mut cmd = Cmd::new("test", "test");
-        // Test with channel
         add_channel_args_windows(&mut cmd, Some("8.0"));
-        // This would add -Channel 8.0
+        assert!(format!("{cmd}").contains("-Channel 8.0"));
 
         let mut cmd = Cmd::new("test", "test");
-        // Test with None
         add_channel_args_windows(&mut cmd, None);
-        // This would add -Channel LTS
+        assert!(format!("{cmd}").contains("-Channel LTS"));
     }
 }