feat: add cargo wdk clean command

crates/cargo-wdk/src/actions/clean/error.rs

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation
+// License: MIT OR Apache-2.0
+//! This module defines error types for the clean action module.
+
+use std::path::PathBuf;
+
+use thiserror::Error;
+
+use crate::providers::error::{CommandError, FileError};
+
+/// Errors for the clean action layer
+#[derive(Error, Debug)]
+pub enum CleanActionError {
+    #[error(transparent)]
+    FileIo(#[from] FileError),
+    #[error("No valid rust projects in the current working directory: {0}")]
+    NoValidRustProjectsInTheDirectory(PathBuf),
+    #[error("One or more projects failed to clean in the emulated workspace: {0}")]
+    OneOrMoreRustProjectsFailedToClean(PathBuf),
+    #[error("Error running cargo clean command")]
+    CargoClean(#[from] CommandError),
+}

crates/cargo-wdk/src/actions/clean/mod.rs

@@ -0,0 +1,182 @@
+// Copyright (c) Microsoft Corporation
+// License: MIT OR Apache-2.0
+//! This module contains the `CleanAction` struct and its associated methods
+//! for cleaning build artifacts produced by the `build` command.
+mod error;
+#[cfg(test)]
+mod tests;
+
+use std::path::{Path, PathBuf, absolute};
+
+use anyhow::Result;
+use error::CleanActionError;
+use mockall_double::double;
+use tracing::{debug, error as err, info};
+
+#[double]
+use crate::providers::{exec::CommandExec, fs::Fs};
+use crate::trace;
+
+pub struct CleanAction<'a> {
+    working_dir: PathBuf,
+    verbosity_level: clap_verbosity_flag::Verbosity,
+
+    // Injected deps
+    command_exec: &'a CommandExec,
+    fs: &'a Fs,
+}
+
+impl<'a> CleanAction<'a> {
+    /// Creates a new instance of `CleanAction`.
+    ///
+    /// # Arguments
+    /// * `working_dir` - The working directory for the clean action
+    /// * `verbosity_level` - The verbosity level for logging
+    /// * `command_exec` - The command execution provider instance
+    /// * `fs` - The file system provider instance
+    ///
+    /// # Returns
+    /// * `Result<Self>` - A result containing either a new instance of
+    ///   `CleanAction` on success, or an `anyhow::Error`.
+    ///
+    /// # Errors
+    /// * [`anyhow::Error`] - If `working_dir` is not a syntactically valid
+    ///   path, e.g. it is empty
+    pub fn new(
+        working_dir: &Path,
+        verbosity_level: clap_verbosity_flag::Verbosity,
+        command_exec: &'a CommandExec,
+        fs: &'a Fs,
+    ) -> Result<Self> {
+        Ok(Self {
+            working_dir: absolute(working_dir)?,
+            verbosity_level,
+            command_exec,
+            fs,
+        })
+    }
+
+    /// Entry point method to execute the clean action flow.
+    ///
+    /// The detection strategy is:
+    /// 1. If the working directory has a `Cargo.toml`, run `cargo clean`
+    ///    directly (standalone project or workspace root).
+    /// 2. Otherwise, treat the directory as an emulated workspace: scan
+    ///    immediate subdirectories for Rust projects and clean each. NOTE: This
+    ///    follows the same logic as the build action.
+    ///
+    /// # Returns
+    /// `Result<(), CleanActionError>`
+    ///
+    /// # Errors
+    /// * `CleanActionError::FileIo` - If there is an IO error.
+    /// * `CleanActionError::CargoClean` - If there is an error running the
+    ///   `cargo clean` command.
+    /// * `CleanActionError::NoValidRustProjectsInTheDirectory` - If no valid
+    ///   Rust projects are found in the working directory.
+    /// * `CleanActionError::OneOrMoreRustProjectsFailedToClean` - If one or
+    ///   more Rust projects fail to clean in an emulated workspace.
+    pub fn run(&self) -> Result<(), CleanActionError> {
+        debug!(
+            "Attempting to clean project at: {}",
+            self.working_dir.display()
+        );
+
+        // Standalone driver/driver workspace support
+        if self.fs.exists(&self.working_dir.join("Cargo.toml")) {
+            debug!(
+                "Found Cargo.toml in {}. Running cargo clean.",
+                self.working_dir.display()
+            );
+            return self.run_cargo_clean(&self.working_dir);
+        }
+
+        // Emulated workspaces support
+        let dirs = self.fs.read_dir_entries(&self.working_dir)?;
+        debug!(
+            "Checking for valid Rust projects in the working directory: {}",
+            self.working_dir.display()
+        );
+
+        let mut is_valid_dir_with_rust_projects = false;
+        for dir in &dirs {
+            if self.fs.dir_file_type(dir)?.is_dir()
+                && self.fs.exists(&dir.path().join("Cargo.toml"))
+            {
+                debug!(
+                    "Found at least one valid Rust project directory: {}, continuing with the \
+                     clean flow",
+                    dir.path()
+                        .file_name()
+                        .expect(
+                            "package sub directory name ended with \"..\" which is not expected",
+                        )
+                        .to_string_lossy()
+                );
+                is_valid_dir_with_rust_projects = true;
+                break;
+            }
+        }
+
+        if !is_valid_dir_with_rust_projects {
+            return Err(CleanActionError::NoValidRustProjectsInTheDirectory(
+                self.working_dir.clone(),
+            ));
+        }
+
+        info!("Cleaning package(s) in {}", self.working_dir.display());
+
+        let mut failed_at_least_one_project = false;
+        for dir in dirs {
+            debug!("Checking dir entry: {}", dir.path().display());
+            if !self.fs.dir_file_type(&dir)?.is_dir()
+                || !self.fs.exists(&dir.path().join("Cargo.toml"))
+            {
+                debug!("Dir entry is not a valid Rust package");
+                continue;
+            }
+
+            let working_dir_path = dir.path();
+            let sub_dir = working_dir_path
+                .file_name()
+                .expect("package sub directory name ended with \"..\" which is not expected")
+                .to_string_lossy();
+
+            debug!("Cleaning package(s) in dir {sub_dir}");
+            if let Err(e) = self.run_cargo_clean(&dir.path()) {
+                failed_at_least_one_project = true;
+                err!(
+                    "Error cleaning project: {sub_dir}, error: {:?}",
+                    anyhow::Error::new(e)
+                );
+            }
+        }
+
+        debug!("Done cleaning package(s) in {}", self.working_dir.display());
+        if failed_at_least_one_project {
+            return Err(CleanActionError::OneOrMoreRustProjectsFailedToClean(
+                self.working_dir.clone(),
+            ));
+        }
+
+        info!(
+            "Clean completed successfully for package(s) in {}",
+            self.working_dir.display()
+        );
+        Ok(())
+    }
+
+    /// Runs `cargo clean` in the specified directory.
+    fn run_cargo_clean(&self, working_dir: &Path) -> Result<(), CleanActionError> {
+        info!("Running cargo clean in {}", working_dir.display());
+        let mut args = vec!["clean"];
+        if let Some(flag) = trace::get_cargo_verbose_flags(self.verbosity_level) {
+            args.push(flag);
+        }
+        self.command_exec
+            .run("cargo", &args, None, Some(working_dir))
+            .map_err(CleanActionError::CargoClean)?;
+        info!("Cleaned project at {}", working_dir.display());
+        Ok(())
+    }
+}

crates/cargo-wdk/src/actions/clean/tests.rs

@@ -0,0 +1,148 @@
+// Copyright (c) Microsoft Corporation
+// License: MIT OR Apache-2.0
+
+use std::{
+    os::windows::process::ExitStatusExt,
+    path::PathBuf,
+    process::{ExitStatus, Output},
+};
+
+use mockall::predicate::eq;
+use mockall_double::double;
+
+use super::CleanAction;
+use crate::providers::error::CommandError;
+#[double]
+use crate::providers::{exec::CommandExec, fs::Fs};
+
+fn create_successful_output() -> Output {
+    Output {
+        status: ExitStatus::from_raw(0),
+        stdout: Vec::new(),
+        stderr: Vec::new(),
+    }
+}
+
+#[test]
+fn new_succeeds_for_valid_args() {
+    let cwd = PathBuf::from("C:\\tmp");
+    let mock_fs = Fs::default();
+    let mock_exec = CommandExec::default();
+
+    let action = CleanAction::new(
+        &cwd,
+        clap_verbosity_flag::Verbosity::default(),
+        &mock_exec,
+        &mock_fs,
+    );
+
+    assert!(action.is_ok());
+}
+
+#[test]
+fn new_fails_for_empty_path() {
+    let cwd = PathBuf::from("");
+    let mock_fs = Fs::default();
+    let mock_exec = CommandExec::default();
+
+    let action = CleanAction::new(
+        &cwd,
+        clap_verbosity_flag::Verbosity::default(),
+        &mock_exec,
+        &mock_fs,
+    );
+
+    assert!(action.is_err());
+}
+
+#[test]
+fn run_invokes_cargo_clean_and_succeeds() {
+    let cwd = PathBuf::from("C:\\tmp");
+    let mut mock_fs = Fs::default();
+    let mut mock_exec = CommandExec::default();
+
+    mock_fs
+        .expect_exists()
+        .with(eq(cwd.join("Cargo.toml")))
+        .returning(|_| true);
+
+    mock_exec
+        .expect_run()
+        .withf(move |cmd, args, _env, working_dir| {
+            cmd == "cargo"
+                && args == ["clean"]
+                && *working_dir == Some(PathBuf::from("C:\\tmp").as_path())
+        })
+        .returning(|_, _, _, _| Ok(create_successful_output()));
+
+    let action = CleanAction::new(
+        &cwd,
+        clap_verbosity_flag::Verbosity::default(),
+        &mock_exec,
+        &mock_fs,
+    )
+    .expect("CleanAction::new should succeed");
+
+    assert!(action.run().is_ok());
+}
+
+#[test]
+fn run_returns_error_when_cargo_clean_fails() {
+    let cwd = PathBuf::from("C:\\tmp");
+    let mut mock_fs = Fs::default();
+    let mut mock_exec = CommandExec::default();
+
+    mock_fs
+        .expect_exists()
+        .with(eq(cwd.join("Cargo.toml")))
+        .returning(|_| true);
+
+    mock_exec
+        .expect_run()
+        .withf(move |cmd, args, _env, working_dir| {
+            cmd == "cargo"
+                && args == ["clean"]
+                && *working_dir == Some(PathBuf::from("C:\\tmp").as_path())
+        })
+        .returning(|_, _, _, _| {
+            Err(CommandError::CommandFailed {
+                command: "cargo".to_string(),
+                args: vec!["clean".to_string()],
+                stdout: "error".to_string(),
+            })
+        });
+
+    let action = CleanAction::new(
+        &cwd,
+        clap_verbosity_flag::Verbosity::default(),
+        &mock_exec,
+        &mock_fs,
+    )
+    .expect("CleanAction::new should succeed");
+
+    assert!(action.run().is_err());
+}
+
+#[test]
+fn run_returns_error_when_no_cargo_toml_and_no_rust_projects() {
+    let cwd = PathBuf::from("C:\\tmp");
+    let mut mock_fs = Fs::default();
+    let mock_exec = CommandExec::default();
+
+    mock_fs
+        .expect_exists()
+        .with(eq(cwd.join("Cargo.toml")))
+        .returning(|_| false);
+
+    mock_fs.expect_read_dir_entries().returning(|_| Ok(vec![]));
+
+    let action = CleanAction::new(
+        &cwd,
+        clap_verbosity_flag::Verbosity::default(),
+        &mock_exec,
+        &mock_fs,
+    )
+    .expect("CleanAction::new should succeed");
+
+    assert!(action.run().is_err());
+}

crates/cargo-wdk/src/actions/mod.rs

@@ -6,7 +6,9 @@
 //! business logic of the cargo-wdk utility are:
 //! * `new` - New action module
 //! * `build` - Build action module
+//! * `clean` - Clean action module
 pub mod build;
+pub mod clean;
 pub mod new;
 
 use std::{

crates/cargo-wdk/src/cli.rs

@@ -18,6 +18,7 @@ use crate::actions::{
     UMDF_STR,
     WDM_STR,
     build::{BuildAction, BuildActionParams},
+    clean::CleanAction,
     new::NewAction,
 };
 #[double]
@@ -101,6 +102,11 @@ pub enum Subcmd {
     New(NewArgs),
     #[clap(name = "build", about = "Build the Windows Driver Kit project")]
     Build(BuildArgs),
+    #[clap(
+        name = "clean",
+        about = "Clean build artifacts of a Windows Driver Kit project"
+    )]
+    Clean,
 }
 
 /// Top level command line interface for cargo wdk
@@ -178,6 +184,10 @@ impl Cli {
                 .run()?;
                 Ok(())
             }
+            Subcmd::Clean => {
+                CleanAction::new(Path::new("."), self.verbose, &command_exec, &fs)?.run()?;
+                Ok(())
+            }
         }
     }
 }