test: harden ping manual partial-connectivity scenario

Author: sanity

apps/freenet-ping/Cargo.lock

@@ -5,6 +5,7 @@ edition = "2021"
 
 [features]
 testing = ["freenet-stdlib/testing", "freenet/testing"]
+manual-tests = []
 
 [dependencies]
 anyhow = "1.0"

apps/freenet-ping/app/Cargo.toml

@@ -47,7 +47,7 @@ pub async fn wait_for_put_response(
     expected_key: &ContractKey,
 ) -> Result<ContractKey, Box<dyn std::error::Error + Send + Sync + 'static>> {
     loop {
-        let resp = timeout(Duration::from_secs(30), client.recv()).await;
+        let resp = timeout(Duration::from_secs(60), client.recv()).await;
         match resp {
             Ok(Ok(HostResponse::ContractResponse(ContractResponse::PutResponse { key }))) => {
                 if &key == expected_key {
@@ -91,7 +91,7 @@ pub async fn wait_for_get_response(
     expected_key: &ContractKey,
 ) -> Result<Ping, Box<dyn std::error::Error + Send + Sync + 'static>> {
     loop {
-        let resp = timeout(Duration::from_secs(30), client.recv()).await;
+        let resp = timeout(Duration::from_secs(60), client.recv()).await;
         match resp {
             Ok(Ok(HostResponse::ContractResponse(ContractResponse::GetResponse {
                 key,
@@ -134,7 +134,7 @@ pub async fn wait_for_subscribe_response(
     expected_key: &ContractKey,
 ) -> Result<(), Box<dyn std::error::Error + Send + Sync + 'static>> {
     loop {
-        let resp = timeout(Duration::from_secs(30), client.recv()).await;
+        let resp = timeout(Duration::from_secs(60), client.recv()).await;
         match resp {
             Ok(Ok(HostResponse::ContractResponse(ContractResponse::SubscribeResponse {
                 key,

apps/freenet-ping/app/src/ping_client.rs

@@ -88,10 +88,10 @@ Run a specific blocked peers test variant:
 cargo test test_ping_blocked_peers_simple
 ```
 
-Run the large-scale partial connectivity network test:
+Run the large-scale partial connectivity network test (requires the manual test feature because the scenario is still experimental):
 
 ```bash
-cargo test -p freenet-ping-app --test run_app_partially_connected_network
+cargo test -p freenet-ping-app --features manual-tests --test run_app test_ping_partially_connected_network
 ```
 
 ---

apps/freenet-ping/app/tests/README.md

@@ -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/common/mod.rs

@@ -1519,8 +1519,8 @@ async fn test_ping_application_loop() -> TestResult {
     Ok(())
 }
 
+#[cfg(feature = "manual-tests")]
 #[tokio::test(flavor = "multi_thread")]
-#[ignore = "Test has never worked - gateway nodes fail on startup with channel closed errors"]
 async fn test_ping_partially_connected_network() -> TestResult {
     /*
      * This test verifies how subscription propagation works in a partially connected network.
@@ -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