From 595097bf804698ff396c211e32137868bac5b803 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Mon, 29 Sep 2025 19:03:55 +0530 Subject: [PATCH 01/33] feat: use STAMPINF_VERSION for stamping DriverVer when available --- crates/cargo-wdk/src/actions/build/package_task.rs | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index f9985765f..a614e2705 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -313,9 +313,17 @@ impl<'a> PackageTask<'a> { &arch, "-c", &cat_file_path, - "-v", - "*", ]; + + if let Ok(version) = std::env::var("STAMPINF_VERSION") { + // If STAMPINF_VERSION is set we rely on stampinf reading it; do NOT add -v. + // Otherwise we pass -v * (see else) to let stampinf auto-generate the version. + info!("Using STAMPINF_VERSION env var to set DriverVer: {version}"); + } else { + args.push("-v"); + args.push("*"); + } + if !wdf_version_flags.is_empty() { args.append(&mut wdf_version_flags.iter().map(String::as_str).collect()); } From a6b66936e0b91fec1600c712df102c6972bd875b Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Mon, 29 Sep 2025 19:56:59 +0530 Subject: [PATCH 02/33] feat: introduce allow_stampinf_version_env_override cfg and make DriverVer override cfg driven --- .cargo/config.toml | 1 + crates/cargo-wdk/Cargo.toml | 4 ++++ .../src/actions/build/package_task.rs | 22 ++++++++++++++----- 3 files changed, 22 insertions(+), 5 deletions(-) diff --git a/.cargo/config.toml b/.cargo/config.toml index b3ae14c45..c56af9e0a 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -9,4 +9,5 @@ rustflags = [ # Unstable cfg options: # "--cfg", "skip_umdf_static_crt_check", + # "--cfg", "allow_stampinf_version_env_override" ] diff --git a/crates/cargo-wdk/Cargo.toml b/crates/cargo-wdk/Cargo.toml index 1cb7c4d5d..d306a66cf 100644 --- a/crates/cargo-wdk/Cargo.toml +++ b/crates/cargo-wdk/Cargo.toml @@ -36,6 +36,10 @@ sha2.workspace = true missing_docs = "warn" unsafe_op_in_unsafe_fn = "forbid" +[lints.rust.unexpected_cfgs] +level = "warn" +check-cfg = ["cfg(wdk_build_unstable)", "cfg(allow_stampinf_version_env_override)"] + [lints.clippy] # Lint Groups all = "deny" diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index a614e2705..74af48cbb 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -315,11 +315,23 @@ impl<'a> PackageTask<'a> { &cat_file_path, ]; - if let Ok(version) = std::env::var("STAMPINF_VERSION") { - // If STAMPINF_VERSION is set we rely on stampinf reading it; do NOT add -v. - // Otherwise we pass -v * (see else) to let stampinf auto-generate the version. - info!("Using STAMPINF_VERSION env var to set DriverVer: {version}"); - } else { + // DriverVer handling: + // 1. When BOTH cfg flags (wdk_build_unstable + allow_stampinf_version_env_override) are + // enabled, allow an external override via STAMPINF_VERSION env var. If the env var is + // absent we fall back to auto-generation (-v *). + // 2. Otherwise (stable / default builds) always request auto-generation (-v *). + #[cfg(all(wdk_build_unstable, allow_stampinf_version_env_override))] + { + if let Ok(version) = std::env::var("STAMPINF_VERSION") { + // Rely on stampinf reading STAMPINF_VERSION; do NOT add -v. + info!("Using STAMPINF_VERSION env var to set DriverVer: {version}"); + } else { + args.push("-v"); + args.push("*"); + } + } + #[cfg(not(all(wdk_build_unstable, allow_stampinf_version_env_override)))] + { args.push("-v"); args.push("*"); } From a958433afa4e43c68a01c2c0a955bd108cd3d0eb Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Mon, 29 Sep 2025 22:28:41 +0530 Subject: [PATCH 03/33] test: add parameterized test for run_stampinf with env overrides --- .../src/actions/build/package_task.rs | 73 +++++++++++++++++++ 1 file changed, 73 insertions(+) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 74af48cbb..9c97ca652 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -651,4 +651,77 @@ mod tests { PackageTask::new(package_task_params, &wdk_build, &command_exec, &fs); } + + // Parameterized test for run_stampinf covering env present/absent. + // Compile-time cfgs determine expectation via cfg! so a single test body suffices. + #[test] + fn run_stampinf_parameterized_env_overrides() { + use std::process::{ExitStatus, Output}; + + let scenarios = [("env_set", Some("1.2.3.4")), ("env_unset", None)]; + + let both_cfgs = cfg!(all(wdk_build_unstable, allow_stampinf_version_env_override)); + + for (name, env_val) in scenarios { + if let Some(v) = env_val { + std::env::set_var("STAMPINF_VERSION", v); + } else { + std::env::remove_var("STAMPINF_VERSION"); + } + + let package_name = "param_pkg"; // reuse + let working_dir = PathBuf::from("C:/abs/wd"); + let target_dir = PathBuf::from("C:/abs/target"); + let arch = CpuArchitecture::Amd64; + + let params = PackageTaskParams { + package_name, + working_dir: &working_dir, + target_dir: &target_dir, + target_arch: &arch, + driver_model: DriverConfig::Kmdf(KmdfConfig::default()), + sample_class: false, + verify_signature: false, + }; + + let wdk_build = WdkBuild::default(); + let fs = Fs::default(); + let mut command_exec = CommandExec::default(); + + let expect_skip_v = env_val.is_some() && both_cfgs; // skip -v only in override path + + command_exec + .expect_run() + .withf(move |cmd: &str, args: &[&str], _, _| { + if cmd != "stampinf" { + return false; + } + let has_v = args.contains(&"-v"); + if expect_skip_v { + !has_v + } else { + args.windows(2).any(|w| w == ["-v", "*"]) + } + }) + .once() + .return_once(|_, _, _, _| { + Ok(Output { + status: ExitStatus::default(), + stdout: vec![], + stderr: vec![], + }) + }); + + let task = PackageTask::new(params, &wdk_build, &command_exec, &fs); + let result = task.run_stampinf(); + assert!( + result.is_ok(), + "scenario {name} failed (cfgs_override_enabled={both_cfgs}, env_set={:?})", + env_val + ); + } + + // Cleanup + std::env::remove_var("STAMPINF_VERSION"); + } } From 0e67838173d1d9441950ba8906ec07c46d193198 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 30 Sep 2025 08:56:37 +0530 Subject: [PATCH 04/33] refactor: improve comments and formatting in run_stampinf function and its tests --- .../cargo-wdk/src/actions/build/package_task.rs | 16 +++++++++------- 1 file changed, 9 insertions(+), 7 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 9c97ca652..35d703c2f 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -316,14 +316,16 @@ impl<'a> PackageTask<'a> { ]; // DriverVer handling: - // 1. When BOTH cfg flags (wdk_build_unstable + allow_stampinf_version_env_override) are - // enabled, allow an external override via STAMPINF_VERSION env var. If the env var is - // absent we fall back to auto-generation (-v *). + // 1. When BOTH cfg flags (wdk_build_unstable + + // allow_stampinf_version_env_override) are enabled, allow an external + // override via STAMPINF_VERSION env var. If the env var is absent we fall + // back to auto-generation (-v *). // 2. Otherwise (stable / default builds) always request auto-generation (-v *). #[cfg(all(wdk_build_unstable, allow_stampinf_version_env_override))] { if let Ok(version) = std::env::var("STAMPINF_VERSION") { - // Rely on stampinf reading STAMPINF_VERSION; do NOT add -v. + // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it + // and populates DriverVer. info!("Using STAMPINF_VERSION env var to set DriverVer: {version}"); } else { args.push("-v"); @@ -653,7 +655,8 @@ mod tests { } // Parameterized test for run_stampinf covering env present/absent. - // Compile-time cfgs determine expectation via cfg! so a single test body suffices. + // Compile-time cfgs determine expectation via cfg! so a single test body + // suffices. #[test] fn run_stampinf_parameterized_env_overrides() { use std::process::{ExitStatus, Output}; @@ -716,8 +719,7 @@ mod tests { let result = task.run_stampinf(); assert!( result.is_ok(), - "scenario {name} failed (cfgs_override_enabled={both_cfgs}, env_set={:?})", - env_val + "scenario {name} failed (cfgs_override_enabled={both_cfgs}, env_set={env_val:?})" ); } From d952b486854ce3ad5fe91dcceeffa7422b6fe9ed Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 30 Sep 2025 09:38:18 +0530 Subject: [PATCH 05/33] refactor: update package name and working directory in run_stampinf test --- crates/cargo-wdk/src/actions/build/package_task.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 35d703c2f..6d454ac0b 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -672,9 +672,9 @@ mod tests { std::env::remove_var("STAMPINF_VERSION"); } - let package_name = "param_pkg"; // reuse - let working_dir = PathBuf::from("C:/abs/wd"); - let target_dir = PathBuf::from("C:/abs/target"); + let package_name = "driver"; // reuse + let working_dir = PathBuf::from("C:/abs/driver"); + let target_dir = PathBuf::from("C:/abs/target/debug"); let arch = CpuArchitecture::Amd64; let params = PackageTaskParams { From 2355f0d8411bd3ec52b6f769cf7ca657b6dabf7c Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 30 Sep 2025 11:04:10 +0530 Subject: [PATCH 06/33] style: format check-cfg section for better readability in Cargo.toml --- crates/cargo-wdk/Cargo.toml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/crates/cargo-wdk/Cargo.toml b/crates/cargo-wdk/Cargo.toml index d306a66cf..6b7e8e9da 100644 --- a/crates/cargo-wdk/Cargo.toml +++ b/crates/cargo-wdk/Cargo.toml @@ -38,7 +38,10 @@ unsafe_op_in_unsafe_fn = "forbid" [lints.rust.unexpected_cfgs] level = "warn" -check-cfg = ["cfg(wdk_build_unstable)", "cfg(allow_stampinf_version_env_override)"] +check-cfg = [ + "cfg(wdk_build_unstable)", + "cfg(allow_stampinf_version_env_override)", +] [lints.clippy] # Lint Groups From 0c8e516f8fa3ad1f21bda8dd0a657bb7072b1a28 Mon Sep 17 00:00:00 2001 From: Krishna Kumar Thokala Date: Wed, 1 Oct 2025 22:05:56 +0530 Subject: [PATCH 07/33] Update crates/cargo-wdk/src/actions/build/package_task.rs remove redundant comment Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Krishna Kumar Thokala --- crates/cargo-wdk/src/actions/build/package_task.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 6d454ac0b..6b86b69aa 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -672,7 +672,7 @@ mod tests { std::env::remove_var("STAMPINF_VERSION"); } - let package_name = "driver"; // reuse + let package_name = "driver"; let working_dir = PathBuf::from("C:/abs/driver"); let target_dir = PathBuf::from("C:/abs/target/debug"); let arch = CpuArchitecture::Amd64; From e5edc09d8c7c95af05e74ad4f7cd827b6b9515fe Mon Sep 17 00:00:00 2001 From: Krishna Kumar Thokala Date: Wed, 1 Oct 2025 22:08:11 +0530 Subject: [PATCH 08/33] Update crates/cargo-wdk/src/actions/build/package_task.rs Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> Signed-off-by: Krishna Kumar Thokala --- crates/cargo-wdk/src/actions/build/package_task.rs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 6b86b69aa..073990c39 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -655,8 +655,7 @@ mod tests { } // Parameterized test for run_stampinf covering env present/absent. - // Compile-time cfgs determine expectation via cfg! so a single test body - // suffices. + // Uses compile-time cfg checks to determine expected behavior, allowing a single test body to handle all scenarios. #[test] fn run_stampinf_parameterized_env_overrides() { use std::process::{ExitStatus, Output}; From bf82cd649643c9df5a44725bc02d25c70935300e Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 1 Oct 2025 19:36:20 +0530 Subject: [PATCH 09/33] feat: add cfg-if dependency and refactor run_stampinf for improved cfg handling --- Cargo.lock | 1 + crates/cargo-wdk/Cargo.toml | 1 + .../src/actions/build/package_task.rs | 31 +++++++++---------- 3 files changed, 17 insertions(+), 16 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b126e243e..bb9801d49 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -176,6 +176,7 @@ dependencies = [ "assert_cmd", "assert_fs", "cargo_metadata", + "cfg-if", "clap", "clap-verbosity-flag", "fs4", diff --git a/crates/cargo-wdk/Cargo.toml b/crates/cargo-wdk/Cargo.toml index 6b7e8e9da..8f136027f 100644 --- a/crates/cargo-wdk/Cargo.toml +++ b/crates/cargo-wdk/Cargo.toml @@ -14,6 +14,7 @@ categories = ["command-line-utilities", "development-tools::cargo-plugins"] [dependencies] anyhow.workspace = true cargo_metadata.workspace = true +cfg-if.workspace = true clap = { workspace = true, features = ["derive"] } clap-verbosity-flag.workspace = true fs4.workspace = true diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 073990c39..648137765 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -316,27 +316,26 @@ impl<'a> PackageTask<'a> { ]; // DriverVer handling: - // 1. When BOTH cfg flags (wdk_build_unstable + - // allow_stampinf_version_env_override) are enabled, allow an external + // 1. When allow_stampinf_version_env_override cfg is enabled, allow an external // override via STAMPINF_VERSION env var. If the env var is absent we fall // back to auto-generation (-v *). // 2. Otherwise (stable / default builds) always request auto-generation (-v *). - #[cfg(all(wdk_build_unstable, allow_stampinf_version_env_override))] - { - if let Ok(version) = std::env::var("STAMPINF_VERSION") { - // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it - // and populates DriverVer. - info!("Using STAMPINF_VERSION env var to set DriverVer: {version}"); + cfg_if::cfg_if! { + if #[cfg(allow_stampinf_version_env_override)] + { + if let Ok(version) = std::env::var("STAMPINF_VERSION") { + // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it + // and populates DriverVer. + info!("Using STAMPINF_VERSION env var to set DriverVer: {version}"); + } else { + args.push("-v"); + args.push("*"); + } } else { args.push("-v"); args.push("*"); } } - #[cfg(not(all(wdk_build_unstable, allow_stampinf_version_env_override)))] - { - args.push("-v"); - args.push("*"); - } if !wdf_version_flags.is_empty() { args.append(&mut wdf_version_flags.iter().map(String::as_str).collect()); @@ -662,7 +661,7 @@ mod tests { let scenarios = [("env_set", Some("1.2.3.4")), ("env_unset", None)]; - let both_cfgs = cfg!(all(wdk_build_unstable, allow_stampinf_version_env_override)); + let is_cfg_set = cfg!(allow_stampinf_version_env_override); for (name, env_val) in scenarios { if let Some(v) = env_val { @@ -690,7 +689,7 @@ mod tests { let fs = Fs::default(); let mut command_exec = CommandExec::default(); - let expect_skip_v = env_val.is_some() && both_cfgs; // skip -v only in override path + let expect_skip_v = env_val.is_some() && is_cfg_set; // skip -v only in override path command_exec .expect_run() @@ -718,7 +717,7 @@ mod tests { let result = task.run_stampinf(); assert!( result.is_ok(), - "scenario {name} failed (cfgs_override_enabled={both_cfgs}, env_set={env_val:?})" + "scenario {name} failed (cfgs_override_enabled={is_cfg_set}, env_set={env_val:?})" ); } From a0e8e08fb1625f1fe79d220314f3520e13b14ac7 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 1 Oct 2025 22:18:49 +0530 Subject: [PATCH 10/33] fix: improve STAMPINF_VERSION handling and update target directory in run_stampinf test --- crates/cargo-wdk/src/actions/build/package_task.rs | 10 ++++------ 1 file changed, 4 insertions(+), 6 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 648137765..fa6340c0c 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -323,17 +323,15 @@ impl<'a> PackageTask<'a> { cfg_if::cfg_if! { if #[cfg(allow_stampinf_version_env_override)] { - if let Ok(version) = std::env::var("STAMPINF_VERSION") { + if let Ok(version) = std::env::var("STAMPINF_VERSION") && !version.trim().is_empty() { // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it // and populates DriverVer. info!("Using STAMPINF_VERSION env var to set DriverVer: {version}"); } else { - args.push("-v"); - args.push("*"); + args.extend(["-v", "*"]); } } else { - args.push("-v"); - args.push("*"); + args.extend(["-v", "*"]); } } @@ -672,7 +670,7 @@ mod tests { let package_name = "driver"; let working_dir = PathBuf::from("C:/abs/driver"); - let target_dir = PathBuf::from("C:/abs/target/debug"); + let target_dir = PathBuf::from("C:/abs/driver/target/debug"); let arch = CpuArchitecture::Amd64; let params = PackageTaskParams { From f366e22e8c08405b235c3ef047ab1ade4d22dfd6 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 1 Oct 2025 22:42:28 +0530 Subject: [PATCH 11/33] test: rename and enhance run_stampinf test for clarity and environment variable handling --- crates/cargo-wdk/src/actions/build/package_task.rs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index fa6340c0c..6edd8d832 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -651,14 +651,15 @@ mod tests { PackageTask::new(package_task_params, &wdk_build, &command_exec, &fs); } - // Parameterized test for run_stampinf covering env present/absent. - // Uses compile-time cfg checks to determine expected behavior, allowing a single test body to handle all scenarios. #[test] - fn run_stampinf_parameterized_env_overrides() { + fn stampinf_version_overrides_with_env_var() { use std::process::{ExitStatus, Output}; + // verify both with and without the env var set scenarios let scenarios = [("env_set", Some("1.2.3.4")), ("env_unset", None)]; + // Compile-time evaluation: cfg!(...) => true only if + // `allow_stampinf_version_env_override` was enabled during build let is_cfg_set = cfg!(allow_stampinf_version_env_override); for (name, env_val) in scenarios { From affb3ee44ba9e42ad846e608b6de6358a2da2505 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Mon, 6 Oct 2025 21:26:22 +0530 Subject: [PATCH 12/33] refactor: remove cfg-if dependency and streamline STAMPINF_VERSION handling in run_stampinf --- .cargo/config.toml | 1 - Cargo.lock | 1 - crates/cargo-wdk/Cargo.toml | 8 ---- .../src/actions/build/package_task.rs | 45 ++++++++----------- 4 files changed, 18 insertions(+), 37 deletions(-) diff --git a/.cargo/config.toml b/.cargo/config.toml index c56af9e0a..b3ae14c45 100644 --- a/.cargo/config.toml +++ b/.cargo/config.toml @@ -9,5 +9,4 @@ rustflags = [ # Unstable cfg options: # "--cfg", "skip_umdf_static_crt_check", - # "--cfg", "allow_stampinf_version_env_override" ] diff --git a/Cargo.lock b/Cargo.lock index bb9801d49..b126e243e 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -176,7 +176,6 @@ dependencies = [ "assert_cmd", "assert_fs", "cargo_metadata", - "cfg-if", "clap", "clap-verbosity-flag", "fs4", diff --git a/crates/cargo-wdk/Cargo.toml b/crates/cargo-wdk/Cargo.toml index 8f136027f..1cb7c4d5d 100644 --- a/crates/cargo-wdk/Cargo.toml +++ b/crates/cargo-wdk/Cargo.toml @@ -14,7 +14,6 @@ categories = ["command-line-utilities", "development-tools::cargo-plugins"] [dependencies] anyhow.workspace = true cargo_metadata.workspace = true -cfg-if.workspace = true clap = { workspace = true, features = ["derive"] } clap-verbosity-flag.workspace = true fs4.workspace = true @@ -37,13 +36,6 @@ sha2.workspace = true missing_docs = "warn" unsafe_op_in_unsafe_fn = "forbid" -[lints.rust.unexpected_cfgs] -level = "warn" -check-cfg = [ - "cfg(wdk_build_unstable)", - "cfg(allow_stampinf_version_env_override)", -] - [lints.clippy] # Lint Groups all = "deny" diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 6edd8d832..1dd6465ec 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -26,6 +26,7 @@ use crate::{actions::build::error::PackageTaskError, providers::error::FileError const MISSING_SAMPLE_FLAG_WDK_BUILD_NUMBER_RANGE: RangeFrom = 25798..; const WDR_TEST_CERT_STORE: &str = "WDRTestCertStore"; const WDR_LOCAL_TEST_CERT: &str = "WDRLocalTestCert"; +const STAMPINF_VERSION_ENV_VAR: &str = "STAMPINF_VERSION"; #[derive(Debug)] pub struct PackageTaskParams<'a> { @@ -315,22 +316,13 @@ impl<'a> PackageTask<'a> { &cat_file_path, ]; - // DriverVer handling: - // 1. When allow_stampinf_version_env_override cfg is enabled, allow an external - // override via STAMPINF_VERSION env var. If the env var is absent we fall - // back to auto-generation (-v *). - // 2. Otherwise (stable / default builds) always request auto-generation (-v *). - cfg_if::cfg_if! { - if #[cfg(allow_stampinf_version_env_override)] - { - if let Ok(version) = std::env::var("STAMPINF_VERSION") && !version.trim().is_empty() { - // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it - // and populates DriverVer. - info!("Using STAMPINF_VERSION env var to set DriverVer: {version}"); - } else { - args.extend(["-v", "*"]); - } - } else { + match std::env::var(STAMPINF_VERSION_ENV_VAR) { + Ok(version) if !version.trim().is_empty() => { + // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it + // and populates DriverVer. + info!("Using {STAMPINF_VERSION_ENV_VAR} env var to set DriverVer: {version}"); + } + _ => { args.extend(["-v", "*"]); } } @@ -656,17 +648,18 @@ mod tests { use std::process::{ExitStatus, Output}; // verify both with and without the env var set scenarios - let scenarios = [("env_set", Some("1.2.3.4")), ("env_unset", None)]; - - // Compile-time evaluation: cfg!(...) => true only if - // `allow_stampinf_version_env_override` was enabled during build - let is_cfg_set = cfg!(allow_stampinf_version_env_override); + let scenarios = [ + ("env_set", Some("1.2.3.4"), true), + ("env_empty", Some(""), false), + ("env_spaces", Some(" "), false), + ("env_unset", None, false), + ]; - for (name, env_val) in scenarios { + for (name, env_val, expect_skip_v) in scenarios { if let Some(v) = env_val { - std::env::set_var("STAMPINF_VERSION", v); + std::env::set_var(STAMPINF_VERSION_ENV_VAR, v); } else { - std::env::remove_var("STAMPINF_VERSION"); + std::env::remove_var(STAMPINF_VERSION_ENV_VAR); } let package_name = "driver"; @@ -688,8 +681,6 @@ mod tests { let fs = Fs::default(); let mut command_exec = CommandExec::default(); - let expect_skip_v = env_val.is_some() && is_cfg_set; // skip -v only in override path - command_exec .expect_run() .withf(move |cmd: &str, args: &[&str], _, _| { @@ -716,7 +707,7 @@ mod tests { let result = task.run_stampinf(); assert!( result.is_ok(), - "scenario {name} failed (cfgs_override_enabled={is_cfg_set}, env_set={env_val:?})" + "scenario {name} failed (env_set={env_val:?})" ); } From aa9872f446d0c861b6232d9f7a51e53375288531 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Mon, 6 Oct 2025 22:29:26 +0530 Subject: [PATCH 13/33] test: refactor stampinf_version_overrides_with_env_var test and add with_env utility function --- .../src/actions/build/package_task.rs | 157 ++++++++++++------ 1 file changed, 108 insertions(+), 49 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 1dd6465ec..eb807388d 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -524,8 +524,12 @@ impl<'a> PackageTask<'a> { } #[cfg(test)] mod tests { + use std::collections::HashMap; + use std::ffi::OsStr; use std::path::PathBuf; + use std::process::{ExitStatus, Output}; + use std::sync::Mutex; use wdk_build::{CpuArchitecture, KmdfConfig}; use super::*; @@ -645,8 +649,6 @@ mod tests { #[test] fn stampinf_version_overrides_with_env_var() { - use std::process::{ExitStatus, Output}; - // verify both with and without the env var set scenarios let scenarios = [ ("env_set", Some("1.2.3.4"), true), @@ -656,55 +658,52 @@ mod tests { ]; for (name, env_val, expect_skip_v) in scenarios { - if let Some(v) = env_val { - std::env::set_var(STAMPINF_VERSION_ENV_VAR, v); - } else { - std::env::remove_var(STAMPINF_VERSION_ENV_VAR); - } - - let package_name = "driver"; - let working_dir = PathBuf::from("C:/abs/driver"); - let target_dir = PathBuf::from("C:/abs/driver/target/debug"); - let arch = CpuArchitecture::Amd64; - - let params = PackageTaskParams { - package_name, - working_dir: &working_dir, - target_dir: &target_dir, - target_arch: &arch, - driver_model: DriverConfig::Kmdf(KmdfConfig::default()), - sample_class: false, - verify_signature: false, - }; - - let wdk_build = WdkBuild::default(); - let fs = Fs::default(); - let mut command_exec = CommandExec::default(); - - command_exec - .expect_run() - .withf(move |cmd: &str, args: &[&str], _, _| { - if cmd != "stampinf" { - return false; - } - let has_v = args.contains(&"-v"); - if expect_skip_v { - !has_v - } else { - args.windows(2).any(|w| w == ["-v", "*"]) - } - }) - .once() - .return_once(|_, _, _, _| { - Ok(Output { - status: ExitStatus::default(), - stdout: vec![], - stderr: vec![], + let result = with_env(&[(STAMPINF_VERSION_ENV_VAR, env_val)], || { + let package_name = "driver"; + let working_dir = PathBuf::from("C:/abs/driver"); + let target_dir = PathBuf::from("C:/abs/driver/target/debug"); + let arch = CpuArchitecture::Amd64; + + let params = PackageTaskParams { + package_name, + working_dir: &working_dir, + target_dir: &target_dir, + target_arch: &arch, + driver_model: DriverConfig::Kmdf(KmdfConfig::default()), + sample_class: false, + verify_signature: false, + }; + + let wdk_build = WdkBuild::default(); + let fs = Fs::default(); + let mut command_exec = CommandExec::default(); + + command_exec + .expect_run() + .withf(move |cmd: &str, args: &[&str], _, _| { + if cmd != "stampinf" { + return false; + } + let has_v = args.contains(&"-v"); + if expect_skip_v { + !has_v + } else { + args.windows(2).any(|w| w == ["-v", "*"]) + } }) - }); + .once() + .return_once(|_, _, _, _| { + Ok(Output { + status: ExitStatus::default(), + stdout: vec![], + stderr: vec![], + }) + }); + + let task = PackageTask::new(params, &wdk_build, &command_exec, &fs); + task.run_stampinf() + }); - let task = PackageTask::new(params, &wdk_build, &command_exec, &fs); - let result = task.run_stampinf(); assert!( result.is_ok(), "scenario {name} failed (env_set={env_val:?})" @@ -714,4 +713,64 @@ mod tests { // Cleanup std::env::remove_var("STAMPINF_VERSION"); } + + /// Runs function after modifying environment variables, and returns the + /// function's return value. + /// + /// The environment is guaranteed to be not modified during the execution + /// of the function, and the environment is reset to its original state + /// after execution of the function. No testing asserts should be called in + /// the function, since a failing test will poison the mutex, and cause all + /// remaining tests to fail. + /// + /// # Panics + /// + /// Panics if called with duplicate environment variable keys. + pub fn with_env(env_vars_key_value_pairs: &[(K, Option)], f: F) -> R + where + K: AsRef + std::cmp::Eq + std::hash::Hash, + V: AsRef, + F: FnOnce() -> R, + { + // Tests can execute in multiple threads in the same process, so mutex must be + // used to guard access to the environment variables + static ENV_MUTEX: Mutex<()> = Mutex::new(()); + + let _mutex_guard = ENV_MUTEX.lock().unwrap(); + let mut original_env_vars = HashMap::new(); + + // set requested environment variables + for (key, value) in env_vars_key_value_pairs { + if let Ok(original_value) = std::env::var(key) { + let insert_result = original_env_vars.insert(key, original_value); + assert!( + insert_result.is_none(), + "Duplicate environment variable keys were provided" + ); + } + + // Remove the env var if value is None + if let Some(value) = value { + std::env::set_var(key, value); + } else { + std::env::remove_var(key); + } + } + + let f_return_value = f(); + + // reset all set environment variables + for (key, _) in env_vars_key_value_pairs { + original_env_vars.get(key).map_or_else( + || { + std::env::remove_var(key); + }, + |value| { + std::env::set_var(key, value); + }, + ); + } + + f_return_value + } } From a45f04cca95d9e649aea72b6aace12e6541000a6 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Mon, 6 Oct 2025 22:50:54 +0530 Subject: [PATCH 14/33] refactor(tests): reorganize imports for clarity and consistency in package_task tests --- crates/cargo-wdk/src/actions/build/package_task.rs | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index eb807388d..cc6604783 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -524,12 +524,14 @@ impl<'a> PackageTask<'a> { } #[cfg(test)] mod tests { - use std::collections::HashMap; - use std::ffi::OsStr; - use std::path::PathBuf; + use std::{ + collections::HashMap, + ffi::OsStr, + path::PathBuf, + process::{ExitStatus, Output}, + sync::Mutex, + }; - use std::process::{ExitStatus, Output}; - use std::sync::Mutex; use wdk_build::{CpuArchitecture, KmdfConfig}; use super::*; From 5ee57828691eadd9c746b8d5fac771a5981f16c8 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Mon, 6 Oct 2025 23:46:28 +0530 Subject: [PATCH 15/33] feat(tests): add regex dependency and enhance driver build tests with cleanup functionality --- Cargo.lock | 1 + crates/cargo-wdk/Cargo.toml | 1 + crates/cargo-wdk/tests/build_command_test.rs | 27 +++++++++++++++++--- 3 files changed, 25 insertions(+), 4 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index b126e243e..61779f9f4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -183,6 +183,7 @@ dependencies = [ "mockall", "mockall_double", "predicates", + "regex", "serde_json", "sha2", "thiserror", diff --git a/crates/cargo-wdk/Cargo.toml b/crates/cargo-wdk/Cargo.toml index 1cb7c4d5d..1696c8912 100644 --- a/crates/cargo-wdk/Cargo.toml +++ b/crates/cargo-wdk/Cargo.toml @@ -29,6 +29,7 @@ wdk-build.workspace = true [dev-dependencies] assert_cmd.workspace = true assert_fs.workspace = true +regex.workspace = true predicates.workspace = true sha2.workspace = true diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index ba3f733c1..e61add03f 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -58,17 +58,17 @@ fn kmdf_driver_builds_successfully() { assert!(output.status.success()); } - with_file_lock(|| build_driver_project("kmdf")); + with_file_lock(|| clean_and_build_driver_project("kmdf")); } #[test] fn umdf_driver_builds_successfully() { - with_file_lock(|| build_driver_project("umdf")); + with_file_lock(|| clean_and_build_driver_project("umdf")); } #[test] fn wdm_driver_builds_successfully() { - with_file_lock(|| build_driver_project("wdm")); + with_file_lock(|| clean_and_build_driver_project("wdm")); } #[test] @@ -94,10 +94,11 @@ fn emulated_workspace_builds_successfully() { }); } -fn build_driver_project(driver_type: &str) { +fn clean_and_build_driver_project(driver_type: &str) { let driver_name = format!("{driver_type}-driver"); let driver_path = format!("tests/{driver_name}"); + run_clean_cmd(&driver_path); let stdout = run_build_cmd(&driver_path); assert!(stdout.contains(&format!("Processing completed for package: {driver_name}"))); @@ -111,6 +112,12 @@ fn build_driver_project(driver_type: &str) { verify_driver_package_files(&driver_path, &driver_name, driver_binary_extension); } +fn run_clean_cmd(driver_path: &str) { + let mut cmd = Command::new("cargo"); + cmd.args(["clean"]).current_dir(driver_path); + cmd.assert().success(); +} + fn run_build_cmd(driver_path: &str) -> String { set_crt_static_flag(); @@ -157,6 +164,18 @@ fn verify_driver_package_files( &format!("{package_path}/WDRLocalTestCert.cer"), &format!("{debug_folder_path}/WDRLocalTestCert.cer"), ); + + fs::read_to_string(format!("{package_path}/{driver_name}.inf")) + .expect("Unable to read inf file") + .lines() + .for_each(|line| { + // Example: DriverVer=09/13/2023,1.0.0.0 + let re = + regex::Regex::new(r"^DriverVer\s+=\s+\d+/\d+/\d+,\d+\.\d+\.\d+\.\d+$").unwrap(); + if line.starts_with("DriverVer") { + assert!(re.captures(line).is_some()); + } + }); } fn assert_dir_exists(path: &str) { From 9fba0d65d04f3275db9c4893596c0015320235a9 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 7 Oct 2025 00:56:00 +0530 Subject: [PATCH 16/33] refactor(tests): enhance with_file_lock to support environment variable management in tests --- crates/cargo-wdk/tests/build_command_test.rs | 69 ++++++++++++++------ crates/cargo-wdk/tests/common.rs | 33 +++++++++- crates/cargo-wdk/tests/new_command_test.rs | 4 +- 3 files changed, 82 insertions(+), 24 deletions(-) diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 3dff9cdd5..89a7b4f2c 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -11,14 +11,16 @@ use assert_cmd::prelude::*; use common::{set_crt_static_flag, with_file_lock}; use sha2::{Digest, Sha256}; +const STAMPINF_VERSION_ENV_VAR: &str = "STAMPINF_VERSION"; + #[test] fn mixed_package_kmdf_workspace_builds_successfully() { - with_file_lock(|| { + with_file_lock::<&str, &str, _>(&[], || { let stdout = run_build_cmd("tests/mixed-package-kmdf-workspace"); assert!(stdout.contains("Building package driver")); assert!(stdout.contains("Building package non_driver_crate")); - verify_driver_package_files("tests/mixed-package-kmdf-workspace", "driver", "sys"); + verify_driver_package_files("tests/mixed-package-kmdf-workspace", "driver", "sys", None); }); } @@ -54,22 +56,29 @@ fn kmdf_driver_builds_successfully() { assert!(output.status.success()); } - with_file_lock(|| clean_and_build_driver_project("kmdf")); + with_file_lock::<&str, &str, _>(&[], || clean_and_build_driver_project("kmdf", None)); } #[test] fn umdf_driver_builds_successfully() { - with_file_lock(|| clean_and_build_driver_project("umdf")); + with_file_lock::<&str, &str, _>(&[], || clean_and_build_driver_project("umdf", None)); } #[test] fn wdm_driver_builds_successfully() { - with_file_lock(|| clean_and_build_driver_project("wdm")); + with_file_lock::<&str, &str, _>(&[], || clean_and_build_driver_project("wdm", None)); +} + +#[test] +fn wdm_driver_builds_successfully_with_given_version() { + with_file_lock::<&str, &str, _>(&[(STAMPINF_VERSION_ENV_VAR, "5.1.0")], || { + clean_and_build_driver_project("wdm", Some("5.1.0.0")); + }); } #[test] fn emulated_workspace_builds_successfully() { - with_file_lock(|| { + with_file_lock::<&str, &str, _>(&[], || { let emulated_workspace_path = "tests/emulated-workspace"; let stdout = run_build_cmd(emulated_workspace_path); @@ -78,12 +87,12 @@ fn emulated_workspace_builds_successfully() { assert!(stdout.contains("Build completed successfully")); let umdf_driver_workspace_path = format!("{emulated_workspace_path}/umdf-driver-workspace"); - verify_driver_package_files(&umdf_driver_workspace_path, "driver_1", "dll"); - verify_driver_package_files(&umdf_driver_workspace_path, "driver_2", "dll"); + verify_driver_package_files(&umdf_driver_workspace_path, "driver_1", "dll", None); + verify_driver_package_files(&umdf_driver_workspace_path, "driver_2", "dll", None); }); } -fn clean_and_build_driver_project(driver_type: &str) { +fn clean_and_build_driver_project(driver_type: &str, driver_version: Option<&str>) { let driver_name = format!("{driver_type}-driver"); let driver_path = format!("tests/{driver_name}"); @@ -98,7 +107,12 @@ fn clean_and_build_driver_project(driver_type: &str) { _ => panic!("Unsupported driver type: {driver_type}"), }; - verify_driver_package_files(&driver_path, &driver_name, driver_binary_extension); + verify_driver_package_files( + &driver_path, + &driver_name, + driver_binary_extension, + driver_version, + ); } fn run_clean_cmd(driver_path: &str) { @@ -124,6 +138,7 @@ fn verify_driver_package_files( driver_or_workspace_path: &str, driver_name: &str, driver_binary_extension: &str, + driver_version: Option<&str>, ) { let driver_name = driver_name.replace('-', "_"); let debug_folder_path = format!("{driver_or_workspace_path}/target/debug"); @@ -154,17 +169,7 @@ fn verify_driver_package_files( &format!("{debug_folder_path}/WDRLocalTestCert.cer"), ); - fs::read_to_string(format!("{package_path}/{driver_name}.inf")) - .expect("Unable to read inf file") - .lines() - .for_each(|line| { - // Example: DriverVer=09/13/2023,1.0.0.0 - let re = - regex::Regex::new(r"^DriverVer\s+=\s+\d+/\d+/\d+,\d+\.\d+\.\d+\.\d+$").unwrap(); - if line.starts_with("DriverVer") { - assert!(re.captures(line).is_some()); - } - }); + assert_driver_ver(&package_path, &driver_name, driver_version); } fn assert_dir_exists(path: &str) { @@ -194,6 +199,28 @@ fn assert_file_hash(path1: &str, path2: &str) { ); } +fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Option<&str>) { + fs::read_to_string(format!("{package_path}/{driver_name}.inf")) + .expect("Unable to read inf file") + .lines() + .for_each(|line| { + // Example: DriverVer=09/13/2023,1.0.0.0 + let driver_version_regex = if let Some(version) = driver_version { + version + } else { + r"\d+\.\d+\.\d+\.\d+" + }; + + let re = regex::Regex::new(&format!( + r"^DriverVer\s+=\s+\d+/\d+/\d+,{driver_version_regex}$" + )) + .unwrap(); + if line.starts_with("DriverVer") { + assert!(re.captures(line).is_some()); + } + }); +} + // Helper to hash a file fn digest_file>(path: P) -> String { let file_contents = fs::read(path).expect("Failed to read file"); diff --git a/crates/cargo-wdk/tests/common.rs b/crates/cargo-wdk/tests/common.rs index 345bdfeda..09def77eb 100644 --- a/crates/cargo-wdk/tests/common.rs +++ b/crates/cargo-wdk/tests/common.rs @@ -2,6 +2,8 @@ #![allow(clippy::literal_string_with_formatting_args)] +use std::{collections::HashMap, ffi::OsStr}; + use fs4::fs_std::FileExt; /// Sets the `RUSTFLAGS` environment variable to include `+crt-static`. @@ -33,13 +35,42 @@ pub fn set_crt_static_flag() { /// * Panics if the lock file cannot be created. /// * Panics if the lock cannot be acquired. /// * Panics if the lock cannot be released. -pub fn with_file_lock(f: F) +pub fn with_file_lock(env_vars_key_value_pairs: &[(K, V)], f: F) where + K: AsRef + std::cmp::Eq + std::hash::Hash, + V: AsRef, F: FnOnce(), { let lock_file = std::fs::File::create("cargo-wdk-test.lock") .expect("Unable to create lock file for cargo-wdk tests"); FileExt::lock_exclusive(&lock_file).expect("Unable to cargo-wdk-test.lock file"); + let mut original_env_vars = HashMap::new(); + + // set requested environment variables + for (key, value) in env_vars_key_value_pairs { + if let Ok(original_value) = std::env::var(key) { + let insert_result = original_env_vars.insert(key, original_value); + assert!( + insert_result.is_none(), + "Duplicate environment variable keys were provided" + ); + } + + std::env::set_var(key, value); + } + f(); + + // reset all set environment variables + for (key, _) in env_vars_key_value_pairs { + original_env_vars.get(key).map_or_else( + || { + std::env::remove_var(key); + }, + |value| { + std::env::set_var(key, value); + }, + ); + } FileExt::unlock(&lock_file).expect("Unable to unlock cargo-wdk-test.lock file"); } diff --git a/crates/cargo-wdk/tests/new_command_test.rs b/crates/cargo-wdk/tests/new_command_test.rs index 6821ce392..0beb8c726 100644 --- a/crates/cargo-wdk/tests/new_command_test.rs +++ b/crates/cargo-wdk/tests/new_command_test.rs @@ -60,7 +60,7 @@ fn help_works() { } fn project_is_created(driver_type: &str) { - with_file_lock(|| { + with_file_lock::<&str, &str, _>(&[], || { let (stdout, _stderr) = create_and_build_new_driver_project(driver_type); assert!(stdout.contains( "Required directive Provider missing, empty, or invalid in [Version] section." @@ -79,7 +79,7 @@ fn test_command_invocation( command_succeeds: bool, assert: F, ) { - with_file_lock(|| { + with_file_lock::<&str, &str, _>(&[], || { let mut args = args .iter() .map(ToString::to_string) From b121954a001091aa411a1c36f05bf56b90eff449 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 7 Oct 2025 02:07:18 +0530 Subject: [PATCH 17/33] refactor(tests): improve test setup by adding clean command execution for driver builds --- crates/cargo-wdk/Cargo.toml | 2 +- crates/cargo-wdk/tests/build_command_test.rs | 38 ++++++++++---------- 2 files changed, 19 insertions(+), 21 deletions(-) diff --git a/crates/cargo-wdk/Cargo.toml b/crates/cargo-wdk/Cargo.toml index db9cc1968..39570ea89 100644 --- a/crates/cargo-wdk/Cargo.toml +++ b/crates/cargo-wdk/Cargo.toml @@ -30,8 +30,8 @@ wdk-build.workspace = true [dev-dependencies] assert_cmd.workspace = true assert_fs.workspace = true -regex.workspace = true predicates.workspace = true +regex.workspace = true sha2.workspace = true [lints.rust] diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 89a7b4f2c..60bc9df7e 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -16,6 +16,7 @@ const STAMPINF_VERSION_ENV_VAR: &str = "STAMPINF_VERSION"; #[test] fn mixed_package_kmdf_workspace_builds_successfully() { with_file_lock::<&str, &str, _>(&[], || { + run_clean_cmd("tests/mixed-package-kmdf-workspace"); let stdout = run_build_cmd("tests/mixed-package-kmdf-workspace"); assert!(stdout.contains("Building package driver")); @@ -80,13 +81,15 @@ fn wdm_driver_builds_successfully_with_given_version() { fn emulated_workspace_builds_successfully() { with_file_lock::<&str, &str, _>(&[], || { let emulated_workspace_path = "tests/emulated-workspace"; + let umdf_driver_workspace_path = format!("{emulated_workspace_path}/umdf-driver-workspace"); + + run_clean_cmd(&umdf_driver_workspace_path); let stdout = run_build_cmd(emulated_workspace_path); assert!(stdout.contains("Building package driver_1")); assert!(stdout.contains("Building package driver_2")); assert!(stdout.contains("Build completed successfully")); - let umdf_driver_workspace_path = format!("{emulated_workspace_path}/umdf-driver-workspace"); verify_driver_package_files(&umdf_driver_workspace_path, "driver_1", "dll", None); verify_driver_package_files(&umdf_driver_workspace_path, "driver_2", "dll", None); }); @@ -200,25 +203,20 @@ fn assert_file_hash(path1: &str, path2: &str) { } fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Option<&str>) { - fs::read_to_string(format!("{package_path}/{driver_name}.inf")) - .expect("Unable to read inf file") - .lines() - .for_each(|line| { - // Example: DriverVer=09/13/2023,1.0.0.0 - let driver_version_regex = if let Some(version) = driver_version { - version - } else { - r"\d+\.\d+\.\d+\.\d+" - }; - - let re = regex::Regex::new(&format!( - r"^DriverVer\s+=\s+\d+/\d+/\d+,{driver_version_regex}$" - )) - .unwrap(); - if line.starts_with("DriverVer") { - assert!(re.captures(line).is_some()); - } - }); + let file_content = + fs::read(format!("{package_path}/{driver_name}.inf")).expect("Unable to read inf file"); + let file_content = String::from_utf8_lossy(&file_content); + file_content.lines().for_each(|line| { + // Example: DriverVer=09/13/2023,1.0.0.0 + let driver_version_regex = driver_version.unwrap_or(r"\d+\.\d+\.\d+\.\d+"); + let re = regex::Regex::new(&format!( + r"^DriverVer\s+=\s+\d+/\d+/\d+,{driver_version_regex}$" + )) + .unwrap(); + if line.starts_with("DriverVer") { + assert!(re.captures(line).is_some()); + } + }); } // Helper to hash a file From 4cc71ef41663dd34bca61e8f213bde51daa6efe7 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 7 Oct 2025 11:41:00 +0530 Subject: [PATCH 18/33] refactor(tests): replace run_clean_cmd with run_cargo_clean for consistency in test cases --- crates/cargo-wdk/src/actions/build/package_task.rs | 2 +- crates/cargo-wdk/tests/build_command_test.rs | 8 ++++---- 2 files changed, 5 insertions(+), 5 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 28ded42b1..db7b62b2a 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -320,7 +320,7 @@ impl<'a> PackageTask<'a> { Ok(version) if !version.trim().is_empty() => { // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it // and populates DriverVer. - info!("Using {STAMPINF_VERSION_ENV_VAR} env var to set DriverVer: {version}"); + debug!("Using {STAMPINF_VERSION_ENV_VAR} env var to set DriverVer: {version}"); } _ => { args.extend(["-v", "*"]); diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 60bc9df7e..cc7a870c2 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -16,7 +16,7 @@ const STAMPINF_VERSION_ENV_VAR: &str = "STAMPINF_VERSION"; #[test] fn mixed_package_kmdf_workspace_builds_successfully() { with_file_lock::<&str, &str, _>(&[], || { - run_clean_cmd("tests/mixed-package-kmdf-workspace"); + run_cargo_clean("tests/mixed-package-kmdf-workspace"); let stdout = run_build_cmd("tests/mixed-package-kmdf-workspace"); assert!(stdout.contains("Building package driver")); @@ -83,7 +83,7 @@ fn emulated_workspace_builds_successfully() { let emulated_workspace_path = "tests/emulated-workspace"; let umdf_driver_workspace_path = format!("{emulated_workspace_path}/umdf-driver-workspace"); - run_clean_cmd(&umdf_driver_workspace_path); + run_cargo_clean(&umdf_driver_workspace_path); let stdout = run_build_cmd(emulated_workspace_path); assert!(stdout.contains("Building package driver_1")); @@ -99,7 +99,7 @@ fn clean_and_build_driver_project(driver_type: &str, driver_version: Option<&str let driver_name = format!("{driver_type}-driver"); let driver_path = format!("tests/{driver_name}"); - run_clean_cmd(&driver_path); + run_cargo_clean(&driver_path); let stdout = run_build_cmd(&driver_path); assert!(stdout.contains(&format!("Building package {driver_name}"))); @@ -118,7 +118,7 @@ fn clean_and_build_driver_project(driver_type: &str, driver_version: Option<&str ); } -fn run_clean_cmd(driver_path: &str) { +fn run_cargo_clean(driver_path: &str) { let mut cmd = Command::new("cargo"); cmd.args(["clean"]).current_dir(driver_path); cmd.assert().success(); From 9afb175ac55e06c19738201895be669060f0ce5e Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 7 Oct 2025 11:52:10 +0530 Subject: [PATCH 19/33] refactor(tests): remove cleanup code for STAMPINF_VERSION environment variable in driver version assertion --- crates/cargo-wdk/src/actions/build/package_task.rs | 3 --- crates/cargo-wdk/tests/build_command_test.rs | 14 ++++++++------ 2 files changed, 8 insertions(+), 9 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index db7b62b2a..a7d168eb5 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -712,9 +712,6 @@ mod tests { "scenario {name} failed (env_set={env_val:?})" ); } - - // Cleanup - std::env::remove_var("STAMPINF_VERSION"); } /// Runs function after modifying environment variables, and returns the diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index cc7a870c2..9fd90b9e4 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -206,13 +206,15 @@ fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Opti let file_content = fs::read(format!("{package_path}/{driver_name}.inf")).expect("Unable to read inf file"); let file_content = String::from_utf8_lossy(&file_content); + + // Example: DriverVer = 09/13/2023,1.0.0.0 + let driver_version_regex = driver_version.unwrap_or(r"\d+\.\d+\.\d+\.\d+"); + let re = regex::Regex::new(&format!( + r"^DriverVer\s+=\s+\d+/\d+/\d+,{driver_version_regex}$" + )) + .unwrap(); + file_content.lines().for_each(|line| { - // Example: DriverVer=09/13/2023,1.0.0.0 - let driver_version_regex = driver_version.unwrap_or(r"\d+\.\d+\.\d+\.\d+"); - let re = regex::Regex::new(&format!( - r"^DriverVer\s+=\s+\d+/\d+/\d+,{driver_version_regex}$" - )) - .unwrap(); if line.starts_with("DriverVer") { assert!(re.captures(line).is_some()); } From 3cb6427207b3bd9a78a596c732ec5a7104939a32 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 7 Oct 2025 12:12:25 +0530 Subject: [PATCH 20/33] refactor(tests): simplify assert_driver_ver by improving line search for DriverVer --- crates/cargo-wdk/tests/build_command_test.rs | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-) diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 9fd90b9e4..26462ffb4 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -203,6 +203,7 @@ fn assert_file_hash(path1: &str, path2: &str) { } fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Option<&str>) { + // Read the INF as raw bytes and produce a best‑effort UTF-8 view let file_content = fs::read(format!("{package_path}/{driver_name}.inf")).expect("Unable to read inf file"); let file_content = String::from_utf8_lossy(&file_content); @@ -214,11 +215,11 @@ fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Opti )) .unwrap(); - file_content.lines().for_each(|line| { - if line.starts_with("DriverVer") { - assert!(re.captures(line).is_some()); - } - }); + let line = file_content + .lines() + .find(|line| line.starts_with("DriverVer")) + .expect("DriverVer line not found in inf file"); + assert!(re.captures(line).is_some()); } // Helper to hash a file From df7726b253c4cb0f28c7b8c087e3bd91d2ca6a60 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 7 Oct 2025 16:11:18 +0530 Subject: [PATCH 21/33] refactor: improve INF file reading in assert_driver_ver to handle UTF-16 LE encoding --- crates/cargo-wdk/tests/build_command_test.rs | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 26462ffb4..03fd9232a 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -203,10 +203,21 @@ fn assert_file_hash(path1: &str, path2: &str) { } fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Option<&str>) { - // Read the INF as raw bytes and produce a best‑effort UTF-8 view + // Read the INF file as raw bytes and produce a best-effort UTF-8 string. let file_content = fs::read(format!("{package_path}/{driver_name}.inf")).expect("Unable to read inf file"); - let file_content = String::from_utf8_lossy(&file_content); + let file_content = if file_content.starts_with(&[0xFF, 0xFE]) { + // Handle UTF-16 LE (BOM 0xFF 0xFE). + let file_content = file_content + .chunks(2) + .map(|pair| u16::from_le_bytes([pair[0], pair[1]])) + .collect::>(); + String::from_utf16_lossy(&file_content) + } else { + // Otherwise, treat the content as UTF-8; our test setups do not include UTF-16 + // BE encoded .inx files. + String::from_utf8_lossy(&file_content).to_string() + }; // Example: DriverVer = 09/13/2023,1.0.0.0 let driver_version_regex = driver_version.unwrap_or(r"\d+\.\d+\.\d+\.\d+"); From 47607c2e5e9ca8d94705b641174df1488eb617da Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Tue, 7 Oct 2025 20:28:12 +0530 Subject: [PATCH 22/33] refactor(tests): streamline environment variable handling in test cases --- .../src/actions/build/package_task.rs | 65 +----------------- crates/cargo-wdk/src/actions/build/tests.rs | 58 +++++++++------- crates/cargo-wdk/src/main.rs | 67 +++++++++++++++++++ 3 files changed, 102 insertions(+), 88 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index a7d168eb5..427938448 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -526,11 +526,8 @@ impl<'a> PackageTask<'a> { #[cfg(test)] mod tests { use std::{ - collections::HashMap, - ffi::OsStr, path::PathBuf, process::{ExitStatus, Output}, - sync::Mutex, }; use wdk_build::{CpuArchitecture, KmdfConfig}; @@ -661,7 +658,7 @@ mod tests { ]; for (name, env_val, expect_skip_v) in scenarios { - let result = with_env(&[(STAMPINF_VERSION_ENV_VAR, env_val)], || { + let result = crate::tests::with_env(&[(STAMPINF_VERSION_ENV_VAR, env_val)], || { let package_name = "driver"; let working_dir = PathBuf::from("C:/abs/driver"); let target_dir = PathBuf::from("C:/abs/driver/target/debug"); @@ -713,64 +710,4 @@ mod tests { ); } } - - /// Runs function after modifying environment variables, and returns the - /// function's return value. - /// - /// The environment is guaranteed to be not modified during the execution - /// of the function, and the environment is reset to its original state - /// after execution of the function. No testing asserts should be called in - /// the function, since a failing test will poison the mutex, and cause all - /// remaining tests to fail. - /// - /// # Panics - /// - /// Panics if called with duplicate environment variable keys. - pub fn with_env(env_vars_key_value_pairs: &[(K, Option)], f: F) -> R - where - K: AsRef + std::cmp::Eq + std::hash::Hash, - V: AsRef, - F: FnOnce() -> R, - { - // Tests can execute in multiple threads in the same process, so mutex must be - // used to guard access to the environment variables - static ENV_MUTEX: Mutex<()> = Mutex::new(()); - - let _mutex_guard = ENV_MUTEX.lock().unwrap(); - let mut original_env_vars = HashMap::new(); - - // set requested environment variables - for (key, value) in env_vars_key_value_pairs { - if let Ok(original_value) = std::env::var(key) { - let insert_result = original_env_vars.insert(key, original_value); - assert!( - insert_result.is_none(), - "Duplicate environment variable keys were provided" - ); - } - - // Remove the env var if value is None - if let Some(value) = value { - std::env::set_var(key, value); - } else { - std::env::remove_var(key); - } - } - - let f_return_value = f(); - - // reset all set environment variables - for (key, _) in env_vars_key_value_pairs { - original_env_vars.get(key).map_or_else( - || { - std::env::remove_var(key); - }, - |value| { - std::env::set_var(key, value); - }, - ); - } - - f_return_value - } } diff --git a/crates/cargo-wdk/src/actions/build/tests.rs b/crates/cargo-wdk/src/actions/build/tests.rs index 56d622c8f..bac46dc83 100644 --- a/crates/cargo-wdk/src/actions/build/tests.rs +++ b/crates/cargo-wdk/src/actions/build/tests.rs @@ -107,7 +107,8 @@ pub fn given_a_driver_project_when_default_values_are_provided_then_it_builds_su test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -177,7 +178,8 @@ pub fn given_a_driver_project_when_profile_is_release_then_it_builds_successfull test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -247,7 +249,8 @@ pub fn given_a_driver_project_when_target_arch_is_arm64_then_it_builds_successfu test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -318,7 +321,8 @@ pub fn given_a_driver_project_when_profile_is_release_and_target_arch_is_arm64_t test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -389,8 +393,8 @@ pub fn given_a_driver_project_when_sample_class_is_true_then_it_builds_successfu test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -462,8 +466,8 @@ pub fn given_a_driver_project_when_verify_signature_is_true_then_it_builds_succe test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -554,8 +558,8 @@ pub fn given_a_driver_project_when_self_signed_exists_then_it_should_skip_callin test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -627,8 +631,8 @@ pub fn given_a_driver_project_when_final_package_dir_exists_then_it_should_skip_ test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -781,7 +785,8 @@ pub fn given_a_driver_project_when_stampinf_command_execution_fails_then_package test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -842,7 +847,8 @@ pub fn given_a_driver_project_when_inf2cat_command_execution_fails_then_package_ test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -905,7 +911,8 @@ pub fn given_a_driver_project_when_certmgr_command_execution_fails_then_package_ test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -969,7 +976,8 @@ pub fn given_a_driver_project_when_makecert_command_execution_fails_then_package test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -1035,7 +1043,8 @@ pub fn given_a_driver_project_when_signtool_command_execution_fails_then_package test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -1103,7 +1112,8 @@ pub fn given_a_driver_project_when_infverif_command_execution_fails_then_package test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -1316,8 +1326,8 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_defau test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -1424,8 +1434,8 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_cwd_i test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } @@ -1540,8 +1550,8 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_verif test_build_action.mock_metadata_provider(), ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - + let build_action = build_action.expect("Failed to init build action"); + let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); assert!(run_result.is_ok()); } diff --git a/crates/cargo-wdk/src/main.rs b/crates/cargo-wdk/src/main.rs index daaf55e02..13e2ce0e0 100644 --- a/crates/cargo-wdk/src/main.rs +++ b/crates/cargo-wdk/src/main.rs @@ -36,3 +36,70 @@ fn main() -> Result<()> { cli.run().inspect_err(|e| error!("{}", e))?; Ok(()) } + +#[cfg(test)] +mod tests { + use std::{collections::HashMap, ffi::OsStr, sync::Mutex}; + + /// This is a helper function used in child module unit tests. + /// + /// Runs function after modifying environment variables, and returns the + /// function's return value. + /// + /// The environment is guaranteed to be not modified during the execution + /// of the function, and the environment is reset to its original state + /// after execution of the function. No testing asserts should be called in + /// the function, since a failing test will poison the mutex, and cause all + /// remaining tests to fail. + /// + /// # Panics + /// + /// Panics if called with duplicate environment variable keys. + pub fn with_env(env_vars_key_value_pairs: &[(K, Option)], f: F) -> R + where + K: AsRef + std::cmp::Eq + std::hash::Hash, + V: AsRef, + F: FnOnce() -> R, + { + // Tests can execute in multiple threads in the same process, so mutex must be + // used to guard access to the environment variables + static ENV_MUTEX: Mutex<()> = Mutex::new(()); + + let _mutex_guard = ENV_MUTEX.lock().unwrap(); + let mut original_env_vars = HashMap::new(); + + // set requested environment variables + for (key, value) in env_vars_key_value_pairs { + if let Ok(original_value) = std::env::var(key) { + let insert_result = original_env_vars.insert(key, original_value); + assert!( + insert_result.is_none(), + "Duplicate environment variable keys were provided" + ); + } + + // Remove the env var if value is None + if let Some(value) = value { + std::env::set_var(key, value); + } else { + std::env::remove_var(key); + } + } + + let f_return_value = f(); + + // reset all set environment variables + for (key, _) in env_vars_key_value_pairs { + original_env_vars.get(key).map_or_else( + || { + std::env::remove_var(key); + }, + |value| { + std::env::set_var(key, value); + }, + ); + } + + f_return_value + } +} From 13f48fa387bd028e1f6061a627baec90bdbcbf48 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 8 Oct 2025 13:48:52 +0530 Subject: [PATCH 23/33] Refactor build tests to reduce duplication and improve readability - Consolidated repeated code in build tests by introducing helper functions: - `initialize_build_action` to create and initialize `BuildAction`. - `assert_build_action_run_is_success` to handle running the build action and asserting success. - `get_certmgr_success_output` to retrieve expected output for certificate manager success. - Moved environment variable handling from `main.rs` into a new `test_utils.rs` file, providing a dedicated module for test utilities. - Removed redundant expected output definitions in multiple test cases, replacing them with calls to the new helper function. --- .../src/actions/build/package_task.rs | 89 +- crates/cargo-wdk/src/actions/build/tests.rs | 793 ++++++------------ crates/cargo-wdk/src/main.rs | 70 +- crates/cargo-wdk/src/test_utils.rs | 63 ++ 4 files changed, 387 insertions(+), 628 deletions(-) create mode 100644 crates/cargo-wdk/src/test_utils.rs diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 427938448..4a9b9fc55 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -658,51 +658,52 @@ mod tests { ]; for (name, env_val, expect_skip_v) in scenarios { - let result = crate::tests::with_env(&[(STAMPINF_VERSION_ENV_VAR, env_val)], || { - let package_name = "driver"; - let working_dir = PathBuf::from("C:/abs/driver"); - let target_dir = PathBuf::from("C:/abs/driver/target/debug"); - let arch = CpuArchitecture::Amd64; - - let params = PackageTaskParams { - package_name, - working_dir: &working_dir, - target_dir: &target_dir, - target_arch: &arch, - driver_model: DriverConfig::Kmdf(KmdfConfig::default()), - sample_class: false, - verify_signature: false, - }; - - let wdk_build = WdkBuild::default(); - let fs = Fs::default(); - let mut command_exec = CommandExec::default(); - - command_exec - .expect_run() - .withf(move |cmd: &str, args: &[&str], _, _| { - if cmd != "stampinf" { - return false; - } - let has_v = args.contains(&"-v"); - if expect_skip_v { - !has_v - } else { - args.windows(2).any(|w| w == ["-v", "*"]) - } - }) - .once() - .return_once(|_, _, _, _| { - Ok(Output { - status: ExitStatus::default(), - stdout: vec![], - stderr: vec![], + let result = + crate::test_utils::with_env(&[(STAMPINF_VERSION_ENV_VAR, env_val)], || { + let package_name = "driver"; + let working_dir = PathBuf::from("C:/abs/driver"); + let target_dir = PathBuf::from("C:/abs/driver/target/debug"); + let arch = CpuArchitecture::Amd64; + + let params = PackageTaskParams { + package_name, + working_dir: &working_dir, + target_dir: &target_dir, + target_arch: &arch, + driver_model: DriverConfig::Kmdf(KmdfConfig::default()), + sample_class: false, + verify_signature: false, + }; + + let wdk_build = WdkBuild::default(); + let fs = Fs::default(); + let mut command_exec = CommandExec::default(); + + command_exec + .expect_run() + .withf(move |cmd: &str, args: &[&str], _, _| { + if cmd != "stampinf" { + return false; + } + let has_v = args.contains(&"-v"); + if expect_skip_v { + !has_v + } else { + args.windows(2).any(|w| w == ["-v", "*"]) + } }) - }); - - let task = PackageTask::new(params, &wdk_build, &command_exec, &fs); - task.run_stampinf() - }); + .once() + .return_once(|_, _, _, _| { + Ok(Output { + status: ExitStatus::default(), + stdout: vec![], + stderr: vec![], + }) + }); + + let task = PackageTask::new(params, &wdk_build, &command_exec, &fs); + task.run_stampinf() + }); assert!( result.is_ok(), diff --git a/crates/cargo-wdk/src/actions/build/tests.rs b/crates/cargo-wdk/src/actions/build/tests.rs index bac46dc83..2ff2b16d6 100644 --- a/crates/cargo-wdk/src/actions/build/tests.rs +++ b/crates/cargo-wdk/src/actions/build/tests.rs @@ -15,23 +15,17 @@ use mockall::predicate::eq; use mockall_double::double; use wdk_build::{ metadata::{TryFromCargoMetadataError, Wdk}, - CpuArchitecture, - DriverConfig, + CpuArchitecture, DriverConfig, }; #[double] use crate::providers::{ - exec::CommandExec, - fs::Fs, - metadata::Metadata as MetadataProvider, - wdk_build::WdkBuild, + exec::CommandExec, fs::Fs, metadata::Metadata as MetadataProvider, wdk_build::WdkBuild, }; use crate::{ actions::{ build::{BuildAction, BuildActionError, BuildActionParams}, - to_target_triple, - Profile, - TargetArch, + to_target_triple, Profile, TargetArch, }, providers::error::{CommandError, FileError}, }; @@ -58,17 +52,7 @@ pub fn given_a_driver_project_when_default_values_are_provided_then_it_builds_su let wdk_metadata = get_cargo_metadata_wdk_metadata(driver_type, 1, 33); let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) @@ -92,24 +76,14 @@ pub fn given_a_driver_project_when_default_values_are_provided_then_it_builds_su .expect_signtool_sign_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -129,17 +103,7 @@ pub fn given_a_driver_project_when_profile_is_release_then_it_builds_successfull let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) @@ -163,24 +127,14 @@ pub fn given_a_driver_project_when_profile_is_release_then_it_builds_successfull .expect_signtool_sign_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -200,17 +154,7 @@ pub fn given_a_driver_project_when_target_arch_is_arm64_then_it_builds_successfu let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) @@ -234,24 +178,14 @@ pub fn given_a_driver_project_when_target_arch_is_arm64_then_it_builds_successfu .expect_signtool_sign_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -272,17 +206,7 @@ pub fn given_a_driver_project_when_profile_is_release_and_target_arch_is_arm64_t let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) @@ -306,24 +230,14 @@ pub fn given_a_driver_project_when_profile_is_release_and_target_arch_is_arm64_t .expect_signtool_sign_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -343,17 +257,7 @@ pub fn given_a_driver_project_when_sample_class_is_true_then_it_builds_successfu let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) @@ -378,24 +282,14 @@ pub fn given_a_driver_project_when_sample_class_is_true_then_it_builds_successfu .expect_infverif(driver_name, &cwd, "KMDF", None) .expect_detect_wdk_build_number(25100u32); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -415,17 +309,7 @@ pub fn given_a_driver_project_when_verify_signature_is_true_then_it_builds_succe let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) @@ -451,24 +335,14 @@ pub fn given_a_driver_project_when_verify_signature_is_true_then_it_builds_succe .expect_signtool_verify_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -543,24 +417,14 @@ pub fn given_a_driver_project_when_self_signed_exists_then_it_should_skip_callin .expect_signtool_verify_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -579,17 +443,7 @@ pub fn given_a_driver_project_when_final_package_dir_exists_then_it_should_skip_ let wdk_metadata = get_cargo_metadata_wdk_metadata(driver_type, 1, 33); let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) @@ -616,24 +470,14 @@ pub fn given_a_driver_project_when_final_package_dir_exists_then_it_should_skip_ .expect_signtool_verify_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -660,19 +504,13 @@ pub fn given_a_driver_project_when_inx_file_do_not_exist_then_package_should_fai .expect_cargo_build(driver_name, &cwd, None) .expect_inx_file_exists(driver_name, &cwd, false); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); let run_result = build_action.expect("Failed to init build action").run(); @@ -710,19 +548,13 @@ pub fn given_a_driver_project_when_copy_of_an_artifact_fails_then_the_package_sh .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, false); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); let run_result = build_action.expect("Failed to init build action").run(); @@ -770,23 +602,16 @@ pub fn given_a_driver_project_when_stampinf_command_execution_fails_then_package .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) .expect_stampinf(driver_name, &cwd, Some(expected_stampinf_output)); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); + let run_result = run_build_action(build_action); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -832,23 +657,16 @@ pub fn given_a_driver_project_when_inf2cat_command_execution_fails_then_package_ .expect_stampinf(driver_name, &cwd, None) .expect_inf2cat(driver_name, &cwd, Some(expected_inf2cat_output)); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); + let run_result = run_build_action(build_action); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -896,23 +714,16 @@ pub fn given_a_driver_project_when_certmgr_command_execution_fails_then_package_ .expect_self_signed_cert_file_exists(&cwd, false) .expect_certmgr_exists_check(Some(expected_output)); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); + let run_result = run_build_action(build_action); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -961,23 +772,16 @@ pub fn given_a_driver_project_when_makecert_command_execution_fails_then_package .expect_certmgr_exists_check(None) .expect_makecert(&cwd, Some(expected_output)); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); + let run_result = run_build_action(build_action); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -1028,23 +832,16 @@ pub fn given_a_driver_project_when_signtool_command_execution_fails_then_package .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, Some(expected_output)); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); + let run_result = run_build_action(build_action); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -1097,23 +894,16 @@ pub fn given_a_driver_project_when_infverif_command_execution_fails_then_package .expect_signtool_sign_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", Some(expected_output)); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); + let run_result = run_build_action(build_action); assert!(matches!( run_result.as_ref().expect_err("expected error"), @@ -1143,24 +933,14 @@ pub fn given_a_non_driver_project_when_default_values_are_provided_with_no_wdk_m .expect_root_manifest_exists(&cwd, true) .expect_cargo_build(driver_name, &cwd, None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - - assert!(run_result.is_ok()); } #[test] @@ -1183,19 +963,13 @@ pub fn given_a_invalid_driver_project_with_partial_wdk_metadata_when_valid_defau .expect_root_manifest_exists(&cwd, true) .expect_cargo_build(driver_name, &cwd, None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); let run_result = build_action.expect("Failed to init build action").run(); @@ -1245,17 +1019,7 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_defau let (workspace_member_3, package_3) = get_cargo_metadata_package(&cwd.join(non_driver), non_driver, non_driver_version, None); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_workspace_with_multiple_driver_projects( @@ -1311,24 +1075,14 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_defau // Non-driver project .expect_cargo_build(non_driver, &cwd.join(non_driver), None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -1370,17 +1124,7 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_cwd_i None, ); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) // Even when cwd is changed to driver project inside the workspace, cargo metadata read is // going to be for the whole workspace @@ -1419,24 +1163,14 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_cwd_i .expect_signtool_verify_cat_file(driver_name_1, &workspace_root_dir, None) .expect_infverif(driver_name_1, &workspace_root_dir, "KMDF", None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -1473,17 +1207,7 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_verif let (workspace_member_3, package_3) = get_cargo_metadata_package(&cwd.join(non_driver), non_driver, non_driver_version, None); - let expected_certmgr_output = Output { - status: ExitStatus::default(), - stdout: r"==============No Certificates ========== - ==============No CTLs ========== - ==============No CRLs ========== - ============================================== - CertMgr Succeeded" - .as_bytes() - .to_vec(), - stderr: vec![], - }; + let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_workspace_with_multiple_driver_projects( @@ -1535,24 +1259,14 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_verif // Non-driver project .expect_cargo_build(non_driver, &cwd.join(non_driver), None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_with_env_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let build_action = build_action.expect("Failed to init build action"); - let run_result = crate::tests::with_env::<&str, &str, _, _>(&[], || build_action.run()); - assert!(run_result.is_ok()); } #[test] @@ -1609,24 +1323,14 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_cwd_i .expect_root_manifest_exists(&cwd, true) .expect_cargo_build(non_driver, &cwd, None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - - assert!(run_result.is_ok()); } #[test] @@ -1675,19 +1379,13 @@ pub fn given_a_workspace_with_multiple_distinct_wdk_configurations_at_each_works .expect_cargo_build(driver_name_1, &cwd.join(driver_name_1), None) .expect_cargo_build(driver_name_2, &cwd.join(driver_name_2), None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); let run_result = build_action.expect("Failed to init build action").run(); @@ -1748,19 +1446,13 @@ pub fn given_a_workspace_with_multiple_distinct_wdk_configurations_at_root_and_w .expect_cargo_build(driver_name_1, &cwd.join(driver_name_1), None) .expect_cargo_build(driver_name_2, &cwd.join(driver_name_2), None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + let build_action = initialize_build_action( + &cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); let run_result = build_action.expect("Failed to init build action").run(); @@ -1802,24 +1494,14 @@ pub fn given_a_workspace_only_with_non_driver_projects_when_cwd_is_workspace_roo .expect_detect_wdk_build_number(25100u32) .expect_cargo_build(non_driver, &cwd.join(non_driver), None); - let build_action = BuildAction::new( - &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), - target_arch, - verify_signature, - is_sample_class: sample_class, - verbosity_level: clap_verbosity_flag::Verbosity::new(1, 0), - }, - test_build_action.mock_wdk_build_provider(), - test_build_action.mock_run_command(), - test_build_action.mock_fs_provider(), - test_build_action.mock_metadata_provider(), + assert_build_action_run_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, ); - assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - - assert!(run_result.is_ok()); } #[test] @@ -1854,10 +1536,49 @@ pub fn given_a_workspace_only_with_non_driver_projects_when_cwd_is_workspace_mem .expect_detect_wdk_build_number(25100u32) .expect_cargo_build(non_driver, &cwd, None); - let build_action = BuildAction::new( + assert_build_action_run_is_success( + &cwd, + profile, + target_arch, + verify_signature, + sample_class, + test_build_action, + ); +} + +fn assert_build_action_run_is_success( + cwd: &PathBuf, + profile: Option, + target_arch: TargetArch, + verify_signature: bool, + sample_class: bool, + test_build_action: &impl TestSetupPackageExpectations, +) { + let build_action = initialize_build_action( + cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, + ); + assert!(build_action.is_ok()); + let run_result = build_action.expect("Failed to init build action").run(); + assert!(run_result.is_ok()); +} + +fn initialize_build_action<'a>( + cwd: &'a PathBuf, + profile: Option<&'a Profile>, + target_arch: TargetArch, + verify_signature: bool, + sample_class: bool, + test_build_action: &'a impl TestSetupPackageExpectations, +) -> Result, anyhow::Error> { + BuildAction::new( &BuildActionParams { - working_dir: &cwd, - profile: profile.as_ref(), + working_dir: cwd, + profile, target_arch, verify_signature, is_sample_class: sample_class, @@ -1867,13 +1588,51 @@ pub fn given_a_workspace_only_with_non_driver_projects_when_cwd_is_workspace_mem test_build_action.mock_run_command(), test_build_action.mock_fs_provider(), test_build_action.mock_metadata_provider(), + ) +} + +fn get_certmgr_success_output() -> Output { + Output { + status: ExitStatus::default(), + stdout: r"==============No Certificates ========== + ==============No CTLs ========== + ==============No CRLs ========== + ============================================== + CertMgr Succeeded" + .as_bytes() + .to_vec(), + stderr: vec![], + } +} + +fn assert_build_action_run_with_env_is_success( + cwd: &PathBuf, + profile: Option, + target_arch: TargetArch, + verify_signature: bool, + sample_class: bool, + test_build_action: &impl TestSetupPackageExpectations, +) { + let build_action = initialize_build_action( + cwd, + profile.as_ref(), + target_arch, + verify_signature, + sample_class, + test_build_action, ); assert!(build_action.is_ok()); - let run_result = build_action.expect("Failed to init build action").run(); - + let run_result = run_build_action(build_action); assert!(run_result.is_ok()); } +fn run_build_action( + build_action: Result, anyhow::Error>, +) -> Result<(), BuildActionError> { + let build_action = build_action.expect("Failed to init build action"); + crate::test_utils::with_env::<&str, &str, _, _>(&[], || build_action.run()) +} + /// Helper functions //////////////////////////////////////////////////////////////////////////////// struct TestBuildAction { diff --git a/crates/cargo-wdk/src/main.rs b/crates/cargo-wdk/src/main.rs index 13e2ce0e0..d4d3bef8b 100644 --- a/crates/cargo-wdk/src/main.rs +++ b/crates/cargo-wdk/src/main.rs @@ -16,6 +16,9 @@ use clap::Parser; use cli::Cli; use tracing::error; +#[cfg(test)] +mod test_utils; + /// Main function for the [`cargo-wdk`][crate] CLI application. /// /// The main function parses the CLI input, sets up tracing and executes the @@ -36,70 +39,3 @@ fn main() -> Result<()> { cli.run().inspect_err(|e| error!("{}", e))?; Ok(()) } - -#[cfg(test)] -mod tests { - use std::{collections::HashMap, ffi::OsStr, sync::Mutex}; - - /// This is a helper function used in child module unit tests. - /// - /// Runs function after modifying environment variables, and returns the - /// function's return value. - /// - /// The environment is guaranteed to be not modified during the execution - /// of the function, and the environment is reset to its original state - /// after execution of the function. No testing asserts should be called in - /// the function, since a failing test will poison the mutex, and cause all - /// remaining tests to fail. - /// - /// # Panics - /// - /// Panics if called with duplicate environment variable keys. - pub fn with_env(env_vars_key_value_pairs: &[(K, Option)], f: F) -> R - where - K: AsRef + std::cmp::Eq + std::hash::Hash, - V: AsRef, - F: FnOnce() -> R, - { - // Tests can execute in multiple threads in the same process, so mutex must be - // used to guard access to the environment variables - static ENV_MUTEX: Mutex<()> = Mutex::new(()); - - let _mutex_guard = ENV_MUTEX.lock().unwrap(); - let mut original_env_vars = HashMap::new(); - - // set requested environment variables - for (key, value) in env_vars_key_value_pairs { - if let Ok(original_value) = std::env::var(key) { - let insert_result = original_env_vars.insert(key, original_value); - assert!( - insert_result.is_none(), - "Duplicate environment variable keys were provided" - ); - } - - // Remove the env var if value is None - if let Some(value) = value { - std::env::set_var(key, value); - } else { - std::env::remove_var(key); - } - } - - let f_return_value = f(); - - // reset all set environment variables - for (key, _) in env_vars_key_value_pairs { - original_env_vars.get(key).map_or_else( - || { - std::env::remove_var(key); - }, - |value| { - std::env::set_var(key, value); - }, - ); - } - - f_return_value - } -} diff --git a/crates/cargo-wdk/src/test_utils.rs b/crates/cargo-wdk/src/test_utils.rs new file mode 100644 index 000000000..0ddfe938b --- /dev/null +++ b/crates/cargo-wdk/src/test_utils.rs @@ -0,0 +1,63 @@ +use std::{collections::HashMap, ffi::OsStr, sync::Mutex}; + +/// This is a helper function used in child module unit tests. +/// +/// Runs function after modifying environment variables, and returns the +/// function's return value. +/// +/// The environment is guaranteed to be not modified during the execution +/// of the function, and the environment is reset to its original state +/// after execution of the function. No testing asserts should be called in +/// the function, since a failing test will poison the mutex, and cause all +/// remaining tests to fail. +/// +/// # Panics +/// +/// Panics if called with duplicate environment variable keys. +pub fn with_env(env_vars_key_value_pairs: &[(K, Option)], f: F) -> R +where + K: AsRef + std::cmp::Eq + std::hash::Hash, + V: AsRef, + F: FnOnce() -> R, +{ + // Tests can execute in multiple threads in the same process, so mutex must be + // used to guard access to the environment variables + static ENV_MUTEX: Mutex<()> = Mutex::new(()); + + let _mutex_guard = ENV_MUTEX.lock().unwrap(); + let mut original_env_vars = HashMap::new(); + + // set requested environment variables + for (key, value) in env_vars_key_value_pairs { + if let Ok(original_value) = std::env::var(key) { + let insert_result = original_env_vars.insert(key, original_value); + assert!( + insert_result.is_none(), + "Duplicate environment variable keys were provided" + ); + } + + // Remove the env var if value is None + if let Some(value) = value { + std::env::set_var(key, value); + } else { + std::env::remove_var(key); + } + } + + let f_return_value = f(); + + // reset all set environment variables + for (key, _) in env_vars_key_value_pairs { + original_env_vars.get(key).map_or_else( + || { + std::env::remove_var(key); + }, + |value| { + std::env::set_var(key, value); + }, + ); + } + + f_return_value +} From a3fcbf97a38e6a8af222203c5da0147059571f72 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 8 Oct 2025 17:54:51 +0530 Subject: [PATCH 24/33] refactor(tests): simplify build action expectations by introducing default task steps --- crates/cargo-wdk/src/actions/build/tests.rs | 370 +++++++------------- 1 file changed, 132 insertions(+), 238 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/tests.rs b/crates/cargo-wdk/src/actions/build/tests.rs index 2ff2b16d6..1ecd8a823 100644 --- a/crates/cargo-wdk/src/actions/build/tests.rs +++ b/crates/cargo-wdk/src/actions/build/tests.rs @@ -52,29 +52,11 @@ pub fn given_a_driver_project_when_default_values_are_provided_then_it_builds_su let wdk_metadata = get_cargo_metadata_wdk_metadata(driver_type, 1, 33); let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = get_certmgr_success_output(); let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) - .expect_final_package_dir_exists(driver_name, &cwd, true) - .expect_inx_file_exists(driver_name, &cwd, true) - .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name, &cwd, true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) - .expect_stampinf(driver_name, &cwd, None) - .expect_inf2cat(driver_name, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output)) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) - .expect_signtool_sign_cat_file(driver_name, &cwd, None) - .expect_infverif(driver_name, &cwd, "KMDF", None); + .expect_default_build_task_steps(driver_name) + .expect_default_package_task_steps(driver_name, "KMDF", verify_signature); assert_build_action_run_with_env_is_success( &cwd, @@ -103,29 +85,10 @@ pub fn given_a_driver_project_when_profile_is_release_then_it_builds_successfull let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = get_certmgr_success_output(); - let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) - .expect_final_package_dir_exists(driver_name, &cwd, true) - .expect_inx_file_exists(driver_name, &cwd, true) - .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name, &cwd, true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) - .expect_stampinf(driver_name, &cwd, None) - .expect_inf2cat(driver_name, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output)) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) - .expect_signtool_sign_cat_file(driver_name, &cwd, None) - .expect_infverif(driver_name, &cwd, "KMDF", None); + .expect_default_build_task_steps(driver_name) + .expect_default_package_task_steps(driver_name, "KMDF", verify_signature); assert_build_action_run_with_env_is_success( &cwd, @@ -154,29 +117,10 @@ pub fn given_a_driver_project_when_target_arch_is_arm64_then_it_builds_successfu let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = get_certmgr_success_output(); - let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) - .expect_final_package_dir_exists(driver_name, &cwd, true) - .expect_inx_file_exists(driver_name, &cwd, true) - .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name, &cwd, true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) - .expect_stampinf(driver_name, &cwd, None) - .expect_inf2cat(driver_name, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output)) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) - .expect_signtool_sign_cat_file(driver_name, &cwd, None) - .expect_infverif(driver_name, &cwd, "KMDF", None); + .expect_default_build_task_steps(driver_name) + .expect_default_package_task_steps(driver_name, "KMDF", verify_signature); assert_build_action_run_with_env_is_success( &cwd, @@ -206,29 +150,10 @@ pub fn given_a_driver_project_when_profile_is_release_and_target_arch_is_arm64_t let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = get_certmgr_success_output(); - let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) - .expect_final_package_dir_exists(driver_name, &cwd, true) - .expect_inx_file_exists(driver_name, &cwd, true) - .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name, &cwd, true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) - .expect_stampinf(driver_name, &cwd, None) - .expect_inf2cat(driver_name, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output)) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) - .expect_signtool_sign_cat_file(driver_name, &cwd, None) - .expect_infverif(driver_name, &cwd, "KMDF", None); + .expect_default_build_task_steps(driver_name) + .expect_default_package_task_steps(driver_name, "KMDF", verify_signature); assert_build_action_run_with_env_is_success( &cwd, @@ -257,29 +182,10 @@ pub fn given_a_driver_project_when_sample_class_is_true_then_it_builds_successfu let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = get_certmgr_success_output(); - let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) - .expect_final_package_dir_exists(driver_name, &cwd, true) - .expect_inx_file_exists(driver_name, &cwd, true) - .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name, &cwd, true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) - .expect_stampinf(driver_name, &cwd, None) - .expect_inf2cat(driver_name, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output)) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) - .expect_signtool_sign_cat_file(driver_name, &cwd, None) - .expect_infverif(driver_name, &cwd, "KMDF", None) + .expect_default_build_task_steps(driver_name) + .expect_default_package_task_steps(driver_name, driver_type, verify_signature) .expect_detect_wdk_build_number(25100u32); assert_build_action_run_with_env_is_success( @@ -309,31 +215,10 @@ pub fn given_a_driver_project_when_verify_signature_is_true_then_it_builds_succe let (workspace_member, package) = get_cargo_metadata_package(&cwd, driver_name, driver_version, Some(wdk_metadata)); - let expected_certmgr_output = get_certmgr_success_output(); - let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) - .expect_final_package_dir_exists(driver_name, &cwd, true) - .expect_inx_file_exists(driver_name, &cwd, true) - .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name, &cwd, true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) - .expect_stampinf(driver_name, &cwd, None) - .expect_inf2cat(driver_name, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output)) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) - .expect_signtool_sign_cat_file(driver_name, &cwd, None) - .expect_signtool_verify_driver_binary_sys_file(driver_name, &cwd, None) - .expect_signtool_verify_cat_file(driver_name, &cwd, None) - .expect_infverif(driver_name, &cwd, "KMDF", None); + .expect_default_build_task_steps(driver_name) + .expect_default_package_task_steps(driver_name, driver_type, verify_signature); assert_build_action_run_with_env_is_success( &cwd, @@ -395,9 +280,7 @@ pub fn given_a_driver_project_when_self_signed_exists_then_it_should_skip_callin let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) @@ -433,7 +316,7 @@ pub fn given_a_driver_project_when_final_package_dir_exists_then_it_should_skip_ let cwd = PathBuf::from("C:\\tmp"); let profile = None; let target_arch = TargetArch::Default(CpuArchitecture::Amd64); - let verify_signature = true; + let verify_signature = false; let sample_class = false; // Driver project data @@ -447,9 +330,7 @@ pub fn given_a_driver_project_when_final_package_dir_exists_then_it_should_skip_ let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, false) .expect_dir_created(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) @@ -466,8 +347,6 @@ pub fn given_a_driver_project_when_final_package_dir_exists_then_it_should_skip_ .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) .expect_signtool_sign_cat_file(driver_name, &cwd, None) - .expect_signtool_verify_driver_binary_sys_file(driver_name, &cwd, None) - .expect_signtool_verify_cat_file(driver_name, &cwd, None) .expect_infverif(driver_name, &cwd, "KMDF", None); assert_build_action_run_with_env_is_success( @@ -499,9 +378,7 @@ pub fn given_a_driver_project_when_inx_file_do_not_exist_then_package_should_fai let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_inx_file_exists(driver_name, &cwd, false); let build_action = initialize_build_action( @@ -540,9 +417,7 @@ pub fn given_a_driver_project_when_copy_of_an_artifact_fails_then_the_package_sh let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) @@ -590,9 +465,7 @@ pub fn given_a_driver_project_when_stampinf_command_execution_fails_then_package let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) @@ -644,9 +517,7 @@ pub fn given_a_driver_project_when_inf2cat_command_execution_fails_then_package_ let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) @@ -699,9 +570,7 @@ pub fn given_a_driver_project_when_certmgr_command_execution_fails_then_package_ let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) @@ -756,9 +625,7 @@ pub fn given_a_driver_project_when_makecert_command_execution_fails_then_package let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) @@ -814,9 +681,7 @@ pub fn given_a_driver_project_when_signtool_command_execution_fails_then_package let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) @@ -874,9 +739,7 @@ pub fn given_a_driver_project_when_infverif_command_execution_fails_then_package let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None) + .expect_default_build_task_steps(driver_name) .expect_final_package_dir_exists(driver_name, &cwd, true) .expect_inx_file_exists(driver_name, &cwd, true) .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) @@ -929,9 +792,7 @@ pub fn given_a_non_driver_project_when_default_values_are_provided_with_no_wdk_m let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_standalone_driver_project((workspace_member, package)) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None); + .expect_default_build_task_steps(driver_name); assert_build_action_run_is_success( &cwd, @@ -959,9 +820,7 @@ pub fn given_a_invalid_driver_project_with_partial_wdk_metadata_when_valid_defau let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_with_custom_toml(&cargo_toml_metadata) - .expect_detect_wdk_build_number(25100u32) - .expect_root_manifest_exists(&cwd, true) - .expect_cargo_build(driver_name, &cwd, None); + .expect_default_build_task_steps(driver_name); let build_action = initialize_build_action( &cwd, @@ -1019,8 +878,6 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_defau let (workspace_member_3, package_3) = get_cargo_metadata_package(&cwd.join(non_driver), non_driver, non_driver_version, None); - let expected_certmgr_output = get_certmgr_success_output(); - let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_workspace_with_multiple_driver_projects( &cwd, @@ -1034,44 +891,18 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_defau .expect_detect_wdk_build_number(25100u32) .expect_root_manifest_exists(&cwd, true) .expect_cargo_build(driver_name_1, &cwd.join(driver_name_1), None) - .expect_final_package_dir_exists(driver_name_1, &cwd, true) - .expect_inx_file_exists(driver_name_1, &cwd.join(driver_name_1), true) - .expect_rename_driver_binary_dll_to_sys(driver_name_1, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name_1, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name_1, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name_1, &cwd.join(driver_name_1), true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name_1, &cwd, true) - .expect_stampinf(driver_name_1, &cwd, None) - .expect_inf2cat(driver_name_1, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output.clone())) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name_1, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name_1, &cwd, None) - .expect_signtool_sign_cat_file(driver_name_1, &cwd, None) - .expect_signtool_verify_driver_binary_sys_file(driver_name_1, &cwd, None) - .expect_signtool_verify_cat_file(driver_name_1, &cwd, None) - .expect_infverif(driver_name_1, &cwd, "KMDF", None) + .expect_default_package_task_steps_for_workspace( + driver_name_1, + driver_type, + verify_signature, + ) // Second driver project .expect_cargo_build(driver_name_2, &cwd.join(driver_name_2), None) - .expect_final_package_dir_exists(driver_name_2, &cwd, true) - .expect_inx_file_exists(driver_name_2, &cwd.join(driver_name_2), true) - .expect_rename_driver_binary_dll_to_sys(driver_name_2, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name_2, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name_2, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name_2, &cwd.join(driver_name_2), true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name_2, &cwd, true) - .expect_stampinf(driver_name_2, &cwd, None) - .expect_inf2cat(driver_name_2, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output)) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name_2, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name_2, &cwd, None) - .expect_signtool_sign_cat_file(driver_name_2, &cwd, None) - .expect_signtool_verify_driver_binary_sys_file(driver_name_2, &cwd, None) - .expect_signtool_verify_cat_file(driver_name_2, &cwd, None) - .expect_infverif(driver_name_2, &cwd, "KMDF", None) + .expect_default_package_task_steps_for_workspace( + driver_name_2, + driver_type, + verify_signature, + ) // Non-driver project .expect_cargo_build(non_driver, &cwd.join(non_driver), None); @@ -1207,8 +1038,6 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_verif let (workspace_member_3, package_3) = get_cargo_metadata_package(&cwd.join(non_driver), non_driver, non_driver_version, None); - let expected_certmgr_output = get_certmgr_success_output(); - let test_build_action = &TestBuildAction::new(cwd.clone(), profile, target_arch, sample_class) .set_up_workspace_with_multiple_driver_projects( &cwd, @@ -1222,40 +1051,18 @@ pub fn given_a_workspace_with_multiple_driver_and_non_driver_projects_when_verif .expect_detect_wdk_build_number(25100u32) .expect_root_manifest_exists(&cwd, true) .expect_cargo_build(driver_name_1, &cwd.join(driver_name_1), None) - .expect_final_package_dir_exists(driver_name_1, &cwd, true) - .expect_inx_file_exists(driver_name_1, &cwd.join(driver_name_1), true) - .expect_rename_driver_binary_dll_to_sys(driver_name_1, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name_1, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name_1, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name_1, &cwd.join(driver_name_1), true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name_1, &cwd, true) - .expect_stampinf(driver_name_1, &cwd, None) - .expect_inf2cat(driver_name_1, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output.clone())) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name_1, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name_1, &cwd, None) - .expect_signtool_sign_cat_file(driver_name_1, &cwd, None) - .expect_infverif(driver_name_1, &cwd, "KMDF", None) + .expect_default_package_task_steps_for_workspace( + driver_name_1, + driver_type, + verify_signature, + ) // Second driver project .expect_cargo_build(driver_name_2, &cwd.join(driver_name_2), None) - .expect_final_package_dir_exists(driver_name_2, &cwd, true) - .expect_inx_file_exists(driver_name_2, &cwd.join(driver_name_2), true) - .expect_rename_driver_binary_dll_to_sys(driver_name_2, &cwd) - .expect_copy_driver_binary_sys_to_package_folder(driver_name_2, &cwd, true) - .expect_copy_pdb_file_to_package_folder(driver_name_2, &cwd, true) - .expect_copy_inx_file_to_package_folder(driver_name_2, &cwd.join(driver_name_2), true, &cwd) - .expect_copy_map_file_to_package_folder(driver_name_2, &cwd, true) - .expect_stampinf(driver_name_2, &cwd, None) - .expect_inf2cat(driver_name_2, &cwd, None) - .expect_self_signed_cert_file_exists(&cwd, false) - .expect_certmgr_exists_check(Some(expected_certmgr_output)) - .expect_makecert(&cwd, None) - .expect_copy_self_signed_cert_file_to_package_folder(driver_name_2, &cwd, true) - .expect_signtool_sign_driver_binary_sys_file(driver_name_2, &cwd, None) - .expect_signtool_sign_cat_file(driver_name_2, &cwd, None) - .expect_infverif(driver_name_2, &cwd, "KMDF", None) + .expect_default_package_task_steps_for_workspace( + driver_name_2, + driver_type, + verify_signature, + ) // Non-driver project .expect_cargo_build(non_driver, &cwd.join(non_driver), None); @@ -1654,6 +1461,20 @@ struct TestBuildAction { // Output argument in any method means to override return output from default // success with no stdout/stderr trait TestSetupPackageExpectations { + fn expect_default_build_task_steps(self, driver_name: &str) -> Self; + fn expect_default_package_task_steps( + self, + driver_name: &str, + driver_type: &str, + verify_signature: bool, + ) -> Self; + fn expect_default_package_task_steps_for_workspace( + self, + driver_name: &str, + driver_type: &str, + verify_signature: bool, + ) -> Self; + fn expect_root_manifest_exists(self, root_dir: &Path, does_exist: bool) -> Self; fn expect_self_signed_cert_file_exists(self, driver_dir: &Path, does_exist: bool) -> Self; fn expect_final_package_dir_exists( @@ -1872,6 +1693,79 @@ impl TestBuildAction { } impl TestSetupPackageExpectations for TestBuildAction { + fn expect_default_build_task_steps(self, driver_name: &str) -> Self { + let cwd = self.cwd.clone(); + self.expect_detect_wdk_build_number(25100u32) + .expect_root_manifest_exists(&cwd, true) + .expect_cargo_build(driver_name, &cwd, None) + } + + fn expect_default_package_task_steps( + self, + driver_name: &str, + driver_type: &str, + verify_signature: bool, + ) -> Self { + let cwd = self.cwd.clone(); + let expected_certmgr_output = get_certmgr_success_output(); + let expectations = self + .expect_final_package_dir_exists(driver_name, &cwd, true) + .expect_inx_file_exists(driver_name, &cwd, true) + .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) + .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, true) + .expect_copy_pdb_file_to_package_folder(driver_name, &cwd, true) + .expect_copy_inx_file_to_package_folder(driver_name, &cwd, true, &cwd) + .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) + .expect_stampinf(driver_name, &cwd, None) + .expect_inf2cat(driver_name, &cwd, None) + .expect_self_signed_cert_file_exists(&cwd, false) + .expect_certmgr_exists_check(Some(expected_certmgr_output)) + .expect_makecert(&cwd, None) + .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) + .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) + .expect_signtool_sign_cat_file(driver_name, &cwd, None) + .expect_infverif(driver_name, &cwd, driver_type, None); + if !verify_signature { + return expectations; + } + expectations + .expect_signtool_verify_driver_binary_sys_file(driver_name, &cwd, None) + .expect_signtool_verify_cat_file(driver_name, &cwd, None) + } + + fn expect_default_package_task_steps_for_workspace( + self, + driver_name: &str, + driver_type: &str, + verify_signature: bool, + ) -> Self { + let cwd = self.cwd.clone(); + let expected_certmgr_output = get_certmgr_success_output(); + let expectations = self + .expect_final_package_dir_exists(driver_name, &cwd, true) + .expect_inx_file_exists(driver_name, &cwd.join(driver_name), true) + .expect_rename_driver_binary_dll_to_sys(driver_name, &cwd) + .expect_copy_driver_binary_sys_to_package_folder(driver_name, &cwd, true) + .expect_copy_pdb_file_to_package_folder(driver_name, &cwd, true) + .expect_copy_inx_file_to_package_folder(driver_name, &cwd.join(driver_name), true, &cwd) + .expect_copy_map_file_to_package_folder(driver_name, &cwd, true) + .expect_stampinf(driver_name, &cwd, None) + .expect_inf2cat(driver_name, &cwd, None) + .expect_self_signed_cert_file_exists(&cwd, false) + .expect_certmgr_exists_check(Some(expected_certmgr_output)) + .expect_makecert(&cwd, None) + .expect_copy_self_signed_cert_file_to_package_folder(driver_name, &cwd, true) + .expect_signtool_sign_driver_binary_sys_file(driver_name, &cwd, None) + .expect_signtool_sign_cat_file(driver_name, &cwd, None) + .expect_infverif(driver_name, &cwd, driver_type, None); + if !verify_signature { + return expectations; + } + expectations + .expect_signtool_verify_driver_binary_sys_file(driver_name, &cwd, None) + .expect_signtool_verify_cat_file(driver_name, &cwd, None) + } + fn expect_root_manifest_exists(mut self, root_dir: &Path, does_exist: bool) -> Self { self.mock_fs_provider .expect_exists() From f111a15e7a4c6d278477c7abcf0bcfd16fae3156 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 8 Oct 2025 18:46:06 +0530 Subject: [PATCH 25/33] refactor: remove TestSetupPackageExpectations trait --- crates/cargo-wdk/src/actions/build/tests.rs | 160 +++----------------- 1 file changed, 17 insertions(+), 143 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/tests.rs b/crates/cargo-wdk/src/actions/build/tests.rs index 1ecd8a823..144248609 100644 --- a/crates/cargo-wdk/src/actions/build/tests.rs +++ b/crates/cargo-wdk/src/actions/build/tests.rs @@ -1359,7 +1359,7 @@ fn assert_build_action_run_is_success( target_arch: TargetArch, verify_signature: bool, sample_class: bool, - test_build_action: &impl TestSetupPackageExpectations, + test_build_action: &TestBuildAction, ) { let build_action = initialize_build_action( cwd, @@ -1380,7 +1380,7 @@ fn initialize_build_action<'a>( target_arch: TargetArch, verify_signature: bool, sample_class: bool, - test_build_action: &'a impl TestSetupPackageExpectations, + test_build_action: &'a TestBuildAction, ) -> Result, anyhow::Error> { BuildAction::new( &BuildActionParams { @@ -1418,7 +1418,7 @@ fn assert_build_action_run_with_env_is_success( target_arch: TargetArch, verify_signature: bool, sample_class: bool, - test_build_action: &impl TestSetupPackageExpectations, + test_build_action: &TestBuildAction, ) { let build_action = initialize_build_action( cwd, @@ -1456,135 +1456,6 @@ struct TestBuildAction { mock_metadata_provider: MetadataProvider, } -// Presence of method ensures specific mock expectation is set -// Dir argument in any method means to operate on the relevant dir -// Output argument in any method means to override return output from default -// success with no stdout/stderr -trait TestSetupPackageExpectations { - fn expect_default_build_task_steps(self, driver_name: &str) -> Self; - fn expect_default_package_task_steps( - self, - driver_name: &str, - driver_type: &str, - verify_signature: bool, - ) -> Self; - fn expect_default_package_task_steps_for_workspace( - self, - driver_name: &str, - driver_type: &str, - verify_signature: bool, - ) -> Self; - - fn expect_root_manifest_exists(self, root_dir: &Path, does_exist: bool) -> Self; - fn expect_self_signed_cert_file_exists(self, driver_dir: &Path, does_exist: bool) -> Self; - fn expect_final_package_dir_exists( - self, - driver_name: &str, - driver_dir: &Path, - does_exist: bool, - ) -> Self; - fn expect_dir_created(self, driver_name: &str, driver_dir: &Path, created: bool) -> Self; - fn expect_cargo_build( - self, - driver_name: &str, - driver_dir: &Path, - override_output: Option, - ) -> Self; - fn expect_inx_file_exists(self, driver_name: &str, driver_dir: &Path, does_exist: bool) - -> Self; - fn expect_rename_driver_binary_dll_to_sys(self, driver_name: &str, driver_dir: &Path) -> Self; - fn expect_copy_driver_binary_sys_to_package_folder( - self, - driver_name: &str, - driver_dir: &Path, - is_success: bool, - ) -> Self; - fn expect_copy_pdb_file_to_package_folder( - self, - driver_name: &str, - driver_dir: &Path, - is_success: bool, - ) -> Self; - fn expect_copy_inx_file_to_package_folder( - self, - driver_name: &str, - driver_dir: &Path, - is_success: bool, - workspace_root_dir: &Path, - ) -> Self; - fn expect_copy_map_file_to_package_folder( - self, - driver_name: &str, - driver_dir: &Path, - is_success: bool, - ) -> Self; - fn expect_copy_self_signed_cert_file_to_package_folder( - self, - driver_name: &str, - driver_dir: &Path, - is_success: bool, - ) -> Self; - - fn expect_stampinf( - self, - driver_name: &str, - driver_dir: &Path, - override_output: Option, - ) -> Self; - fn expect_inf2cat( - self, - driver_name: &str, - driver_dir: &Path, - override_output: Option, - ) -> Self; - fn expect_certmgr_exists_check(self, override_output: Option) -> Self; - fn expect_certmgr_create_cert_from_store( - self, - driver_dir: &Path, - override_output: Option, - ) -> Self; - fn expect_makecert(self, driver_dir: &Path, override_output: Option) -> Self; - - fn expect_signtool_sign_driver_binary_sys_file( - self, - driver_name: &str, - driver_dir: &Path, - override_output: Option, - ) -> Self; - fn expect_signtool_sign_cat_file( - self, - driver_name: &str, - driver_dir: &Path, - override_output: Option, - ) -> Self; - fn expect_signtool_verify_driver_binary_sys_file( - self, - driver_name: &str, - driver_dir: &Path, - override_output: Option, - ) -> Self; - fn expect_signtool_verify_cat_file( - self, - driver_name: &str, - driver_dir: &Path, - override_output: Option, - ) -> Self; - - fn expect_detect_wdk_build_number(self, expected_wdk_build_number: u32) -> Self; - fn expect_infverif( - self, - driver_name: &str, - driver_dir: &Path, - driver_type: &str, - override_output: Option, - ) -> Self; - - fn mock_wdk_build_provider(&self) -> &WdkBuild; - fn mock_run_command(&self) -> &CommandExec; - fn mock_fs_provider(&self) -> &Fs; - fn mock_metadata_provider(&self) -> &MetadataProvider; -} - impl TestBuildAction { fn new( cwd: PathBuf, @@ -1613,7 +1484,7 @@ impl TestBuildAction { fn set_up_standalone_driver_project( mut self, package_metadata: (TestMetadataWorkspaceMemberId, TestMetadataPackage), - ) -> impl TestSetupPackageExpectations { + ) -> Self { let cargo_toml_metadata = get_cargo_metadata( &self.cwd, vec![package_metadata.1], @@ -1637,7 +1508,7 @@ impl TestBuildAction { workspace_root_dir: &Path, workspace_additional_metadata: Option, package_metadata_list: Vec<(TestMetadataWorkspaceMemberId, TestMetadataPackage)>, - ) -> impl TestSetupPackageExpectations { + ) -> Self { let cargo_toml_metadata = get_cargo_metadata( workspace_root_dir, package_metadata_list.iter().map(|p| p.1.clone()).collect(), @@ -1661,10 +1532,7 @@ impl TestBuildAction { self } - fn set_up_with_custom_toml( - mut self, - cargo_toml_metadata: &str, - ) -> impl TestSetupPackageExpectations { + fn set_up_with_custom_toml(mut self, cargo_toml_metadata: &str) -> Self { let cargo_toml_metadata = serde_json::from_str::(cargo_toml_metadata) .expect("Failed to parse cargo metadata in set_up_with_custom_toml"); @@ -1692,7 +1560,13 @@ impl TestBuildAction { } } -impl TestSetupPackageExpectations for TestBuildAction { +// Presence of method ensures specific mock expectation is set +// Dir argument in any method means to operate on the relevant dir +// Output argument in any method means to override return output from default +// is_success boolean means success result of copy operation +// does_exist boolean means existence of the file or dir +// is_created boolean means whether the dir was created or not +impl TestBuildAction { fn expect_default_build_task_steps(self, driver_name: &str) -> Self { let cwd = self.cwd.clone(); self.expect_detect_wdk_build_number(25100u32) @@ -2687,19 +2561,19 @@ impl TestSetupPackageExpectations for TestBuildAction { self } - fn mock_wdk_build_provider(&self) -> &WdkBuild { + const fn mock_wdk_build_provider(&self) -> &WdkBuild { &self.mock_wdk_build_provider } - fn mock_run_command(&self) -> &CommandExec { + const fn mock_run_command(&self) -> &CommandExec { &self.mock_run_command } - fn mock_fs_provider(&self) -> &Fs { + const fn mock_fs_provider(&self) -> &Fs { &self.mock_fs_provider } - fn mock_metadata_provider(&self) -> &MetadataProvider { + const fn mock_metadata_provider(&self) -> &MetadataProvider { &self.mock_metadata_provider } } From f27b56a7632885254c180424840fceeb90a8ae24 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 8 Oct 2025 20:09:23 +0530 Subject: [PATCH 26/33] refactor: improve logging and regex handling for DriverVer in packaging tasks --- crates/cargo-wdk/src/actions/build/package_task.rs | 5 ++++- crates/cargo-wdk/tests/build_command_test.rs | 3 ++- 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 4a9b9fc55..5dd810d55 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -320,7 +320,10 @@ impl<'a> PackageTask<'a> { Ok(version) if !version.trim().is_empty() => { // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it // and populates DriverVer. - debug!("Using {STAMPINF_VERSION_ENV_VAR} env var to set DriverVer: {version}"); + debug!( + DriverVer = version, + "Using {STAMPINF_VERSION_ENV_VAR} env var to set DriverVer" + ); } _ => { args.extend(["-v", "*"]); diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 03fd9232a..54862b3f9 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -220,7 +220,8 @@ fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Opti }; // Example: DriverVer = 09/13/2023,1.0.0.0 - let driver_version_regex = driver_version.unwrap_or(r"\d+\.\d+\.\d+\.\d+"); + let driver_version_regex = + driver_version.map_or(r"\d+\.\d+\.\d+\.\d+".to_string(), regex::escape); let re = regex::Regex::new(&format!( r"^DriverVer\s+=\s+\d+/\d+/\d+,{driver_version_regex}$" )) From 359c9ae5ea43795581e9885f02bdf3f1806c2734 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 8 Oct 2025 20:10:22 +0530 Subject: [PATCH 27/33] refactor: organize imports for improved readability in build tests --- crates/cargo-wdk/src/actions/build/tests.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/tests.rs b/crates/cargo-wdk/src/actions/build/tests.rs index 144248609..992c614a0 100644 --- a/crates/cargo-wdk/src/actions/build/tests.rs +++ b/crates/cargo-wdk/src/actions/build/tests.rs @@ -15,17 +15,23 @@ use mockall::predicate::eq; use mockall_double::double; use wdk_build::{ metadata::{TryFromCargoMetadataError, Wdk}, - CpuArchitecture, DriverConfig, + CpuArchitecture, + DriverConfig, }; #[double] use crate::providers::{ - exec::CommandExec, fs::Fs, metadata::Metadata as MetadataProvider, wdk_build::WdkBuild, + exec::CommandExec, + fs::Fs, + metadata::Metadata as MetadataProvider, + wdk_build::WdkBuild, }; use crate::{ actions::{ build::{BuildAction, BuildActionError, BuildActionParams}, - to_target_triple, Profile, TargetArch, + to_target_triple, + Profile, + TargetArch, }, providers::error::{CommandError, FileError}, }; From 5546bb2928172bb7746b150d297b9e8cd64f52ef Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Wed, 8 Oct 2025 21:45:12 +0530 Subject: [PATCH 28/33] refactor: simplify regex handling for driver version in assert_driver_ver function --- crates/cargo-wdk/tests/build_command_test.rs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 54862b3f9..7782aa785 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -221,7 +221,7 @@ fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Opti // Example: DriverVer = 09/13/2023,1.0.0.0 let driver_version_regex = - driver_version.map_or(r"\d+\.\d+\.\d+\.\d+".to_string(), regex::escape); + driver_version.map_or_else(|| r"\d+\.\d+\.\d+\.\d+".to_string(), regex::escape); let re = regex::Regex::new(&format!( r"^DriverVer\s+=\s+\d+/\d+/\d+,{driver_version_regex}$" )) From b9f4e56fe0f3f2185854b8d1ceb01e1525941445 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Thu, 9 Oct 2025 15:37:55 +0530 Subject: [PATCH 29/33] refactor: improve comments for clarity in packaging and driver version assertion functions --- crates/cargo-wdk/src/actions/build/package_task.rs | 5 +++-- crates/cargo-wdk/tests/build_command_test.rs | 4 ++-- 2 files changed, 5 insertions(+), 4 deletions(-) diff --git a/crates/cargo-wdk/src/actions/build/package_task.rs b/crates/cargo-wdk/src/actions/build/package_task.rs index 5dd810d55..11f47a8f0 100644 --- a/crates/cargo-wdk/src/actions/build/package_task.rs +++ b/crates/cargo-wdk/src/actions/build/package_task.rs @@ -318,8 +318,9 @@ impl<'a> PackageTask<'a> { match std::env::var(STAMPINF_VERSION_ENV_VAR) { Ok(version) if !version.trim().is_empty() => { - // When STAMPINF_VERSION is set we intentionally omit -v so stampinf reads it - // and populates DriverVer. + // When STAMPINF_VERSION is set to a non-empty, non-whitespace value, we + // intentionally omit -v so stampinf reads it and populates + // DriverVer. (Whitespace-only values are ignored.) debug!( DriverVer = version, "Using {STAMPINF_VERSION_ENV_VAR} env var to set DriverVer" diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 7782aa785..7a051aabf 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -214,8 +214,8 @@ fn assert_driver_ver(package_path: &str, driver_name: &str, driver_version: Opti .collect::>(); String::from_utf16_lossy(&file_content) } else { - // Otherwise, treat the content as UTF-8; our test setups do not include UTF-16 - // BE encoded .inx files. + // Otherwise, treat the content as UTF-8; our test setups do not include + // UTF16-BE encoded .inx files. String::from_utf8_lossy(&file_content).to_string() }; From 8b37bcee90b16a6e5d896592aceb42a28bb98a26 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Fri, 10 Oct 2025 01:16:57 +0530 Subject: [PATCH 30/33] refactor: streamline file lock usage and enhance environment variable handling in tests --- crates/cargo-wdk/tests/build_command_test.rs | 43 +++++----- crates/cargo-wdk/tests/common.rs | 86 +++++++++++++------- crates/cargo-wdk/tests/new_command_test.rs | 50 ++++++------ 3 files changed, 103 insertions(+), 76 deletions(-) diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 7a051aabf..54e0ec040 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -8,21 +8,21 @@ use std::{ }; use assert_cmd::prelude::*; -use common::{set_crt_static_flag, with_file_lock}; +use common::{set_crt_static_flag, with_env, with_file_lock}; use sha2::{Digest, Sha256}; const STAMPINF_VERSION_ENV_VAR: &str = "STAMPINF_VERSION"; #[test] fn mixed_package_kmdf_workspace_builds_successfully() { - with_file_lock::<&str, &str, _>(&[], || { + let stdout = with_file_lock(|| { run_cargo_clean("tests/mixed-package-kmdf-workspace"); - let stdout = run_build_cmd("tests/mixed-package-kmdf-workspace"); - - assert!(stdout.contains("Building package driver")); - assert!(stdout.contains("Building package non_driver_crate")); - verify_driver_package_files("tests/mixed-package-kmdf-workspace", "driver", "sys", None); + run_build_cmd("tests/mixed-package-kmdf-workspace") }); + + assert!(stdout.contains("Building package driver")); + assert!(stdout.contains("Building package non_driver_crate")); + verify_driver_package_files("tests/mixed-package-kmdf-workspace", "driver", "sys", None); } #[test] @@ -57,42 +57,41 @@ fn kmdf_driver_builds_successfully() { assert!(output.status.success()); } - with_file_lock::<&str, &str, _>(&[], || clean_and_build_driver_project("kmdf", None)); + with_file_lock(|| clean_and_build_driver_project("kmdf", None)); } #[test] fn umdf_driver_builds_successfully() { - with_file_lock::<&str, &str, _>(&[], || clean_and_build_driver_project("umdf", None)); + with_file_lock(|| clean_and_build_driver_project("umdf", None)); } #[test] fn wdm_driver_builds_successfully() { - with_file_lock::<&str, &str, _>(&[], || clean_and_build_driver_project("wdm", None)); + with_file_lock(|| clean_and_build_driver_project("wdm", None)); } #[test] fn wdm_driver_builds_successfully_with_given_version() { - with_file_lock::<&str, &str, _>(&[(STAMPINF_VERSION_ENV_VAR, "5.1.0")], || { + with_env(&[(STAMPINF_VERSION_ENV_VAR, Some("5.1.0"))], || { clean_and_build_driver_project("wdm", Some("5.1.0.0")); }); } #[test] fn emulated_workspace_builds_successfully() { - with_file_lock::<&str, &str, _>(&[], || { - let emulated_workspace_path = "tests/emulated-workspace"; - let umdf_driver_workspace_path = format!("{emulated_workspace_path}/umdf-driver-workspace"); - + let emulated_workspace_path = "tests/emulated-workspace"; + let umdf_driver_workspace_path = format!("{emulated_workspace_path}/umdf-driver-workspace"); + let stdout = with_file_lock(|| { run_cargo_clean(&umdf_driver_workspace_path); - let stdout = run_build_cmd(emulated_workspace_path); + run_build_cmd(emulated_workspace_path) + }); - assert!(stdout.contains("Building package driver_1")); - assert!(stdout.contains("Building package driver_2")); - assert!(stdout.contains("Build completed successfully")); + assert!(stdout.contains("Building package driver_1")); + assert!(stdout.contains("Building package driver_2")); + assert!(stdout.contains("Build completed successfully")); - verify_driver_package_files(&umdf_driver_workspace_path, "driver_1", "dll", None); - verify_driver_package_files(&umdf_driver_workspace_path, "driver_2", "dll", None); - }); + verify_driver_package_files(&umdf_driver_workspace_path, "driver_1", "dll", None); + verify_driver_package_files(&umdf_driver_workspace_path, "driver_2", "dll", None); } fn clean_and_build_driver_project(driver_type: &str, driver_version: Option<&str>) { diff --git a/crates/cargo-wdk/tests/common.rs b/crates/cargo-wdk/tests/common.rs index 09def77eb..c71e6199d 100644 --- a/crates/cargo-wdk/tests/common.rs +++ b/crates/cargo-wdk/tests/common.rs @@ -35,42 +35,72 @@ pub fn set_crt_static_flag() { /// * Panics if the lock file cannot be created. /// * Panics if the lock cannot be acquired. /// * Panics if the lock cannot be released. -pub fn with_file_lock(env_vars_key_value_pairs: &[(K, V)], f: F) +pub fn with_file_lock(f: F) -> R where - K: AsRef + std::cmp::Eq + std::hash::Hash, - V: AsRef, - F: FnOnce(), + F: FnOnce() -> R, { let lock_file = std::fs::File::create("cargo-wdk-test.lock") .expect("Unable to create lock file for cargo-wdk tests"); FileExt::lock_exclusive(&lock_file).expect("Unable to cargo-wdk-test.lock file"); - let mut original_env_vars = HashMap::new(); + let result = f(); + FileExt::unlock(&lock_file).expect("Unable to unlock cargo-wdk-test.lock file"); + result +} - // set requested environment variables - for (key, value) in env_vars_key_value_pairs { - if let Ok(original_value) = std::env::var(key) { - let insert_result = original_env_vars.insert(key, original_value); - assert!( - insert_result.is_none(), - "Duplicate environment variable keys were provided" - ); +/// Runs function after modifying environment variables, and returns the +/// function's return value. +/// +/// The environment is guaranteed to be not modified during the execution +/// of the function, and the environment is reset to its original state +/// after execution of the function. No testing asserts should be called in +/// the function, since a failing test will poison the mutex, and cause all +/// remaining tests to fail. +/// +/// # Panics +/// +/// * Panics if called with duplicate environment variable keys. +/// * If the lock file cannot be created/locked/released. +pub fn with_env(env_vars_key_value_pairs: &[(K, Option)], f: F) -> R +where + K: AsRef + std::cmp::Eq + std::hash::Hash, + V: AsRef, + F: FnOnce() -> R, +{ + with_file_lock(|| { + let mut original_env_vars = HashMap::new(); + + // set requested environment variables + for (key, value) in env_vars_key_value_pairs { + if let Ok(original_value) = std::env::var(key) { + let insert_result = original_env_vars.insert(key, original_value); + assert!( + insert_result.is_none(), + "Duplicate environment variable keys were provided" + ); + } + + // Remove the env var if value is None + if let Some(value) = value { + std::env::set_var(key, value); + } else { + std::env::remove_var(key); + } } - std::env::set_var(key, value); - } + let result = f(); - f(); + // reset all set environment variables + for (key, _) in env_vars_key_value_pairs { + original_env_vars.get(key).map_or_else( + || { + std::env::remove_var(key); + }, + |value| { + std::env::set_var(key, value); + }, + ); + } - // reset all set environment variables - for (key, _) in env_vars_key_value_pairs { - original_env_vars.get(key).map_or_else( - || { - std::env::remove_var(key); - }, - |value| { - std::env::set_var(key, value); - }, - ); - } - FileExt::unlock(&lock_file).expect("Unable to unlock cargo-wdk-test.lock file"); + result + }) } diff --git a/crates/cargo-wdk/tests/new_command_test.rs b/crates/cargo-wdk/tests/new_command_test.rs index 0beb8c726..f06e03f71 100644 --- a/crates/cargo-wdk/tests/new_command_test.rs +++ b/crates/cargo-wdk/tests/new_command_test.rs @@ -60,17 +60,14 @@ fn help_works() { } fn project_is_created(driver_type: &str) { - with_file_lock::<&str, &str, _>(&[], || { - let (stdout, _stderr) = create_and_build_new_driver_project(driver_type); - assert!(stdout.contains( - "Required directive Provider missing, empty, or invalid in [Version] section." - )); - assert!(stdout - .contains("Required directive Class missing, empty, or invalid in [Version] section.")); - assert!(stdout - .contains("Invalid ClassGuid \"\", expecting {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}.")); - assert!(stdout.contains("INF is NOT VALID")); - }); + let (stdout, _stderr) = with_file_lock(|| create_and_build_new_driver_project(driver_type)); + assert!(stdout + .contains("Required directive Provider missing, empty, or invalid in [Version] section.")); + assert!(stdout + .contains("Required directive Class missing, empty, or invalid in [Version] section.")); + assert!(stdout + .contains("Invalid ClassGuid \"\", expecting {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}.")); + assert!(stdout.contains("INF is NOT VALID")); } fn test_command_invocation( @@ -79,7 +76,7 @@ fn test_command_invocation( command_succeeds: bool, assert: F, ) { - with_file_lock::<&str, &str, _>(&[], || { + let mut cmd = with_file_lock(|| { let mut args = args .iter() .map(ToString::to_string) @@ -96,21 +93,22 @@ fn test_command_invocation( let mut cmd = Command::cargo_bin("cargo-wdk").expect("unable to find cargo-wdk binary"); cmd.args(args); - - let cmd_assertion = cmd.assert(); - let cmd_assertion = if command_succeeds { - cmd_assertion.success() - } else { - cmd_assertion.failure() - }; - let output = cmd_assertion.get_output(); - let stdout = String::from_utf8_lossy(&output.stdout); - println!("stdout: {stdout}"); - let stderr = String::from_utf8_lossy(&output.stderr); - println!("stderr: {stderr}"); - - assert(&stdout, &stderr); + cmd }); + + let cmd_assertion = cmd.assert(); + let cmd_assertion = if command_succeeds { + cmd_assertion.success() + } else { + cmd_assertion.failure() + }; + let output = cmd_assertion.get_output(); + let stdout = String::from_utf8_lossy(&output.stdout); + println!("stdout: {stdout}"); + let stderr = String::from_utf8_lossy(&output.stderr); + println!("stderr: {stderr}"); + + assert(&stdout, &stderr); } fn create_and_build_new_driver_project(driver_type: &str) -> (String, String) { From 9b8d02270195acd86d12cbb67376752e251fd456 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Fri, 10 Oct 2025 01:41:15 +0530 Subject: [PATCH 31/33] refactor: replace common module with _test_utils for test utility functions --- crates/cargo-wdk/tests/{common.rs => _test_utils.rs} | 3 +++ crates/cargo-wdk/tests/build_command_test.rs | 4 ++-- crates/cargo-wdk/tests/new_command_test.rs | 4 ++-- 3 files changed, 7 insertions(+), 4 deletions(-) rename crates/cargo-wdk/tests/{common.rs => _test_utils.rs} (96%) diff --git a/crates/cargo-wdk/tests/common.rs b/crates/cargo-wdk/tests/_test_utils.rs similarity index 96% rename from crates/cargo-wdk/tests/common.rs rename to crates/cargo-wdk/tests/_test_utils.rs index c71e6199d..457123246 100644 --- a/crates/cargo-wdk/tests/common.rs +++ b/crates/cargo-wdk/tests/_test_utils.rs @@ -47,6 +47,9 @@ where result } +// FIXME: For whatever reason, clippy flags this function as dead code, even +// though it is used in build_command_test.rs +#[allow(dead_code)] /// Runs function after modifying environment variables, and returns the /// function's return value. /// diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index 54e0ec040..f5570d78e 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -1,14 +1,14 @@ //! System level tests for cargo wdk build flow #![allow(clippy::literal_string_with_formatting_args)] -mod common; +mod _test_utils; use std::{ fs, path::{Path, PathBuf}, process::Command, }; +use _test_utils::{set_crt_static_flag, with_env, with_file_lock}; use assert_cmd::prelude::*; -use common::{set_crt_static_flag, with_env, with_file_lock}; use sha2::{Digest, Sha256}; const STAMPINF_VERSION_ENV_VAR: &str = "STAMPINF_VERSION"; diff --git a/crates/cargo-wdk/tests/new_command_test.rs b/crates/cargo-wdk/tests/new_command_test.rs index f06e03f71..4bb0d1596 100644 --- a/crates/cargo-wdk/tests/new_command_test.rs +++ b/crates/cargo-wdk/tests/new_command_test.rs @@ -1,11 +1,11 @@ //! System level tests for cargo wdk new flow #![allow(clippy::literal_string_with_formatting_args)] -mod common; +mod _test_utils; use std::path::PathBuf; +use _test_utils::{set_crt_static_flag, with_file_lock}; use assert_cmd::Command; use assert_fs::{assert::PathAssert, prelude::PathChild, TempDir}; -use common::{set_crt_static_flag, with_file_lock}; use mockall::PredicateBooleanExt; #[test] From 246949ab598f5a778708dd1e700482635434f028 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Fri, 10 Oct 2025 13:38:00 +0530 Subject: [PATCH 32/33] refactor: replace _test_utils module with test_utils for consistency in test utility functions --- crates/cargo-wdk/tests/build_command_test.rs | 5 ++--- crates/cargo-wdk/tests/new_command_test.rs | 5 ++--- .../cargo-wdk/tests/{_test_utils.rs => test_utils/mod.rs} | 7 ++++--- 3 files changed, 8 insertions(+), 9 deletions(-) rename crates/cargo-wdk/tests/{_test_utils.rs => test_utils/mod.rs} (93%) diff --git a/crates/cargo-wdk/tests/build_command_test.rs b/crates/cargo-wdk/tests/build_command_test.rs index f5570d78e..0c88954ca 100644 --- a/crates/cargo-wdk/tests/build_command_test.rs +++ b/crates/cargo-wdk/tests/build_command_test.rs @@ -1,15 +1,14 @@ //! System level tests for cargo wdk build flow -#![allow(clippy::literal_string_with_formatting_args)] -mod _test_utils; +mod test_utils; use std::{ fs, path::{Path, PathBuf}, process::Command, }; -use _test_utils::{set_crt_static_flag, with_env, with_file_lock}; use assert_cmd::prelude::*; use sha2::{Digest, Sha256}; +use test_utils::{set_crt_static_flag, with_env, with_file_lock}; const STAMPINF_VERSION_ENV_VAR: &str = "STAMPINF_VERSION"; diff --git a/crates/cargo-wdk/tests/new_command_test.rs b/crates/cargo-wdk/tests/new_command_test.rs index 4bb0d1596..f551dfad7 100644 --- a/crates/cargo-wdk/tests/new_command_test.rs +++ b/crates/cargo-wdk/tests/new_command_test.rs @@ -1,12 +1,11 @@ //! System level tests for cargo wdk new flow -#![allow(clippy::literal_string_with_formatting_args)] -mod _test_utils; +mod test_utils; use std::path::PathBuf; -use _test_utils::{set_crt_static_flag, with_file_lock}; use assert_cmd::Command; use assert_fs::{assert::PathAssert, prelude::PathChild, TempDir}; use mockall::PredicateBooleanExt; +use test_utils::{set_crt_static_flag, with_file_lock}; #[test] fn kmdf_driver_is_created_successfully() { diff --git a/crates/cargo-wdk/tests/_test_utils.rs b/crates/cargo-wdk/tests/test_utils/mod.rs similarity index 93% rename from crates/cargo-wdk/tests/_test_utils.rs rename to crates/cargo-wdk/tests/test_utils/mod.rs index 457123246..7dd0563f3 100644 --- a/crates/cargo-wdk/tests/_test_utils.rs +++ b/crates/cargo-wdk/tests/test_utils/mod.rs @@ -1,6 +1,7 @@ -//! Common methods for tests. - -#![allow(clippy::literal_string_with_formatting_args)] +//! Utility methods for tests. +//! Note: The current layout (`tests/test_utils/mod.rs`) is intentional; using a +//! subdirectory prevents Cargo from treating this as an independent integration +//! test crate and instead lets other tests import it as a regular module. use std::{collections::HashMap, ffi::OsStr}; From 1ca8dc31c863a3fc370b2dbbead6364b8d7060f4 Mon Sep 17 00:00:00 2001 From: krishnakumar4a4 Date: Fri, 10 Oct 2025 18:22:17 +0530 Subject: [PATCH 33/33] refactor: update dead code allowance for with_env function to clarify usage in tests --- crates/cargo-wdk/tests/test_utils/mod.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/crates/cargo-wdk/tests/test_utils/mod.rs b/crates/cargo-wdk/tests/test_utils/mod.rs index 7dd0563f3..e266d6d9f 100644 --- a/crates/cargo-wdk/tests/test_utils/mod.rs +++ b/crates/cargo-wdk/tests/test_utils/mod.rs @@ -48,9 +48,11 @@ where result } -// FIXME: For whatever reason, clippy flags this function as dead code, even -// though it is used in build_command_test.rs -#[allow(dead_code)] +#[allow( + dead_code, + reason = "This method is used only in build_command_test.rs; appears unused in other \ + integration test crates when running with --all-targets." +)] /// Runs function after modifying environment variables, and returns the /// function's return value. ///