test: increase coverage build function

crates/pop-cli/src/commands/build/contract.rs

@@ -1,12 +1,13 @@
 // SPDX-License-Identifier: GPL-3.0
-
-use std::path::PathBuf;
-
 use clap::Args;
 use cliclack::{clear_screen, intro, log, outro, set_theme};
 use console::style;
+use std::path::PathBuf;
 
+#[cfg(test)]
+use crate::mock::build_smart_contract;
 use crate::style::Theme;
+#[cfg(not(test))]
 use pop_contracts::build_smart_contract;
 
 #[derive(Args)]
@@ -27,3 +28,32 @@ impl BuildContractCommand {
 		Ok(())
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::new::contract::NewContractCommand;
+	use anyhow::{Error, Result};
+
+	async fn setup_test_environment() -> Result<tempfile::TempDir, Error> {
+		let temp_contract_dir = tempfile::tempdir().expect("Could not create temp dir");
+		let command = NewContractCommand {
+			name: "test_contract".to_string(),
+			path: Some(PathBuf::from(temp_contract_dir.path())),
+		};
+		command.execute().await?;
+
+		Ok(temp_contract_dir)
+	}
+
+	#[tokio::test]
+	async fn test_build_success() -> Result<()> {
+		let temp_dir = setup_test_environment().await?;
+		let command = BuildContractCommand {
+			path: Some(PathBuf::from(temp_dir.path().join("test_contract"))),
+		};
+
+		command.execute()?;
+		Ok(())
+	}
+}

crates/pop-cli/src/commands/build/parachain.rs

@@ -1,8 +1,10 @@
 // SPDX-License-Identifier: GPL-3.0
-
+#[cfg(test)]
+use crate::mock::build_parachain;
 use crate::style::{style, Theme};
 use clap::Args;
 use cliclack::{clear_screen, intro, log::warning, outro, set_theme};
+#[cfg(not(test))]
 use pop_parachains::build_parachain;
 use std::path::PathBuf;
 
@@ -29,3 +31,38 @@ impl BuildParachainCommand {
 		Ok(())
 	}
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use crate::new::parachain::NewParachainCommand;
+	use anyhow::{Error, Result};
+	use pop_parachains::{Provider, Template};
+
+	async fn setup_test_environment() -> Result<tempfile::TempDir, Error> {
+		let temp_dir = tempfile::tempdir().expect("Could not create temp dir");
+		let command = NewParachainCommand {
+			name: Some(temp_dir.path().join("test_parachain").to_str().unwrap().to_string()),
+			provider: Some(Provider::Pop),
+			template: Some(Template::Standard),
+			release_tag: None,
+			symbol: Some("UNIT".to_string()),
+			decimals: Some(12),
+			initial_endowment: Some("1u64 << 60".to_string()),
+		};
+		command.execute().await?;
+
+		Ok(temp_dir)
+	}
+
+	#[tokio::test]
+	async fn test_build_success() -> Result<()> {
+		let temp_dir = setup_test_environment().await?;
+		let command = BuildParachainCommand {
+			path: Some(PathBuf::from(temp_dir.path().join("test_parachain"))),
+		};
+
+		command.execute()?;
+		Ok(())
+	}
+}

crates/pop-cli/src/main.rs

@@ -5,6 +5,8 @@ compile_error!("feature \"contract\" or feature \"parachain\" must be enabled");
 
 #[cfg(any(feature = "parachain", feature = "contract"))]
 mod commands;
+#[cfg(test)]
+mod mock;
 mod style;
 
 use anyhow::anyhow;

crates/pop-cli/src/mock.rs

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: GPL-3.0
+use std::path::PathBuf;
+
+// Mock the build function for parachains
+#[cfg(test)]
+pub fn build_parachain(_path: &Option<PathBuf>) -> anyhow::Result<()> {
+	Ok(())
+}
+
+// Mock the build function for smart contracts
+#[cfg(test)]
+pub fn build_smart_contract(_path: &Option<PathBuf>) -> anyhow::Result<String> {
+	Ok("Ok".to_string())
+}

crates/pop-contracts/src/build.rs

@@ -1,5 +1,8 @@
 // SPDX-License-Identifier: GPL-3.0
-use contract_build::{execute, ExecuteArgs};
+#[cfg(test)]
+use crate::mock::execute;
+#[cfg(not(test))]
+use contract_build::execute;
 use std::path::PathBuf;
 
 use crate::utils::helpers::get_manifest_path;
@@ -8,11 +11,28 @@ use crate::utils::helpers::get_manifest_path;
 pub fn build_smart_contract(path: &Option<PathBuf>) -> anyhow::Result<String> {
 	let manifest_path = get_manifest_path(path)?;
 	// Default values
-	let args = ExecuteArgs { manifest_path, ..Default::default() };
+	let args = contract_build::ExecuteArgs { manifest_path, ..Default::default() };
 
 	// Execute the build and log the output of the build
 	let result = execute(args)?;
 	let formatted_result = result.display();
 
 	Ok(formatted_result)
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use anyhow::Result;
+
+	#[test]
+	fn test_build_contract() -> Result<()> {
+		let temp_dir = tempfile::tempdir().expect("Could not create temp dir");
+		let result = build_smart_contract(&Some(PathBuf::from(temp_dir.path())))?;
+		assert!(result.contains("Original wasm size:"));
+		assert!(result.contains("64.0K"));
+		assert!(result.contains("Optimized:"));
+		assert!(result.contains("32.0K"));
+		Ok(())
+	}
+}

crates/pop-contracts/src/lib.rs

@@ -8,6 +8,9 @@ mod test;
 mod up;
 mod utils;
 
+#[cfg(test)]
+mod mock;
+
 pub use build::build_smart_contract;
 pub use call::{
 	call_smart_contract, dry_run_call, dry_run_gas_estimate_call, set_up_call, CallOpts,

crates/pop-contracts/src/mock.rs

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: GPL-3.0
+use std::path::PathBuf;
+
+use contract_build::{
+	BuildResult, ExecuteArgs, MetadataArtifacts, OptimizationResult, OutputType, Verbosity,
+};
+// Mock the call to the `execute` function of the `contract_build' crate that builds the contract
+pub fn execute(_args: ExecuteArgs) -> anyhow::Result<BuildResult> {
+	Ok(BuildResult {
+		dest_wasm: Some(PathBuf::from("/path/to/contract.wasm")),
+		metadata_result: Some(MetadataArtifacts {
+			dest_metadata: PathBuf::from("/path/to/contract.json"),
+			dest_bundle: PathBuf::from("/path/to/contract.contract"),
+		}),
+		target_directory: PathBuf::from("/path/to/target"),
+		optimization_result: Some(OptimizationResult { original_size: 64.0, optimized_size: 32.0 }),
+		build_mode: Default::default(),
+		build_artifact: Default::default(),
+		image: None,
+		verbosity: Verbosity::Quiet,
+		output_type: OutputType::Json,
+	})
+}

crates/pop-parachains/src/build.rs

@@ -1,4 +1,7 @@
 // SPDX-License-Identifier: GPL-3.0
+#[cfg(test)]
+use crate::mock::cmd;
+#[cfg(not(test))]
 use duct::cmd;
 use std::path::PathBuf;
 
@@ -10,3 +13,16 @@ pub fn build_parachain(path: &Option<PathBuf>) -> anyhow::Result<()> {
 
 	Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+	use super::*;
+	use anyhow::Result;
+
+	#[test]
+	fn test_build_parachain() -> Result<()> {
+		let temp_dir = tempfile::tempdir().expect("Could not create temp dir");
+		build_parachain(&Some(PathBuf::from(temp_dir.path())))?;
+		Ok(())
+	}
+}

crates/pop-parachains/src/lib.rs

@@ -9,6 +9,9 @@ mod templates;
 mod up;
 mod utils;
 
+#[cfg(test)]
+mod mock;
+
 pub use build::build_parachain;
 pub use errors::Error;
 pub use new_pallet::{create_pallet_template, TemplatePalletConfig};

crates/pop-parachains/src/mock.rs

@@ -0,0 +1,6 @@
+// SPDX-License-Identifier: GPL-3.0
+
+// Mock the command that builds the parachain
+pub fn cmd(_program: &str, _args: Vec<&str>) -> duct::Expression {
+	duct::cmd!("echo")
+}