From e91b9d2fce8d40ccbaa5efd95f3fd715a11be6ee Mon Sep 17 00:00:00 2001 From: nabil-Tounarti Date: Wed, 8 Oct 2025 10:20:00 +0200 Subject: [PATCH 1/4] feat: rename bulk env vars --- pre-compute/src/compute/pre_compute_app.rs | 2 +- pre-compute/src/compute/pre_compute_args.rs | 112 ++++++++------------ pre-compute/src/compute/utils/env_utils.rs | 71 ++++++------- 3 files changed, 79 insertions(+), 106 deletions(-) diff --git a/pre-compute/src/compute/pre_compute_app.rs b/pre-compute/src/compute/pre_compute_app.rs index 829ded0..ca12b10 100644 --- a/pre-compute/src/compute/pre_compute_app.rs +++ b/pre-compute/src/compute/pre_compute_app.rs @@ -187,7 +187,7 @@ mod tests { input_files: urls.into_iter().map(String::from).collect(), output_dir: output_dir.to_string(), is_dataset_required: true, - bulk_size: 0, + iexec_bulk_slice_size: 0, datasets: vec![Dataset { url: HTTP_DATASET_URL.to_string(), checksum: DATASET_CHECKSUM.to_string(), diff --git a/pre-compute/src/compute/pre_compute_args.rs b/pre-compute/src/compute/pre_compute_args.rs index 781d893..2472e4d 100644 --- a/pre-compute/src/compute/pre_compute_args.rs +++ b/pre-compute/src/compute/pre_compute_args.rs @@ -15,7 +15,7 @@ pub struct PreComputeArgs { // Input files pub input_files: Vec, // Bulk processing - pub bulk_size: usize, + pub iexec_bulk_slice_size: usize, pub datasets: Vec, } @@ -28,24 +28,24 @@ impl PreComputeArgs { /// - `IEXEC_PRE_COMPUTE_OUT`: Output directory path /// - `IEXEC_DATASET_REQUIRED`: Boolean ("true"/"false") indicating dataset requirement /// - `IEXEC_INPUT_FILES_NUMBER`: Number of input files to load - /// - `BULK_SIZE`: Number of bulk datasets (0 means no bulk processing) + /// - `IEXEC_BULK_SLICE_SIZE`: Number of bulk datasets (0 means no bulk processing) /// - Required when `IEXEC_DATASET_REQUIRED` = "true": /// - `IEXEC_DATASET_URL`: Encrypted dataset URL /// - `IEXEC_DATASET_KEY`: Base64-encoded dataset encryption key /// - `IEXEC_DATASET_CHECKSUM`: Encrypted dataset checksum /// - `IEXEC_DATASET_FILENAME`: Decrypted dataset filename - /// - Required when `BULK_SIZE` > 0 (for each dataset index from 1 to BULK_SIZE): - /// - `BULK_DATASET_#_URL`: Dataset URL - /// - `BULK_DATASET_#_CHECKSUM`: Dataset checksum - /// - `BULK_DATASET_#_FILENAME`: Dataset filename - /// - `BULK_DATASET_#_KEY`: Dataset decryption key + /// - Required when `IEXEC_BULK_SLICE_SIZE` > 0 (for each dataset index from 1 to IEXEC_BULK_SLICE_SIZE): + /// - `IEXEC_DATASET_#_URL`: Dataset URL + /// - `IEXEC_DATASET_#_CHECKSUM`: Dataset checksum + /// - `IEXEC_DATASET_#_FILENAME`: Dataset filename + /// - `IEXEC_DATASET_#_KEY`: Dataset decryption key /// - Input file URLs (`IEXEC_INPUT_FILE_URL_1`, `IEXEC_INPUT_FILE_URL_2`, etc.) /// /// # Errors /// Returns `ReplicateStatusCause` error variants for: /// - Missing required environment variables /// - Invalid boolean values in `IEXEC_DATASET_REQUIRED` - /// - Invalid numeric format in `IEXEC_INPUT_FILES_NUMBER` or `BULK_SIZE` + /// - Invalid numeric format in `IEXEC_INPUT_FILES_NUMBER` or `IEXEC_BULK_SLICE_SIZE` /// - Missing dataset parameters when required /// - Missing input file URLs /// - Missing bulk dataset parameters when bulk processing is enabled @@ -73,51 +73,33 @@ impl PreComputeArgs { .parse::() .map_err(|_| ReplicateStatusCause::PreComputeIsDatasetRequiredMissing)?; - // Read bulk size (defaults to 0 if not present for backward compatibility) - let bulk_size_str = std::env::var(TeeSessionEnvironmentVariable::BulkSize.name()) - .unwrap_or("0".to_string()); - let bulk_size = bulk_size_str + // Read iexec bulk slice size (defaults to 0 if not present for backward compatibility) + let iexec_bulk_slice_size_str = + std::env::var(TeeSessionEnvironmentVariable::IexecBulkSliceSize.name()) + .unwrap_or("0".to_string()); + let iexec_bulk_slice_size = iexec_bulk_slice_size_str .parse::() .map_err(|_| ReplicateStatusCause::PreComputeIsDatasetRequiredMissing)?; - let mut datasets = Vec::with_capacity(bulk_size + 1); + let mut datasets = Vec::with_capacity(iexec_bulk_slice_size + 1); - if is_dataset_required { + // Read datasets + let start_index = if is_dataset_required { 0 } else { 1 }; + for i in start_index..=iexec_bulk_slice_size { let url = get_env_var_or_error( - TeeSessionEnvironmentVariable::IexecDatasetUrl, - ReplicateStatusCause::PreComputeDatasetUrlMissing, - )?; - let key = get_env_var_or_error( - TeeSessionEnvironmentVariable::IexecDatasetKey, - ReplicateStatusCause::PreComputeDatasetKeyMissing, - )?; - let checksum = get_env_var_or_error( - TeeSessionEnvironmentVariable::IexecDatasetChecksum, - ReplicateStatusCause::PreComputeDatasetChecksumMissing, - )?; - let filename = get_env_var_or_error( - TeeSessionEnvironmentVariable::IexecDatasetFilename, - ReplicateStatusCause::PreComputeDatasetFilenameMissing, - )?; - datasets.push(Dataset::new(url, checksum, filename, key)); - } - - // Read bulk datasets - for i in 1..=bulk_size { - let url = get_env_var_or_error( - TeeSessionEnvironmentVariable::BulkDatasetUrl(i), + TeeSessionEnvironmentVariable::IexecDatasetUrl(i), ReplicateStatusCause::PreComputeDatasetUrlMissing, )?; let checksum = get_env_var_or_error( - TeeSessionEnvironmentVariable::BulkDatasetChecksum(i), + TeeSessionEnvironmentVariable::IexecDatasetChecksum(i), ReplicateStatusCause::PreComputeDatasetChecksumMissing, )?; let filename = get_env_var_or_error( - TeeSessionEnvironmentVariable::BulkDatasetFilename(i), + TeeSessionEnvironmentVariable::IexecDatasetFilename(i), ReplicateStatusCause::PreComputeDatasetFilenameMissing, )?; let key = get_env_var_or_error( - TeeSessionEnvironmentVariable::BulkDatasetKey(i), + TeeSessionEnvironmentVariable::IexecDatasetKey(i), ReplicateStatusCause::PreComputeDatasetKeyMissing, )?; @@ -145,7 +127,7 @@ impl PreComputeArgs { output_dir, is_dataset_required, input_files, - bulk_size, + iexec_bulk_slice_size, datasets, }) } @@ -169,16 +151,16 @@ mod tests { vars.insert(IexecPreComputeOut.name(), OUTPUT_DIR.to_string()); vars.insert(IsDatasetRequired.name(), "true".to_string()); vars.insert(IexecInputFilesNumber.name(), "0".to_string()); - vars.insert(BulkSize.name(), "0".to_string()); // Default to no bulk processing + vars.insert(IexecBulkSliceSize.name(), "0".to_string()); // Default to no bulk processing vars } fn setup_dataset_env_vars() -> HashMap { let mut vars = HashMap::new(); - vars.insert(IexecDatasetUrl.name(), DATASET_URL.to_string()); - vars.insert(IexecDatasetKey.name(), DATASET_KEY.to_string()); - vars.insert(IexecDatasetChecksum.name(), DATASET_CHECKSUM.to_string()); - vars.insert(IexecDatasetFilename.name(), DATASET_FILENAME.to_string()); + vars.insert(IexecDatasetUrl(0).name(), DATASET_URL.to_string()); + vars.insert(IexecDatasetKey(0).name(), DATASET_KEY.to_string()); + vars.insert(IexecDatasetChecksum(0).name(), DATASET_CHECKSUM.to_string()); + vars.insert(IexecDatasetFilename(0).name(), DATASET_FILENAME.to_string()); vars } @@ -198,19 +180,19 @@ mod tests { // TODO: Collect all errors instead of propagating immediately, and return the list of errors fn setup_bulk_dataset_env_vars(count: usize) -> HashMap { let mut vars = HashMap::new(); - vars.insert(BulkSize.name(), count.to_string()); + vars.insert(IexecBulkSliceSize.name(), count.to_string()); for i in 1..=count { vars.insert( - BulkDatasetUrl(i).name(), + IexecDatasetUrl(i).name(), format!("https://bulk-dataset-{i}.bin"), ); - vars.insert(BulkDatasetChecksum(i).name(), format!("0x{i}23checksum")); + vars.insert(IexecDatasetChecksum(i).name(), format!("0x{i}23checksum")); vars.insert( - BulkDatasetFilename(i).name(), + IexecDatasetFilename(i).name(), format!("bulk-dataset-{i}.txt"), ); - vars.insert(BulkDatasetKey(i).name(), format!("bulkKey{i}23")); + vars.insert(IexecDatasetKey(i).name(), format!("bulkKey{i}23")); } vars } @@ -235,7 +217,7 @@ mod tests { assert!(!args.is_dataset_required); assert_eq!(args.input_files.len(), 1); assert_eq!(args.input_files[0], "https://input-1.txt"); - assert_eq!(args.bulk_size, 0); + assert_eq!(args.iexec_bulk_slice_size, 0); assert_eq!(args.datasets.len(), 0); }); } @@ -260,7 +242,7 @@ mod tests { assert_eq!(args.datasets[0].checksum, DATASET_CHECKSUM.to_string()); assert_eq!(args.datasets[0].filename, DATASET_FILENAME.to_string()); assert_eq!(args.input_files.len(), 0); - assert_eq!(args.bulk_size, 0); + assert_eq!(args.iexec_bulk_slice_size, 0); assert_eq!(args.datasets.len(), 1); }); } @@ -285,7 +267,7 @@ mod tests { assert_eq!(args.input_files[0], "https://input-1.txt"); assert_eq!(args.input_files[1], "https://input-2.txt"); assert_eq!(args.input_files[2], "https://input-3.txt"); - assert_eq!(args.bulk_size, 0); + assert_eq!(args.iexec_bulk_slice_size, 0); assert_eq!(args.datasets.len(), 0); }); } @@ -359,7 +341,7 @@ mod tests { assert_eq!(args.output_dir, OUTPUT_DIR); assert!(!args.is_dataset_required); - assert_eq!(args.bulk_size, 3); + assert_eq!(args.iexec_bulk_slice_size, 3); assert_eq!(args.datasets.len(), 3); assert_eq!(args.input_files.len(), 0); @@ -398,7 +380,7 @@ mod tests { assert_eq!(args.output_dir, OUTPUT_DIR); assert!(args.is_dataset_required); - assert_eq!(args.bulk_size, 2); + assert_eq!(args.iexec_bulk_slice_size, 2); assert_eq!(args.datasets.len(), 3); // 1 regular + 2 bulk datasets assert_eq!(args.input_files.len(), 0); @@ -415,10 +397,10 @@ mod tests { } #[test] - fn read_args_fails_when_invalid_bulk_size_format() { + fn read_args_fails_when_invalid_iexec_bulk_slice_size_format() { let mut env_vars = setup_basic_env_vars(); env_vars.insert(IsDatasetRequired.name(), "false".to_string()); - env_vars.insert(BulkSize.name(), "not-a-number".to_string()); + env_vars.insert(IexecBulkSliceSize.name(), "not-a-number".to_string()); env_vars.extend(setup_input_files_env_vars(0)); temp_env::with_vars(to_temp_env_vars(env_vars), || { @@ -438,7 +420,7 @@ mod tests { env_vars.extend(setup_input_files_env_vars(0)); env_vars.extend(setup_bulk_dataset_env_vars(2)); // Remove one of the bulk dataset URLs - env_vars.remove(&BulkDatasetUrl(1).name()); + env_vars.remove(&IexecDatasetUrl(1).name()); temp_env::with_vars(to_temp_env_vars(env_vars), || { let result = PreComputeArgs::read_args(); @@ -457,7 +439,7 @@ mod tests { env_vars.extend(setup_input_files_env_vars(0)); env_vars.extend(setup_bulk_dataset_env_vars(2)); // Remove one of the bulk dataset checksums - env_vars.remove(&BulkDatasetChecksum(2).name()); + env_vars.remove(&IexecDatasetChecksum(2).name()); temp_env::with_vars(to_temp_env_vars(env_vars), || { let result = PreComputeArgs::read_args(); @@ -476,7 +458,7 @@ mod tests { env_vars.extend(setup_input_files_env_vars(0)); env_vars.extend(setup_bulk_dataset_env_vars(3)); // Remove one of the bulk dataset filenames - env_vars.remove(&BulkDatasetFilename(2).name()); + env_vars.remove(&IexecDatasetFilename(2).name()); temp_env::with_vars(to_temp_env_vars(env_vars), || { let result = PreComputeArgs::read_args(); @@ -495,7 +477,7 @@ mod tests { env_vars.extend(setup_input_files_env_vars(0)); env_vars.extend(setup_bulk_dataset_env_vars(2)); // Remove one of the bulk dataset keys - env_vars.remove(&BulkDatasetKey(1).name()); + env_vars.remove(&IexecDatasetKey(1).name()); temp_env::with_vars(to_temp_env_vars(env_vars), || { let result = PreComputeArgs::read_args(); @@ -525,19 +507,19 @@ mod tests { ReplicateStatusCause::PreComputeInputFilesNumberMissing, ), ( - IexecDatasetUrl, + IexecDatasetUrl(0), ReplicateStatusCause::PreComputeDatasetUrlMissing, ), ( - IexecDatasetKey, + IexecDatasetKey(0), ReplicateStatusCause::PreComputeDatasetKeyMissing, ), ( - IexecDatasetChecksum, + IexecDatasetChecksum(0), ReplicateStatusCause::PreComputeDatasetChecksumMissing, ), ( - IexecDatasetFilename, + IexecDatasetFilename(0), ReplicateStatusCause::PreComputeDatasetFilenameMissing, ), ( diff --git a/pre-compute/src/compute/utils/env_utils.rs b/pre-compute/src/compute/utils/env_utils.rs index 972b1f4..53aa0d7 100644 --- a/pre-compute/src/compute/utils/env_utils.rs +++ b/pre-compute/src/compute/utils/env_utils.rs @@ -2,15 +2,11 @@ use crate::compute::errors::ReplicateStatusCause; use std::env; pub enum TeeSessionEnvironmentVariable { - BulkSize, - BulkDatasetUrl(usize), - BulkDatasetChecksum(usize), - BulkDatasetFilename(usize), - BulkDatasetKey(usize), - IexecDatasetChecksum, - IexecDatasetFilename, - IexecDatasetKey, - IexecDatasetUrl, + IexecBulkSliceSize, + IexecDatasetChecksum(usize), + IexecDatasetFilename(usize), + IexecDatasetKey(usize), + IexecDatasetUrl(usize), IexecInputFileUrlPrefix(usize), IexecInputFilesNumber, IexecPreComputeOut, @@ -24,43 +20,38 @@ pub enum TeeSessionEnvironmentVariable { impl TeeSessionEnvironmentVariable { pub fn name(&self) -> String { match self { - TeeSessionEnvironmentVariable::BulkSize => "BULK_SIZE".to_string(), - TeeSessionEnvironmentVariable::BulkDatasetUrl(index) => { - format!("BULK_DATASET_{index}_URL") - } - TeeSessionEnvironmentVariable::BulkDatasetChecksum(index) => { - format!("BULK_DATASET_{index}_CHECKSUM") - } - TeeSessionEnvironmentVariable::BulkDatasetFilename(index) => { - format!("BULK_DATASET_{index}_FILENAME") + Self::IexecBulkSliceSize => "IEXEC_BULK_SLICE_SIZE".to_string(), + + Self::IexecDatasetChecksum(0) => "IEXEC_DATASET_CHECKSUM".to_string(), + Self::IexecDatasetChecksum(index) => { + format!("IEXEC_DATASET_{index}_CHECKSUM") } - TeeSessionEnvironmentVariable::BulkDatasetKey(index) => { - format!("BULK_DATASET_{index}_KEY") + + Self::IexecDatasetFilename(0) => "IEXEC_DATASET_FILENAME".to_string(), + Self::IexecDatasetFilename(index) => { + format!("IEXEC_DATASET_{index}_FILENAME") } - TeeSessionEnvironmentVariable::IexecDatasetChecksum => { - "IEXEC_DATASET_CHECKSUM".to_string() + + Self::IexecDatasetKey(0) => "IEXEC_DATASET_KEY".to_string(), + Self::IexecDatasetKey(index) => { + format!("IEXEC_DATASET_{index}_KEY") } - TeeSessionEnvironmentVariable::IexecDatasetFilename => { - "IEXEC_DATASET_FILENAME".to_string() + + Self::IexecDatasetUrl(0) => "IEXEC_DATASET_URL".to_string(), + Self::IexecDatasetUrl(index) => { + format!("IEXEC_DATASET_{index}_URL") } - TeeSessionEnvironmentVariable::IexecDatasetKey => "IEXEC_DATASET_KEY".to_string(), - TeeSessionEnvironmentVariable::IexecDatasetUrl => "IEXEC_DATASET_URL".to_string(), - TeeSessionEnvironmentVariable::IexecInputFileUrlPrefix(index) => { + + Self::IexecInputFileUrlPrefix(index) => { format!("IEXEC_INPUT_FILE_URL_{index}") } - TeeSessionEnvironmentVariable::IexecInputFilesNumber => { - "IEXEC_INPUT_FILES_NUMBER".to_string() - } - TeeSessionEnvironmentVariable::IexecPreComputeOut => { - "IEXEC_PRE_COMPUTE_OUT".to_string() - } - TeeSessionEnvironmentVariable::IexecTaskId => "IEXEC_TASK_ID".to_string(), - TeeSessionEnvironmentVariable::IsDatasetRequired => "IS_DATASET_REQUIRED".to_string(), - TeeSessionEnvironmentVariable::SignTeeChallengePrivateKey => { - "SIGN_TEE_CHALLENGE_PRIVATE_KEY".to_string() - } - TeeSessionEnvironmentVariable::SignWorkerAddress => "SIGN_WORKER_ADDRESS".to_string(), - TeeSessionEnvironmentVariable::WorkerHostEnvVar => "WORKER_HOST_ENV_VAR".to_string(), + Self::IexecInputFilesNumber => "IEXEC_INPUT_FILES_NUMBER".to_string(), + Self::IexecPreComputeOut => "IEXEC_PRE_COMPUTE_OUT".to_string(), + Self::IexecTaskId => "IEXEC_TASK_ID".to_string(), + Self::IsDatasetRequired => "IS_DATASET_REQUIRED".to_string(), + Self::SignTeeChallengePrivateKey => "SIGN_TEE_CHALLENGE_PRIVATE_KEY".to_string(), + Self::SignWorkerAddress => "SIGN_WORKER_ADDRESS".to_string(), + Self::WorkerHostEnvVar => "WORKER_HOST_ENV_VAR".to_string(), } } } From ad910bb877d0160652745969e601c1b6962612c6 Mon Sep 17 00:00:00 2001 From: nabil-Tounarti Date: Wed, 8 Oct 2025 14:25:12 +0200 Subject: [PATCH 2/4] test: add tests for env_utils --- pre-compute/src/compute/utils/env_utils.rs | 146 +++++++++++++++++++++ 1 file changed, 146 insertions(+) diff --git a/pre-compute/src/compute/utils/env_utils.rs b/pre-compute/src/compute/utils/env_utils.rs index 53aa0d7..9f69aeb 100644 --- a/pre-compute/src/compute/utils/env_utils.rs +++ b/pre-compute/src/compute/utils/env_utils.rs @@ -65,3 +65,149 @@ pub fn get_env_var_or_error( _ => Err(status_cause_if_missing), } } + +#[cfg(test)] +mod tests { + use super::*; + use temp_env; + + #[test] + fn name_succeeds_when_simple_environment_variable_names() { + assert_eq!( + TeeSessionEnvironmentVariable::IexecBulkSliceSize.name(), + "IEXEC_BULK_SLICE_SIZE" + ); + + assert_eq!( + TeeSessionEnvironmentVariable::IexecInputFilesNumber.name(), + "IEXEC_INPUT_FILES_NUMBER" + ); + assert_eq!( + TeeSessionEnvironmentVariable::IexecPreComputeOut.name(), + "IEXEC_PRE_COMPUTE_OUT" + ); + assert_eq!( + TeeSessionEnvironmentVariable::IexecTaskId.name(), + "IEXEC_TASK_ID" + ); + assert_eq!( + TeeSessionEnvironmentVariable::IsDatasetRequired.name(), + "IS_DATASET_REQUIRED" + ); + assert_eq!( + TeeSessionEnvironmentVariable::SignTeeChallengePrivateKey.name(), + "SIGN_TEE_CHALLENGE_PRIVATE_KEY" + ); + assert_eq!( + TeeSessionEnvironmentVariable::SignWorkerAddress.name(), + "SIGN_WORKER_ADDRESS" + ); + assert_eq!( + TeeSessionEnvironmentVariable::WorkerHostEnvVar.name(), + "WORKER_HOST_ENV_VAR" + ); + } + + #[test] + fn name_succeeds_when_indexed_environment_variable_names() { + // Test IexecDatasetChecksum + let env_var = TeeSessionEnvironmentVariable::IexecDatasetChecksum(0); + assert_eq!(env_var.name(), "IEXEC_DATASET_CHECKSUM"); + let env_var = TeeSessionEnvironmentVariable::IexecDatasetChecksum(1); + assert_eq!(env_var.name(), "IEXEC_DATASET_1_CHECKSUM"); + let env_var = TeeSessionEnvironmentVariable::IexecDatasetChecksum(10); + assert_eq!(env_var.name(), "IEXEC_DATASET_42_CHECKSUM"); + + // Test IexecDatasetFilename + let env_var = TeeSessionEnvironmentVariable::IexecDatasetFilename(0); + assert_eq!(env_var.name(), "IEXEC_DATASET_FILENAME"); + let env_var = TeeSessionEnvironmentVariable::IexecDatasetFilename(1); + assert_eq!(env_var.name(), "IEXEC_DATASET_1_FILENAME"); + let env_var = TeeSessionEnvironmentVariable::IexecDatasetFilename(5); + assert_eq!(env_var.name(), "IEXEC_DATASET_10_FILENAME"); + + // Test IexecDatasetKey + let env_var = TeeSessionEnvironmentVariable::IexecDatasetKey(0); + assert_eq!(env_var.name(), "IEXEC_DATASET_KEY"); + let env_var = TeeSessionEnvironmentVariable::IexecDatasetKey(1); + assert_eq!(env_var.name(), "IEXEC_DATASET_1_KEY"); + let env_var = TeeSessionEnvironmentVariable::IexecDatasetKey(20); + assert_eq!(env_var.name(), "IEXEC_DATASET_5_KEY"); + + // Test IexecDatasetUrl + let env_var = TeeSessionEnvironmentVariable::IexecDatasetUrl(0); + assert_eq!(env_var.name(), "IEXEC_DATASET_URL"); + let env_var = TeeSessionEnvironmentVariable::IexecDatasetUrl(1); + assert_eq!(env_var.name(), "IEXEC_DATASET_1_URL"); + let env_var = TeeSessionEnvironmentVariable::IexecDatasetUrl(99); + assert_eq!(env_var.name(), "IEXEC_DATASET_99_URL"); + + // Test IexecInputFileUrlPrefix + let env_var = TeeSessionEnvironmentVariable::IexecInputFileUrlPrefix(0); + assert_eq!(env_var.name(), "IEXEC_INPUT_FILE_URL_0"); + let env_var = TeeSessionEnvironmentVariable::IexecInputFileUrlPrefix(1); + assert_eq!(env_var.name(), "IEXEC_INPUT_FILE_URL_1"); + let env_var = TeeSessionEnvironmentVariable::IexecInputFileUrlPrefix(123); + assert_eq!(env_var.name(), "IEXEC_INPUT_FILE_URL_123"); + } + + #[test] + fn get_env_var_or_error_success() { + let env_var = TeeSessionEnvironmentVariable::IexecTaskId; + let status_cause = ReplicateStatusCause::PreComputeTaskIdMissing; + + temp_env::with_var("IEXEC_TASK_ID", Some("test-task-id-123"), || { + let result = get_env_var_or_error(env_var, status_cause.clone()); + assert!(result.is_ok()); + assert_eq!(result.unwrap(), "test-task-id-123"); + }); + } + + #[test] + fn get_env_var_or_error_fails_when_missing_variable() { + let env_var = TeeSessionEnvironmentVariable::IexecTaskId; + let status_cause = ReplicateStatusCause::PreComputeTaskIdMissing; + + temp_env::with_var_unset("IEXEC_TASK_ID", || { + let result = get_env_var_or_error(env_var, status_cause.clone()); + assert!(result.is_err()); + assert_eq!(result.unwrap_err(), status_cause); + }); + } + + #[test] + fn get_env_var_or_error_succeeds_when_empty_variable() { + let env_var = TeeSessionEnvironmentVariable::IexecTaskId; + let status_cause = ReplicateStatusCause::PreComputeTaskIdMissing; + + temp_env::with_var("IEXEC_TASK_ID", Some(""), || { + let result = get_env_var_or_error(env_var, status_cause.clone()); + assert!(result.is_err()); + assert_eq!(result.unwrap_err(), status_cause); + }); + } + + #[test] + fn get_env_var_or_error_succeeds_when_whitespace_only_variable() { + let env_var = TeeSessionEnvironmentVariable::IexecTaskId; + let status_cause = ReplicateStatusCause::PreComputeTaskIdMissing; + + temp_env::with_var("IEXEC_TASK_ID", Some(" "), || { + let result = get_env_var_or_error(env_var, status_cause.clone()); + assert!(result.is_ok()); + assert_eq!(result.unwrap(), " "); + }); + } + + #[test] + fn get_env_var_or_error_succeeds_when_indexed_variables() { + let env_var = TeeSessionEnvironmentVariable::IexecDatasetChecksum(1); + let status_cause = ReplicateStatusCause::PreComputeDatasetChecksumMissing; + + temp_env::with_var("IEXEC_DATASET_1_CHECKSUM", Some("abc123def456"), || { + let result = get_env_var_or_error(env_var, status_cause.clone()); + assert!(result.is_ok()); + assert_eq!(result.unwrap(), "abc123def456"); + }); + } +} From ac6f73b39b28abda1c0dcb0cb33448aa032f9172 Mon Sep 17 00:00:00 2001 From: nabil-Tounarti Date: Wed, 8 Oct 2025 16:08:21 +0200 Subject: [PATCH 3/4] fix: adjust test cases --- pre-compute/src/compute/utils/env_utils.rs | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pre-compute/src/compute/utils/env_utils.rs b/pre-compute/src/compute/utils/env_utils.rs index 9f69aeb..270f0d6 100644 --- a/pre-compute/src/compute/utils/env_utils.rs +++ b/pre-compute/src/compute/utils/env_utils.rs @@ -116,7 +116,7 @@ mod tests { let env_var = TeeSessionEnvironmentVariable::IexecDatasetChecksum(1); assert_eq!(env_var.name(), "IEXEC_DATASET_1_CHECKSUM"); let env_var = TeeSessionEnvironmentVariable::IexecDatasetChecksum(10); - assert_eq!(env_var.name(), "IEXEC_DATASET_42_CHECKSUM"); + assert_eq!(env_var.name(), "IEXEC_DATASET_10_CHECKSUM"); // Test IexecDatasetFilename let env_var = TeeSessionEnvironmentVariable::IexecDatasetFilename(0); @@ -124,7 +124,7 @@ mod tests { let env_var = TeeSessionEnvironmentVariable::IexecDatasetFilename(1); assert_eq!(env_var.name(), "IEXEC_DATASET_1_FILENAME"); let env_var = TeeSessionEnvironmentVariable::IexecDatasetFilename(5); - assert_eq!(env_var.name(), "IEXEC_DATASET_10_FILENAME"); + assert_eq!(env_var.name(), "IEXEC_DATASET_5_FILENAME"); // Test IexecDatasetKey let env_var = TeeSessionEnvironmentVariable::IexecDatasetKey(0); @@ -132,7 +132,7 @@ mod tests { let env_var = TeeSessionEnvironmentVariable::IexecDatasetKey(1); assert_eq!(env_var.name(), "IEXEC_DATASET_1_KEY"); let env_var = TeeSessionEnvironmentVariable::IexecDatasetKey(20); - assert_eq!(env_var.name(), "IEXEC_DATASET_5_KEY"); + assert_eq!(env_var.name(), "IEXEC_DATASET_20_KEY"); // Test IexecDatasetUrl let env_var = TeeSessionEnvironmentVariable::IexecDatasetUrl(0); From 7dfe67d65021ba3dbd30fa2d069a15d3c00d0163 Mon Sep 17 00:00:00 2001 From: nabil-Tounarti Date: Thu, 9 Oct 2025 10:31:51 +0200 Subject: [PATCH 4/4] fix: replace dataset parsing error with generic PreComputeFailedUnknownIssue --- pre-compute/src/compute/pre_compute_args.rs | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pre-compute/src/compute/pre_compute_args.rs b/pre-compute/src/compute/pre_compute_args.rs index 2472e4d..1bd074c 100644 --- a/pre-compute/src/compute/pre_compute_args.rs +++ b/pre-compute/src/compute/pre_compute_args.rs @@ -79,7 +79,7 @@ impl PreComputeArgs { .unwrap_or("0".to_string()); let iexec_bulk_slice_size = iexec_bulk_slice_size_str .parse::() - .map_err(|_| ReplicateStatusCause::PreComputeIsDatasetRequiredMissing)?; + .map_err(|_| ReplicateStatusCause::PreComputeFailedUnknownIssue)?; // TODO: replace with a more specific error let mut datasets = Vec::with_capacity(iexec_bulk_slice_size + 1); @@ -88,19 +88,19 @@ impl PreComputeArgs { for i in start_index..=iexec_bulk_slice_size { let url = get_env_var_or_error( TeeSessionEnvironmentVariable::IexecDatasetUrl(i), - ReplicateStatusCause::PreComputeDatasetUrlMissing, + ReplicateStatusCause::PreComputeDatasetUrlMissing, // TODO: replace with a more specific error for bulk dataset )?; let checksum = get_env_var_or_error( TeeSessionEnvironmentVariable::IexecDatasetChecksum(i), - ReplicateStatusCause::PreComputeDatasetChecksumMissing, + ReplicateStatusCause::PreComputeDatasetChecksumMissing, // TODO: replace with a more specific error for bulk dataset )?; let filename = get_env_var_or_error( TeeSessionEnvironmentVariable::IexecDatasetFilename(i), - ReplicateStatusCause::PreComputeDatasetFilenameMissing, + ReplicateStatusCause::PreComputeDatasetFilenameMissing, // TODO: replace with a more specific error for bulk dataset )?; let key = get_env_var_or_error( TeeSessionEnvironmentVariable::IexecDatasetKey(i), - ReplicateStatusCause::PreComputeDatasetKeyMissing, + ReplicateStatusCause::PreComputeDatasetKeyMissing, // TODO: replace with a more specific error for bulk dataset )?; datasets.push(Dataset::new(url, checksum, filename, key)); @@ -408,7 +408,7 @@ mod tests { assert!(result.is_err()); assert_eq!( result.unwrap_err(), - ReplicateStatusCause::PreComputeIsDatasetRequiredMissing + ReplicateStatusCause::PreComputeFailedUnknownIssue ); }); }