refactor: build action from tasks and updated unit tests

Author: krishnakumar4a4

crates/cargo-wdk/src/actions/build/build_task.rs

@@ -5,10 +5,14 @@
 //! building a driver package with the provided options using the `cargo build`
 //! command.
 
+#![allow(dead_code)]
+#![allow(clippy::unused_self)]
+
 use std::path::{Path, PathBuf};
 
 use anyhow::Result;
 use cargo_metadata::Message;
+use mockall::automock;
 use mockall_double::double;
 use tracing::debug;
 use wdk_build::CpuArchitecture;
@@ -33,6 +37,40 @@ pub struct BuildTask<'a> {
     working_dir: &'a Path,
 }
 
+#[derive(Debug)]
+pub struct BuildTaskRunParams<'a> {
+    pub package_name: &'a str,
+    pub working_dir: &'a Path,
+    pub profile: Option<&'a Profile>,
+    pub target_arch: Option<CpuArchitecture>,
+    pub locked: bool,
+    pub verbosity_level: clap_verbosity_flag::Verbosity,
+}
+
+#[derive(Debug, Default)]
+pub struct BuildTaskRunner {}
+
+#[automock]
+impl BuildTaskRunner {
+    pub fn run<'a>(
+        &self,
+        params: &BuildTaskRunParams<'a>,
+        command_exec: &CommandExec,
+    ) -> Result<Vec<Result<Message, std::io::Error>>, BuildTaskError> {
+        BuildTask::new(
+            params.package_name,
+            params.working_dir,
+            params.profile,
+            params.target_arch,
+            params.locked,
+            params.verbosity_level,
+            command_exec,
+        )
+        .run()
+        .map(Iterator::collect)
+    }
+}
+
 impl<'a> BuildTask<'a> {
     /// Creates a new instance of `BuildTask`.
     ///

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

@@ -18,12 +18,10 @@ use std::{
 };
 
 use anyhow::Result;
-use build_task::BuildTask;
 use cargo_metadata::{CrateType, Message, Metadata as CargoMetadata, Package, TargetKind};
 use error::BuildActionError;
 use mockall_double::double;
 pub use package_task::SignMode;
-use package_task::{PackageTask, PackageTaskParams};
 use tracing::{debug, error as err, info, trace, warn};
 use wdk_build::{
     CpuArchitecture,
@@ -32,7 +30,13 @@ use wdk_build::{
 
 use crate::actions::Profile;
 #[double]
+use build_task::BuildTaskRunner;
+use build_task::BuildTaskRunParams;
+#[double]
 use crate::providers::{exec::CommandExec, fs::Fs, metadata::Metadata, wdk_build::WdkBuild};
+#[double]
+use package_task::PackageTaskRunner;
+use package_task::PackageTaskParams;
 
 pub struct BuildActionParams<'a> {
     pub working_dir: &'a Path,
@@ -60,6 +64,8 @@ pub struct BuildAction<'a> {
     command_exec: &'a CommandExec,
     fs: &'a Fs,
     metadata: &'a Metadata,
+    build_task_runner: BuildTaskRunner,
+    package_task_runner: PackageTaskRunner,
 }
 
 impl<'a> BuildAction<'a> {
@@ -86,6 +92,26 @@ impl<'a> BuildAction<'a> {
         command_exec: &'a CommandExec,
         fs: &'a Fs,
         metadata: &'a Metadata,
+    ) -> Result<Self> {
+        Self::new_with_runners(
+            params,
+            wdk_build,
+            command_exec,
+            fs,
+            metadata,
+            BuildTaskRunner::default(),
+            PackageTaskRunner::default(),
+        )
+    }
+
+    fn new_with_runners(
+        params: &BuildActionParams<'a>,
+        wdk_build: &'a WdkBuild,
+        command_exec: &'a CommandExec,
+        fs: &'a Fs,
+        metadata: &'a Metadata,
+        build_task_runner: BuildTaskRunner,
+        package_task_runner: PackageTaskRunner,
     ) -> Result<Self> {
         // TODO: validate params
         anyhow::ensure!(
@@ -104,6 +130,8 @@ impl<'a> BuildAction<'a> {
             command_exec,
             fs,
             metadata,
+            build_task_runner,
+            package_task_runner,
         })
     }
 
@@ -339,16 +367,17 @@ impl<'a> BuildAction<'a> {
         let package_name = package.name.as_str();
         info!("Building package {package_name}");
 
-        let build_task = BuildTask::new(
-            package_name,
-            working_dir,
-            self.profile,
-            self.target_arch,
-            self.locked,
-            self.verbosity_level,
+        let output_message_iter = self.build_task_runner.run(
+            &BuildTaskRunParams {
+                package_name,
+                working_dir,
+                profile: self.profile,
+                target_arch: self.target_arch,
+                locked: self.locked,
+                verbosity_level: self.verbosity_level,
+            },
             self.command_exec,
-        );
-        let output_message_iter = build_task.run()?;
+        )?;
 
         let wdk_metadata = if let Ok(wdk_metadata) = wdk_metadata {
             debug!("Found wdk metadata in package: {}", package_name);
@@ -382,28 +411,29 @@ impl<'a> BuildAction<'a> {
             self.get_target_arch_from_cargo_rustc(working_dir)?
         };
         debug!("Target architecture for package: {package_name} is: {target_arch}");
-        let target_dir = Self::get_target_dir_from_output(package, output_message_iter)?;
+        let target_dir = Self::get_target_dir_from_output(package, output_message_iter.into_iter())?;
         debug!(
             "Target directory for package: {} is: {}",
             package_name,
             target_dir.display()
         );
 
-        PackageTask::new(
-            PackageTaskParams {
-                package_name,
-                working_dir,
-                target_dir: &target_dir,
-                target_arch: &target_arch,
-                sign_mode: self.sign_mode,
-                sample_class: self.is_sample_class,
-                driver_model,
-            },
+        let package_task_params = PackageTaskParams {
+            package_name,
+            working_dir,
+            target_dir: &target_dir,
+            target_arch: &target_arch,
+            sign_mode: self.sign_mode,
+            sample_class: self.is_sample_class,
+            driver_model,
+        };
+
+        self.package_task_runner.run(
+            &package_task_params,
             self.wdk_build,
             self.command_exec,
             self.fs,
-        )
-        .run()?;
+        )?;
 
         info!("Finished building {package_name}");
         Ok(())