Merge branch 'tests-fix-log-level-restart'

3 files changed, 63 insertions, 57 deletions

diff --git a/test/test-manager/src/logging.rs b/test/test-manager/src/logging.rs
index 75b3d3f5cd..d2ce1ec28d 100644
--- a/test/test-manager/src/logging.rs
+++ b/test/test-manager/src/logging.rs
@@ -239,30 +239,7 @@ impl TestOutput {
 
         println_with_time!("{}", format!("TEST {} HAD LOGS:", self.test_name).red());
         match &self.log_output {
-            Some(log) => {
-                match &log.settings_json {
-                    Ok(settings) => println_with_time!("settings.json: {}", settings),
-                    Err(e) => println_with_time!("Could not get settings.json: {}", e),
-                }
-
-                match &log.log_files {
-                    Ok(log_files) => {
-                        for log in log_files {
-                            match log {
-                                Ok(log) => {
-                                    println_with_time!(
-                                        "Log {}:\n{}",
-                                        log.name.to_str().unwrap(),
-                                        log.content
-                                    )
-                                }
-                                Err(e) => println_with_time!("Could not get log: {}", e),
-                            }
-                        }
-                    }
-                    Err(e) => println_with_time!("Could not get logs: {}", e),
-                }
-            }
+            Some(log) => print_mullvad_logs(log),
             None => println_with_time!("Missing logs for {}", self.test_name),
         }
 
@@ -281,3 +258,24 @@ impl TestOutput {
         println_with_time!("{}", format!("TEST {} END OF OUTPUT", self.test_name).red());
     }
 }
+
+pub fn print_mullvad_logs(log: &LogOutput) {
+    match &log.settings_json {
+        Ok(settings) => println_with_time!("settings.json: {}", settings),
+        Err(e) => println_with_time!("Could not get settings.json: {}", e),
+    }
+
+    match &log.log_files {
+        Ok(log_files) => {
+            for log in log_files {
+                match log {
+                    Ok(log) => {
+                        println_with_time!("Log {}:\n{}", log.name.to_str().unwrap(), log.content)
+                    }
+                    Err(e) => println_with_time!("Could not get log: {}", e),
+                }
+            }
+        }
+        Err(e) => println_with_time!("Could not get logs: {}", e),
+    }
+}
diff --git a/test/test-manager/src/tests/helpers.rs b/test/test-manager/src/tests/helpers.rs
index 16fe4e1e13..55b7b2384e 100644
--- a/test/test-manager/src/tests/helpers.rs
+++ b/test/test-manager/src/tests/helpers.rs
@@ -34,9 +34,7 @@ use std::{
     time::{Duration, Instant},
 };
 use talpid_types::net::wireguard::{PeerConfig, PrivateKey, TunnelConfig};
-use test_rpc::{
-    AmIMullvad, ServiceClient, SpawnOpts, meta::Os, mullvad_daemon::ServiceStatus, package::Package,
-};
+use test_rpc::{AmIMullvad, ServiceClient, SpawnOpts, meta::Os, package::Package};
 use tokio::time::sleep;
 
 pub const THROTTLE_RETRY_DELAY: Duration = Duration::from_secs(120);
@@ -74,26 +72,19 @@ pub async fn install_app(
     log::info!("Installing app '{}'", app_filename);
     rpc.install_app(get_package_desc(app_filename)).await?;
 
-    // verify that daemon is running
-    tokio::time::timeout(Duration::from_secs(5), async {
-        loop {
-            if rpc.mullvad_daemon_get_status().await? == ServiceStatus::Running {
-                return Ok::<_, Error>(());
-            }
-            sleep(Duration::from_millis(100)).await;
-        }
-    })
-    .await
-    .map_err(|_timeout| Error::DaemonNotRunning)??;
-
     // Set the log level to trace
     rpc.set_daemon_log_level(test_rpc::mullvad_daemon::Verbosity::Trace)
-        .await?;
+        .await
+        .context("Failed to set log level")?;
 
-    replace_openvpn_certificate(rpc).await?;
+    replace_openvpn_certificate(rpc)
+        .await
+        .context("Replace OpenVPN certs")?;
 
     // Override env vars
-    rpc.set_daemon_environment(get_app_env().await?).await?;
+    rpc.set_daemon_environment(get_app_env().await?)
+        .await
+        .context("Failed to set daemon environment")?;
 
     // Wait for the relay list to be updated
     let mut mullvad_client = rpc_provider.new_client().await;
diff --git a/test/test-manager/src/tests/mod.rs b/test/test-manager/src/tests/mod.rs
index 1981cc0e07..f39e4371d1 100644
--- a/test/test-manager/src/tests/mod.rs
+++ b/test/test-manager/src/tests/mod.rs
@@ -25,7 +25,9 @@ use anyhow::Context;
 use futures::future::BoxFuture;
 use std::{ops::Not, time::Duration};
 
-use crate::{mullvad_daemon::RpcClientProvider, package::get_version_from_path};
+use crate::{
+    logging::print_mullvad_logs, mullvad_daemon::RpcClientProvider, package::get_version_from_path,
+};
 use config::TEST_CONFIG;
 use helpers::{find_custom_list, get_app_env, install_app, set_location};
 pub use install::test_upgrade_app;
@@ -152,22 +154,37 @@ pub async fn prepare_daemon(
     rpc: &ServiceClient,
     rpc_provider: &RpcClientProvider,
 ) -> anyhow::Result<MullvadProxyClient> {
-    // Check if daemon should be restarted
-    let mut mullvad_client = ensure_daemon_version(rpc, rpc_provider)
-        .await
-        .context("Failed to restart daemon")?;
+    let client = async {
+        // Check if daemon should be restarted
+        let mut mullvad_client = ensure_daemon_version(rpc, rpc_provider)
+            .await
+            .context("Failed to restart daemon")?;
 
-    log::debug!("Resetting daemon settings before test");
-    helpers::disconnect_and_wait(&mut mullvad_client)
-        .await
-        .context("Failed to disconnect daemon after test")?;
-    mullvad_client
-        .reset_settings()
-        .await
-        .context("Failed to reset settings")?;
-    helpers::ensure_logged_in(&mut mullvad_client).await?;
+        log::debug!("Resetting daemon settings before test");
+        helpers::disconnect_and_wait(&mut mullvad_client)
+            .await
+            .context("Failed to disconnect daemon after test")?;
+        mullvad_client
+            .reset_settings()
+            .await
+            .context("Failed to reset settings")?;
+        helpers::ensure_logged_in(&mut mullvad_client).await?;
+
+        Ok(mullvad_client)
+    }
+    .await;
+
+    if client.is_err() {
+        log::error!("Failed to prepare daemon. Attempting to get logs from daemon");
+        match rpc.get_mullvad_app_logs().await {
+            Ok(logs) => print_mullvad_logs(&logs),
+            Err(err) => {
+                log::error!("Failed to get logs from daemon: {err}");
+            }
+        }
+    }
 
-    Ok(mullvad_client)
+    client
 }
 
 /// Create and selects an "anonymous" custom list for this test. The custom list will