fix(tests): stabilize multi-gateway integration

Author: sanity

apps/freenet-ping/app/tests/common/mod.rs

@@ -208,13 +208,23 @@ pub(crate) enum PackageType {
     Delegate,
 }
 
+const CONTRACT_EXTRA_FEATURES: [&str; 1] = ["contract"];
+const NO_EXTRA_FEATURES: [&str; 0] = [];
+
 impl PackageType {
     pub fn feature(&self) -> &'static str {
         match self {
             PackageType::Contract => "freenet-main-contract",
             PackageType::Delegate => "freenet-main-delegate",
         }
     }
+
+    pub fn extra_features(&self) -> &'static [&'static str] {
+        match self {
+            PackageType::Contract => &CONTRACT_EXTRA_FEATURES,
+            PackageType::Delegate => &NO_EXTRA_FEATURES,
+        }
+    }
 }
 
 impl std::fmt::Display for PackageType {
@@ -250,9 +260,10 @@ fn compile_options(cli_config: &BuildToolConfig) -> impl Iterator<Item = String>
         .iter()
         .flat_map(|s| {
             s.split(',')
-                .filter(|p| *p != cli_config.package_type.feature())
+                .filter(|p| *p != cli_config.package_type.feature() && *p != "contract")
         })
-        .chain([cli_config.package_type.feature()]);
+        .chain([cli_config.package_type.feature()])
+        .chain(cli_config.package_type.extra_features().iter().copied());
     let features = [
         "--features".to_string(),
         feature_list.collect::<Vec<_>>().join(","),
@@ -262,7 +273,33 @@ fn compile_options(cli_config: &BuildToolConfig) -> impl Iterator<Item = String>
         .chain(release.iter().map(|s| s.to_string()))
 }
 // TODO: refactor so we share the implementation with fdev (need to extract to )
+fn ensure_target_dir_env() {
+    if std::env::var(TARGET_DIR_VAR).is_err() {
+        let workspace_dir = std::env::var("CARGO_WORKSPACE_DIR")
+            .map(PathBuf::from)
+            .unwrap_or_else(|_| find_workspace_root());
+        let target_dir = workspace_dir.join("target");
+        std::env::set_var(TARGET_DIR_VAR, &target_dir);
+    }
+}
+
+fn find_workspace_root() -> PathBuf {
+    let manifest_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    manifest_dir
+        .ancestors()
+        .find(|dir| {
+            let cargo_toml = dir.join("Cargo.toml");
+            cargo_toml.exists()
+                && std::fs::read_to_string(&cargo_toml)
+                    .map(|contents| contents.contains("[workspace]"))
+                    .unwrap_or(false)
+        })
+        .expect("Could not determine workspace root from manifest directory")
+        .to_path_buf()
+}
+
 fn compile_contract(contract_path: &PathBuf) -> anyhow::Result<Vec<u8>> {
+    ensure_target_dir_env();
     println!("module path: {contract_path:?}");
     let target = std::env::var(TARGET_DIR_VAR)
         .map_err(|_| anyhow::anyhow!("CARGO_TARGET_DIR should be set"))?;

apps/freenet-ping/app/tests/run_app.rs

@@ -1750,15 +1750,18 @@ async fn test_ping_partially_connected_network() -> TestResult {
                           i, NUM_GATEWAYS, num_connections);
         }
 
-        // Load the ping contract
+        // Load the ping contract. Compile once to determine the code hash, then again with proper options.
         let path_to_code = PathBuf::from(PACKAGE_DIR).join(PATH_TO_CONTRACT);
         tracing::info!(path=%path_to_code.display(), "loading contract code");
-        let code = std::fs::read(path_to_code)
-            .ok()
-            .ok_or_else(|| anyhow!("Failed to read contract code"))?;
-        let code_hash = CodeHash::from_code(&code);
-
-        // Create ping contract options
+        let temp_options = PingContractOptions {
+            frequency: Duration::from_secs(3),
+            ttl: Duration::from_secs(60),
+            tag: APP_TAG.to_string(),
+            code_key: String::new(),
+        };
+        let temp_params = Parameters::from(serde_json::to_vec(&temp_options).unwrap());
+        let temp_container = common::load_contract(&path_to_code, temp_params)?;
+        let code_hash = CodeHash::from_code(temp_container.data());
         let ping_options = PingContractOptions {
             frequency: Duration::from_secs(3),
             ttl: Duration::from_secs(60),
@@ -1767,7 +1770,7 @@ async fn test_ping_partially_connected_network() -> TestResult {
         };
 
         let params = Parameters::from(serde_json::to_vec(&ping_options).unwrap());
-        let container = ContractContainer::try_from((code, &params))?;
+        let container = common::load_contract(&path_to_code, params)?;
         let contract_key = container.key();
 
         // Choose a node to publish the contract